@fungi.computer/oyster 0.5.0 → 0.7.0

package/dist/installation-execution.js

@@ -49,12 +49,10 @@ export async function executeInstallation(host, input) {
         const declaration = verified.declaration ?? emptyAppDeclaration;
         const baseline = command.baseline;
         const declaredOperations = await deriveDeclaredOperations(verified.release, declaration, host.capabilities ?? []);
-        // A Workflow reuses the owner's approval; any capability or anonymous
-        // method its baseline has not approved waits for the owner.
+        // A Workflow reuses the owner's approval; any capability its baseline
+        // has not approved waits for the owner.
         if (command.admission.origin === "workflow" &&
-            (pendingCapabilities(baseline?.authority ?? { approvedGrants: [] }, declaration, declaredOperations).length > 0 ||
-                declaredOperations.anonymousMethods.some((method) => !(baseline?.approvedAnonymousMethods ?? []).some((approved) => approved.name === method.name &&
-                    approved.digest === method.digest))))
+            pendingCapabilities(baseline?.authority ?? { approvedGrants: [] }, declaration, declaredOperations).length > 0)
             return refused(409, "needs_consent");
         const reduced = applyInstallationCommand(baseline, baseline === null
             ? {
@@ -77,6 +75,13 @@ export async function executeInstallation(host, input) {
                 installationId: command.installationId,
                 instanceId: command.instanceId,
             },
+            // Only a fresh owner-direct Tourtois install in the configured home
+            // slot receives the ordinary persisted Shell grant. App/workflow
+            // requests cannot opt in; selection only intersects existing grants.
+            builtInShell: baseline === null &&
+                command.admission.origin === "owner-direct" &&
+                verified.release.appId === "app_tourtois" &&
+                command.installationId === host.homeInstallationId,
         });
         if (Result.isFailure(reduced))
             return refused(409, reduced.failure.code);

package/dist/installation-operations.d.ts

@@ -60,28 +60,6 @@ declare const installationOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             disabled: "disabled";
             deleted: "deleted";
         }>;
-        visibility: z.ZodEnum<{
-            private: "private";
-            public: "public";
-        }>;
-        approvedAnonymousMethods: 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>>>>;
-        anonymousApproval: 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>;
     creation: z.ZodEnum<{
         fresh: "fresh";
@@ -300,28 +278,6 @@ export declare const installationOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
             disabled: "disabled";
             deleted: "deleted";
         }>;
-        visibility: z.ZodEnum<{
-            private: "private";
-            public: "public";
-        }>;
-        approvedAnonymousMethods: 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>>>>;
-        anonymousApproval: 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>>;
 }, z.core.$strict>, z.ZodObject<{
     state: z.ZodLiteral<"refused">;
@@ -400,8 +356,8 @@ declare const installationAdmissionSchema: z.ZodObject<{
         "create-only": "create-only";
     }>;
     origin: z.ZodEnum<{
-        workflow: "workflow";
         "owner-direct": "owner-direct";
+        workflow: "workflow";
     }>;
 }, z.core.$strict>;
 export type InstallationAdmission = z.output<typeof installationAdmissionSchema>;
@@ -439,8 +395,8 @@ export declare const retainedInstallationCommandSchema: z.ZodObject<{
             "create-only": "create-only";
         }>;
         origin: z.ZodEnum<{
-            workflow: "workflow";
             "owner-direct": "owner-direct";
+            workflow: "workflow";
         }>;
     }, z.core.$strict>;
     scope: z.ZodObject<{
@@ -503,28 +459,6 @@ export declare const retainedInstallationCommandSchema: z.ZodObject<{
             disabled: "disabled";
             deleted: "deleted";
         }>;
-        visibility: z.ZodEnum<{
-            private: "private";
-            public: "public";
-        }>;
-        approvedAnonymousMethods: 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>>>>;
-        anonymousApproval: 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>>;
     acceptedAt: z.ZodNumber;
     creation: z.ZodEnum<{
@@ -586,28 +520,6 @@ export declare const retainedInstallationCommandSchema: z.ZodObject<{
                 disabled: "disabled";
                 deleted: "deleted";
             }>;
-            visibility: z.ZodEnum<{
-                private: "private";
-                public: "public";
-            }>;
-            approvedAnonymousMethods: 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>>>>;
-            anonymousApproval: 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>;
         hasBackend: z.ZodBoolean;
         prepared: z.ZodBoolean;
@@ -731,8 +643,8 @@ declare const installationOperationRequestSchema: z.ZodDiscriminatedUnion<[z.Zod
             "create-only": "create-only";
         }>;
         origin: z.ZodEnum<{
-            workflow: "workflow";
             "owner-direct": "owner-direct";
+            workflow: "workflow";
         }>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
@@ -810,28 +722,6 @@ declare const installationOperationRequestSchema: z.ZodDiscriminatedUnion<[z.Zod
             disabled: "disabled";
             deleted: "deleted";
         }>;
-        visibility: z.ZodEnum<{
-            private: "private";
-            public: "public";
-        }>;
-        approvedAnonymousMethods: 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>>>>;
-        anonymousApproval: 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>;
     hasBackend: z.ZodBoolean;
 }, z.core.$strict>, z.ZodObject<{
@@ -1052,28 +942,6 @@ declare const installationOperationReplySchema: z.ZodDiscriminatedUnion<[z.ZodOb
                 disabled: "disabled";
                 deleted: "deleted";
             }>;
-            visibility: z.ZodEnum<{
-                private: "private";
-                public: "public";
-            }>;
-            approvedAnonymousMethods: 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>>>>;
-            anonymousApproval: 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>>;
     }, z.core.$strict>, z.ZodObject<{
         state: z.ZodLiteral<"refused">;
@@ -1154,8 +1022,8 @@ declare const installationOperationReplySchema: z.ZodDiscriminatedUnion<[z.ZodOb
                 "create-only": "create-only";
             }>;
             origin: z.ZodEnum<{
-                workflow: "workflow";
                 "owner-direct": "owner-direct";
+                workflow: "workflow";
             }>;
         }, z.core.$strict>;
         scope: z.ZodObject<{
@@ -1218,28 +1086,6 @@ declare const installationOperationReplySchema: z.ZodDiscriminatedUnion<[z.ZodOb
                 disabled: "disabled";
                 deleted: "deleted";
             }>;
-            visibility: z.ZodEnum<{
-                private: "private";
-                public: "public";
-            }>;
-            approvedAnonymousMethods: 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>>>>;
-            anonymousApproval: 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>>;
         acceptedAt: z.ZodNumber;
         creation: z.ZodEnum<{
@@ -1301,28 +1147,6 @@ declare const installationOperationReplySchema: z.ZodDiscriminatedUnion<[z.ZodOb
                     disabled: "disabled";
                     deleted: "deleted";
                 }>;
-                visibility: z.ZodEnum<{
-                    private: "private";
-                    public: "public";
-                }>;
-                approvedAnonymousMethods: 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>>>>;
-                anonymousApproval: 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>;
             hasBackend: z.ZodBoolean;
             prepared: z.ZodBoolean;

package/dist/installation-operations.js

@@ -296,15 +296,11 @@ const version = (record) => record?.authority.authorityVersion ?? 0;
 /** Whether a plan only reuses, or narrows, the approval its baseline holds. */
 function reusesApproval(baseline, next) {
     const grants = baseline?.authority.approvedGrants ?? [];
-    const methods = baseline?.approvedAnonymousMethods ?? [];
     return (next.authority.approvedGrants.every((grant) => grants.some((held) => held.capability === grant.capability &&
         same(held.resources, grant.resources) &&
         grant.operations.every((operation) => held.operations.includes(operation)))) &&
         (next.authority.approval === null ||
-            same(next.authority.approval, baseline?.authority.approval ?? null)) &&
-        next.approvedAnonymousMethods.every((method) => methods.some((held) => held.name === method.name && held.digest === method.digest)) &&
-        (next.anonymousApproval === null ||
-            same(next.anonymousApproval, baseline?.anonymousApproval ?? null)));
+            same(next.authority.approval, baseline?.authority.approval ?? null)));
 }
 /**
  * One registry-owned command journal joined to maintained Watchdog transactions.

package/dist/installation-store-generation.d.ts

@@ -1,3 +1,6 @@
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 /** Own one persisted store incarnation, independent of installation row revisions. */
-export declare function createInstallationStoreGeneration(sql: WatchdogSqliteOwner["sql"]): () => string;
+export declare function createInstallationStoreGeneration(owner: WatchdogSqliteOwner): {
+    generation: () => string;
+    resetAt: () => number | null;
+};

package/dist/installation-store-generation.js

@@ -1,16 +1,69 @@
 import * as Schema from "effect/Schema";
 import { defineIdFamily } from "@fungi.computer/cairn/id";
+import { installationsFromOlderOyster } from "./older-oyster-store.js";
 const installationStoreIds = defineIdFamily({
     family: "installation-store",
     version: 1,
     kinds: { generation: { prefix: "store" } },
 });
 const generationRow = Schema.decodeUnknownSync(Schema.Struct({ generation: Schema.NonEmptyString }));
+const resetRow = Schema.decodeUnknownSync(Schema.Struct({ reset_at: Schema.NullOr(Schema.Int) }));
+const columnRow = Schema.decodeUnknownSync(Schema.Struct({ name: Schema.String }));
+const countRow = Schema.decodeUnknownSync(Schema.Struct({ count: Schema.Int }));
+/** Recognize only the retired producer's keys, never general decode failures. */
+function preOwnerOnlyInstallations(sql) {
+    if (sql
+        .exec("SELECT 1 FROM sqlite_master WHERE type='table' AND name='installations'")
+        .toArray().length === 0)
+        return false;
+    // Missing authority belongs to the existing pre-0.3 refusal, not this reset.
+    if (installationsFromOlderOyster(sql))
+        return false;
+    return (sql
+        .exec(`SELECT 1 FROM installations WHERE json_valid(record) AND (
+      json_type(record, '$.visibility') IS NOT NULL OR
+      json_type(record, '$.approvedAnonymousMethods') IS NOT NULL OR
+      json_type(record, '$.anonymousApproval') IS NOT NULL
+    ) LIMIT 1`)
+        .toArray().length > 0);
+}
 /** Own one persisted store incarnation, independent of installation row revisions. */
-export function createInstallationStoreGeneration(sql) {
-    sql.exec("CREATE TABLE IF NOT EXISTS installation_store (id INTEGER PRIMARY KEY CHECK (id=1), generation TEXT NOT NULL) STRICT");
-    sql.exec("INSERT OR IGNORE INTO installation_store (id,generation) VALUES(1,?)", installationStoreIds.generation.generate());
-    return () => generationRow(sql
-        .exec("SELECT generation FROM installation_store WHERE id=1")
-        .toArray()[0]).generation;
+export function createInstallationStoreGeneration(owner) {
+    const { sql } = owner;
+    const needsReset = preOwnerOnlyInstallations(sql);
+    const resetAt = () => resetRow(sql
+        .exec("SELECT reset_at FROM installation_store WHERE id=1")
+        .toArray()[0]).reset_at;
+    owner.transactionSync(() => {
+        sql.exec("CREATE TABLE IF NOT EXISTS installation_store (id INTEGER PRIMARY KEY CHECK (id=1), generation TEXT NOT NULL, reset_at INTEGER, reset_rows INTEGER) STRICT");
+        // Enroll the existing incarnation singleton in its current audit shape.
+        const columns = sql
+            .exec("PRAGMA table_info(installation_store)")
+            .toArray()
+            .map((row) => columnRow(row));
+        if (!columns.some(({ name }) => name === "reset_at"))
+            sql.exec("ALTER TABLE installation_store ADD COLUMN reset_at INTEGER");
+        if (!columns.some(({ name }) => name === "reset_rows"))
+            sql.exec("ALTER TABLE installation_store ADD COLUMN reset_rows INTEGER");
+        sql.exec("INSERT OR IGNORE INTO installation_store (id,generation) VALUES(1,?)", installationStoreIds.generation.generate());
+        if (!needsReset || resetAt() !== null || !preOwnerOnlyInstallations(sql))
+            return;
+        const rows = countRow(sql.exec("SELECT COUNT(*) AS count FROM installations").toArray()[0]).count;
+        // any row keyed by an installationId that is read as authority must be
+        // cleared in the same transaction. Other owners and Watchdog job identities
+        // remain intact; their existing missing-command handling settles orphan work.
+        sql.exec("DELETE FROM installations");
+        if (sql
+            .exec("SELECT 1 FROM sqlite_master WHERE type='table' AND name='installation_commands'")
+            .toArray().length > 0)
+            sql.exec("DELETE FROM installation_commands");
+        sql.exec("UPDATE installation_store SET generation=? WHERE id=1", installationStoreIds.generation.generate());
+        sql.exec("UPDATE installation_store SET reset_at=?, reset_rows=? WHERE id=1", Date.now(), rows);
+    });
+    return {
+        generation: () => generationRow(sql
+            .exec("SELECT generation FROM installation_store WHERE id=1")
+            .toArray()[0]).generation,
+        resetAt,
+    };
 }

package/dist/internal/delivery.js

@@ -92,7 +92,6 @@ export async function deliverBackground(host, raw) {
                     case "not_declared":
                     case "approval_required":
                     case "invalid_input":
-                    case "visitor_read_only":
                         return { kind: "refused", code: "denied" };
                 }
             }

package/dist/internal/host-gate.d.ts

@@ -1,14 +1,17 @@
 /** Release verification and gate facts shared by the HTTP host and its delivery engines. */
+import type { TenantPrincipal } from "../tenant.js";
 import type { Release } from "@fungi.computer/puffball";
 import type { GateFacts } from "../apps/gate.js";
 import type { Installation } from "../apps/installation.js";
-import type { OysterHost, OysterPrincipal } from "../host.js";
+import type { OysterHost } from "../host.js";
 import { type ArtifactStore, type VerifiedRelease } from "../release.js";
 /**
- * Verify each Release once per process: a failed read is not cached, so the
- * next request reads it again. Installation verified every asset; serving
- * verifies each on read.
+ * Verify each Release once per owner (an isolate's HTTP host, or the
+ * Registry): a failed read is not cached, so the next request reads it again.
+ * Installation verified every asset; serving verifies each on read. A Release
+ * is content-addressed and immutable, so the key is its ID and root digest and
+ * a hit never goes stale; the bound only forgets the oldest-verified Releases.
  */
-export declare function releaseCache(artifacts: ArtifactStore): (release: Release) => Promise<VerifiedRelease>;
+export declare function releaseCache(artifacts: ArtifactStore, limit?: number): (release: Release) => Promise<VerifiedRelease>;
 /** The gate facts one principal presents to one installation. */
-export declare function hostGateFacts(host: OysterHost, installation: Installation, release: VerifiedRelease, principal: OysterPrincipal): Promise<GateFacts>;
+export declare function hostGateFacts(host: OysterHost, installation: Installation, release: VerifiedRelease, principal: TenantPrincipal): Promise<GateFacts>;

package/dist/internal/host-gate.js

@@ -1,53 +1,47 @@
 import { emptyAppDeclaration } from "@fungi.computer/puffball/app";
 import { deriveDeclaredOperations } from "../apps/operations.js";
-import { keyAppAccess } from "../keys.js";
+import { appToolAccess, authorityOf, hostAuthorityPorts, } from "../authorization.js";
 import { defaultAssetPolicy, verifyRelease, } from "../release.js";
+/** Verified Releases one cache keeps; the least recently added leaves first. */
+const releaseCacheLimit = 256;
 /**
- * Verify each Release once per process: a failed read is not cached, so the
- * next request reads it again. Installation verified every asset; serving
- * verifies each on read.
+ * Verify each Release once per owner (an isolate's HTTP host, or the
+ * Registry): a failed read is not cached, so the next request reads it again.
+ * Installation verified every asset; serving verifies each on read. A Release
+ * is content-addressed and immutable, so the key is its ID and root digest and
+ * a hit never goes stale; the bound only forgets the oldest-verified Releases.
  */
-export function releaseCache(artifacts) {
+export function releaseCache(artifacts, limit = releaseCacheLimit) {
     const verified = new Map();
     return (release) => {
         const key = `${release.releaseId}:${release.artifact.artifactDigest}`;
         let entry = verified.get(key);
         if (entry === undefined) {
-            // A failed read is not cached: the next request reads the Release again.
-            // Installation verified every asset; serving verifies each on read.
-            entry = verifyRelease(artifacts, release, defaultAssetPolicy, false).then((value) => value, (cause) => {
+            entry = verifyRelease(artifacts, release, defaultAssetPolicy, false).catch((cause) => {
                 verified.delete(key);
                 throw cause;
             });
             verified.set(key, entry);
+            for (const oldest of verified.keys()) {
+                if (verified.size <= limit)
+                    break;
+                verified.delete(oldest);
+            }
         }
         return entry;
     };
 }
-/**
- * Only Agents and keys hold tool policy; members and visitors never ask. An
- * Agent keeps its one blanket policy; a key's access is its own grants for
- * this one installation -- `null` when its live key is unknown, revoked,
- * expired or suspended, or simply does not reach this installation, which
- * then refuses `not_approved`, the same as an Agent with no approval.
- */
-async function hostToolPolicy(host, actor, installationId) {
-    if (actor.kind === "agent")
-        return (await host.appToolPolicy?.(actor)) ?? null;
-    if (actor.kind !== "team-key")
-        return null;
-    const key = (await host.keys?.live(actor.keyId)) ?? null;
-    return key === null ? null : keyAppAccess(key, installationId);
-}
 /** The gate facts one principal presents to one installation. */
 export async function hostGateFacts(host, installation, release, principal) {
     const { actor } = principal;
     const declaration = release.declaration ?? emptyAppDeclaration;
-    const toolPolicy = await hostToolPolicy(host, actor, installation.installationId);
+    // Only Agents and keys hold tool policy (`authorization.ts`); `null`
+    // refuses `not_approved`, the same as an Agent with no approval.
+    const ports = hostAuthorityPorts(host);
+    const toolPolicy = await appToolAccess(await authorityOf(principal, ports), installation.installationId, ports);
     return {
         installation: {
             status: installation.status,
-            visibility: installation.visibility,
             instanceId: installation.instanceId,
             authority: installation.authority,
             artifactDigest: installation.release.artifact.artifactDigest,

package/dist/internal/invocation-timing.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Name where a slow App invocation waited, as the Instance saw it: verifying
+ * its backend, waiting for the frame permit, running the guest, and the guest's
+ * binding packets inside that run. Durable Object wall time otherwise hides
+ * which of these a caller's seconds went to.
+ */
+export declare function reportSlowInvocation(name: string, host: Readonly<{
+    bindingWaits: {
+        count: number;
+        ms: number;
+    };
+}>, at: Readonly<{
+    entered: number;
+    verified: number;
+    admitted: number;
+}>, now?: () => number): void;

package/dist/internal/invocation-timing.js

@@ -0,0 +1,23 @@
+/** Stage timing for slow App invocations, logged by the Instance that ran them. */
+/** Invocations slower than this log their stages; faster ones log nothing. */
+const slowInvocationMs = 200;
+/**
+ * Name where a slow App invocation waited, as the Instance saw it: verifying
+ * its backend, waiting for the frame permit, running the guest, and the guest's
+ * binding packets inside that run. Durable Object wall time otherwise hides
+ * which of these a caller's seconds went to.
+ */
+export function reportSlowInvocation(name, host, at, now = Date.now) {
+    const finished = now();
+    if (finished - at.entered < slowInvocationMs)
+        return;
+    console.log("Slow App invocation", {
+        name,
+        totalMs: finished - at.entered,
+        verifyMs: at.verified - at.entered,
+        permitMs: at.admitted - at.verified,
+        runMs: finished - at.admitted,
+        bindingCalls: host.bindingWaits.count,
+        bindingMs: host.bindingWaits.ms,
+    });
+}

package/dist/internal/registry-installations.js

@@ -5,6 +5,7 @@ export function registryInstallations(env, scope) {
     return {
         operations: installationOperationsPort((request) => registry().installationOperation(request), { tenantId: scope.tenantId, origin: scope.origin }),
         generation: async () => registry().generation(),
+        resetAt: async () => registry().installationResetAt(),
         list: async () => registry().list(),
         get: async (id) => registry().get(id),
         compareAndPut: async (installation, expectedAuthorityVersion, expectedGeneration) => await registry().compareAndPut(installation, expectedAuthorityVersion, expectedGeneration, scope.tenantId),

package/dist/invocation.d.ts

@@ -1,4 +1,5 @@
-import type { OysterHost, OysterPrincipal } from "./host.js";
+import type { TenantPrincipal } from "./tenant.js";
+import type { OysterHost } from "./host.js";
 import type { VerifiedRelease } from "./release.js";
 import type { Installation } from "./apps/installation.js";
 import { type InvocationGrants } from "./apps/gate.js";
@@ -191,9 +192,9 @@ export type BackgroundFrameState = {
 export declare function assertBackgroundBinding(frame: InvocationFrame<BackgroundFrameState>, binding: AppBackendBindingName): void;
 /** Consume this frame's one origin check before awaiting verification, then retain only its decision. */
 export declare function admitBackgroundFrame(key: CryptoKey, frame: InvocationFrame<BackgroundFrameState>, raw: unknown): Promise<ClaimedJobAdmission>;
-/** The host's native guest-abort and authority-close hooks. */
+/** The host's native guest-abort and frame-authority-close hooks. */
 export type InvocationGatePorts<Host> = Readonly<{
-    /** Stop the guest when the captured invocation's authority closes. */
+    /** Stop the shared guest at cohort drain or revocation, before the last close. */
     abortGuest: () => Promise<void>;
     /** Release the host resources belonging to this completed or revoked frame. */
     close: (frame: InvocationFrame<Host>) => Promise<void>;
@@ -202,10 +203,10 @@ export type InvocationGatePorts<Host> = Readonly<{
 }>;
 /** One invocation owner shared by Hub shards and standalone Instances. */
 export type InvocationGate<Host> = Readonly<{
-    /** Run work within one immutable frame and close its authority afterward. */
+    /** Run one immutable frame; verified foreground reads may share until drain. */
     run: <A>(facts: InvocationFacts, host: Host, work: (frame: InvocationFrame<Host>) => Promise<A>) => Promise<A>;
-    /** Resolve the sole admitted frame, refusing outside an active invocation. */
-    active: () => InvocationFrame<Host>;
+    /** Resolve one live frame by its id, refusing a closed or unknown frame. */
+    active: (frameId: string) => InvocationFrame<Host>;
     /** Close live authority, optionally restricted to frames of a selected run. */
     revoke: (reason?: Error, target?: Readonly<{
         runId: string;
@@ -215,7 +216,15 @@ export type InvocationGate<Host> = Readonly<{
 }>;
 /** Decode only identities minted from the invocation-frame ID family. */
 export declare const invocationFrameIdSchema: Schema.String;
-/** Serialize authority, preempt replay only for verified writes, and close each guest before admission. */
+/**
+ * One Instance shares up to eight verified foreground reads; all other work
+ * runs alone in first-come order. Every finish fences its frame; the last live
+ * frame stops the native guest before closing authority and releasing admission.
+ * Binding checks alone cannot stop a timer mutating the facet's own SQLite.
+ * Revocation, expiry and a verified write preempting replay stop every live frame.
+ * Arrivals wait for a stopping guest. Once the opening deadline passes, new
+ * reads queue exclusively so the current cohort cannot be prolonged forever.
+ */
 export declare function createInvocationGate<Host>(ports: InvocationGatePorts<Host>): InvocationGate<Host>;
 /** Verified selection, artifact and binding grants before caller attribution. */
 export type InvocationAuthority = Omit<InvocationFacts, "subject" | "deadlineAt">;
@@ -226,11 +235,10 @@ export type InvocationDeadline = Readonly<{
 }>;
 /**
  * Project an admitted principal into App attribution; only the host chooses
- * the fixed Computer context. The App caller grammar has no visitor actor, so
- * the anonymous public reader is attributed as the reserved `visitor` key
- * without a Computer. Host admission reads the principal, never this projection.
+ * the fixed Computer context. Host admission reads the principal, never this
+ * projection.
  */
-export declare function invocationCallerContext(principal: OysterPrincipal, computerId: string | null): AppMethodCallContext;
+export declare function invocationCallerContext(principal: TenantPrincipal, computerId: string | null): AppMethodCallContext;
 /** Shared host-held caller/Workflow fact builders, never guest argument decoders. */
 export declare const invocationFacts: {
     /** Combine host-admitted caller facts with the invocation and grant deadlines. */