@fungi.computer/agar 0.2.0 → 0.3.1

package/README.md

@@ -1,9 +1,8 @@
 # Agar (`@fungi.computer/agar`)
 
 Agar defines typed App backends and host capabilities. Most people want
-[Oyster](https://docs.fungi.computer/reference/packages/#oyster) to run Apps or
-[Shiitake](https://docs.fungi.computer/reference/packages/#shiitake) to run
-Agents.
+[Oyster](https://docs.fungi.computer/oyster/) to run Apps or
+[Shiitake](https://docs.fungi.computer/shiitake/) to run Agents.
 
 Agar is the App contract for fungi.computer. It defines an App's typed backend
 methods, connects its frontend to a host through typed capabilities, and gives
@@ -336,10 +335,15 @@ the declared methods separately.
 
 ## Connect and release
 
-connectApp takes an exact `expectedHostOrigin` and optional abort signal. It
-checks the parent window, origin, protocol and transferred port before returning
-an AppRoot. It permits one live connection per frontend page. Do not use a
-wildcard origin or a stranger-controlled query parameter as the expected host.
+`connectApp({ host: "parent", signal })` discovers the host through the existing
+parent handshake, without reading a referrer or accepting an origin parameter.
+Serve the App document with CSP `frame-ancestors` pinned to its allowed host.
+The browser checks the entire ancestor chain; without that policy an unrelated
+site embedding the App could become its host. Hub and Oyster supply this policy
+on their App document routes. Only the public, secret-free ready announcement
+uses `"*"`; connection acceptance checks the actual parent Window, its
+non-opaque origin, protocol and single transferred port before returning an
+AppRoot. It permits one live connection per frontend page.
 
 The root supplies:
 
@@ -557,14 +561,18 @@ const dispose = mountApp(root, { name: "Bazaar" }, ({ app }) => (
 import.meta.hot?.dispose(dispose);
 ```
 
-`mountApp` authenticates the iframe host using the parsed referrer origin,
-applies and subscribes to its theme, and restores the original theme on
+`mountApp` discovers its actual parent through Agar's existing handshake,
+independently of referrer policy. The parent must have a non-opaque origin and
+transfer exactly one port for the validated epoch. Top-level launches remain
+standalone; embedded pages without a valid handshake report `not-hosted` with an
+`AppError` and a visible alert rather than silently becoming standalone. It
+applies and subscribes to the host's theme, and restores the original theme on
 disconnect or unmount. Its render callback receives `connecting`, `live`,
-`standalone` (no host or usable referrer), or `ended` (failed/closed
-connection). Only `live` carries an AppRoot. The returned disposer aborts a
-pending handshake, releases subscriptions, disposes the connection and unmounts
-React. A late connection is disposed too. Existing App-open React performance
-marks are emitted at root render and commits.
+`standalone` (a top-level launch), `not-hosted` (an initial connection failure),
+or `ended` (a closed live connection). Only `live` carries an AppRoot. The
+returned disposer aborts a pending handshake, releases subscriptions, disposes
+the connection and unmounts React. A late connection is disposed too. Existing
+App-open React performance marks are emitted at root render and commits.
 
 Supply `queryClient` to wrap the App in `QueryClientProvider`. The caller owns
 that client, its cache policy and grant invalidation; mounting does not clear
@@ -751,6 +759,13 @@ The exported `mediaGenerationDescriptionSchema`,
 `mediaGenerationJsonReplySchema` and `mediaGenerationReferenceSchema` decode
 these boundaries with the existing Agar Media grammar.
 
+Failures may include safe `provider` facts: an allowlisted category and bounded
+code, or `result_download` and an HTTP status. JSON, RPC and
+`MediaGenerationError.provider` preserve the same facts and retry truth.
+`./errors` exposes declaration-safe diagnostic types and decoder helpers; one
+internal Effect schema owns validation. Private provider messages, bodies, URLs
+and causes are not diagnostic fields and are rejected at this boundary.
+
 Attempts retain their canonical request ID when restored or when polling
 Pending. The shared Agar Pending validator requires an integer `retryAfterMs`
 from 1000 to 60000. Cancellation aborts the attempt's active local requests;
@@ -761,7 +776,8 @@ the platform DOM types and `ESNext.Disposable`.
 See the [generated API](docs/api/README.md) for signatures and host ports.
 
 `@fungi.computer/agar/computer-contracts` is the runtime-neutral public home for
-`workflowGitPassResultSchema` and `WorkflowGitPassResult`. App backend
-definitions can validate host-issued Workflow pass metadata without importing
-the Computer RPC client. The parser preserves the complete credential-free HTTPS
-remote; admission, expiry and revocation remain host authority.
+Computer admission, input, dispatch, timeout and attachment-budget outcomes. App
+backend definitions can validate these outcomes without importing the Computer
+RPC client. Apps request ordinary Computer execution; Workflow Git credential
+issuance, carriage, renewal and revocation stay inside the trusted host and
+native execution boundary, not the App contract.

package/dist/agent-message-meta.d.ts

@@ -3,6 +3,7 @@ import * as z from "zod";
 export declare const FungiAuthorSchema: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
+    kind: z.ZodOptional<z.ZodLiteral<"agent">>;
 }, z.core.$strict>>;
 /** Who a Session line came from, as the admitting host authenticated them. */
 export type FungiAuthor = z.infer<typeof FungiAuthorSchema>;
@@ -34,7 +35,9 @@ export declare const FungiMessageMetaSchema: z.ZodObject<{
     author: z.ZodOptional<z.ZodLazy<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
+        kind: z.ZodOptional<z.ZodLiteral<"agent">>;
     }, z.core.$strict>>>;
+    sourceRequestId: z.ZodOptional<z.ZodLazy<z.ZodString>>;
     delegation: z.ZodOptional<z.ZodObject<{
         ancestors: z.ZodArray<z.ZodLazy<z.ZodString>>;
         maxDepth: z.ZodNumber;
@@ -68,7 +71,9 @@ export declare function messageAuthor(meta: MessageMetaValue | undefined): Fungi
 export declare function messageDelegationReply(meta: MessageMetaValue | undefined): FungiDelegationReply | undefined;
 /** The metadata the host attaches for one authenticated author, as JSON. */
 export type AuthorMeta = Readonly<{
-    author: Readonly<FungiAuthor>;
+    author: Readonly<{
+        [K in keyof FungiAuthor]: Exclude<FungiAuthor[K], undefined>;
+    }>;
 }>;
 /** The metadata the host attaches for one authenticated author. */
 export declare function authorMeta(author: FungiAuthor): AuthorMeta;

package/dist/agent-message-meta.js

@@ -3,6 +3,12 @@ import * as z from "zod";
 export const FungiAuthorSchema = z.lazy(() => z.strictObject({
     id: z.string().min(1).max(256),
     name: z.string().min(1).max(128),
+    /**
+     * Present only when the author is another Agent the host admitted a
+     * delegated send or reply from; a line's text never sets it. Human
+     * authors carry no kind.
+     */
+    kind: z.literal("agent").optional(),
 }));
 const identifier = z.lazy(() => z.string().min(1).max(256));
 /**
@@ -31,6 +37,8 @@ export const FungiDelegationReplySchema = z.lazy(() => z.strictObject({
  */
 export const FungiMessageMetaSchema = z.strictObject({
     author: FungiAuthorSchema.optional(),
+    /** Original caller identity when the host translates its request into an owner key. */
+    sourceRequestId: identifier.optional(),
     /** Host-admitted delegation path and its inherited abuse bound. */
     delegation: z
         .strictObject({
@@ -59,5 +67,8 @@ export function messageDelegationReply(meta) {
 }
 /** The metadata the host attaches for one authenticated author. */
 export function authorMeta(author) {
-    return { author: { id: author.id, name: author.name } };
+    const { id, name, kind } = author;
+    return kind === undefined
+        ? { author: { id, name } }
+        : { author: { id, name, kind } };
 }

package/dist/approvals.d.ts

@@ -0,0 +1,5 @@
+import { type Approvals } from "@fungi.computer/approvals";
+import { type CapabilityContract } from "./capabilities.js";
+export type { Approvals } from "@fungi.computer/approvals";
+/** Member-bound approval view. Authentication and current rights belong to the host. */
+export declare const approvals: CapabilityContract<Approvals>;

package/dist/approvals.js

@@ -0,0 +1,36 @@
+import * as Schema from "effect/Schema";
+import * as z from "zod";
+import { ApprovalViewSchema, ApprovalRefusalReasonSchema, AutoApproveInputSchema, } from "@fungi.computer/approvals";
+import { defineCapability } from "./capabilities.js";
+import { rpcDataSchema, rpcHandleSchema, rpcMethod, } from "./internal/rpc-contract.js";
+const refusal = Schema.Struct({
+    kind: Schema.Literal("refused"),
+    reason: ApprovalRefusalReasonSchema,
+});
+const page = Schema.Struct({
+    items: Schema.Array(ApprovalViewSchema),
+    nextCursor: Schema.NullOr(Schema.String),
+});
+const answer = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("answered"), view: ApprovalViewSchema }),
+    refusal,
+]);
+const policy = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("updated"),
+        rule: AutoApproveInputSchema,
+    }),
+    refusal,
+]);
+// Match the existing storage/Agent capability adapters: the maintained RPC
+// helpers bind native stub receivers, decode data and release result envelopes.
+const data = (schema) => rpcDataSchema(z
+    .unknown()
+    .transform((value) => Schema.decodeUnknownSync(schema, { onExcessProperty: "error" })(value)));
+/** Member-bound approval view. Authentication and current rights belong to the host. */
+export const approvals = defineCapability("approvals", 1, z.lazy(() => rpcHandleSchema({
+    list: rpcMethod(data(page)),
+    get: rpcMethod(data(Schema.NullOr(ApprovalViewSchema))),
+    answer: rpcMethod(data(answer)),
+    setAutoApprove: rpcMethod(data(policy)),
+})));

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/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.ZodLazy<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";
@@ -63,11 +54,3 @@ 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.ZodLazy<z.ZodObject<{
-    error: z.ZodEnum<{
-        unavailable: "unavailable";
-        revoked: "revoked";
-        not_granted: "not_granted";
-    }>;
-}, 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.lazy(() => 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",
@@ -51,7 +36,3 @@ 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.lazy(() => z.strictObject({
-    error: z.enum(["revoked", "not_granted", "unavailable"]),
-}));

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", {

package/dist/errors.d.ts

@@ -1,6 +1,44 @@
+import * as z from "zod";
+/** Declaration-safe projection of the canonical Media diagnostic grammar. */
+export type MediaProviderDiagnostic = Readonly<{
+    /** Allowlisted Workers AI category; never a provider message. */
+    category: "InferenceUpstreamError" | "AiInternalError" | "TypeError" | "AbortError" | "TimeoutError" | "Error";
+    /** Four- or five-digit provider prefix, or null when absent. */
+    code: number | null;
+}> | Readonly<{
+    /** A completed video result could not be downloaded. */
+    category: "result_download";
+    /** Native Response status, including zero. */
+    status: number;
+}>;
+/** Decode only safe provider facts, rejecting unmodeled private fields. */
+export declare function decodeMediaProviderDiagnostic(input: unknown): MediaProviderDiagnostic;
+/**
+ * Documentable wire projection of the canonical diagnostic grammar.
+ * Maintained converters preserve its closed objects and numeric bounds;
+ * decoding still returns the declaration-safe public diagnostic type.
+ */
+export declare const mediaProviderDiagnosticWireSchema: z.ZodPipe<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodTransform<Readonly<{
+    /** Allowlisted Workers AI category; never a provider message. */
+    category: "InferenceUpstreamError" | "AiInternalError" | "TypeError" | "AbortError" | "TimeoutError" | "Error";
+    /** Four- or five-digit provider prefix, or null when absent. */
+    code: number | null;
+}> | Readonly<{
+    /** A completed video result could not be downloaded. */
+    category: "result_download";
+    /** Native Response status, including zero. */
+    status: number;
+}>, unknown>>;
+/** Decode an ordinary Error name without retaining arbitrary upstream text. */
+export declare function decodeMediaProviderErrorCategory(input: string | undefined): Exclude<MediaProviderDiagnostic["category"], "result_download">;
 /** The closed set of reasons an AppError can state; every SDK and
  * host-reported failure is tagged with exactly one of these codes. */
-export type AppErrorCode = "CANCELLED" | "CAPABILITY_DENIED" | "CAPABILITY_REVOKED" | "COMMAND_NOT_DECLARED" | "CONFLICT" | "DISCONNECTED" | "FILE_TOO_LARGE" | "HOST_FAILURE" | "IDENTITY" | "INSUFFICIENT_CREDIT" | "INVALID_ARGUMENT" | "PROTOCOL" | "SAFETY_FILTER_REFUSED" | "SELECTION_CHANGED" | "TIMEOUT";
+export declare const appErrorCodes: readonly ["CANCELLED", "CAPABILITY_DENIED", "CAPABILITY_REVOKED", "COMMAND_NOT_DECLARED", "CONFLICT", "DELIVERY_PENDING", "DISCONNECTED", "FILE_TOO_LARGE", "HOST_FAILURE", "IDENTITY", "INSUFFICIENT_CREDIT", "INVALID_ARGUMENT", "PROTOCOL", "SAFETY_FILTER_REFUSED", "SELECTION_CHANGED", "TIMEOUT"];
+export type AppErrorCode = (typeof appErrorCodes)[number];
+/** One pending-delivery refusal shared by admission and the shell. */
+export type AppDeliveryPending = Readonly<{
+    code: Extract<AppErrorCode, "DELIVERY_PENDING">;
+}>;
 /** Required construction options for an AppError. */
 export type AppErrorOptions = {
     readonly cause?: unknown;

package/dist/errors.js

@@ -1,3 +1,53 @@
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import * as z from "zod";
+import { mediaProviderDiagnosticSchema, mediaProviderErrorCategorySchema, } from "./internal/media-diagnostic.js";
+/** Decode only safe provider facts, rejecting unmodeled private fields. */
+export function decodeMediaProviderDiagnostic(input) {
+    // Bidirectional projection check, erased from the Promise declaration graph.
+    return Schema.decodeUnknownSync(mediaProviderDiagnosticSchema, {
+        onExcessProperty: "error",
+    })(input);
+}
+/**
+ * Documentable wire projection of the canonical diagnostic grammar.
+ * Maintained converters preserve its closed objects and numeric bounds;
+ * decoding still returns the declaration-safe public diagnostic type.
+ */
+export const mediaProviderDiagnosticWireSchema = z
+    .fromJSONSchema(Schema.toJsonSchemaDocument(mediaProviderDiagnosticSchema, {
+    onExcessProperty: "error",
+}).schema)
+    .transform(decodeMediaProviderDiagnostic);
+/** Decode an ordinary Error name without retaining arbitrary upstream text. */
+export function decodeMediaProviderErrorCategory(input) {
+    return (Option.getOrUndefined(Schema.decodeUnknownOption(mediaProviderErrorCategorySchema)(input)) ?? "Error");
+}
+/** The closed set of reasons an AppError can state; every SDK and
+ * host-reported failure is tagged with exactly one of these codes. */
+export const appErrorCodes = [
+    "CANCELLED",
+    "CAPABILITY_DENIED",
+    "CAPABILITY_REVOKED",
+    "COMMAND_NOT_DECLARED",
+    "CONFLICT",
+    "DELIVERY_PENDING",
+    "DISCONNECTED",
+    "FILE_TOO_LARGE",
+    "HOST_FAILURE",
+    "IDENTITY",
+    "INSUFFICIENT_CREDIT",
+    "INVALID_ARGUMENT",
+    "PROTOCOL",
+    "SAFETY_FILTER_REFUSED",
+    "SELECTION_CHANGED",
+    "TIMEOUT",
+];
+const describedAppErrorSchema = Schema.Struct({
+    name: Schema.Literal("AppError"),
+    code: Schema.Literals(appErrorCodes),
+    retryable: Schema.Boolean,
+});
 /** The SDK's one typed failure. Carries a closed `code` naming the failure
  * kind and an explicit `retryable` verdict, instead of leaving callers to
  * guess either from the message or exception shape. */
@@ -35,6 +85,10 @@ const errorCopy = {
         title: "File changed",
         message: "This file changed elsewhere. Review it before saving again.",
     },
+    DELIVERY_PENDING: {
+        title: "App delivery pending",
+        message: "The App hasn't finished getting ready. Try opening it again.",
+    },
     DISCONNECTED: {
         title: "Connection lost",
         message: "Reopen the App to connect again.",
@@ -90,15 +144,18 @@ const errorCopy = {
  * prerequisites, so they can accompany a non-retryable operation.
  */
 export function describeAppError(cause, overrides) {
-    if (!(cause instanceof AppError))
+    // The picked shell and host can be separate bundles of this same SDK.
+    const decoded = Schema.decodeUnknownOption(describedAppErrorSchema)(cause);
+    if (Option.isNone(decoded))
         return { ...errorCopy.UNKNOWN, retryable: false };
-    const entry = errorCopy[cause.code];
-    const copy = overrides?.[cause.code] ?? entry;
-    const action = entry.action ?? (cause.retryable ? "retry" : undefined);
+    const error = decoded.value;
+    const entry = errorCopy[error.code];
+    const copy = overrides?.[error.code] ?? entry;
+    const action = entry.action ?? (error.retryable ? "retry" : undefined);
     const description = {
         title: copy.title,
         message: copy.message,
-        retryable: cause.retryable,
+        retryable: error.retryable,
     };
     if (action)
         return { ...description, action };

package/dist/index.d.ts

@@ -16,6 +16,8 @@ export type { ConnectAppOptions } from "./connect.js";
 export { APP_CONNECT_TYPE, APP_PROTOCOL_VERSION, APP_READY_TYPE, } from "./internal/protocol.js";
 export type { AppConnectMessage, AppReadyMessage, } from "./internal/protocol.js";
 export { AppError } from "./errors.js";
+export { appDeliveryPendingSchema } from "./internal/schemas.js";
+export type { AppDeliveryPending } from "./errors.js";
 export { statusActionAllowed, statusText } from "./status.js";
 export { APP_BROWSER_SAVE_MAX_BYTES, APP_BROWSER_COPY_MAX_BYTES, APP_STATUS_ITEMS_MAX, APP_STATUS_OPTIONS_MAX, APP_STATUS_TEXT_MAX, } from "./ui.js";
 export { parseStatusAction as parseAppStatusAction, parseStatusItems as parseAppStatusItems, } from "./internal/schemas.js";
@@ -30,3 +32,4 @@ export { APP_NAVIGATION_CONTRACT_VERSION, APP_NAVIGATION_CRUMBS_MAX, APP_NAVIGAT
 export type { AppBackHandler, AppCrumb, AppHeaderCommand, AppHeaderStatus, AppNavigationActivation, AppNavigationActivationHandler, AppNavigationState, AppWindow, BeforeAppClose, HostNavigation, } from "./window.js";
 export { appStorage, AppStorageError } from "./storage.js";
 export type { AppStorage, AppStorageWatch, AppStorageWrite, AppStorageReset, ResolvedAppStorage, } from "./storage.js";
+export { approvals } from "./approvals.js";

package/dist/index.js

@@ -8,9 +8,11 @@ export { connectApp } from "./connect.js";
 /** Data exchanged by iframe and host before the RPC MessagePort takes over. */
 export { APP_CONNECT_TYPE, APP_PROTOCOL_VERSION, APP_READY_TYPE, } from "./internal/protocol.js";
 export { AppError } from "./errors.js";
+export { appDeliveryPendingSchema } from "./internal/schemas.js";
 export { statusActionAllowed, statusText } from "./status.js";
 export { APP_BROWSER_SAVE_MAX_BYTES, APP_BROWSER_COPY_MAX_BYTES, APP_STATUS_ITEMS_MAX, APP_STATUS_OPTIONS_MAX, APP_STATUS_TEXT_MAX, } from "./ui.js";
 export { parseStatusAction as parseAppStatusAction, parseStatusItems as parseAppStatusItems, } from "./internal/schemas.js";
 export { resultRowSchemaV1 } from "@fungi.computer/gills";
 export { APP_NAVIGATION_CONTRACT_VERSION, APP_NAVIGATION_CRUMBS_MAX, APP_NAVIGATION_LABEL_MAX, APP_NAVIGATION_MENU_MAX, APP_NAVIGATION_PRIMARY_MAX, APP_NAVIGATION_SIBLINGS_MAX, APP_NAVIGATION_STATUS_MAX, APP_NAVIGATION_TITLE_MAX, inertHostNavigation, navigationActivationAllowed, } from "./window.js";
 export { appStorage, AppStorageError } from "./storage.js";
+export { approvals } from "./approvals.js";

package/dist/internal/media-diagnostic.d.ts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+/** Names emitted by the maintained Workers AI boundary, never arbitrary names. */
+export declare const mediaProviderErrorCategorySchema: Schema.Literals<readonly ["InferenceUpstreamError", "AiInternalError", "TypeError", "AbortError", "TimeoutError", "Error"]>;
+/** One canonical grammar for safe provider facts across Media transports. */
+export declare const mediaProviderDiagnosticSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly category: Schema.Literals<readonly ["InferenceUpstreamError", "AiInternalError", "TypeError", "AbortError", "TimeoutError", "Error"]>;
+    readonly code: Schema.NullOr<Schema.Int>;
+}>, Schema.Struct<{
+    readonly category: Schema.Literal<"result_download">;
+    readonly status: Schema.Int;
+}>]>;

package/dist/internal/media-diagnostic.js

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+/** Names emitted by the maintained Workers AI boundary, never arbitrary names. */
+export const mediaProviderErrorCategorySchema = Schema.Literals([
+    "InferenceUpstreamError",
+    "AiInternalError",
+    "TypeError",
+    "AbortError",
+    "TimeoutError",
+    "Error",
+]);
+/** One canonical grammar for safe provider facts across Media transports. */
+export const mediaProviderDiagnosticSchema = Schema.Union([
+    Schema.Struct({
+        category: mediaProviderErrorCategorySchema,
+        code: Schema.NullOr(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 99_999 }))),
+    }),
+    Schema.Struct({
+        category: Schema.Literal("result_download"),
+        status: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 599 })),
+    }),
+]);

package/dist/internal/schemas.d.ts

@@ -12,6 +12,10 @@ import type { CapabilityGrantWire, AppHostReconfigurationWire, CommandInvocation
 import type { RpcResult } from "./result.js";
 import { type AppNavigationActivation } from "../window.js";
 import { type AppConnectMessage, type AppReadyMessage, type CommandInvocationWire, type ConnectRequestWire, type ReservedChord, type VersionedFact } from "./protocol.js";
+/** Effect projection of the error owner's declaration-safe pending refusal. */
+export declare const appDeliveryPendingSchema: Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["DELIVERY_PENDING"]>;
+}>;
 export declare function appInvocation(value: CommandInvocationWire, signal: AbortSignal): Readonly<AppCommandInvocation>;
 export declare const parseCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions | undefined) => Readonly<{
     readonly id: string;
@@ -275,6 +279,7 @@ export declare const parseNavigationState: (input: unknown, options?: import("ef
     primary?: readonly Readonly<{
         id: string;
         label: string;
+        icon?: "play";
         variant?: "primary" | "outline" | "ghost";
         tone?: "destructive";
         disabled?: boolean;
@@ -282,6 +287,7 @@ export declare const parseNavigationState: (input: unknown, options?: import("ef
     menu?: readonly Readonly<{
         id: string;
         label: string;
+        icon?: "play";
         variant?: "primary" | "outline" | "ghost";
         tone?: "destructive";
         disabled?: boolean;
@@ -289,6 +295,7 @@ export declare const parseNavigationState: (input: unknown, options?: import("ef
     status?: readonly Readonly<{
         id: string;
         label: string;
+        presentation?: "bead";
         tone?: "neutral" | "info" | "warning" | "success" | "error";
     }>[];
 }>;