@fungi.computer/oyster 0.2.0 → 0.3.1

package/dist/apps/installation.js

@@ -4,7 +4,8 @@ import * as Result from "effect/Result";
 import { appCapabilityIdSchema, appApiMethodNameSchema, } from "@fungi.computer/puffball/app";
 import { hostActorSchema } from "@fungi.computer/puffball/app-method-runtime";
 import { appIdSchema, releaseSchema, sha256DigestSchema, } from "@fungi.computer/puffball/effect";
-import { instanceIdSchema } from "../index.js";
+import { instanceIdSchema } from "../instance-id.js";
+import { permissionCatalog } from "./catalog.js";
 /** Reuse the owning Effect codec at a JSON/storage boundary. */
 export function ownerCodec(schema) {
     const decode = Schema.decodeUnknownResult(schema, {
@@ -22,7 +23,7 @@ export function ownerCodec(schema) {
 /** Installation names cannot contain the tenant separator. */
 export const installationIdSchema = z.lazy(() => z.string().regex(/^[a-z](?:[a-z0-9]|-(?!-)){0,62}$/u));
 /** A resource identity minted and resolved by the host, never by this module. */
-const resourceRefSchema = z.lazy(() => z
+export const resourceRefSchema = z.lazy(() => z
     .strictObject({
     kind: z.string().min(1),
     id: z.string().min(1),
@@ -38,10 +39,10 @@ const operationsSchema = z.lazy(() => z
  * no new consent; a new capability does. Release selection intersects stored
  * operations instead of adding approvals. Each Worker call is still restricted
  * to that method's declared requires, never the App's complete capability set.
- * Only an approved install or set-grants command mints capabilityApproved.
+ * Only an approved install or change-grants command mints capabilityApproved.
  * Empty operation rows retain that consent; removing the capability revokes it.
  * route:app.methods rows record approval detail, not a method allowlist: narrowing
- * them in set-grants does not restrict methods using an approved capability.
+ * them in change-grants does not restrict methods using an approved capability.
  * Exact operation rows are enforced for capability routes and backend bindings.
  */
 export const approvedGrantSchema = z
@@ -60,18 +61,23 @@ const approvedGrantsSchema = z.lazy(() => z
     .array(approvedGrantSchema)
     .refine((grants) => new Set(grants.map((grant) => grant.capability)).size === grants.length, "Capabilities must be unique")
     .readonly());
-/** Shorthand is accepted only on a command and expanded at approval time. */
-const grantRequestSchema = z.union([
-    z.literal("none"),
-    z.literal("declared"),
-    z
-        .array(approvedGrantSchema
+/** A bounded owner edit. Unnamed approvals are not part of the command. */
+export const grantChangeSchema = z
+    .strictObject({
+    capability: ownerCodec(appCapabilityIdSchema),
+    grant: approvedGrantSchema
         .unwrap()
-        .omit({ capabilityApproved: true })
-        .readonly())
-        .refine((grants) => new Set(grants.map((grant) => grant.capability)).size === grants.length, "Capabilities must be unique")
-        .readonly(),
-]);
+        .omit({ capabilityApproved: true, capability: true })
+        .readonly()
+        .nullable(),
+})
+    .readonly();
+const grantChangesSchema = z
+    .array(grantChangeSchema)
+    .min(1)
+    .refine((changes) => new Set(changes.map((change) => change.capability)).size ===
+    changes.length, "Capabilities must be unique")
+    .readonly();
 const versionSchema = z.lazy(() => z.number().int().positive());
 /** An owner's approval of a fixed operation snapshot. */
 const approvalSchema = z.lazy(() => z
@@ -81,6 +87,109 @@ const approvalSchema = z.lazy(() => z
     authorityVersion: versionSchema,
 })
     .readonly());
+/** The complete grant state. Hosts own storage and compare-and-set commits. */
+export const appAuthoritySchema = z.strictObject({
+    authorityVersion: versionSchema,
+    declaredOperationsDigest: ownerCodec(sha256DigestSchema),
+    approvedGrants: approvedGrantsSchema,
+    approval: approvalSchema.nullable(),
+});
+export const grantCommandSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("install") }),
+    z.strictObject({
+        kind: z.literal("change-grants"),
+        changes: grantChangesSchema,
+    }),
+    z.strictObject({ kind: z.literal("select-release") }),
+    z.strictObject({ kind: z.literal("delete") }),
+]);
+/** One host-independent approval policy; selection only intersects existing grants. */
+export function applyGrantCommand(current, rawCommand, context) {
+    const refuse = (code) => Result.fail({ kind: "refused", code });
+    const parsed = grantCommandSchema.safeParse(rawCommand);
+    if (!parsed.success)
+        return refuse("invalid_command");
+    const command = parsed.data;
+    if ((current === null && command.kind !== "install") ||
+        (current !== null && command.kind === "install"))
+        return refuse("invalid_command");
+    if ((context.expectedVersion ?? 0) !== (current?.authorityVersion ?? 0) ||
+        (current !== null &&
+            command.kind !== "select-release" &&
+            current.declaredOperationsDigest !== context.declaredOperations.digest))
+        return refuse("stale_authority");
+    if (context.principal.role === null ||
+        context.principal.actor.kind === "visitor" ||
+        (command.kind === "change-grants" && context.principal.role !== "owner"))
+        return refuse("not_owner");
+    const declared = (capability) => context.declaredOperations.capabilities.find((row) => row.capability === capability)?.operations ?? [];
+    const version = (current?.authorityVersion ?? 0) + 1;
+    let grants = current?.approvedGrants ?? [];
+    let approval = current?.approval ?? null;
+    switch (command.kind) {
+        case "install":
+            grants =
+                context.principal.role === "owner"
+                    ? context.declaration.capabilities
+                        .filter((capability) => permissionCatalog[capability].consent === "install")
+                        .map((capability) => ({
+                        capability,
+                        capabilityApproved: true,
+                        operations: declared(capability),
+                        resources: "tenant-scope",
+                    }))
+                    : [];
+            break;
+        case "change-grants": {
+            for (const { capability, grant } of command.changes) {
+                if (!context.declaration.capabilities.includes(capability) ||
+                    grant?.operations.some((operation) => !declared(capability).includes(operation)))
+                    return refuse("not_declared");
+                const scope = permissionCatalog[capability].scope;
+                if (grant !== null &&
+                    grant.resources !== "tenant-scope" &&
+                    (scope === null ||
+                        grant.resources.some((resource) => resource.kind !== scope)))
+                    return refuse("invalid_command");
+            }
+            const changed = new Map(command.changes.map((change) => [change.capability, change.grant]));
+            grants = [
+                ...grants.filter((grant) => !changed.has(grant.capability)),
+                ...command.changes.flatMap(({ capability, grant }) => grant === null ||
+                    (grant.resources !== "tenant-scope" && grant.resources.length === 0)
+                    ? []
+                    : [{ capability, ...grant, capabilityApproved: true }]),
+            ];
+            break;
+        }
+        case "select-release":
+            grants = grants
+                .filter((grant) => context.declaration.capabilities.includes(grant.capability))
+                .map((grant) => ({
+                ...grant,
+                operations: grant.operations.filter((operation) => declared(grant.capability).includes(operation)),
+            }));
+            break;
+        case "delete":
+            grants = [];
+            break;
+    }
+    if (grants.length === 0)
+        approval = null;
+    else if (command.kind === "install" || command.kind === "change-grants") {
+        approval = {
+            by: context.principal.actor,
+            at: context.now,
+            authorityVersion: version,
+        };
+    }
+    return Result.succeed({
+        authorityVersion: version,
+        declaredOperationsDigest: context.declaredOperations.digest,
+        approvedGrants: grants,
+        approval,
+    });
+}
 const anonymousMethodsSchema = z
     .array(z
     .strictObject({
@@ -115,12 +224,9 @@ export const installationSchema = z
     appId: ownerCodec(appIdSchema),
     release: ownerCodec(releaseSchema),
     releasePin: z.enum(["pinned", "floating"]),
-    authorityVersion: versionSchema,
+    authority: appAuthoritySchema,
     status: z.enum(["enabled", "disabled", "deleted"]),
     visibility: z.enum(["private", "public"]),
-    declaredOperationsDigest: ownerCodec(sha256DigestSchema),
-    approvedGrants: approvedGrantsSchema,
-    approval: approvalSchema.nullable(),
     approvedAnonymousMethods: anonymousMethodsSchema,
     anonymousApproval: approvalSchema.nullable(),
 })
@@ -132,7 +238,7 @@ export const installationSchema = z
         : installation.status !== "deleted" &&
             installation.approvedAnonymousMethods.length > 0 &&
             approval.by.kind === "member" &&
-            approval.authorityVersion <= installation.authorityVersion;
+            approval.authorityVersion <= installation.authority.authorityVersion;
 }, "Anonymous authority requires a retained human approval receipt");
 const releaseFields = {
     release: ownerCodec(releaseSchema),
@@ -143,7 +249,6 @@ export const installationCommandSchema = z.lazy(() => z.discriminatedUnion("kind
     z.strictObject({
         kind: z.literal("install"),
         ...releaseFields,
-        grants: grantRequestSchema,
     }),
     z.strictObject({ kind: z.literal("select-release"), ...releaseFields }),
     z.strictObject({
@@ -155,8 +260,8 @@ export const installationCommandSchema = z.lazy(() => z.discriminatedUnion("kind
         visibility: installationSchema.shape.visibility,
     }),
     z.strictObject({
-        kind: z.literal("set-grants"),
-        grants: grantRequestSchema,
+        kind: z.literal("change-grants"),
+        changes: grantChangesSchema,
     }),
     z.strictObject({
         kind: z.literal("approve-anonymous"),
@@ -191,12 +296,10 @@ export function applyInstallationCommand(current, rawCommand, context) {
             return refuse("stale_authority");
     }
     else if (command.kind === "install" ||
-        context.expectedVersion !== current.authorityVersion) {
+        context.expectedVersion !== current.authority.authorityVersion) {
         return refuse("stale_authority");
     }
-    if ((command.kind === "set-grants" ||
-        (command.kind === "install" && command.grants !== "none")) &&
-        context.role !== "owner")
+    if (command.kind === "change-grants" && context.role !== "owner")
         return refuse("not_owner");
     const anonymousConsent = context.by.kind === "member" &&
         context.anonymousConsent?.memberId === context.by.memberId;
@@ -216,14 +319,38 @@ export function applyInstallationCommand(current, rawCommand, context) {
         release.artifact.artifactDigest ||
         (current !== null &&
             command.kind !== "select-release" &&
-            context.declaredOperations.digest !== current.declaredOperationsDigest))
+            context.declaredOperations.digest !==
+                current.authority.declaredOperationsDigest))
         return refuse("stale_authority");
-    const declared = (capability) => context.declaration.capabilities.includes(capability)
-        ? (context.declaredOperations.capabilities.find((row) => row.capability === capability)?.operations ?? [])
-        : [];
-    const version = (current?.authorityVersion ?? 0) + 1;
-    let grants = current?.approvedGrants ?? [];
-    let approval = current?.approval ?? null;
+    const version = (current?.authority.authorityVersion ?? 0) + 1;
+    const grantCommand = command.kind === "install" || command.kind === "select-release"
+        ? { kind: command.kind }
+        : command.kind === "change-grants"
+            ? command
+            : command.kind === "set-status" && command.status === "deleted"
+                ? { kind: "delete" }
+                : null;
+    const authority = grantCommand === null
+        ? current === null
+            ? Result.fail({
+                kind: "refused",
+                code: "invalid_command",
+            })
+            : Result.succeed({
+                authorityVersion: version,
+                declaredOperationsDigest: current.authority.declaredOperationsDigest,
+                approvedGrants: current.authority.approvedGrants,
+                approval: current.authority.approval,
+            })
+        : applyGrantCommand(current?.authority ?? null, grantCommand, {
+            principal: { actor: context.by, role: context.role },
+            expectedVersion: context.expectedVersion,
+            declaration: context.declaration,
+            declaredOperations: context.declaredOperations,
+            now: context.now,
+        });
+    if (Result.isFailure(authority))
+        return refuse(authority.failure.code);
     let anonymousMethods = current?.approvedAnonymousMethods ?? [];
     let anonymousApproval = current?.anonymousApproval ?? null;
     if (command.kind === "approve-anonymous") {
@@ -240,44 +367,12 @@ export function applyInstallationCommand(current, rawCommand, context) {
                 authorityVersion: version,
             };
     }
-    if (command.kind === "install" || command.kind === "set-grants") {
-        grants =
-            command.grants === "none"
-                ? []
-                : command.grants === "declared"
-                    ? context.declaredOperations.capabilities
-                        .filter((row) => context.declaration.capabilities.includes(row.capability))
-                        .map((row) => ({
-                        ...row,
-                        capabilityApproved: true,
-                        resources: "tenant-scope",
-                    }))
-                    : command.grants.map((grant) => ({
-                        ...grant,
-                        capabilityApproved: true,
-                    }));
-        if (grants.some((grant) => !context.declaration.capabilities.includes(grant.capability) ||
-            grant.operations.some((operation) => !declared(grant.capability).includes(operation))))
-            return refuse("not_declared");
-        approval =
-            command.grants === "none"
-                ? null
-                : { by: context.by, at: context.now, authorityVersion: version };
-    }
     if (command.kind === "select-release") {
         anonymousMethods = anonymousMethods.filter((method) => context.declaredOperations.anonymousMethods.some((declared) => declared.name === method.name && declared.digest === method.digest));
         if (anonymousMethods.length === 0)
             anonymousApproval = null;
-        grants = grants
-            .map((grant) => ({
-            ...grant,
-            operations: grant.operations.filter((operation) => declared(grant.capability).includes(operation)),
-        }))
-            .filter((grant) => context.declaration.capabilities.includes(grant.capability));
     }
     if (command.kind === "set-status" && command.status === "deleted") {
-        grants = [];
-        approval = null;
         anonymousMethods = [];
         anonymousApproval = null;
     }
@@ -289,16 +384,13 @@ export function applyInstallationCommand(current, rawCommand, context) {
         releasePin: command.kind === "install" || command.kind === "select-release"
             ? command.releasePin
             : current?.releasePin,
-        authorityVersion: version,
         status: command.kind === "set-status"
             ? command.status
             : (current?.status ?? "enabled"),
         visibility: command.kind === "set-visibility"
             ? command.visibility
             : (current?.visibility ?? "private"),
-        declaredOperationsDigest: context.declaredOperations.digest,
-        approvedGrants: grants,
-        approval,
+        authority: authority.success,
         approvedAnonymousMethods: anonymousMethods,
         anonymousApproval,
     });
@@ -306,3 +398,17 @@ export function applyInstallationCommand(current, rawCommand, context) {
         ? Result.succeed({ next: next.data, authorityChanged: true })
         : refuse("invalid_command");
 }
+/** Only the committed installation may activate this exact owner selection. */
+export function isCommittedInstallation(current, state, release) {
+    return (current !== null &&
+        state.owner.kind === "installation" &&
+        current.installationId === state.owner.id &&
+        current.instanceId === state.instanceId &&
+        current.appId === state.appId &&
+        current.authority.authorityVersion === state.authorityVersion &&
+        current.status === state.status &&
+        current.release.releaseId === state.releaseId &&
+        release.releaseId === state.releaseId &&
+        release.appId === state.appId &&
+        current.release.artifact.artifactDigest === release.artifact.artifactDigest);
+}

package/dist/apps/permissions.d.ts

@@ -0,0 +1,247 @@
+import * as z from "zod";
+import type { AppPermissionRequest } from "@fungi.computer/agar";
+import { type AppDeclaration, type AppCapabilityId } from "@fungi.computer/puffball/app";
+import { type PermissionCatalogEntry } from "./catalog.js";
+import type { SigilName } from "@fungi.computer/sigils";
+import { type AppAuthority, type DeclaredOperations, type GrantCommand, type GrantChange, type ResourceRef } from "./installation.js";
+/** A host-provided resource identity and its display label. */
+export type ResourceOption = {
+    kind: string;
+    id: string;
+    label: string;
+};
+/** Includes newly declared operations and capabilities the owner has narrowed. */
+export declare function pendingCapabilities(authority: Pick<AppAuthority, "approvedGrants">, declaration: Pick<AppDeclaration, "capabilities">, declaredOperations: DeclaredOperations): AppDeclaration["capabilities"];
+/** How an App's runtime permission request relates to the owner's stored grants. */
+export type GrantRequestDecision = Readonly<{
+    kind: "covered";
+}> | Readonly<{
+    kind: "customize";
+}> | Readonly<{
+    kind: "refused";
+    code: "not_declared" | "stale_authority" | "window_scope_unavailable";
+}> | Readonly<{
+    kind: "ask";
+    adds: readonly GrantChange[];
+    command: Extract<GrantCommand, {
+        kind: "change-grants";
+    }>;
+}>;
+/** Bound the real SDK request; an Allow never silently widens selected resources. */
+export declare function grantRequestFor(authority: AppAuthority, facts: Readonly<{
+    declaration: Pick<AppDeclaration, "capabilities">;
+    declaredOperations: DeclaredOperations;
+}>, request: AppPermissionRequest, window: Readonly<{
+    computerId: string | null;
+}>): GrantRequestDecision;
+/**
+ * A draft contains approvals, never the broader declared-operation projection.
+ * @inline
+ */
+export type PermissionGrant = Readonly<{
+    operations: readonly string[];
+    resources: "tenant-scope" | readonly ResourceRef[];
+}>;
+/**
+ * Capability approvals being edited; null removes the capability's grant.
+ * @inlineType PermissionGrant
+ */
+export type PermissionDraft = ReadonlyMap<AppCapabilityId, PermissionGrant | null>;
+/** One switch, scope, resource or operation change applied to a draft. */
+export type PermissionEdit = Readonly<{
+    kind: "switch" | "all";
+    capability: AppCapabilityId;
+    on: boolean;
+}> | Readonly<{
+    kind: "resource";
+    capability: AppCapabilityId;
+    resource: ResourceRef;
+    on: boolean;
+}> | Readonly<{
+    kind: "operation";
+    capability: AppCapabilityId;
+    operation: string;
+    on: boolean;
+}>;
+/** The saved operation ceiling is the starting point, including empty operation rows. */
+export declare function draftOf(authority: AppAuthority): PermissionDraft;
+/** An edit changes one capability; unrelated saved operations and scopes are retained. */
+export declare function editPermissions(draft: PermissionDraft, edit: PermissionEdit, declared: DeclaredOperations): PermissionDraft;
+/** Only touched capability rows cross the save boundary. */
+export declare function planGrantChange(baseline: AppAuthority, draft: PermissionDraft): readonly GrantChange[];
+/** A conflict preserves the person's edits while taking fresh untouched capabilities. */
+export declare function rebaseDraft(draft: PermissionDraft, baseline: AppAuthority, current: AppAuthority): PermissionDraft;
+/** Serializable host facts; the browser derives presentation, never authority. */
+export declare const appPermissionsWireSchema: z.ZodObject<{
+    authority: z.ZodObject<{
+        authorityVersion: z.ZodLazy<z.ZodNumber>;
+        declaredOperationsDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+        approvedGrants: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+            capabilityApproved: z.ZodLiteral<true>;
+            operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strict>>>>>]>;
+        }, z.core.$strict>>>>>;
+        approval: z.ZodNullable<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+            by: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+                kind: import("zod/mini").ZodMiniLiteral<"member">;
+                memberId: import("zod/mini").ZodMiniString<string>;
+            }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+                kind: import("zod/mini").ZodMiniLiteral<"agent">;
+                agentId: import("zod/mini").ZodMiniString<string>;
+            }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+                kind: import("zod/mini").ZodMiniLiteral<"team-key">;
+                keyId: import("zod/mini").ZodMiniString<string>;
+            }, z.core.$strip>], "kind">;
+            at: z.ZodNumber;
+            authorityVersion: z.ZodLazy<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>;
+    declaredOperations: z.ZodLazy<z.ZodObject<{
+        artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+        digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+        anonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
+            digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+        }, z.core.$strict>>>>;
+        capabilities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+            operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Host-supplied authority and declared operations used to derive permission UI. */
+export type AppPermissionsWire = z.output<typeof appPermissionsWireSchema>;
+export type PermissionCellState = "on" | "off" | "via-all";
+/**
+ * Catalog copy and pending status shared by a group's scoped and switch columns.
+ * @inline
+ */
+export type PermissionColumn = Readonly<{
+    capability: AppCapabilityId;
+    label: string;
+    caption: string;
+    description: string;
+    sigil: SigilName;
+    warning: string | null;
+    pending: boolean;
+}>;
+/**
+ * Catalog-derived permission groups, resource cells and operation switches.
+ * @inlineType PermissionColumn
+ */
+export type PermissionScreen = Readonly<{
+    canEdit: boolean;
+    pending: readonly AppCapabilityId[];
+    groups: readonly Readonly<{
+        id: PermissionCatalogEntry["group"];
+        scope: "computer" | "agent" | null;
+        columns: readonly PermissionColumn[];
+        rows: readonly Readonly<{
+            resource: ResourceRef | "all";
+            label: string;
+            cells: readonly Readonly<{
+                capability: AppCapabilityId;
+                state: PermissionCellState;
+            }>[];
+        }>[];
+        switches: readonly (PermissionColumn & Readonly<{
+            on: boolean;
+        }>)[];
+        operations: readonly Readonly<{
+            capability: "apps.call";
+            operation: string;
+            on: boolean;
+        }>[];
+    }>[];
+}>;
+/** Every declared permission is visible, including removable saved resources no longer listed by the host. */
+export declare function permissionScreen(input: AppPermissionsWire & Readonly<{
+    resources: readonly ResourceOption[];
+    canEdit: boolean;
+}>): PermissionScreen;
+/** Owner-direct permission page and JSON projection. Copy stays in the catalog. */
+export declare const permissionPinsSchema: z.ZodObject<{
+    storeGeneration: z.ZodString;
+    authorityVersion: z.ZodNumber;
+    artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+}, z.core.$strict>;
+/** Generation, authority version and artifact digest fencing a permission edit. */
+export type PermissionPins = z.output<typeof permissionPinsSchema>;
+/** Permission edit command coupled to the version pins read by the owner. */
+export declare const permissionSaveSchema: z.ZodObject<{
+    storeGeneration: z.ZodString;
+    authorityVersion: z.ZodNumber;
+    artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+    command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"install">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"change-grants">;
+        changes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+            grant: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodString;
+                    id: z.ZodString;
+                }, z.core.$strict>>>>>]>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"select-release">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"delete">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+/** Owner permission-page identity, artifact and current permission facts. */
+export declare const appPermissionPageSchema: z.ZodObject<{
+    storeGeneration: z.ZodString;
+    installationId: z.ZodString;
+    appId: z.ZodString;
+    appName: z.ZodString;
+    artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+    permissions: z.ZodObject<{
+        authority: z.ZodObject<{
+            authorityVersion: z.ZodLazy<z.ZodNumber>;
+            declaredOperationsDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+            approvedGrants: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+                capabilityApproved: z.ZodLiteral<true>;
+                operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodString;
+                    id: z.ZodString;
+                }, z.core.$strict>>>>>]>;
+            }, z.core.$strict>>>>>;
+            approval: z.ZodNullable<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+                by: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+                    kind: import("zod/mini").ZodMiniLiteral<"member">;
+                    memberId: import("zod/mini").ZodMiniString<string>;
+                }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+                    kind: import("zod/mini").ZodMiniLiteral<"agent">;
+                    agentId: import("zod/mini").ZodMiniString<string>;
+                }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+                    kind: import("zod/mini").ZodMiniLiteral<"team-key">;
+                    keyId: import("zod/mini").ZodMiniString<string>;
+                }, z.core.$strip>], "kind">;
+                at: z.ZodNumber;
+                authorityVersion: z.ZodLazy<z.ZodNumber>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+        declaredOperations: z.ZodLazy<z.ZodObject<{
+            artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+            digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+            anonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
+                digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+            }, z.core.$strict>>>>;
+            capabilities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+                operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;