@fungi.computer/agar 0.1.0 → 0.3.0

package/dist/backend-definition.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import type { GillCall, GillReply } from "@fungi.computer/gills";
+import type { GillCall, GillReply, ResultRow } from "@fungi.computer/gills";
 import type { AppBackendGill } from "./gills.js";
 export type { AppBackendGill } from "./gills.js";
 import { type AppMethodCallContext } from "@fungi.computer/puffball/app-method-runtime";
@@ -10,10 +10,10 @@ export { pending, pendingSchema, type Pending } from "./pending.js";
 /** EVENTS.emit acknowledges delivery with native void, not a JSON value. */
 export declare const appEventEmitResultSchema: z.ZodUndefined;
 /** App-originated Session send refusal; retry advice is a duration, not a timestamp. */
-export declare const appSendBudgetRefusalSchema: z.ZodObject<{
+export declare const appSendBudgetRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodLiteral<"send_budget_exceeded">;
     retryAfterMs: z.ZodNumber;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** A declined Session send, with how long to wait before retrying. */
 export type AppSendBudgetRefusal = z.output<typeof appSendBudgetRefusalSchema>;
 /** A method's schemas own both its TypeScript contract and JSON boundary. */
@@ -27,19 +27,56 @@ export type MethodPolicy = Readonly<{
     anonymous?: true;
     /** Allow the shared Pending result while this method is still working. */
     pending?: true;
+    /** Past tense for timelines ("made", "wrote"); the row itself comes from {@link MethodPresentation}. */
+    present?: Readonly<{
+        verb: string;
+    }>;
+}>;
+/** Decodes and bounds result rows; see `resultRows` in `@fungi.computer/agar/method-presentation`. */
+export type ResultRowCodec = Readonly<{
+    /** Check one projected row against the shared row's bounds; throws when it breaks them. */
+    decode: (row: ResultRow) => ResultRow;
+    /** The row's JSON boundary, as the generated `present` method's output. */
+    schema: z.ZodType;
+}>;
+/**
+ * How a finished call reads to a person: a pure projection run in the App
+ * backend. `rows` is `resultRows` from
+ * `@fungi.computer/agar/method-presentation`; only a backend that presents
+ * imports it, so one without presentations carries no row decoder.
+ */
+export type MethodPresentation<I, O> = Readonly<{
+    /** Past tense for timelines: "made", "wrote", "pushed". */
+    verb: string;
+    /** Pure: one finished call to the row a person reads. */
+    row: (call: Readonly<{
+        input: I;
+        output: O;
+    }>) => ResultRow;
+    /** The shared row codec, `resultRows`. */
+    rows: ResultRowCodec;
 }>;
+/** Name of the generated, hidden read method that projects a finished call into its row. */
+export declare const presentMethodName = "present";
 /** Prepared method export consumed by the backend and its build. */
 export type AppBackendMethod<Context = void> = Readonly<{
     policy: MethodPolicy;
     input: z.ZodType;
     output: z.ZodType;
+    /** Parse a recorded call against this method's schemas and project its row. */
+    present?: (input: WhistleJsonValue, output: WhistleJsonValue) => ResultRow;
+    /** The row's JSON boundary, present exactly when `present` is. */
+    presentRow?: z.ZodType;
     /** Parse the raw input, run the handler, and return its JSON result. */
     call: (input: WhistleJsonValue, context: Context, caller: AppMethodCallContext) => Promise<WhistleJsonValue>;
 }>;
+/** The prepared methods of one backend, keyed by their public names. */
+export type AppBackendMethods<Context = void> = Readonly<Record<string, AppBackendMethod<Context>>>;
 /** Define a typed method once; neither discovery nor builds execute its handler. */
-export declare function defineAppMethod<I extends z.ZodType, O extends z.ZodType, Context = void>(method: MethodPolicy & {
+export declare function defineAppMethod<I extends z.ZodType, O extends z.ZodType, Context = void>(method: Omit<MethodPolicy, "present"> & {
     input: I;
     output: O;
+    present?: MethodPresentation<z.output<I>, z.output<O>>;
 } & ({
     pending: true;
     handler: (input: z.output<I>, context: Context, caller: AppMethodCallContext) => z.input<O> | Pending | Promise<z.input<O> | Pending>;

package/dist/backend-definition.js

@@ -6,10 +6,12 @@ export { pending, pendingSchema } from "./pending.js";
 /** EVENTS.emit acknowledges delivery with native void, not a JSON value. */
 export const appEventEmitResultSchema = z.undefined();
 /** App-originated Session send refusal; retry advice is a duration, not a timestamp. */
-export const appSendBudgetRefusalSchema = z.strictObject({
+export const appSendBudgetRefusalSchema = z.lazy(() => z.strictObject({
     error: z.literal("send_budget_exceeded"),
     retryAfterMs: z.number().int().min(1).max(60_000),
-});
+}));
+/** Name of the generated, hidden read method that projects a finished call into its row. */
+export const presentMethodName = "present";
 /** Define a typed method once; neither discovery nor builds execute its handler. */
 export function defineAppMethod(method) {
     const output = method.pending === true
@@ -26,16 +28,31 @@ export function defineAppMethod(method) {
         policy = { ...policy, hidden: true };
     if (method.anonymous === true)
         policy = { ...policy, anonymous: true };
+    const call = async (rawInput, context, rawCaller) => {
+        const caller = parseAppMethodCallContext(rawCaller);
+        const parsed = method.input.parse(rawInput);
+        const result = await method.handler(parsed, context, caller);
+        return z.json().parse(output.parse(result));
+    };
+    const presentation = method.present;
+    if (presentation === undefined)
+        return Object.freeze({
+            policy: Object.freeze(policy),
+            input: method.input,
+            output,
+            call,
+        });
+    policy = { ...policy, present: Object.freeze({ verb: presentation.verb }) };
     return Object.freeze({
         policy: Object.freeze(policy),
         input: method.input,
         output,
-        call: async (rawInput, context, rawCaller) => {
-            const caller = parseAppMethodCallContext(rawCaller);
-            const parsed = method.input.parse(rawInput);
-            const result = await method.handler(parsed, context, caller);
-            return z.json().parse(output.parse(result));
-        },
+        present: (rawInput, rawOutput) => presentation.rows.decode(presentation.row({
+            input: method.input.parse(rawInput),
+            output: method.output.parse(rawOutput),
+        })),
+        presentRow: presentation.rows.schema,
+        call,
     });
 }
 /** The generated method RPC answers with a typed reply: a handler's
@@ -54,9 +71,52 @@ async function methodReply(run) {
         });
     }
 }
+const presentInput = z.strictObject({
+    method: z.string().min(1).max(80),
+    input: z.json(),
+    output: z.json(),
+});
+const generatedPresentMethods = new WeakSet();
+/**
+ * Methods that declare a presentation share one generated, hidden read method
+ * that projects a recorded call into its row, so hosts reach it through the
+ * ordinary method admission instead of a second invocation path.
+ */
+function withPresentation(all) {
+    // A backend rebuilt from another definition's methods regenerates its own.
+    const methods = Object.fromEntries(Object.entries(all).filter(([name, method]) => name !== presentMethodName || !generatedPresentMethods.has(method)));
+    const presenting = new Map(Object.entries(methods).filter(([, method]) => method.present !== undefined));
+    const presentRow = [...presenting.values()][0]?.presentRow;
+    if (presentRow === undefined)
+        return methods;
+    if (Object.hasOwn(methods, presentMethodName))
+        throw new Error(`App backend method is reserved: ${presentMethodName}`);
+    const present = Object.freeze({
+        policy: Object.freeze({
+            description: "Project one finished call of a presenting method into its result row.",
+            effect: "read",
+            requires: Object.freeze([]),
+            hidden: true,
+        }),
+        input: presentInput,
+        output: presentRow,
+        call: (rawInput) => Promise.resolve().then(() => {
+            const request = presentInput.parse(rawInput);
+            const row = presenting
+                .get(request.method)
+                ?.present?.(request.input, request.output);
+            if (row === undefined)
+                throw new Error(`Undeclared App presentation: ${request.method}`);
+            return z.json().parse(presentRow.parse(row));
+        }),
+    });
+    generatedPresentMethods.add(present);
+    return { ...methods, [presentMethodName]: present };
+}
 /** Generate the API from the method exports; callers cannot supply a second catalog. */
 export function defineAppBackend(options) {
-    const methods = new Map(Object.entries(options.methods));
+    const declared = withPresentation(options.methods);
+    const methods = new Map(Object.entries(declared));
     for (const name of methods.keys())
         if (!isAppApiMethodName(name))
             throw new Error(`Invalid App backend method name: ${name}`);
@@ -97,7 +157,7 @@ export function defineAppBackend(options) {
         });
     };
     let definition = {
-        methods: Object.freeze({ ...options.methods }),
+        methods: Object.freeze({ ...declared }),
         implement: (implementation) => {
             const members = new Map();
             let prototype = implementation.prototype;

package/dist/backend-refusal.d.ts

@@ -3,6 +3,7 @@ import * as z from "zod";
 export declare const appBackendRefusalSchema: z.ZodObject<{
     error: z.ZodLiteral<"App execution unavailable">;
     reason: z.ZodEnum<{
+        disabled: "disabled";
         exec_isolation_required: "exec_isolation_required";
         execution_not_admitted: "execution_not_admitted";
         artifact_unavailable: "artifact_unavailable";

package/dist/backend-refusal.js

@@ -6,5 +6,6 @@ export const appBackendRefusalSchema = z.strictObject({
         "exec_isolation_required",
         "execution_not_admitted",
         "artifact_unavailable",
+        "disabled",
     ]),
 });

package/dist/backend.js

@@ -3,18 +3,18 @@ import { defineCapability } from "./capabilities.js";
 import { parseJsonValue } from "@fungi.computer/whistle/wire";
 import { rpcDataSchema, rpcHandleSchema, rpcMethod, } from "./internal/rpc-contract.js";
 /** Invoke this App's admitted backend. The App defines its JSON request/result. */
-export const appBackend = defineCapability("app.backend", 1, rpcHandleSchema({
+export const appBackend = defineCapability("app.backend", 1, z.lazy(() => rpcHandleSchema({
     request: rpcMethod(rpcDataSchema(z.unknown().transform((value) => parseJsonValue(value)))),
-}));
+})));
 /**
  * Call one of this App's declared, typed methods through its host. Unlike
  * `appBackend`, the host knows which method is called, so it can apply the
  * method's declared effect (for example, allow only `read` methods to a
  * visitor of a public App).
  */
-export const appMethods = defineCapability("app.methods", 1, rpcHandleSchema({
+export const appMethods = defineCapability("app.methods", 1, z.lazy(() => rpcHandleSchema({
     call: rpcMethod(rpcDataSchema(z.unknown().transform((value) => parseJsonValue(value)))),
-}));
+})));
 /** The admitting host overwrites this header from its authenticated principal.
  * App request bodies and incoming browser headers never supply this identity. */
 export const appBackendActorHeader = "X-Agar-Actor-Id";

package/dist/channels.js

@@ -84,14 +84,14 @@ export const appWebsiteReplyResponseSchema = z.strictObject({
     status: z.literal("sent"),
 });
 /** Reading website conversations is never an automatic default-App grant. */
-export const channelsRead = defineCapability("channels.read", 1, rpcHandleSchema({
+export const channelsRead = defineCapability("channels.read", 1, z.lazy(() => rpcHandleSchema({
     list: rpcMethod(rpcDataSchema(appWebsitePageSchema)),
     conversations: rpcMethod(rpcDataSchema(appWebsiteConversationPageSchema)),
-}));
+})));
 /** Member-only takeover; separate consent from read-only channel access. */
-export const channelsPersonalManage = defineCapability("channels.personal.manage", 1, rpcHandleSchema({
+export const channelsPersonalManage = defineCapability("channels.personal.manage", 1, z.lazy(() => rpcHandleSchema({
     hold: rpcMethod(rpcDataSchema(appWebsiteConversationSchema)),
     release: rpcMethod(rpcDataSchema(appWebsiteConversationSchema)),
     dismiss: rpcMethod(rpcDataSchema(appWebsiteConversationSchema)),
     reply: rpcMethod(rpcDataSchema(appWebsiteReplyResponseSchema)),
-}));
+})));

package/dist/computer-contracts.d.ts

@@ -1,13 +1,4 @@
 import * as z from "zod";
-/** Public metadata for one host-admitted Workflow Git pass; parsing never grants authority. */
-export declare const workflowGitPassResultSchema: z.ZodObject<{
-    passId: z.ZodString;
-    remote: z.ZodURL;
-    expiresAt: z.ZodNumber;
-    bearer: z.ZodExactOptional<z.ZodString>;
-}, z.core.$strict>;
-/** The complete remote stays opaque; the host owns admission, renewal and revocation. */
-export type WorkflowGitPassResult = z.output<typeof workflowGitPassResultSchema>;
 /** Existing attachment budget operation kinds shared by Computer and Media. */
 export declare const connectorOperationBudgetKindSchema: z.ZodEnum<{
     write: "write";
@@ -15,7 +6,7 @@ export declare const connectorOperationBudgetKindSchema: z.ZodEnum<{
     exec: "exec";
 }>;
 /** Existing owner budget refusal; it remains a domain result, not a wire envelope. */
-export declare const connectorOperationBudgetRefusalSchema: z.ZodObject<{
+export declare const connectorOperationBudgetRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodLiteral<"attachment_budget_exceeded">;
     kind: z.ZodEnum<{
         write: "write";
@@ -23,16 +14,16 @@ export declare const connectorOperationBudgetRefusalSchema: z.ZodObject<{
         exec: "exec";
     }>;
     retryAfterMs: z.ZodNumber;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Computer admission refusals returned before native dispatch. */
-export declare const appComputerAdmissionRefusalSchema: z.ZodUnion<readonly [z.ZodObject<{
+export declare const appComputerAdmissionRefusalSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
     error: z.ZodEnum<{
         unavailable: "unavailable";
         revoked: "revoked";
         not_granted: "not_granted";
         grantor_lost_authority: "grantor_lost_authority";
     }>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strict>, z.ZodLazy<z.ZodObject<{
     error: z.ZodLiteral<"attachment_budget_exceeded">;
     kind: z.ZodEnum<{
         write: "write";
@@ -40,34 +31,26 @@ export declare const appComputerAdmissionRefusalSchema: z.ZodUnion<readonly [z.Z
         exec: "exec";
     }>;
     retryAfterMs: z.ZodNumber;
-}, z.core.$strict>]>;
+}, z.core.$strict>>]>>;
 /** Existing Computer broker argument refusals. */
-export declare const appComputerInputRefusalSchema: z.ZodObject<{
+export declare const appComputerInputRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodEnum<{
         invalid: "invalid";
         too_large: "too_large";
         invalid_path: "invalid_path";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Existing Computer dispatch status/decoding refusals. */
-export declare const appComputerDispatchRefusalSchema: z.ZodObject<{
+export declare const appComputerDispatchRefusalSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodEnum<{
         unavailable: "unavailable";
         conflict: "conflict";
         not_granted: "not_granted";
         too_large: "too_large";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** An execution wait can time out while its durable request remains identifiable. */
-export declare const appComputerExecTimeoutSchema: z.ZodObject<{
+export declare const appComputerExecTimeoutSchema: z.ZodLazy<z.ZodObject<{
     error: z.ZodLiteral<"timeout">;
     requestId: z.ZodString;
-}, z.core.$strict>;
-/** The Workflow Git-pass owner has exactly these existing domain refusals. */
-export declare const workflowGitPassRefusalSchema: z.ZodObject<{
-    error: z.ZodEnum<{
-        unavailable: "unavailable";
-        revoked: "revoked";
-        not_granted: "not_granted";
-    }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;

package/dist/computer-contracts.js

@@ -1,19 +1,4 @@
 import * as z from "zod";
-/** Public metadata for one host-admitted Workflow Git pass; parsing never grants authority. */
-export const workflowGitPassResultSchema = z.strictObject({
-    passId: z.string().min(1),
-    remote: z.url({ protocol: /^https$/, abort: true }).refine((value) => {
-        const remote = new URL(value);
-        return remote.username === "" && remote.password === "";
-    }, "Workflow Git remotes must not contain credentials"),
-    expiresAt: z.number().int().positive(),
-    /**
-     * Present when the host admits this pass by `Authorization: Bearer` on the
-     * remote. It is never part of the remote; a command receives it only as
-     * command-local Git config, never written to a repository config.
-     */
-    bearer: z.string().min(1).exactOptional(),
-});
 /** Existing attachment budget operation kinds shared by Computer and Media. */
 export const connectorOperationBudgetKindSchema = z.enum([
     "exec",
@@ -21,13 +6,13 @@ export const connectorOperationBudgetKindSchema = z.enum([
     "media",
 ]);
 /** Existing owner budget refusal; it remains a domain result, not a wire envelope. */
-export const connectorOperationBudgetRefusalSchema = z.strictObject({
+export const connectorOperationBudgetRefusalSchema = z.lazy(() => z.strictObject({
     error: z.literal("attachment_budget_exceeded"),
     kind: connectorOperationBudgetKindSchema,
     retryAfterMs: z.number(),
-});
+}));
 /** Computer admission refusals returned before native dispatch. */
-export const appComputerAdmissionRefusalSchema = z.union([
+export const appComputerAdmissionRefusalSchema = z.lazy(() => z.union([
     z.strictObject({
         error: z.enum([
             "revoked",
@@ -37,21 +22,17 @@ export const appComputerAdmissionRefusalSchema = z.union([
         ]),
     }),
     connectorOperationBudgetRefusalSchema,
-]);
+]));
 /** Existing Computer broker argument refusals. */
-export const appComputerInputRefusalSchema = z.strictObject({
+export const appComputerInputRefusalSchema = z.lazy(() => z.strictObject({
     error: z.enum(["too_large", "invalid_path", "invalid"]),
-});
+}));
 /** Existing Computer dispatch status/decoding refusals. */
-export const appComputerDispatchRefusalSchema = z.strictObject({
+export const appComputerDispatchRefusalSchema = z.lazy(() => z.strictObject({
     error: z.enum(["not_granted", "too_large", "conflict", "unavailable"]),
-});
+}));
 /** An execution wait can time out while its durable request remains identifiable. */
-export const appComputerExecTimeoutSchema = z.strictObject({
+export const appComputerExecTimeoutSchema = z.lazy(() => z.strictObject({
     error: z.literal("timeout"),
     requestId: z.string(),
-});
-/** The Workflow Git-pass owner has exactly these existing domain refusals. */
-export const workflowGitPassRefusalSchema = z.strictObject({
-    error: z.enum(["revoked", "not_granted", "unavailable"]),
-});
+}));

package/dist/computer.js

@@ -15,11 +15,11 @@ export const computerListingSchema = Schema.Struct({
     })),
     nextOffset: Schema.NullOr(Schema.Number),
 });
-export const computerList = defineCapability("computer.list", 1, rpcHandleSchema({
+export const computerList = defineCapability("computer.list", 1, z.lazy(() => rpcHandleSchema({
     list: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerListingSchema)(value)))),
-}));
+})));
 export const computerRuntimeStateSchema = Schema.Union([
     Schema.Struct({
         state: Schema.Literals(["running", "sleeping", "starting"]),
@@ -50,12 +50,12 @@ export const computerInstrumentSnapshotSchema = Schema.Struct({
     })),
     internet: computerInternetAccessSchema,
 });
-export const computerInstrumentRead = defineCapability("computer.instrument.read", 1, rpcHandleSchema({
+export const computerInstrumentRead = defineCapability("computer.instrument.read", 1, z.lazy(() => rpcHandleSchema({
     read: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerInstrumentSnapshotSchema)(value)))),
-}));
-export const computerInstrumentControl = defineCapability("computer.instrument.control", 1, rpcHandleSchema({
+})));
+export const computerInstrumentControl = defineCapability("computer.instrument.control", 1, z.lazy(() => rpcHandleSchema({
     start: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerRuntimeStateSchema)(value)))),
@@ -65,7 +65,7 @@ export const computerInstrumentControl = defineCapability("computer.instrument.c
     detachLocal: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(Schema.Struct({ detached: Schema.Boolean }))(value)))),
-}));
+})));
 export async function readComputerInstrument(capabilities) {
     return Schema.decodeUnknownSync(computerInstrumentSnapshotSchema)(await capabilities.require(computerInstrumentRead).read());
 }
@@ -106,7 +106,7 @@ export const computerPortRemovalSchema = Schema.Struct({
     removed: Schema.Boolean,
 });
 /** The selected Computer's admitted preview URLs and port mutations. */
-export const computerPorts = defineCapability("computer.ports", 2, rpcHandleSchema({
+export const computerPorts = defineCapability("computer.ports", 2, z.lazy(() => rpcHandleSchema({
     list: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerPortsResultSchema)(value)))),
@@ -116,7 +116,7 @@ export const computerPorts = defineCapability("computer.ports", 2, rpcHandleSche
     unexpose: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerPortRemovalSchema)(value)))),
-}));
+})));
 /** Decode exposed ports at the SDK boundary. */
 export async function listComputerPorts(capabilities) {
     const result = Schema.decodeUnknownSync(computerPortsResultSchema)(await capabilities.require(computerPorts).list());
@@ -178,7 +178,7 @@ export const computerProcessStartSchema = Schema.Struct({
     port: Schema.optionalKey(computerPortExposureSchema.fields.port),
 });
 /** Read the authoritative process inventory from the selected Computer. */
-export const computerProcesses = defineCapability("computer.processes", 1, rpcHandleSchema({
+export const computerProcesses = defineCapability("computer.processes", 1, z.lazy(() => rpcHandleSchema({
     start: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerProcessSchema)(value)))),
@@ -188,7 +188,7 @@ export const computerProcesses = defineCapability("computer.processes", 1, rpcHa
     kill: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerProcessKillSchema)(value)))),
-}));
+})));
 /** Decode the Computer owner's process inventory at the App boundary. */
 export async function listComputerProcesses(capabilities) {
     return Schema.decodeUnknownSync(computerProcessesSchema)(await capabilities.require(computerProcesses).list());
@@ -197,12 +197,12 @@ export async function listComputerProcesses(capabilities) {
 export async function killComputerProcess(capabilities, id) {
     return Schema.decodeUnknownSync(computerProcessKillSchema)(await capabilities.require(computerProcesses).kill(id));
 }
-export const computerReadFile = defineCapability("computer.readFile", 1, rpcHandleSchema({
+export const computerReadFile = defineCapability("computer.readFile", 1, z.lazy(() => rpcHandleSchema({
     open: rpcMethod(rpcHandleSchema({
         response: rpcMethod(z.instanceof(Response)),
         close: rpcVoid,
     })),
-}));
+})));
 /** The caller receives native file bytes; HTTP details stay in the SDK adapter. */
 export async function readComputerFile(capabilities, input, options) {
     return await readAppFile(await capabilities.require(computerReadFile).open(input), { ...options, name: input.path.split("/").at(-1) ?? "file" });
@@ -211,13 +211,13 @@ export async function readComputerFile(capabilities, input, options) {
 export async function listComputerFiles(capabilities, input) {
     return Schema.decodeUnknownSync(computerListingSchema)(await capabilities.require(computerList).list(input));
 }
-export const computerWriteFile = defineCapability("computer.writeFile", 3, rpcHandleSchema({
+export const computerWriteFile = defineCapability("computer.writeFile", 3, z.lazy(() => rpcHandleSchema({
     open: rpcMethod(rpcHandleSchema({ write: rpcVoid, close: rpcVoid })),
     mkdir: rpcVoid,
     replace: rpcMethod(rpcDataSchema(z
         .unknown()
         .transform((value) => Schema.decodeUnknownSync(computerFileReplacementOutcomeSchema)(value)))),
-}));
+})));
 const computerFileReplacementOutcomeSchema = Schema.Union([
     Schema.Struct({
         kind: Schema.Literal("replaced"),
@@ -244,7 +244,7 @@ export const computerTerminalInformationSchema = Schema.Struct({
     uptimeSeconds: Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0))),
     version: Schema.NonEmptyString.pipe(Schema.check(Schema.isMaxLength(64))),
 });
-export const computerTerminal = defineCapability("computer.terminal", 2, rpcHandleSchema({
+export const computerTerminal = defineCapability("computer.terminal", 2, z.lazy(() => rpcHandleSchema({
     open: rpcMethod(rpcHandleSchema({
         information: rpcMethod(rpcDataSchema(z
             .unknown()
@@ -258,7 +258,7 @@ export const computerTerminal = defineCapability("computer.terminal", 2, rpcHand
         resize: rpcVoid,
         close: rpcVoid,
     })),
-}));
+})));
 /** Open one host-owned terminal and bind its lifetime to the mounted App. */
 export async function openComputerTerminal(capabilities, size, options = {}) {
     options.signal?.throwIfAborted();

package/dist/connect.d.ts

@@ -1,9 +1,9 @@
 import type { AppRoot } from "./root.js";
 /** Options for connecting this iframe page to its authenticated host. */
 export type ConnectAppOptions = {
-    /** The origin the host handshake message must come from; the connection
-     * is refused when it comes from anywhere else. */
-    readonly expectedHostOrigin: string;
+    /** The parent is the host. Serve the App with CSP `frame-ancestors` pinned
+     * to its allowed host so an unrelated site cannot become its parent. */
+    readonly host: "parent";
     /** Cancels a pending connection attempt. */
     readonly signal?: AbortSignal;
 };

package/dist/connect.js

@@ -14,28 +14,23 @@ let liveConnection = false;
 class PendingAppConnection {
     options;
     #appWindow;
-    #origin;
     #port;
     #settled = false;
     #readyRetry;
     #deadline;
     constructor(options) {
         this.options = options;
-        this.#origin = expectedOrigin(options.expectedHostOrigin);
         this.#appWindow = globalThis.window;
     }
     start() {
         performance.mark("fungi.app-open.agar-connect-start");
-        const origin = this.#origin;
-        if (!origin)
-            return Promise.reject(invalidOrigin());
         const error = this.#startError();
         if (error)
             return Promise.reject(error);
         liveConnection = true;
-        return this.#awaitConnection(origin);
+        return this.#awaitConnection();
     }
-    #awaitConnection(origin) {
+    #awaitConnection() {
         return new Promise((resolve, reject) => {
             const finish = (error, root) => {
                 this.#finish(error, root, onMessage, onAbort, resolve, reject);
@@ -44,14 +39,14 @@ class PendingAppConnection {
                 finish(cancelled());
             };
             const onMessage = (event) => {
-                this.#onMessage(event, origin, finish, onMessage);
+                this.#onMessage(event, finish, onMessage);
             };
             this.#appWindow.addEventListener("message", onMessage);
             this.options.signal?.addEventListener("abort", onAbort, { once: true });
             const notify = () => {
                 try {
                     performance.mark("fungi.app-open.agar-ready-sent");
-                    this.#appWindow.parent.postMessage({ protocolVersion: APP_PROTOCOL_VERSION, type: APP_READY_TYPE }, origin);
+                    this.#appWindow.parent.postMessage({ protocolVersion: APP_PROTOCOL_VERSION, type: APP_READY_TYPE }, "*");
                 }
                 catch (cause) {
                     reportCatchFailure("connect.notify-host", cause);
@@ -82,11 +77,12 @@ class PendingAppConnection {
         }
         resolve(root);
     }
-    #onMessage(event, origin, finish, onMessage) {
+    #onMessage(event, finish, onMessage) {
         if (!isConnectMessage(event.data))
             return;
         performance.mark("fungi.app-open.agar-connect-received");
-        if (event.source !== this.#appWindow.parent || event.origin !== origin) {
+        if (event.source !== this.#appWindow.parent ||
+            expectedOrigin(event.origin) === undefined) {
             finish(identityError());
             return;
         }
@@ -176,12 +172,6 @@ function identityError() {
         retryable: false,
     });
 }
-function invalidOrigin() {
-    return new AppError("expectedHostOrigin must be an origin", {
-        code: "INVALID_ARGUMENT",
-        retryable: false,
-    });
-}
 const isConnectMessage = Schema.is(Schema.Struct({ type: Schema.Literal(APP_CONNECT_TYPE) }));
 function notifyError(cause) {
     return new AppError("Unable to notify the app host", {