@fungi.computer/oyster 0.1.0 → 0.3.0

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>;

package/dist/apps/permissions.js

@@ -0,0 +1,255 @@
+import * as z from "zod";
+import { permissionCatalog } from "./catalog.js";
+import { sha256DigestSchema } from "@fungi.computer/puffball/effect";
+import { appAuthoritySchema, declaredOperationsSchema, ownerCodec, grantCommandSchema, } from "./installation.js";
+/** Includes newly declared operations and capabilities the owner has narrowed. */
+export function pendingCapabilities(authority, declaration, declaredOperations) {
+    return declaration.capabilities.filter((capability) => {
+        if (permissionCatalog[capability].consent === "affordance")
+            return false;
+        const grant = authority.approvedGrants.find((row) => row.capability === capability);
+        return (grant === undefined ||
+            (grant.resources !== "tenant-scope" && grant.resources.length === 0) ||
+            declaredOperations.capabilities
+                .find((row) => row.capability === capability)
+                ?.operations.some((operation) => !grant.operations.includes(operation)) === true);
+    });
+}
+/** Bound the real SDK request; an Allow never silently widens selected resources. */
+export function grantRequestFor(authority, facts, request, window) {
+    if (authority.declaredOperationsDigest !== facts.declaredOperations.digest)
+        return { kind: "refused", code: "stale_authority" };
+    const requested = [
+        ...new Set([...(request.agents ?? []), ...(request.computers ?? [])]),
+    ];
+    if (requested.some((capability) => !facts.declaration.capabilities.includes(capability)))
+        return { kind: "refused", code: "not_declared" };
+    const adds = [];
+    for (const capability of requested) {
+        const existing = authority.approvedGrants.find((row) => row.capability === capability);
+        const operations = facts.declaredOperations.capabilities.find((row) => row.capability === capability)?.operations ?? [];
+        if (existing !== undefined &&
+            existing.resources !== "tenant-scope" &&
+            existing.resources.length > 0) {
+            // approvedGrantSchema admits only capabilityApproved: true.
+            // A replay can use that approval, but cannot extend its finite scope.
+            if (permissionCatalog[capability].scope === "computer" &&
+                window.computerId !== null &&
+                existing.resources.some((resource) => resource.kind === "computer" && resource.id === window.computerId) &&
+                operations.every((operation) => existing.operations.includes(operation)))
+                continue;
+            return { kind: "customize" };
+        }
+        if (existing?.resources === "tenant-scope" &&
+            operations.every((operation) => existing.operations.includes(operation)))
+            continue;
+        let resources = "tenant-scope";
+        if (permissionCatalog[capability].scope === "computer") {
+            // Only the embedding host supplies this fact, never the App's request.
+            const computerId = window.computerId;
+            if (computerId == null)
+                return { kind: "refused", code: "window_scope_unavailable" };
+            resources = [{ kind: "computer", id: computerId }];
+        }
+        adds.push({ capability, grant: { operations, resources } });
+    }
+    if (adds.length === 0)
+        return { kind: "covered" };
+    return {
+        kind: "ask",
+        adds,
+        command: { kind: "change-grants", changes: adds },
+    };
+}
+/** The saved operation ceiling is the starting point, including empty operation rows. */
+export function draftOf(authority) {
+    return new Map(authority.approvedGrants.map(({ capability, operations, resources }) => [
+        capability,
+        { operations, resources },
+    ]));
+}
+function sameGrant(a, b) {
+    if (a == null || b == null)
+        return a == null && b == null;
+    const sameValues = (left, right) => left.length === right.length &&
+        left.every((value) => right.includes(value));
+    if (!sameValues(a.operations, b.operations))
+        return false;
+    if (a.resources === "tenant-scope" || b.resources === "tenant-scope")
+        return a.resources === b.resources;
+    return (a.resources.length === b.resources.length &&
+        a.resources.every((resource) => b.resources !== "tenant-scope" &&
+            b.resources.some((other) => resource.kind === other.kind && resource.id === other.id)));
+}
+/** An edit changes one capability; unrelated saved operations and scopes are retained. */
+export function editPermissions(draft, edit, declared) {
+    const row = declared.capabilities.find(({ capability }) => capability === edit.capability);
+    const policy = permissionCatalog[edit.capability];
+    if (row === undefined || policy.consent === "affordance")
+        return draft;
+    const next = new Map(draft);
+    const existing = draft.get(edit.capability);
+    const enabled = existing ?? {
+        operations: row.operations,
+        resources: "tenant-scope",
+    };
+    switch (edit.kind) {
+        case "switch":
+            next.set(edit.capability, edit.on ? enabled : null);
+            break;
+        case "all":
+            if (policy.scope === null)
+                return draft;
+            next.set(edit.capability, edit.on ? { ...enabled, resources: "tenant-scope" } : null);
+            break;
+        case "resource": {
+            if (policy.scope !== edit.resource.kind ||
+                existing?.resources === "tenant-scope")
+                return draft;
+            const resources = existing?.resources ?? [];
+            const kept = resources.filter((resource) => resource.kind !== edit.resource.kind ||
+                resource.id !== edit.resource.id);
+            const changed = edit.on ? [...kept, edit.resource] : kept;
+            next.set(edit.capability, changed.length === 0 ? null : { ...enabled, resources: changed });
+            break;
+        }
+        case "operation": {
+            if (edit.capability !== "apps.call" ||
+                !row.operations.includes(edit.operation))
+                return draft;
+            const kept = (existing?.operations ?? []).filter((operation) => operation !== edit.operation);
+            const operations = edit.on ? [...kept, edit.operation] : kept;
+            next.set(edit.capability, operations.length === 0 ? null : { ...enabled, operations });
+            break;
+        }
+    }
+    return next;
+}
+/** Only touched capability rows cross the save boundary. */
+export function planGrantChange(baseline, draft) {
+    const saved = draftOf(baseline);
+    const capabilities = new Set([...saved.keys(), ...draft.keys()]);
+    return [...capabilities].flatMap((capability) => sameGrant(saved.get(capability), draft.get(capability))
+        ? []
+        : [{ capability, grant: draft.get(capability) ?? null }]);
+}
+/** A conflict preserves the person's edits while taking fresh untouched capabilities. */
+export function rebaseDraft(draft, baseline, current) {
+    const rebased = new Map(draftOf(current));
+    for (const change of planGrantChange(baseline, draft))
+        rebased.set(change.capability, change.grant);
+    return rebased;
+}
+/** Serializable host facts; the browser derives presentation, never authority. */
+export const appPermissionsWireSchema = z.strictObject({
+    authority: appAuthoritySchema,
+    declaredOperations: declaredOperationsSchema,
+});
+/** Every declared permission is visible, including removable saved resources no longer listed by the host. */
+export function permissionScreen(input) {
+    const pending = pendingCapabilities(input.authority, {
+        capabilities: input.declaredOperations.capabilities.map((row) => row.capability),
+    }, input.declaredOperations);
+    const draft = draftOf(input.authority);
+    const grouped = new Map();
+    for (const { capability } of input.declaredOperations.capabilities) {
+        const group = permissionCatalog[capability].group;
+        grouped.set(group, [...(grouped.get(group) ?? []), capability]);
+    }
+    const column = (capability) => {
+        const { label, caption, description, sigil, warning } = permissionCatalog[capability];
+        return {
+            capability,
+            label,
+            caption,
+            description,
+            sigil,
+            warning,
+            pending: pending.includes(capability),
+        };
+    };
+    return {
+        canEdit: input.canEdit,
+        pending,
+        groups: [...grouped].map(([id, capabilities]) => {
+            const scoped = capabilities.filter((capability) => permissionCatalog[capability].scope !== null);
+            const scope = scoped.length === 0
+                ? null
+                : permissionCatalog[scoped[0] ?? "apps.open"].scope;
+            const resources = new Map(input.resources
+                .filter((resource) => resource.kind === scope)
+                .map((resource) => [resource.id, resource]));
+            for (const capability of scoped) {
+                const grant = draft.get(capability);
+                if (grant == null || grant.resources === "tenant-scope")
+                    continue;
+                for (const resource of grant.resources) {
+                    if (resource.kind === scope && !resources.has(resource.id))
+                        resources.set(resource.id, { ...resource, label: resource.id });
+                }
+            }
+            const row = (resource, label) => ({
+                resource,
+                label,
+                cells: scoped.map((capability) => {
+                    const grant = draft.get(capability);
+                    const state = grant == null
+                        ? "off"
+                        : grant.resources === "tenant-scope"
+                            ? resource === "all"
+                                ? "on"
+                                : "via-all"
+                            : resource !== "all" &&
+                                grant.resources.some((ref) => ref.kind === resource.kind && ref.id === resource.id)
+                                ? "on"
+                                : "off";
+                    return { capability, state };
+                }),
+            });
+            return {
+                id,
+                scope,
+                columns: scoped.map(column),
+                rows: scope === null
+                    ? []
+                    : [
+                        row("all", scope === "computer" ? "All Computers" : "All Agents"),
+                        ...[...resources.values()].map((resource) => row(resource, resource.label)),
+                    ],
+                switches: capabilities
+                    .filter((capability) => permissionCatalog[capability].scope === null)
+                    .map((capability) => ({
+                    ...column(capability),
+                    on: permissionCatalog[capability].consent === "affordance" ||
+                        draft.get(capability) != null,
+                })),
+                operations: capabilities.includes("apps.call")
+                    ? (input.declaredOperations.capabilities.find((capability) => capability.capability === "apps.call")?.operations ?? []).map((operation) => ({
+                        capability: "apps.call",
+                        operation,
+                        on: draft.get("apps.call")?.operations.includes(operation) === true,
+                    }))
+                    : [],
+            };
+        }),
+    };
+}
+/** Owner-direct permission page and JSON projection. Copy stays in the catalog. */
+export const permissionPinsSchema = z.strictObject({
+    storeGeneration: z.string().min(1),
+    authorityVersion: z.number().int().positive(),
+    artifactDigest: ownerCodec(sha256DigestSchema),
+});
+/** Permission edit command coupled to the version pins read by the owner. */
+export const permissionSaveSchema = permissionPinsSchema.extend({
+    command: grantCommandSchema,
+});
+/** Owner permission-page identity, artifact and current permission facts. */
+export const appPermissionPageSchema = z.strictObject({
+    storeGeneration: permissionPinsSchema.shape.storeGeneration,
+    installationId: z.string(),
+    appId: z.string(),
+    appName: z.string(),
+    artifactDigest: ownerCodec(sha256DigestSchema),
+    permissions: appPermissionsWireSchema,
+});

package/dist/boot-capability-route.d.ts

@@ -0,0 +1,15 @@
+import { type BootCapabilityStore } from "./boot-capability.js";
+/** The artifact bucket read the route needs; an R2 bucket is one. */
+export type BootAssetBucket = Readonly<{
+    get(key: string): Promise<Readonly<{
+        size: number;
+        body: ReadableStream<Uint8Array>;
+    }> | null>;
+}>;
+export type BootCapabilityRouteOptions = Readonly<{
+    configuredOrigin: string;
+    bucket: BootAssetBucket;
+    capabilities: BootCapabilityStore;
+}>;
+/** Worker-only HTTPS endpoint for a single digest-authorized boot lease. */
+export declare function serveBootCapability(request: Request, options: BootCapabilityRouteOptions): Promise<Response | null>;