@fungi.computer/agar 0.0.0-stage → 0.0.1

package/dist/lifecycle.d.ts

@@ -0,0 +1,44 @@
+/** The host-published state surrounding a connected App: its Computer
+ * selection, focus, visibility, and any pending open request. */
+export type AppContext = {
+    /** Host-selected Computer backing this App's admitted resource capabilities. */
+    readonly computerId: string | null;
+    /** Whether the Team has Computers, when this host owns its Team directory. */
+    readonly teamHasComputers?: boolean | null | undefined;
+    /** Whether this App has execute access across the Team, when known. */
+    readonly computerAccessGranted?: boolean | undefined;
+    readonly focus: FocusState;
+    /** One host-issued App open action, present only on the launch/reconfigure. */
+    readonly openRequest: AppOpenRequest | null;
+    readonly visibility: "hidden" | "visible";
+};
+/** One host-issued action an App must act on when it opens or reconfigures:
+ * start composing given text, or navigate
+ * to the given params. Each carries a `requestId` so the App can tell a
+ * repeated open from a fresh one. */
+export type AppOpenRequest = Readonly<{
+    kind: "compose";
+    requestId: string;
+    text: string;
+}> | Readonly<{
+    kind: "navigate";
+    requestId: string;
+    params: readonly Readonly<{
+        key: string;
+        value: string;
+    }>[];
+}>;
+/** The App's own identity, as admitted by its host. */
+export type AppIdentity = {
+    readonly appId: string;
+    readonly releaseId: string;
+    readonly surfaceId: string;
+};
+/** The connection state of this App's session with its host. */
+export type AppLifecycle = "connected" | "connecting" | "disconnected" | "disposed" | "disposing" | "suspended";
+/** Whether the App's own surface is being edited and which surface, if
+ * any, the host considers focused. */
+export type FocusState = {
+    readonly editing: boolean;
+    readonly surface: null | string;
+};

package/dist/lifecycle.js

@@ -0,0 +1 @@
+export {};

package/dist/marketplace.d.ts

@@ -0,0 +1,159 @@
+import * as Schema from "effect/Schema";
+import type { CapabilityContract } from "./capabilities.js";
+/** Gallery shelves, in display order. */
+export declare const marketplaceCategories: readonly ["agents", "creative", "developer", "games", "productivity"];
+export declare const marketplaceCategorySchema: Schema.Literals<readonly ["agents", "creative", "developer", "games", "productivity"]>;
+export type MarketplaceCategory = Schema.Schema.Type<typeof marketplaceCategorySchema>;
+export declare const marketplacePriceSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"free">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"one-time">;
+    readonly currency: Schema.Literal<"usd">;
+    readonly amountMinor: Schema.Number;
+}>]>;
+export type MarketplacePrice = Schema.Schema.Type<typeof marketplacePriceSchema>;
+/**
+ * One gallery entry as the viewing Team sees it. `availability` says what
+ * acquiring it means: `included` Apps already ship with every Team,
+ * `coming-soon` entries are not yet installable. `installed` is the Team's
+ * current state, not an authority.
+ */
+export declare const marketplaceListingSchema: Schema.Struct<{
+    readonly listingId: Schema.String;
+    readonly appId: Schema.String;
+    readonly name: Schema.String;
+    readonly tagline: Schema.String;
+    readonly description: Schema.String;
+    readonly category: Schema.Literals<readonly ["agents", "creative", "developer", "games", "productivity"]>;
+    readonly icon: Schema.NullOr<Schema.String>;
+    readonly screenshots: Schema.$Array<Schema.Struct<{
+        readonly src: Schema.String;
+        readonly alt: Schema.String;
+    }>>;
+    readonly price: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"free">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"one-time">;
+        readonly currency: Schema.Literal<"usd">;
+        readonly amountMinor: Schema.Number;
+    }>]>;
+    readonly seller: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"platform">;
+        readonly accountId: Schema.String;
+        readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"creator">;
+        readonly accountId: Schema.String;
+        readonly name: Schema.String;
+    }>]>;
+    readonly availability: Schema.Literals<readonly ["available", "included", "coming-soon"]>;
+    readonly installed: Schema.Boolean;
+    readonly featured: Schema.Boolean;
+}>;
+export type MarketplaceListing = Schema.Schema.Type<typeof marketplaceListingSchema>;
+export declare const marketplaceBrowseResultSchema: Schema.Struct<{
+    readonly listings: Schema.$Array<Schema.Struct<{
+        readonly listingId: Schema.String;
+        readonly appId: Schema.String;
+        readonly name: Schema.String;
+        readonly tagline: Schema.String;
+        readonly description: Schema.String;
+        readonly category: Schema.Literals<readonly ["agents", "creative", "developer", "games", "productivity"]>;
+        readonly icon: Schema.NullOr<Schema.String>;
+        readonly screenshots: Schema.$Array<Schema.Struct<{
+            readonly src: Schema.String;
+            readonly alt: Schema.String;
+        }>>;
+        readonly price: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"free">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"one-time">;
+            readonly currency: Schema.Literal<"usd">;
+            readonly amountMinor: Schema.Number;
+        }>]>;
+        readonly seller: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"platform">;
+            readonly accountId: Schema.String;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"creator">;
+            readonly accountId: Schema.String;
+            readonly name: Schema.String;
+        }>]>;
+        readonly availability: Schema.Literals<readonly ["available", "included", "coming-soon"]>;
+        readonly installed: Schema.Boolean;
+        readonly featured: Schema.Boolean;
+    }>>;
+    readonly paid: Schema.Boolean;
+}>;
+export type MarketplaceBrowseResult = Schema.Schema.Type<typeof marketplaceBrowseResultSchema>;
+/** One catalog family: an ordinary App listing. */
+export declare const decodeMarketplaceBrowseResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly listings: readonly {
+        readonly listingId: string;
+        readonly appId: string;
+        readonly name: string;
+        readonly tagline: string;
+        readonly description: string;
+        readonly category: "agents" | "games" | "creative" | "developer" | "productivity";
+        readonly icon: string | null;
+        readonly screenshots: readonly {
+            readonly src: string;
+            readonly alt: string;
+        }[];
+        readonly price: {
+            readonly kind: "free";
+        } | {
+            readonly kind: "one-time";
+            readonly currency: "usd";
+            readonly amountMinor: number;
+        };
+        readonly seller: {
+            readonly kind: "platform";
+            readonly accountId: string;
+            readonly name: string;
+        } | {
+            readonly kind: "creator";
+            readonly accountId: string;
+            readonly name: string;
+        };
+        readonly availability: "available" | "included" | "coming-soon";
+        readonly installed: boolean;
+        readonly featured: boolean;
+    }[];
+    readonly paid: boolean;
+};
+export declare const marketplaceAcquisitionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"installed">;
+    readonly listingId: Schema.String;
+    readonly appId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"included">;
+    readonly listingId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"checkout">;
+    readonly listingId: Schema.String;
+    readonly url: Schema.String;
+}>]>;
+export type MarketplaceAcquisition = Schema.Schema.Type<typeof marketplaceAcquisitionSchema>;
+export type MarketplaceBrowseInput = Readonly<{
+    query?: string;
+    category?: MarketplaceCategory | null;
+}>;
+/** Read the Marketplace gallery as the Team that mounted this App. */
+export declare const marketplaceBrowse: CapabilityContract<{
+    list(input: MarketplaceBrowseInput): Promise<MarketplaceBrowseResult>;
+}>;
+/**
+ * Acquire a listing for the mounting Team. Free listings install at once;
+ * paid listings return a hosted Checkout URL and install after payment.
+ * The host re-checks Team authority and entitlement on every call.
+ */
+export declare const marketplacePurchase: CapabilityContract<{
+    acquire(input: Readonly<{
+        listingId: string;
+        requestId: string;
+    }>): Promise<MarketplaceAcquisition>;
+}>;
+/** Anonymous discovery only; acquisition and launch still require Team admission. */
+export declare function browsePublicMarketplace(hubOrigin: string, category: MarketplaceCategory, request?: typeof fetch): Promise<readonly MarketplaceListing[]>;

package/dist/marketplace.js

@@ -0,0 +1,102 @@
+import * as z from "zod";
+import { defineCapability } from "./capabilities.js";
+import { rpcDataSchema, rpcHandleSchema, rpcMethod, } from "./internal/rpc-contract.js";
+import * as Schema from "effect/Schema";
+/** Gallery shelves, in display order. */
+export const marketplaceCategories = [
+    "agents",
+    "creative",
+    "developer",
+    "games",
+    "productivity",
+];
+export const marketplaceCategorySchema = Schema.Literals(marketplaceCategories);
+const text = (maximum) => Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(maximum)));
+export const marketplacePriceSchema = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("free") }),
+    Schema.Struct({
+        kind: Schema.Literal("one-time"),
+        currency: Schema.Literal("usd"),
+        amountMinor: Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+    }),
+]);
+/**
+ * One gallery entry as the viewing Team sees it. `availability` says what
+ * acquiring it means: `included` Apps already ship with every Team,
+ * `coming-soon` entries are not yet installable. `installed` is the Team's
+ * current state, not an authority.
+ */
+export const marketplaceListingSchema = Schema.Struct({
+    listingId: text(128),
+    appId: text(128),
+    name: text(60),
+    tagline: text(140),
+    description: text(4_000),
+    category: marketplaceCategorySchema,
+    icon: Schema.NullOr(text(400_000)),
+    screenshots: Schema.Array(Schema.Struct({ src: text(400_000), alt: text(160) })).pipe(Schema.check(Schema.isMaxLength(6))),
+    price: marketplacePriceSchema,
+    seller: Schema.Union([
+        Schema.Struct({
+            kind: Schema.Literal("platform"),
+            accountId: text(128),
+            name: text(80),
+        }),
+        Schema.Struct({
+            kind: Schema.Literal("creator"),
+            accountId: text(128),
+            name: text(80),
+        }),
+    ]),
+    availability: Schema.Literals(["available", "included", "coming-soon"]),
+    installed: Schema.Boolean,
+    featured: Schema.Boolean,
+});
+export const marketplaceBrowseResultSchema = Schema.Struct({
+    listings: Schema.Array(marketplaceListingSchema).pipe(Schema.check(Schema.isMaxLength(200))),
+    paid: Schema.Boolean,
+});
+/** One catalog family: an ordinary App listing. */
+export const decodeMarketplaceBrowseResult = Schema.decodeUnknownSync(marketplaceBrowseResultSchema);
+export const marketplaceAcquisitionSchema = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("installed"),
+        listingId: text(128),
+        appId: text(128),
+    }),
+    Schema.Struct({ kind: Schema.Literal("included"), listingId: text(128) }),
+    Schema.Struct({
+        kind: Schema.Literal("checkout"),
+        listingId: text(128),
+        url: Schema.String.pipe(Schema.check(Schema.makeFilter((value) => value.startsWith("https://")))),
+    }),
+]);
+/** Read the Marketplace gallery as the Team that mounted this App. */
+export const marketplaceBrowse = defineCapability("marketplace.browse", 1, rpcHandleSchema({
+    list: rpcMethod(rpcDataSchema(z.unknown().transform((value) => decodeMarketplaceBrowseResult(value)))),
+}));
+/**
+ * Acquire a listing for the mounting Team. Free listings install at once;
+ * paid listings return a hosted Checkout URL and install after payment.
+ * The host re-checks Team authority and entitlement on every call.
+ */
+export const marketplacePurchase = defineCapability("marketplace.purchase", 1, rpcHandleSchema({
+    acquire: rpcMethod(rpcDataSchema(z
+        .unknown()
+        .transform((value) => Schema.decodeUnknownSync(marketplaceAcquisitionSchema)(value)))),
+}));
+/** Anonymous discovery only; acquisition and launch still require Team admission. */
+export async function browsePublicMarketplace(hubOrigin, category, request = fetch) {
+    const url = new URL("/api/public/marketplace/listings", hubOrigin);
+    url.searchParams.set("category", category);
+    const response = await request(url, {
+        credentials: "omit",
+        cache: "no-store",
+    });
+    if (!response.ok)
+        throw new Error("Marketplace is unavailable");
+    const page = Schema.decodeUnknownSync(Schema.Struct({
+        listings: Schema.Array(marketplaceListingSchema).pipe(Schema.check(Schema.isMaxLength(48))),
+    }))(await response.json());
+    return page.listings;
+}

package/dist/media-json.d.ts

@@ -0,0 +1,181 @@
+import { type MediaGenerationHandle, type MediaGenerationAttemptHandle, type MediaGenerationReference, type MediaGenerationInput, type MediaGenerationOutcome, type MediaModel } from "./media.js";
+import * as Schema from "effect/Schema";
+declare const RpcTarget: new () => object;
+export { mediaGenerationReferenceSchema } from "./media.js";
+/** Page-local generic JSON method caller. Signals never enter JSON or RPC. */
+export type MediaGenerationJsonCaller = (method: string, input?: Schema.Json, options?: {
+    readonly signal?: AbortSignal;
+}) => Promise<Schema.Json | undefined>;
+/** Plain JSON catalog reply, decoded with Agar's Media model grammar. */
+export declare const mediaGenerationDescriptionSchema: Schema.Struct<{
+    /** Fixed Computer identity supplied by the host. */
+    readonly computerId: Schema.String;
+    /** Whether the admitted host permits generation. */
+    readonly canGenerate: Schema.Boolean;
+    /** Models supplied by the host catalog owner. */
+    readonly models: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly input: Schema.Struct<{
+            readonly defaultHeight: Schema.Number;
+            readonly defaultSteps: Schema.NullOr<Schema.Number>;
+            readonly defaultWidth: Schema.Number;
+            readonly dimensions: Schema.Literals<readonly ["none", "own"]>;
+            readonly maxDimension: Schema.NullOr<Schema.Number>;
+            readonly maxReferences: Schema.Number;
+            readonly maxSteps: Schema.NullOr<Schema.Number>;
+            readonly referenceField: Schema.NullOr<Schema.String>;
+            readonly steps: Schema.Literals<readonly ["steps", "num_steps", "fixed"]>;
+            readonly transport: Schema.Literals<readonly ["json", "multipart"]>;
+        }>;
+        readonly kind: Schema.Literals<readonly ["image", "video"]>;
+        readonly label: Schema.String;
+        readonly tier: Schema.Literals<readonly ["draft", "balanced", "premium", "max"]>;
+        readonly outputFormats: Schema.$Array<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
+        readonly sizes: Schema.NullOr<Schema.$Array<Schema.String>>;
+        readonly video: Schema.NullOr<Schema.Struct<{
+            readonly minSeconds: Schema.Number;
+            readonly maxSeconds: Schema.Number;
+            readonly defaultSeconds: Schema.Number;
+            readonly durations: Schema.$Array<Schema.Number>;
+            readonly provider: Schema.Literals<readonly ["seedance", "veo", "minimax"]>;
+            readonly formats: Schema.$Array<Schema.Struct<{
+                readonly resolution: Schema.Literals<readonly ["480p", "720p", "768p", "1080p", "4k"]>;
+                readonly aspectRatio: Schema.Literals<readonly ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "9:21"]>;
+                readonly width: Schema.Number;
+                readonly height: Schema.Number;
+            }>>;
+            readonly defaultResolution: Schema.Literals<readonly ["480p", "720p", "768p", "1080p", "4k"]>;
+            readonly defaultAspectRatio: Schema.Literals<readonly ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "9:21"]>;
+            readonly defaultGenerateAudio: Schema.NullOr<Schema.Boolean>;
+            readonly maxPromptLength: Schema.Number;
+            readonly referenceRoles: Schema.$Array<Schema.Literals<readonly ["first-frame", "last-frame", "reference"]>>;
+            readonly maxReferenceImages: Schema.Number;
+            readonly referenceResolutions: Schema.$Array<Schema.Literals<readonly ["480p", "720p", "768p", "1080p", "4k"]>>;
+            readonly prices: Schema.$Array<Schema.Struct<{
+                readonly resolution: Schema.Literals<readonly ["480p", "720p", "768p", "1080p", "4k"]>;
+                readonly silentMilliunitsPerSecond: Schema.Number;
+                readonly audioMilliunitsPerSecond: Schema.Number;
+            }>>;
+        }>>;
+    }>>;
+}>;
+/** A generation call carries paths and a replay ID; the host supplies authority. */
+export declare const mediaGenerationJsonRequestSchema: Schema.Struct<{
+    /** Agar-owned image and video selection, including path references. */
+    readonly settings: Schema.Struct<{
+        readonly model: Schema.String;
+        readonly prompt: Schema.String;
+        readonly width: Schema.Number;
+        readonly height: Schema.Number;
+        readonly steps: Schema.optional<Schema.Number>;
+        readonly durationSeconds: Schema.optional<Schema.Number>;
+        readonly resolution: Schema.optional<Schema.Literals<readonly ["480p", "720p", "768p", "1080p", "4k"]>>;
+        readonly aspectRatio: Schema.optional<Schema.Literals<readonly ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "9:21"]>>;
+        readonly generateAudio: Schema.optional<Schema.Boolean>;
+        readonly references: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly role: Schema.optional<Schema.Literals<readonly ["first-frame", "last-frame", "reference"]>>;
+        }>>>;
+    }>;
+    readonly destination: Schema.Struct<{
+        readonly path: Schema.String;
+    }>;
+    /** Canonical replay identity reused for polling and restoration. */
+    readonly requestId: Schema.String;
+}>;
+/** Plain JSON generation input for an admitted capability's generate method. */
+export type MediaGenerationJsonRequest = Schema.Schema.Type<typeof mediaGenerationJsonRequestSchema>;
+/** A typed completion or refusal; no live attempt handles cross this boundary. */
+export declare const mediaGenerationJsonOutcomeSchema: Schema.Union<readonly [Schema.Struct<{
+    /** Completed generation. */
+    readonly kind: Schema.Literal<"succeeded">;
+    /** Retained and saved host result. */
+    readonly result: Schema.Struct<{
+        readonly [Symbol.dispose]: Schema.optional<Schema.Unknown>;
+        readonly bytes: Schema.Number;
+        readonly costMilliunits: Schema.Number;
+        readonly destination: Schema.Struct<{
+            readonly computerId: Schema.String;
+            readonly path: Schema.String;
+        }>;
+        readonly format: Schema.Literals<readonly ["png", "jpeg", "gif", "webp", "mp4"]>;
+        readonly height: Schema.Number;
+        readonly model: Schema.String;
+        readonly width: Schema.Number;
+    }>;
+}>, Schema.Struct<{
+    /** Refused or failed generation. */
+    readonly kind: Schema.Literal<"failed">;
+    /** Sanitized failure with truthful retry semantics. */
+    readonly failure: Schema.Struct<{
+        readonly message: Schema.String;
+        readonly stage: Schema.optional<Schema.Literals<readonly ["admission", "generation-authorization", "settings", "estimate", "billing", "operation", "provider", "normalization", "artifact", "destination-authorization", "destination-write"]>>;
+        readonly code: Schema.Literals<readonly ["CANCELLED", "CAPABILITY_DENIED", "CAPABILITY_REVOKED", "DISCONNECTED", "HOST_FAILURE", "IDENTITY", "INSUFFICIENT_CREDIT", "INVALID_ARGUMENT", "PROTOCOL", "SAFETY_FILTER_REFUSED", "TIMEOUT"]>;
+        readonly retryable: Schema.Boolean;
+    }>;
+}>]>;
+/** Generate may also report Agar's canonical, bounded Pending result. */
+export declare const mediaGenerationJsonReplySchema: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    /** Completed generation. */
+    readonly kind: Schema.Literal<"succeeded">;
+    /** Retained and saved host result. */
+    readonly result: Schema.Struct<{
+        readonly [Symbol.dispose]: Schema.optional<Schema.Unknown>;
+        readonly bytes: Schema.Number;
+        readonly costMilliunits: Schema.Number;
+        readonly destination: Schema.Struct<{
+            readonly computerId: Schema.String;
+            readonly path: Schema.String;
+        }>;
+        readonly format: Schema.Literals<readonly ["png", "jpeg", "gif", "webp", "mp4"]>;
+        readonly height: Schema.Number;
+        readonly model: Schema.String;
+        readonly width: Schema.Number;
+    }>;
+}>, Schema.Struct<{
+    /** Refused or failed generation. */
+    readonly kind: Schema.Literal<"failed">;
+    /** Sanitized failure with truthful retry semantics. */
+    readonly failure: Schema.Struct<{
+        readonly message: Schema.String;
+        readonly stage: Schema.optional<Schema.Literals<readonly ["admission", "generation-authorization", "settings", "estimate", "billing", "operation", "provider", "normalization", "artifact", "destination-authorization", "destination-write"]>>;
+        readonly code: Schema.Literals<readonly ["CANCELLED", "CAPABILITY_DENIED", "CAPABILITY_REVOKED", "DISCONNECTED", "HOST_FAILURE", "IDENTITY", "INSUFFICIENT_CREDIT", "INVALID_ARGUMENT", "PROTOCOL", "SAFETY_FILTER_REFUSED", "TIMEOUT"]>;
+        readonly retryable: Schema.Boolean;
+    }>;
+}>]>, Schema.declare<Readonly<{
+    kind: "pending";
+    retryAfterMs: number;
+}>, unknown>]>;
+/** JSON generation reply, including the shared Pending owner. */
+export type MediaGenerationJsonReply = Schema.Schema.Type<typeof mediaGenerationJsonReplySchema>;
+/** Catalog and permission snapshot for the handle's fixed Computer. */
+export type MediaGenerationDescription = Readonly<{
+    /** Fixed Computer identity. */
+    computerId: string;
+    /** Host-described permission to start generation. */
+    canGenerate: boolean;
+    /** The host's catalog, decoded with Agar's Media wire grammar. */
+    models: readonly MediaModel[];
+}>;
+/** Page-side Agar handle over an admitted generic JSON method caller. */
+export declare class MediaGeneration extends RpcTarget implements MediaGenerationHandle {
+    #private;
+    constructor(call: MediaGenerationJsonCaller, computerId: string, signal?: AbortSignal);
+    /** Describe this handle's fixed Computer through the admitted JSON method. */
+    describe(): Promise<MediaGenerationDescription>;
+    /** Issue a canonical replay identity for a new generation attempt. */
+    createAttempt(): Promise<MediaGenerationAttempt>;
+    /** Resume the original Computer and canonical request without issuing a new ID. */
+    restoreAttempt(reference: MediaGenerationReference): Promise<MediaGenerationAttempt>;
+    /** Abort every active browser request belonging to this attempt. */
+    cancelAttempt(reference: MediaGenerationReference): Promise<void>;
+}
+/** One replayable host-issued Media attempt, sharing cancellation with its handle. */
+export declare class MediaGenerationAttempt extends RpcTarget implements MediaGenerationAttemptHandle {
+    #private;
+    constructor(call: MediaGenerationJsonCaller, computerId: string, signal: AbortSignal | undefined, requestId: string, activeRequests: Map<string, Set<AbortController>>);
+    /** Return the stable Computer and request identity for replay. */
+    reference(): Promise<MediaGenerationReference>;
+    /** Save through the admitted host; poll pending work with the same replay identity. */
+    generate(input: MediaGenerationInput): Promise<MediaGenerationOutcome>;
+}