@nylorun/runtime 0.16.0-beta → 0.17.0-beta

package/dist/store/postgres/schema.js

@@ -5,9 +5,8 @@
  * "snake_case"`, here, in `db.ts` and in `drizzle.config.ts`).
  *
  * - `nylorun` holds the Tenant's state: the one `tenant` row, the document tables, Action
- *   endpoints, principals, vaults and credentials, signing keys, publishable keys, subject
- *   epochs and usage, settings, the model usage ledger, the model budgets, the Tool Gate's
- *   crossings and file artifacts with their versions.
+ *   endpoints, principals, vaults and credentials, signing keys, settings, the model usage
+ *   ledger, the model budgets, the Tool Gate's crossings and file artifacts with their versions.
  * - `nylorun_streams` holds the record (Durable Streams §6): `session_events`,
  *   `session_log_heads` and the relay's `relay_slots`. The relay's publication is custom SQL
  *   (`drizzle/0002_stream_relay.sql`).
@@ -160,11 +159,15 @@ export const vaults = nylorun.table("vaults", {
     /** JSON text, or null. */
     metadataJson: text(),
     createdAt: textC().notNull(),
-    scope: text({ enum: ["user", "host"] }).notNull().default("user"),
+    /**
+     * `user`: one person's (owner `ownerUserId`); `installation`: the installation's own,
+     * attachable to any session (owner `installation`); `host`: the model vault, never attached.
+     */
+    scope: text({ enum: ["user", "installation", "host"] }).notNull().default("user"),
 }, (t) => [
     index("vaults_owner").on(t.ownerUserId, t.createdAt, t.id),
     uniqueIndex("vaults_one_host").on(t.scope).where(sql `scope = 'host'`),
-    check("vaults_scope_check", sql `scope IN ('user', 'host')`),
+    check("vaults_scope_check", sql `scope IN ('user', 'installation', 'host')`),
 ]);
 /** A credential of a vault: its binding in the clear, its secret sealed. */
 export const vaultCredentials = nylorun.table("vault_credentials", {
@@ -207,11 +210,48 @@ export const vaultIdempotency = nylorun.table("vault_idempotency", {
     /** JSON text of the original response. */
     response: text().notNull(),
 });
+/**
+ * An MCP OAuth connect between its start and its callback (F9 C2): found by the SHA-256 of its
+ * `state`, used once, for ten minutes. The PKCE verifier and any client secret are sealed under
+ * the vault key (`sealBytes`), which only the keys module holds.
+ */
+export const oauthPending = nylorun.table("oauth_pending", {
+    stateHash: text().primaryKey(),
+    vaultId: text().notNull(),
+    /** The MCP server's name in the agent, the credential's name. */
+    server: text().notNull(),
+    /** The MCP server's URL (normalized): the credential's binding. */
+    url: text().notNull(),
+    tokenEndpoint: text().notNull(),
+    clientId: text().notNull(),
+    /** How the client authenticates at the token endpoint: `none`, `client_secret_basic` or `client_secret_post`. */
+    tokenEndpointAuth: text({ enum: ["none", "client_secret_basic", "client_secret_post"] }).notNull(),
+    /** The RFC 8707 resource indicator sent with the authorization request, if any. */
+    resource: text(),
+    kekId: text().notNull(),
+    /** Sealed; null for a public client. */
+    clientSecret: bytes(),
+    /** Sealed. */
+    codeVerifier: bytes().notNull(),
+    redirectUri: text().notNull(),
+    expiresAt: textC().notNull(),
+    createdAt: textC().notNull(),
+}, (t) => [
+    foreignKey({
+        name: "oauth_pending_vault_id_fkey",
+        columns: [t.vaultId],
+        foreignColumns: [vaults.id],
+    }).onDelete("cascade"),
+    index("oauth_pending_expires").on(t.expiresAt),
+]);
 export const tenantSettings = nylorun.table("tenant_settings", {
     key: text().primaryKey(),
     value: text().notNull(),
 });
-/** The Tenant's signing keys (subject tokens): the private half sealed, the public JWK not. */
+/**
+ * The Tenant's signing keys (delivery tokens, capability links, run and host tokens): the
+ * private half sealed, the public JWK not.
+ */
 export const signingKeys = nylorun.table("signing_keys", {
     id: textC().primaryKey(),
     state: text({ enum: ["standby", "current", "previous", "revoked"] }).notNull(),
@@ -233,28 +273,6 @@ export const signingKeys = nylorun.table("signing_keys", {
     uniqueIndex("signing_keys_one_current").on(t.state).where(sql `state = 'current'`),
     uniqueIndex("signing_keys_one_previous").on(t.state).where(sql `state = 'previous'`),
 ]);
-/** Each subject's revocation epoch. */
-export const subjectEpochs = nylorun.table("subject_epochs", {
-    subject: textC().primaryKey(),
-    epoch: bigint({ mode: "number" }).notNull(),
-    revokedAt: text().notNull(),
-});
-/** Each subject's turn bucket: tokens left and when they were last refilled. */
-export const subjectUsage = nylorun.table("subject_usage", {
-    subject: textC().primaryKey(),
-    turnTokens: doublePrecision().notNull(),
-    refilledAt: text().notNull(),
-});
-/** Publishable keys (Host feature `browser-access`): public by design. */
-export const publishableKeys = nylorun.table("publishable_keys", {
-    id: textC().primaryKey(),
-    key: textC().notNull().unique("publishable_keys_key_key"),
-    name: text().notNull().unique("publishable_keys_name_key"),
-    /** JSON array of allowed origins. */
-    originsJson: text().notNull(),
-    createdAt: text().notNull(),
-    revokedAt: text(),
-});
 /**
  * Action endpoints: where the Runtime delivers each agent's Actions over HTTP, and the health
  * recent deliveries and the last ping report.

package/dist/store/postgres/store.js

@@ -56,7 +56,7 @@ import { database, driverError } from "./db.js";
 import { expectedSchemaVersion, readSchemaVersion } from "./migrate.js";
 import { createPostgresRecordReader } from "./record.js";
 import { postgresRecordWriter, postgresSandboxRecordWriter } from "./record-writer.js";
-import { actions, artifacts, artifactVersions, artifactContent, commands, definitions, effects, endpoints, links, modelBudgets, modelUsage, principals, publishableKeys, sandboxes, sandboxEvents, sandboxResources, sessionEvents, sessionLogHeads, sessions, toJson, toolCrossings, signingKeys, subjectEpochs, subjectUsage, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, } from "./schema.js";
+import { actions, artifacts, artifactVersions, artifactContent, commands, definitions, effects, endpoints, links, modelBudgets, modelUsage, principals, sandboxes, sandboxEvents, sandboxResources, sessionEvents, sessionLogHeads, sessions, toJson, toolCrossings, signingKeys, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, oauthPending, } from "./schema.js";
 export function createPostgresSessionStore(options) {
     return new PostgresSessionStore(options);
 }
@@ -760,6 +760,30 @@ class PostgresTx {
             .orderBy(principals.id);
         return rows.map((row) => row.tokenHash);
     }
+    async listPrincipals() {
+        this.check();
+        return await this.db.select().from(principals).orderBy(principals.id);
+    }
+    async putPrincipal(id, tokenHash, createdAt) {
+        this.check();
+        const [row] = await this.db
+            .insert(principals)
+            .values({ id, role: "application", tokenHash, idempotencyKey: null, createdAt })
+            .onConflictDoUpdate({
+            target: principals.id,
+            set: { tokenHash, createdAt, idempotencyKey: null },
+        })
+            .returning();
+        return row;
+    }
+    async deletePrincipal(id) {
+        this.check();
+        const rows = await this.db
+            .delete(principals)
+            .where(eq(principals.id, id))
+            .returning({ id: principals.id });
+        return rows.length > 0;
+    }
     // --- vault ---------------------------------------------------------------
     async insertVault(row) {
         this.check();
@@ -778,6 +802,14 @@ class PostgresTx {
             .where(and(eq(vaults.ownerUserId, ownerUserId), eq(vaults.scope, "user")))
             .orderBy(vaults.createdAt, vaults.id);
     }
+    async installationVaults() {
+        this.check();
+        return this.db
+            .select()
+            .from(vaults)
+            .where(eq(vaults.scope, "installation"))
+            .orderBy(vaults.createdAt, vaults.id);
+    }
     async updateVaultMetadata(id, metadataJson) {
         this.check();
         await this.db.update(vaults).set({ metadataJson }).where(eq(vaults.id, id));
@@ -858,7 +890,24 @@ class PostgresTx {
         this.check();
         await this.db.insert(vaultIdempotency).values(row);
     }
-    // --- subject tokens ------------------------------------------------------
+    async insertOAuthPending(row) {
+        this.check();
+        await this.db.insert(oauthPending).values(row);
+    }
+    async takeOAuthPending(stateHash) {
+        this.check();
+        const [row] = await this.db
+            .delete(oauthPending)
+            .where(eq(oauthPending.stateHash, stateHash))
+            .returning();
+        return row;
+    }
+    async deleteExpiredOAuthPending(now) {
+        this.check();
+        const result = await this.db.delete(oauthPending).where(lt(oauthPending.expiresAt, now));
+        return result.count;
+    }
+    // --- signing keys --------------------------------------------------------
     async lockSigningKeys() {
         this.check();
         await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.signing_keys'))`);
@@ -895,103 +944,6 @@ class PostgresTx {
         const [row] = await this.db.select({ n: count() }).from(signingKeys);
         return row.n;
     }
-    async subjectEpoch(subject) {
-        this.check();
-        const [row] = await this.db
-            .select({ epoch: subjectEpochs.epoch })
-            .from(subjectEpochs)
-            .where(eq(subjectEpochs.subject, subject));
-        return row?.epoch ?? 0;
-    }
-    async subjectEpochs(subjects) {
-        this.check();
-        if (subjects.length === 0)
-            return new Map();
-        const rows = await this.db
-            .select({ subject: subjectEpochs.subject, epoch: subjectEpochs.epoch })
-            .from(subjectEpochs)
-            .where(inArray(subjectEpochs.subject, subjects));
-        return new Map(rows.map((row) => [row.subject, row.epoch]));
-    }
-    async bumpSubjectEpoch(subject, at) {
-        this.check();
-        const [row] = await this.db
-            .insert(subjectEpochs)
-            .values({ subject, epoch: 1, revokedAt: at })
-            .onConflictDoUpdate({
-            target: subjectEpochs.subject,
-            set: { epoch: sql `${subjectEpochs.epoch} + 1`, revokedAt: excluded("revoked_at") },
-        })
-            .returning({ epoch: subjectEpochs.epoch });
-        return row.epoch;
-    }
-    async lockSubjectUsage(initial) {
-        this.check();
-        await this.db.insert(subjectUsage).values(initial).onConflictDoNothing();
-        const [row] = await this.db
-            .select()
-            .from(subjectUsage)
-            .where(eq(subjectUsage.subject, initial.subject))
-            .for("update");
-        return row;
-    }
-    async putSubjectUsage(row) {
-        this.check();
-        await this.db
-            .insert(subjectUsage)
-            .values(row)
-            .onConflictDoUpdate({
-            target: subjectUsage.subject,
-            set: { turnTokens: excluded("turn_tokens"), refilledAt: excluded("refilled_at") },
-        });
-    }
-    async countOwnerSessions(ownerUserId, statuses) {
-        this.check();
-        const [row] = await this.db
-            .select({ n: count() })
-            .from(sessions)
-            .where(and(eq(sessions.ownerUserId, ownerUserId), inArray(sessions.status, statuses)));
-        return row.n;
-    }
-    // --- publishable keys ----------------------------------------------------
-    async insertPublishableKey(row) {
-        this.check();
-        await this.db.insert(publishableKeys).values(row);
-    }
-    async publishableKeyByKey(key) {
-        this.check();
-        const [row] = await this.db
-            .select()
-            .from(publishableKeys)
-            .where(eq(publishableKeys.key, key));
-        return row;
-    }
-    async publishableKey(id) {
-        this.check();
-        const [row] = await this.db
-            .select()
-            .from(publishableKeys)
-            .where(eq(publishableKeys.id, id));
-        return row;
-    }
-    async publishableKeys() {
-        this.check();
-        return this.db
-            .select()
-            .from(publishableKeys)
-            .orderBy(publishableKeys.createdAt, publishableKeys.id);
-    }
-    async updatePublishableKey(id, patch) {
-        this.check();
-        if (patch.originsJson === undefined && patch.revokedAt === undefined)
-            return (await this.publishableKey(id)) !== undefined;
-        const rows = await this.db
-            .update(publishableKeys)
-            .set(patch)
-            .where(eq(publishableKeys.id, id))
-            .returning({ id: publishableKeys.id });
-        return rows.length === 1;
-    }
     // --- model usage ---------------------------------------------------------
     async recordModelUsage(row) {
         this.check();
@@ -1208,7 +1160,6 @@ class PostgresTx {
         if (scope === "sessions" || scope === "all") {
             for (const table of SESSION_TABLES)
                 await db.delete(table);
-            await db.delete(subjectUsage);
             await db.delete(toolCrossings);
             // A session's artifacts go with it (their versions by cascade).
             await db.delete(artifacts).where(isNotNull(artifacts.sessionId));

package/dist/store/postgres/tenant.d.ts

@@ -16,7 +16,7 @@ export interface TenantCreation {
     /** Ignored when the Tenant exists. */
     name: string;
     /**
-     * The principals the Tenant must have, given its id (derived keys depend on it). Created
+     * The principals the Tenant must have, given its id (Studio's derived key depends on it). Created
      * with the Tenant; on later opens, the missing ones are added.
      */
     principals?(tenantId: string): readonly InitialPrincipal[];

package/dist/store/postgres/tenant.js

@@ -14,8 +14,8 @@
  * 3. When `nylorun.tenant` is empty, create the Tenant: its row (id, name, created time) and
  *    its first principals. A database whose row is gone but that holds a Tenant's data
  *    (principals, sessions, agents, vaults, keys) is `envelope-invalid`, never given a new
- *    Tenant. Principals given later that the Tenant does not have yet are added (a derived
- *    principal configured after the first start); existing ones are kept.
+ *    Tenant. Principals given later that the Tenant does not have yet are added (the
+ *    ephemeral Runtime's application key); existing ones are kept, as ordinary keys.
  * 4. Read the envelope back (`envelope-invalid` when it does not parse), and open the store.
  *
  * A lost connection or an unavailable server says nothing about the Tenant: it is thrown as

package/dist/store/types.d.ts

@@ -58,7 +58,7 @@ import type { RecordReader } from "../streams/relay/types.js";
 import type { Action, EventPayload, EventType, LiveEvent, SandboxEvent, SandboxEventPayload, SandboxEventType, SandboxKind, SandboxPodDesired, SandboxPodObserved, SessionEventOf } from "@nylorun/core/contracts";
 import type { SandboxManifest } from "@nylorun/core/define";
 import type { HostEffect } from "@nylorun/harness/run";
-import type { ArtifactRow, ArtifactVersionRow, ModelBudgetRow, ModelUsageRow, PrincipalRow, ToolCrossingRow, PublishableKeyRow, SigningKeyRow, SubjectUsageRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow } from "./postgres/schema.js";
+import type { ArtifactRow, ArtifactVersionRow, ModelBudgetRow, ModelUsageRow, PrincipalRow, ToolCrossingRow, SigningKeyRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow, OAuthPendingRow } from "./postgres/schema.js";
 /** Tables holding JSON documents keyed by `id`. */
 export type DocTable = "definitions" | "sessions" | "commands" | "effects" | "actions" | "sandboxes" | "links";
 export declare const DOC_TABLES: readonly DocTable[];
@@ -242,10 +242,9 @@ export type EndpointHealthUpdate =
  * The rows of the typed tables, inferred from the tables Drizzle defines
  * (`store/postgres/schema.ts`): a principal, a vault and its credentials (secrets sealed in
  * `bytea` columns, never inside a JSON body), the vault's audit and idempotency records, the
- * Tenant's signing keys, a subject's turn bucket, a publishable key, a model call in the usage
- * ledger and a model budget.
+ * Tenant's signing keys, a model call in the usage ledger and a model budget.
  */
-export type { ArtifactRow, ArtifactVersionRow, ModelBudgetRow, ModelUsageRow, ToolCrossingRow, PrincipalRow, PublishableKeyRow, SigningKeyRow, SubjectUsageRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow, };
+export type { ArtifactRow, ArtifactVersionRow, ModelBudgetRow, ModelUsageRow, ToolCrossingRow, PrincipalRow, SigningKeyRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow, OAuthPendingRow, };
 /** Which rows of the usage ledger a total covers. */
 export interface ModelUsageQuery {
     scope: "tenant" | "agent" | "turn";
@@ -480,11 +479,23 @@ export interface Tx {
     principalByTokenHash(tokenHash: string): Promise<PrincipalRow | undefined>;
     principalById(id: string): Promise<PrincipalRow | undefined>;
     applicationTokenHashes(): Promise<string[]>;
+    /** Every principal, ordered by id. */
+    listPrincipals(): Promise<PrincipalRow[]>;
+    /**
+     * Creates application principal `id` with `tokenHash`, or gives an existing one this hash
+     * (and `createdAt`): its previous key stops authenticating. Rejects when another principal
+     * holds the hash.
+     */
+    putPrincipal(id: string, tokenHash: string, createdAt: string): Promise<PrincipalRow>;
+    /** Deletes principal `id`; false when there was none. */
+    deletePrincipal(id: string): Promise<boolean>;
     /** Rejects on a duplicate id, or a second `host` vault. */
     insertVault(row: VaultRow): Promise<void>;
     getVault(id: string): Promise<VaultRow | undefined>;
     /** User vaults of one owner, ordered by `createdAt`, then id. */
     vaultsByOwner(ownerUserId: string): Promise<VaultRow[]>;
+    /** Installation vaults (any session may attach them), ordered by `createdAt`, then id. */
+    installationVaults(): Promise<VaultRow[]>;
     updateVaultMetadata(id: string, metadataJson: string | null): Promise<void>;
     /** Deletes the vault and its credentials. */
     deleteVault(id: string): Promise<void>;
@@ -510,6 +521,12 @@ export interface Tx {
     getVaultIdempotency(id: string): Promise<VaultIdempotencyRow | undefined>;
     /** Rejects when the id exists. */
     insertVaultIdempotency(row: VaultIdempotencyRow): Promise<void>;
+    /** An MCP OAuth connect's start (F9 C2). Rejects on a duplicate state or an unknown vault. */
+    insertOAuthPending(row: OAuthPendingRow): Promise<void>;
+    /** Deletes and returns the pending connect of `stateHash`, expired or not: each is used once. */
+    takeOAuthPending(stateHash: string): Promise<OAuthPendingRow | undefined>;
+    /** Deletes the pending connects that expired before `now` (ISO); returns how many. */
+    deleteExpiredOAuthPending(now: string): Promise<number>;
     /**
      * Serializes signing key changes: held until the transaction ends. Take it before reading
      * the keys a change depends on, so concurrent first uses or rotations do not collide.
@@ -527,28 +544,6 @@ export interface Tx {
      */
     setSigningKeyState(id: string, from: SigningKeyRow["state"], to: SigningKeyRow["state"], at: string): Promise<boolean>;
     countSigningKeys(): Promise<number>;
-    /** The subject's revocation epoch; 0 when it was never revoked. */
-    subjectEpoch(subject: string): Promise<number>;
-    /** The epochs of several subjects; subjects never revoked are absent. */
-    subjectEpochs(subjects: readonly string[]): Promise<Map<string, number>>;
-    /** Adds one to the subject's epoch and returns the new value. */
-    bumpSubjectEpoch(subject: string, at: string): Promise<number>;
-    /**
-     * The subject's turn bucket, created from `initial` when missing, locked until the
-     * transaction ends so concurrent commands of one subject serialize.
-     */
-    lockSubjectUsage(initial: SubjectUsageRow): Promise<SubjectUsageRow>;
-    putSubjectUsage(row: SubjectUsageRow): Promise<void>;
-    /** How many sessions of `ownerUserId` are in one of `statuses`. */
-    countOwnerSessions(ownerUserId: string, statuses: readonly string[]): Promise<number>;
-    /** Rejects on a duplicate id, key or name. */
-    insertPublishableKey(row: PublishableKeyRow): Promise<void>;
-    publishableKeyByKey(key: string): Promise<PublishableKeyRow | undefined>;
-    publishableKey(id: string): Promise<PublishableKeyRow | undefined>;
-    /** All keys, revoked ones included, ordered by `createdAt`, then id. */
-    publishableKeys(): Promise<PublishableKeyRow[]>;
-    /** Returns false when the key does not exist. */
-    updatePublishableKey(id: string, patch: Partial<Pick<PublishableKeyRow, "originsJson" | "revokedAt">>): Promise<boolean>;
     /** Appends a row, setting `duplicate` when one with the same `effectKey` exists; returns it. */
     recordModelUsage(row: Omit<ModelUsageRow, "duplicate">): Promise<ModelUsageRow>;
     modelUsageTotals(query: ModelUsageQuery): Promise<ModelUsageTotals>;
@@ -616,15 +611,14 @@ export interface Tx {
     putSetting(key: string, value: string): Promise<void>;
     /**
      * Deletes Tenant state by scope, in this transaction:
-     * - `sessions`: sessions, commands, effects, actions, links, subject turn
-     *   buckets, the artifacts of sessions (their blobs are the caller's to delete) and the
+     * - `sessions`: sessions, commands, effects, actions, links, the artifacts of sessions (their blobs are the caller's to delete) and the
      *   Tenant's record rows and log heads. The Tenant moves to the next basin
      *   generation and the current one is retired, so session ids it frees start again in an
      *   empty basin;
      * - `sandboxes`: sandbox records, sandbox resources and their lifecycle streams;
      * - `all`: both, plus definitions, Action endpoints, user vaults with their credentials,
-     *   the model usage ledger, the model budgets and Tenant-wide artifacts. The host vault, principals, signing keys, subject epochs,
-     *   publishable keys, settings, audit and vault idempotency rows stay.
+     *   the model usage ledger, the model budgets and Tenant-wide artifacts. The host vault, principals, signing keys,
+     *   settings, audit and vault idempotency rows stay.
      */
     reset(scope: ResetScope): Promise<void>;
 }

package/dist/streams/control.d.ts

@@ -13,8 +13,3 @@ export declare function signalActionResolved(streams: DurableStreams, basin: str
  * Tenant open moves its readers to `generation` and ends the streams of deleted sessions.
  */
 export declare function signalSessionsReset(streams: DurableStreams, basin: string, generation: number): Promise<void>;
-/**
- * Appends a `subject.revoked` signal: every process with the Tenant open ends the subject's
- * streams opened with a token older than `epoch`.
- */
-export declare function signalSubjectRevoked(streams: DurableStreams, basin: string, subject: string, epoch: number): Promise<void>;

package/dist/streams/control.js

@@ -28,11 +28,3 @@ export async function signalSessionsReset(streams, basin, generation) {
     const signal = { type: "sessions.reset", generation };
     await streams.append(basin, CONTROL_STREAM, [signal]);
 }
-/**
- * Appends a `subject.revoked` signal: every process with the Tenant open ends the subject's
- * streams opened with a token older than `epoch`.
- */
-export async function signalSubjectRevoked(streams, basin, subject, epoch) {
-    const signal = { type: "subject.revoked", subject, epoch };
-    await streams.append(basin, CONTROL_STREAM, [signal]);
-}

package/dist/streams/types.d.ts

@@ -7,7 +7,7 @@
  * | Stream | Contents | Written by | Read by |
  * | --- | --- | --- | --- |
  * | `sessions/<sessionId>` | every event of the session, in sequence | the stream relay, from the record | history and session SSE |
- * | `tenant/control` | `session.cancel`, `sessions.reset` and `subject.revoked` signals | API nodes | every process with the Tenant open |
+ * | `tenant/control` | `session.cancel`, `sessions.reset` and `action.resolved` signals | API nodes | every process with the Tenant open |
  *
  * **Basin generations.** A session id is unique within its Tenant's basin generation. A
  * Tenant reset, the only path that frees ids, moves the Tenant to the next generation, so
@@ -138,15 +138,6 @@ export interface SessionsResetSignal {
     type: "sessions.reset";
     generation?: number;
 }
-/**
- * A subject's tokens older than `epoch` were revoked: each process ends that subject's
- * streams opened with them.
- */
-export interface SubjectRevokedSignal {
-    type: "subject.revoked";
-    subject: string;
-    epoch: number;
-}
 /**
  * An Action of `sessionId` has its outcome (F6.2): the process whose harness holds the
  * session's run while the Action is pending passes it on (`effect.resolved`).
@@ -156,4 +147,4 @@ export interface ActionResolvedSignal {
     sessionId: string;
     actionId: string;
 }
-export type ControlSignal = SessionCancelSignal | SessionsResetSignal | SubjectRevokedSignal | ActionResolvedSignal;
+export type ControlSignal = SessionCancelSignal | SessionsResetSignal | ActionResolvedSignal;

package/dist/streams/types.js

@@ -7,7 +7,7 @@
  * | Stream | Contents | Written by | Read by |
  * | --- | --- | --- | --- |
  * | `sessions/<sessionId>` | every event of the session, in sequence | the stream relay, from the record | history and session SSE |
- * | `tenant/control` | `session.cancel`, `sessions.reset` and `subject.revoked` signals | API nodes | every process with the Tenant open |
+ * | `tenant/control` | `session.cancel`, `sessions.reset` and `action.resolved` signals | API nodes | every process with the Tenant open |
  *
  * **Basin generations.** A session id is unique within its Tenant's basin generation. A
  * Tenant reset, the only path that frees ids, moves the Tenant to the next generation, so

package/dist/tenant/auth.d.ts

@@ -1,15 +1,17 @@
 /**
  * Tenant request authentication and authorization: a bearer token resolves to an application
- * principal, a subject token or a delivery token; anything else is the opaque 404 (D5).
- * An application principal may act for a subject (`Nylorun-Subject`, `Nylorun-Scopes`); a
- * subject token names its subject itself. `authorize` limits both to the routes their scopes
- * allow, decided from the route alone.
+ * principal, a trusted issuer's token or a delivery token; anything else is the opaque 404
+ * (D5). An application principal may act for a subject (`Nylorun-Subject`, `Nylorun-Scopes`);
+ * an issuer token names its subject itself. `requireScopes` limits them to the routes their
+ * scopes allow, decided from the route alone.
+ *
+ * Browsers: a request with `Origin` may carry an issuer token (CORS is the operator's proxy's),
+ * never an application key or a delivery token, which are server secrets.
  */
 import type { IncomingMessage } from "node:http";
 import { type Action, type SubjectScope } from "@nylorun/core/contracts";
 import type { AuthScope, SessionAccess, TenantContext } from "./context.js";
-import type { BrowserClient } from "./browser.js";
-export declare function authenticate(ctx: TenantContext, request: IncomingMessage, client?: BrowserClient): Promise<AuthScope>;
+export declare function authenticate(ctx: TenantContext, request: IncomingMessage): Promise<AuthScope>;
 /**
  * What a subject needs for a route: any one of the scopes, nothing grants it (`never`), or
  * any caller may (`any`, public data such as the JWKS). Each route declares it
@@ -17,12 +19,12 @@ export declare function authenticate(ctx: TenantContext, request: IncomingMessag
  */
 export type SubjectAccess = readonly SubjectScope[] | "never" | "any";
 /**
- * A subject, subject token or publishable key reaches a route only with one of the scopes it
- * declares: `403 scope_required`, decided from the route alone before anything is read.
+ * A subject or a token caller reaches a route only with one of the scopes it declares:
+ * `403 scope_required`, decided from the route alone before anything is read.
  */
 export declare function requireScopes(scope: AuthScope, access: SubjectAccess): void;
 export declare function accessOf(scope: AuthScope): SessionAccess | undefined;
-/** The subject whose sessions and vaults the request is limited to, if it acts for one. */
+/** The subject whose sessions the request is limited to, if it acts for one. */
 export declare function ownerOf(scope: AuthScope): string | undefined;
 /** The application principal behind the request, acting for a subject or not. */
 export declare function requirePrincipal(scope: AuthScope): string;
@@ -31,4 +33,6 @@ export declare function requirePrincipal(scope: AuthScope): string;
  * is still the Action's is checked by each callback.
  */
 export declare function scoped(scope: AuthScope, action: Action): void;
+/** True when a token caller may reach `agentId` (its issuer's allowlist). Other callers always may. */
+export declare function mayUseAgent(scope: AuthScope, agentId: string): boolean;
 export declare function requireApplication(scope: AuthScope): string;