@fungi.computer/oyster 0.0.0-stage → 0.1.0

package/dist/apps/operations.js

@@ -0,0 +1,98 @@
+import { appBackendBindingOperation, } from "@fungi.computer/puffball/app";
+import { sha256 } from "../release.js";
+import canonicalJson from "fast-json-stable-stringify";
+import { declaredOperationsSchema, } from "./installation.js";
+/** Qualify backend operations so a same-named browser method grants no backend authority. */
+export function bindingOperationKey(binding, operation) {
+    return `binding:${binding}:${operation}`;
+}
+/** Approval identity for one UI-side target method; upgrades intersect these exact pairs. */
+export function appCallOperation(appId, method) {
+    return `route:apps.call:${appId}:${method}`;
+}
+/** Sole derivation owner. Inputs are the verified Release declaration and existing host adapters. */
+export async function deriveDeclaredOperations(release, declaration, descriptors) {
+    if (descriptors.some((descriptor) => descriptor.id === "app.methods"))
+        throw new Error("app_methods_descriptor_reserved");
+    const capabilities = new Map(declaration.capabilities.map((capability) => [
+        capability,
+        new Set(),
+    ]));
+    for (const call of declaration.calls ?? [])
+        for (const method of call.methods)
+            capabilities.get("apps.call")?.add(appCallOperation(call.appId, method));
+    for (const [name, method] of Object.entries(declaration.api?.methods ?? {}))
+        for (const capability of method.requires)
+            capabilities.get(capability)?.add(`route:app.methods:${name}`);
+    const routes = descriptors
+        .filter((descriptor) => capabilities.has(descriptor.permission))
+        .map((descriptor) => {
+        const methods = Object.entries(descriptor.methods).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+        for (const [name] of methods)
+            capabilities
+                .get(descriptor.permission)
+                ?.add(`route:${descriptor.id}:${name}`);
+        return { id: descriptor.id, permission: descriptor.permission, methods };
+    })
+        .sort((a, b) => a.id < b.id
+        ? -1
+        : a.id > b.id
+            ? 1
+            : a.permission < b.permission
+                ? -1
+                : a.permission > b.permission
+                    ? 1
+                    : 0);
+    const bindings = (declaration.backend?.bindings ?? [])
+        .flatMap((binding) => binding.operations.flatMap((name) => {
+        const operation = appBackendBindingOperation(binding.name, name);
+        if (!operation?.requires.every((capability) => capabilities.has(capability)))
+            return [];
+        for (const capability of operation.requires)
+            capabilities
+                .get(capability)
+                ?.add(bindingOperationKey(binding.name, name));
+        return [
+            {
+                binding: binding.name,
+                operation: name,
+                effect: operation.effect,
+                requires: [...operation.requires].sort(),
+            },
+        ];
+    }))
+        .sort((a, b) => bindingOperationKey(a.binding, a.operation) <
+        bindingOperationKey(b.binding, b.operation)
+        ? -1
+        : bindingOperationKey(a.binding, a.operation) >
+            bindingOperationKey(b.binding, b.operation)
+            ? 1
+            : 0);
+    const rows = [...capabilities]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([capability, operations]) => ({
+        capability,
+        operations: [...operations].sort(),
+    }));
+    const artifactDigest = release.artifact.artifactDigest;
+    const anonymousMethods = await Promise.all(Object.entries(declaration.api?.methods ?? {})
+        .filter(([, method]) => method.anonymous === true)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(async ([name, method]) => ({
+        name,
+        digest: await sha256(new TextEncoder().encode(canonicalJson(method))),
+    })));
+    const digest = await sha256(new TextEncoder().encode(JSON.stringify({
+        artifactDigest,
+        capabilities: rows,
+        routes,
+        bindings,
+        anonymousMethods,
+    })));
+    return declaredOperationsSchema.parse({
+        artifactDigest,
+        digest,
+        capabilities: rows,
+        anonymousMethods,
+    });
+}

package/dist/apps/tools.d.ts

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+import type { AppApi, AppDeclaration } from "@fungi.computer/puffball/app";
+import type { Installation, DeclaredOperations } from "./installation.js";
+/**
+ * One App-tool access level, with its own freshness pin. An Agent's comes
+ * from the owner's stored direct approval; a key's is computed fresh from
+ * its own Ear Tag grants (`keyAppAccess`), never stored as this shape --
+ * only read through it, for one call or one installation at a time.
+ */
+export declare const appToolPolicySchema: Schema.Struct<{
+    readonly level: Schema.Literals<readonly ["read", "write"]>;
+    readonly revision: Schema.NonEmptyString;
+    readonly grantedBy: Schema.NonEmptyString;
+}>;
+/** The authenticated attaching member is recorded when this policy is approved. */
+export type AppToolPolicy = typeof appToolPolicySchema.Type;
+/** One installation's binding under the captured host approval. */
+export declare const appToolAccessSchema: Schema.Struct<{
+    readonly bindingName: Schema.NonEmptyString;
+    readonly level: Schema.Literals<readonly ["read", "write"]>;
+    readonly revision: Schema.NonEmptyString;
+    readonly grantedBy: Schema.NonEmptyString;
+}>;
+/** One installation binding constrained by an authenticated tool-policy approval. */
+export type AppToolAccess = typeof appToolAccessSchema.Type;
+/** Pre-read entries: the catalog never resolves installations or calls back into a host. */
+export type AppToolEntry = Readonly<{
+    installation: Installation;
+    declaration: AppDeclaration;
+    declaredOperations: DeclaredOperations;
+    api: AppApi | null;
+    access: AppToolAccess | null;
+}>;

package/dist/apps/tools.js

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+/**
+ * One App-tool access level, with its own freshness pin. An Agent's comes
+ * from the owner's stored direct approval; a key's is computed fresh from
+ * its own Ear Tag grants (`keyAppAccess`), never stored as this shape --
+ * only read through it, for one call or one installation at a time.
+ */
+export const appToolPolicySchema = Schema.Struct({
+    level: Schema.Literals(["read", "write"]),
+    revision: Schema.NonEmptyString,
+    grantedBy: Schema.NonEmptyString,
+});
+/** One installation's binding under the captured host approval. */
+export const appToolAccessSchema = Schema.Struct({
+    ...appToolPolicySchema.fields,
+    bindingName: Schema.NonEmptyString,
+});

package/dist/auth.d.ts

@@ -0,0 +1,11 @@
+import type { OysterAuth } from "./host.js";
+import type { OysterKeyStore } from "./keys.js";
+/** Cookie emitted by ownerKeyAuth, for composing credential-specific adapters. */
+export declare const ownerKeyCookieName = "oyster_session";
+/**
+ * Single-owner sign-in: a bearer token or a session cookie holding the
+ * owner key's digest. The key itself is never stored in the browser.
+ */
+export declare function ownerKeyAuth(ownerKey: string, ownerId?: string): OysterAuth;
+/** The owner key, or a named key admitted as its canonical Team-key actor. */
+export declare function ownerOrKeyAuth(ownerKey: string, ownerId: string, keys: () => Pick<OysterKeyStore, "verify">): OysterAuth;

package/dist/auth.js

@@ -0,0 +1,93 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { presentedGitKey } from "./git-auth.js";
+import { sha256 } from "./release.js";
+/** Cookie emitted by ownerKeyAuth, for composing credential-specific adapters. */
+export const ownerKeyCookieName = "oyster_session";
+const loginFormSchema = Schema.Struct({ key: Schema.String });
+/** Compare two secrets through their fixed-length digests, in constant time. */
+async function constantTimeEqual(a, b) {
+    const [left, right] = await Promise.all([
+        sha256(new TextEncoder().encode(a)),
+        sha256(new TextEncoder().encode(b)),
+    ]);
+    let difference = 0;
+    for (let index = 0; index < left.length; index += 1)
+        difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+    return difference === 0;
+}
+/**
+ * Single-owner sign-in: a bearer token or a session cookie holding the
+ * owner key's digest. The key itself is never stored in the browser.
+ */
+export function ownerKeyAuth(ownerKey, ownerId = "owner") {
+    if (ownerKey.length < 24)
+        throw new Error("OYSTER_OWNER_KEY must be at least 24 characters");
+    const sessionValue = sha256(new TextEncoder().encode(`oyster:${ownerKey}`));
+    const owner = {
+        kind: "admitted",
+        principal: { actor: { kind: "member", memberId: ownerId }, role: "owner" },
+    };
+    return {
+        resolve: (actor) => Promise.resolve(actor.kind === "member" && actor.memberId === ownerId
+            ? owner.principal
+            : null),
+        async authenticate(request) {
+            const authorization = request.headers.get("Authorization");
+            if (authorization?.startsWith("Bearer ") === true)
+                return (await constantTimeEqual(authorization.slice(7), ownerKey))
+                    ? owner
+                    : { kind: "refused", status: 401 };
+            const cookie = (request.headers.get("Cookie") ?? "")
+                .split(";")
+                .map((part) => part.trim())
+                .find((part) => part.startsWith(`${ownerKeyCookieName}=`));
+            if (cookie !== undefined &&
+                (await constantTimeEqual(cookie.slice(ownerKeyCookieName.length + 1), await sessionValue)))
+                return owner;
+            return { kind: "refused", status: 401 };
+        },
+        async login(request) {
+            const form = Schema.decodeUnknownOption(loginFormSchema)(Object.fromEntries(await request.formData()));
+            if (Option.isNone(form) ||
+                !(await constantTimeEqual(form.value.key, ownerKey)))
+                return new Response("Wrong key", { status: 401 });
+            return new Response(null, {
+                status: 303,
+                headers: {
+                    Location: "/",
+                    "Set-Cookie": `${ownerKeyCookieName}=${await sessionValue}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=2592000`,
+                },
+            });
+        },
+    };
+}
+/** The owner key, or a named key admitted as its canonical Team-key actor. */
+export function ownerOrKeyAuth(ownerKey, ownerId, keys) {
+    const owner = ownerKeyAuth(ownerKey, ownerId);
+    return {
+        resolve: (actor) => owner.resolve(actor),
+        async authenticate(request) {
+            const result = await owner.authenticate(request);
+            if (result.kind === "admitted")
+                return result;
+            const presented = presentedGitKey(request);
+            if (presented.kind !== "key")
+                return result;
+            const verified = await keys().verify(presented.value);
+            // A revoked or expired key, or one belonging to a different owner (a
+            // presented secret can never prove that on its own), authenticates as
+            // no one; the owner-key result above still stands.
+            return verified.kind === "ok" && verified.value.owner === ownerId
+                ? {
+                    kind: "admitted",
+                    principal: {
+                        actor: { kind: "team-key", keyId: verified.value.keyId },
+                    },
+                }
+                : result;
+        },
+        login: (request) => owner.login?.(request) ??
+            Promise.resolve(new Response("Sign-in is not available", { status: 404 })),
+    };
+}

package/dist/backend-request.d.ts

@@ -0,0 +1,3 @@
+export declare function appFacetRequest(request: Request): Request;
+/** Only content metadata crosses back from a guest; origin policy is host-owned. */
+export declare function appFacetResponse(response: Response): Response;

package/dist/backend-request.js

@@ -0,0 +1,53 @@
+/** Second boundary before an admitted request enters customer backend code.
+ * Hub normally builds this shape itself; callers of the App runtime must not
+ * be able to pass their own headers through the facet.
+ */
+import { appBackendActorHeader, appBackendComputerHeader, } from "@fungi.computer/agar/backend";
+export function appFacetRequest(request) {
+    const headers = new Headers();
+    for (const name of [
+        "Content-Type",
+        appBackendActorHeader,
+        appBackendComputerHeader,
+    ]) {
+        const value = request.headers.get(name);
+        if (value !== null)
+            headers.set(name, value);
+    }
+    const init = {
+        method: request.method,
+        headers,
+        body: request.body,
+        redirect: "manual",
+    };
+    if (request.body !== null)
+        init.duplex = "half";
+    return new Request(request.url, init);
+}
+/** Only content metadata crosses back from a guest; origin policy is host-owned. */
+export function appFacetResponse(response) {
+    const headers = new Headers();
+    for (const name of [
+        "Content-Type",
+        "Content-Language",
+        "Content-Encoding",
+        "Content-Length",
+        "Content-Disposition",
+        "Content-Range",
+        "Accept-Ranges",
+        "ETag",
+        "Last-Modified",
+    ]) {
+        const value = response.headers.get(name);
+        if (value !== null)
+            headers.set(name, value);
+    }
+    headers.set("Cache-Control", "no-store");
+    headers.set("Content-Security-Policy", "sandbox; default-src 'none'");
+    headers.set("X-Content-Type-Options", "nosniff");
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}

package/dist/build/artifact-writer.d.ts

@@ -0,0 +1,40 @@
+import { type AssetBuildPolicy } from "@fungi.computer/puffball/assets";
+import { type ArtifactRef, type Sha256Digest } from "@fungi.computer/puffball";
+import type { BuildOutput, StoredArtifact } from "./effect.js";
+import type { CandidateOutputManifest } from "./submission-contract.js";
+/** Write-once object storage for one artifact root. */
+export type ImmutableArtifactObjects = Readonly<{
+    /** Create the object, or answer `exists` when the reference is taken. */
+    create(artifactRef: ArtifactRef, bytes: Uint8Array): Promise<"created" | "exists">;
+    /** Read the object's bytes, or `null` when absent. */
+    read(artifactRef: ArtifactRef): Promise<Uint8Array | null>;
+}>;
+/** One object ready to store under its reference. */
+export type StagedArtifactObject = Readonly<{
+    artifactRef: ArtifactRef;
+    bytes: Uint8Array;
+    digest: Sha256Digest;
+}>;
+/** A build's output manifest and each distinct object it names. */
+export type StagedBuildOutput = Readonly<{
+    manifest: CandidateOutputManifest;
+    objects: readonly StagedArtifactObject[];
+}>;
+/**
+ * Stage a build's bytes: the output manifest that names each object by its
+ * digest and size, and each distinct object once.
+ */
+export declare function stageBuildOutput(output: BuildOutput): StagedBuildOutput;
+/**
+ * Write the asset manifest and App root an output manifest names. The
+ * objects it names are already stored, and checked, by the caller.
+ */
+export declare function writeArtifactRoot(manifest: CandidateOutputManifest, objects: ImmutableArtifactObjects, options: Readonly<{
+    rootArtifactRef: ArtifactRef;
+    assetPolicy: AssetBuildPolicy | undefined;
+}>): Promise<StoredArtifact>;
+/** Persist one build's UI, backend and root; an existing object must hold the same bytes. */
+export declare function writeImmutableArtifact(output: BuildOutput, objects: ImmutableArtifactObjects, options: Readonly<{
+    rootArtifactRef: ArtifactRef;
+    assetPolicy: AssetBuildPolicy | undefined;
+}>): Promise<StoredArtifact>;

package/dist/build/artifact-writer.js

@@ -0,0 +1,181 @@
+/**
+ * Oyster's one immutable artifact representation: digest-addressed bytes
+ * keyed by artifact reference, with media types carried by the App build
+ * and asset manifests (never by the store). The local packer writes it to a
+ * directory, and a host's build owner writes it to that host's artifact store,
+ * so a Release built on the host and one packed and uploaded share objects.
+ *
+ * It has two halves. Staging turns a build's bytes into content-addressed
+ * objects and the output manifest that names them by digest and size. The
+ * root half turns an output manifest into the small objects only the store's
+ * owner writes: the asset manifest and the App root. The local packer runs
+ * both; a host whose builder uploaded the objects itself runs only the root
+ * half, over the same manifest, so both write identical root bytes.
+ *
+ * Every object is derived and checked before the first is stored: an asset
+ * build that its policy refuses, or a root over its bound, stores nothing.
+ */
+import { createHash } from "node:crypto";
+import mime from "mime";
+import * as Schema from "effect/Schema";
+import { assetBuildJsonSchema, assetPathSchema, decodeAssetBuild, } from "@fungi.computer/puffball/assets";
+import { appBuildJsonSchema, createAppBuild, } from "@fungi.computer/puffball/app";
+import { parseArtifactRef, parseSha256Digest, } from "@fungi.computer/puffball";
+function sha256(bytes) {
+    return parseSha256Digest(`sha256:${createHash("sha256").update(bytes).digest("hex")}`);
+}
+/** The content address of an object: `artifact:sha256-<hex>`. */
+function contentArtifactRef(digest) {
+    return parseArtifactRef(`artifact:sha256-${digest.slice("sha256:".length)}`);
+}
+/**
+ * The root bound for an App whose recipe declares no asset policy: this
+ * writer's private fallback, not recipe policy. An asset recipe's own
+ * `maxManifestBytes` bounds its root as it bounds its asset manifest.
+ */
+const fallbackRootBytes = 1024 * 1024;
+/**
+ * Stage a build's bytes: the output manifest that names each object by its
+ * digest and size, and each distinct object once.
+ */
+export function stageBuildOutput(output) {
+    const objects = [];
+    const stage = (bytes) => {
+        const digest = sha256(bytes);
+        if (!objects.some((object) => object.digest === digest))
+            objects.push({
+                artifactRef: contentArtifactRef(digest),
+                bytes: bytes.slice(),
+                digest,
+            });
+        return { digest, byteLength: bytes.byteLength };
+    };
+    const declared = output.declaration === undefined ? {} : { declaration: output.declaration };
+    const ui = (prepared) => prepared.content.kind === "html"
+        ? {
+            mediaType: "text/html; charset=utf-8",
+            content: { kind: "html", ...stage(prepared.content.bytes) },
+        }
+        : {
+            mediaType: "application/vnd.fungi.app-assets+json",
+            content: {
+                kind: "assets",
+                base: prepared.content.base,
+                assets: prepared.content.assets.map((asset) => ({
+                    path: asset.path,
+                    ...stage(asset.bytes),
+                })),
+            },
+        };
+    const manifest = output.kind === "ui"
+        ? { kind: "ui", ui: ui(output.ui), ...declared }
+        : output.kind === "backend"
+            ? { kind: "backend", backend: stage(output.backend), ...declared }
+            : {
+                kind: "app",
+                ui: ui(output.ui),
+                backend: stage(output.backend),
+                ...declared,
+            };
+    return { manifest, objects };
+}
+/**
+ * Derive the asset manifest (for an asset UI) and the App root an output
+ * manifest names, each checked against the policy, without storing either.
+ */
+function artifactRootObjects(manifest, options) {
+    const objects = [];
+    const referenced = (object) => ({
+        artifactRef: contentArtifactRef(object.digest),
+        digest: object.digest,
+        version: object.digest,
+        byteLength: object.byteLength,
+    });
+    const stage = (bytes, ref) => {
+        const digest = sha256(bytes);
+        const artifactRef = ref ?? contentArtifactRef(digest);
+        objects.push({ artifactRef, bytes, digest });
+        return {
+            artifactRef,
+            digest,
+            version: digest,
+            byteLength: bytes.byteLength,
+        };
+    };
+    const ui = manifest.kind === "backend" ? null : manifest.ui;
+    const storedUi = (() => {
+        if (ui === null)
+            return null;
+        if (ui.content.kind === "html")
+            return { ...referenced(ui.content), mediaType: ui.mediaType };
+        if (!options.assetPolicy)
+            throw new Error("Asset writer requires explicit policy");
+        const byPath = new Map();
+        for (const asset of ui.content.assets) {
+            const path = Schema.decodeUnknownSync(assetPathSchema)(asset.path);
+            if (byPath.has(path))
+                throw new Error("Duplicate build path");
+            byPath.set(path, asset);
+        }
+        const assets = [];
+        for (const [path, asset] of [...byPath].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+            const mediaType = mime.getType(path);
+            const contentType = mediaType?.startsWith("text/")
+                ? `${mediaType}; charset=utf-8`
+                : mediaType;
+            if (!contentType)
+                throw new Error("Build asset has no maintained content type");
+            assets.push({ path, ...referenced(asset), contentType });
+        }
+        const assetManifest = new TextEncoder().encode(Schema.encodeUnknownSync(assetBuildJsonSchema)({
+            format: "fungi-assets-v1",
+            base: ui.content.base,
+            assets,
+        }));
+        decodeAssetBuild(assetManifest, options.assetPolicy);
+        return { ...stage(assetManifest), mediaType: ui.mediaType };
+    })();
+    const storedBackend = manifest.kind === "ui"
+        ? null
+        : {
+            ...referenced(manifest.backend),
+            mediaType: "application/vnd.fungi.app-backend+json",
+        };
+    const rootBytes = new TextEncoder().encode(Schema.encodeUnknownSync(appBuildJsonSchema)(createAppBuild(storedUi, storedBackend, manifest.declaration)));
+    if (rootBytes.byteLength >
+        (options.assetPolicy?.maxManifestBytes ?? fallbackRootBytes))
+        throw new Error("App root exceeds its manifest bound");
+    const root = stage(rootBytes, options.rootArtifactRef);
+    return {
+        objects,
+        root: Object.freeze({
+            artifactRef: root.artifactRef,
+            artifactDigest: root.digest,
+        }),
+    };
+}
+/** Store each object once; an existing object must hold the same bytes. */
+async function storeObjects(staged, objects) {
+    for (const { artifactRef, bytes, digest } of staged)
+        if ((await objects.create(artifactRef, bytes)) === "exists") {
+            const existing = await objects.read(artifactRef);
+            if (existing === null || sha256(existing) !== digest)
+                throw new Error("Immutable artifact collision");
+        }
+}
+/**
+ * Write the asset manifest and App root an output manifest names. The
+ * objects it names are already stored, and checked, by the caller.
+ */
+export async function writeArtifactRoot(manifest, objects, options) {
+    const derived = artifactRootObjects(manifest, options);
+    await storeObjects(derived.objects, objects);
+    return derived.root;
+}
+/** Persist one build's UI, backend and root; an existing object must hold the same bytes. */
+export async function writeImmutableArtifact(output, objects, options) {
+    const staged = stageBuildOutput(output);
+    const derived = artifactRootObjects(staged.manifest, options);
+    await storeObjects([...staged.objects, ...derived.objects], objects);
+    return derived.root;
+}

package/dist/build/build-jobs.d.ts

@@ -0,0 +1,128 @@
+import * as Schema from "effect/Schema";
+import type { Sha256Digest } from "@fungi.computer/puffball";
+import type { PinnedRecipe } from "./effect.js";
+/** The secret-free Team job; no provider token enters publication. */
+declare const jobSchema: Schema.Struct<{
+    readonly jobId: Schema.NonEmptyString;
+    readonly computerId: Schema.NonEmptyString;
+    readonly credentialId: Schema.NonEmptyString;
+    readonly issuedAt: Schema.Number;
+    readonly repository: Schema.NonEmptyString;
+    readonly expiresAt: Schema.Number;
+    readonly remote: Schema.NonEmptyString;
+    readonly reportUrl: Schema.NonEmptyString;
+    readonly status: Schema.Literals<readonly ["running", "succeeded", "failed", "revoked"]>;
+    readonly artifact: Schema.NullOr<Schema.Struct<{
+        readonly digest: Schema.NonEmptyString;
+        readonly bytes: Schema.Number;
+    }>>;
+    readonly detail: Schema.NullOr<Schema.String>;
+}>;
+export type TeamBuildJob = Schema.Schema.Type<typeof jobSchema>;
+export type BuildCredential = Pick<TeamBuildJob, "jobId" | "computerId" | "credentialId" | "repository" | "issuedAt" | "expiresAt" | "remote" | "reportUrl">;
+declare const executionSchema: Schema.Struct<{
+    readonly output: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly exitCode: Schema.NullOr<Schema.Number>;
+        readonly stderr: Schema.optional<Schema.String>;
+    }>>>;
+}>;
+export type TeamBuildComputer = Readonly<{
+    applyBuildDecision: (decision: {
+        kind: "build";
+        schemaVersion: 1;
+        teamId: string;
+        computerId: string;
+        jobId: string;
+        credentialId: string;
+        operations: readonly ["computer.execute"];
+        sequence: number;
+        issuedAt: number;
+        expiresAt: number;
+        status: "allowed" | "revoked";
+        basis: {
+            credentialExpiresAt: number;
+        };
+    }) => Promise<void>;
+    execute: (input: {
+        teamId: string;
+        computerId: string;
+        jobId: string;
+        credentialId: string;
+        command: string;
+        timeoutMs: number;
+    }) => Promise<Schema.Schema.Type<typeof executionSchema>>;
+    deliverTeamGitEvents: () => Promise<number>;
+}>;
+/** Publisher executes builds; Team retains job authority, Computer runs them. */
+export declare function createTeamBuildPublisher(options: Readonly<{
+    team: Readonly<{
+        mintTeamBuildCredential: (input: {
+            jobId: string;
+            repository: string;
+            computerId: string;
+            ttlMs: number;
+        }) => Promise<BuildCredential>;
+        revokeTeamBuild: (jobId: string) => Promise<TeamBuildJob>;
+        /** One Team-owned door checks Computer ownership and settles its job. */
+        build: () => Promise<Readonly<{
+            prepare: (jobId: string) => Promise<TeamBuildJob>;
+            read: (jobId: string) => Promise<TeamBuildJob | null>;
+            complete: (jobId: string, status: "succeeded" | "failed", detail: string) => Promise<TeamBuildJob>;
+            deliverProjection: () => Promise<void>;
+            [Symbol.dispose]: () => void;
+        }>>;
+    }>;
+    computer: (computerId: string) => TeamBuildComputer;
+    now?: () => number;
+    teamId: string;
+    maxPermissionAgeMs?: number;
+}>): Readonly<{
+    mint(input: Parameters<typeof options.team.mintTeamBuildCredential>[0]): Promise<BuildCredential>;
+    read(jobId: string): Promise<{
+        readonly jobId: string;
+        readonly computerId: string;
+        readonly credentialId: string;
+        readonly issuedAt: number;
+        readonly repository: string;
+        readonly expiresAt: number;
+        readonly remote: string;
+        readonly reportUrl: string;
+        readonly status: "revoked" | "running" | "failed" | "succeeded";
+        readonly artifact: {
+            readonly digest: string;
+            readonly bytes: number;
+        } | null;
+        readonly detail: string | null;
+    } | null>;
+    revoke(jobId: string): Promise<{
+        readonly jobId: string;
+        readonly computerId: string;
+        readonly credentialId: string;
+        readonly issuedAt: number;
+        readonly repository: string;
+        readonly expiresAt: number;
+        readonly remote: string;
+        readonly reportUrl: string;
+        readonly status: "revoked" | "running" | "failed" | "succeeded";
+        readonly artifact: {
+            readonly digest: string;
+            readonly bytes: number;
+        } | null;
+        readonly detail: string | null;
+    }>;
+    run(input: {
+        jobId: string;
+        command: string;
+        timeoutMs: number;
+    }): Promise<TeamBuildJob>;
+}>;
+/** Fixed captured builder command; neither source nor the customer supplies shell code. */
+export declare function teamAppBuildCommand(configuration: Readonly<{
+    appId: string;
+    sourceRevision: string;
+    source: Readonly<{
+        recipe: PinnedRecipe;
+        buildRecipeDigest: Sha256Digest;
+    }>;
+}>, uploadGrant: string): string;
+export {};