@poppykit/client 0.4.1 → 0.6.0

package/dist/protocol/wire.d.ts

@@ -1,17 +1,27 @@
+import type { BusinessOperation, OperationApproval } from './operations.js';
 export type Json = null | boolean | number | string | Json[] | {
     [key: string]: Json;
 };
 export type JsonObject = {
     [key: string]: Json;
 };
-export type Sender = 'agent' | 'human';
+export type AuthorType = 'agent' | 'human';
+export interface Author {
+    type: AuthorType;
+    id?: string;
+    name?: string;
+    image?: string;
+    [key: string]: unknown;
+}
 export type Status = 'working' | 'idle' | 'queued' | 'closed';
 export interface Message {
     id: string;
-    sender: Sender;
+    author: Author;
     text?: string;
     data?: JsonObject;
     context?: JsonObject;
+    operation?: BusinessOperation;
+    approval?: OperationApproval;
     [key: string]: unknown;
 }
 export interface RecordedMessage extends Message {
@@ -25,7 +35,7 @@ export interface ConversationRequest {
 export interface ConversationState {
     conversation_id: string;
     status: Status;
-    responder: Sender;
+    responder: AuthorType;
     [key: string]: unknown;
 }
 export interface ConversationEvent {
@@ -40,11 +50,7 @@ export type KnownEvent = (ConversationEvent & {
 }) | (ConversationEvent & {
     type: 'state';
     status: Status;
-    responder: Sender;
-}) | (ConversationEvent & {
-    type: 'authorization';
-    error: 'sign_in_required';
-    scope?: string;
+    responder: AuthorType;
 }) | (ConversationEvent & {
     type: 'authorization';
     error: 'insufficient_scope';
@@ -64,10 +70,8 @@ export interface EventPage extends ConversationState {
 export interface TokenResponse {
     access_token: string;
     token_type: 'DPoP' | 'Bearer';
-    expires_in: number;
-    scope: string;
-    session_id: string;
-    signed_in: boolean;
+    expires_in?: number;
+    scope?: string;
     refresh_token?: string;
     refresh_token_expires_in?: number;
     [key: string]: unknown;
@@ -92,11 +96,12 @@ export declare function id(value: unknown, field: string): string;
 export declare function parseMessage(value: unknown, options?: {
     recorded?: boolean;
     company?: boolean;
+    operations?: boolean;
 }): Message | RecordedMessage;
-export declare function parseConversationRequest(value: unknown): ConversationRequest;
+export declare function parseConversationRequest(value: unknown, operations?: boolean): ConversationRequest;
 export declare function parseConversationState(value: unknown): ConversationState;
-export declare function parseEvent(value: unknown): ConversationEvent;
-export declare function parseEventPage(value: unknown, requestCursor?: string): EventPage;
+export declare function parseEvent(value: unknown, operations?: boolean): ConversationEvent;
+export declare function parseEventPage(value: unknown, requestCursor?: string, operations?: boolean): EventPage;
 export declare function parseTokenResponse(value: unknown): TokenResponse;
 export declare function parseProtocolError(value: unknown): ProtocolErrorBody;
 export declare function parseReadOptions(url: URL, maxWaitSeconds: number): {

package/dist/protocol/wire.js

@@ -1,3 +1,4 @@
+import { parseBusinessOperation, parseOperationApproval } from './operations.js';
 export class ValidationError extends Error {
     field;
     constructor(field) {
@@ -50,8 +51,38 @@ function positive(value, field) {
 export function parseMessage(value, options = {}) {
     const message = { ...object(value, 'message') };
     id(message.id, 'message.id');
-    member(message.sender, ['agent', 'human'], 'message.sender');
-    if (!['text', 'data', 'context'].some(key => key in message))
+    const author = object(message.author, 'message.author');
+    member(author.type, ['agent', 'human'], 'message.author.type');
+    if ('sender' in message)
+        throw new ValidationError('message.sender');
+    for (const key of ['id', 'name', 'image'])
+        if (key in author) {
+            if (!options.company && !(options.recorded && message.role === 'company'))
+                throw new ValidationError('message.author.' + key);
+            string(author[key], 'message.author.' + key);
+        }
+    if ('image' in author) {
+        try {
+            const url = new URL(author.image);
+            if (url.protocol !== 'https:' || url.username || url.password)
+                throw 0;
+        }
+        catch {
+            throw new ValidationError('message.author.image');
+        }
+    }
+    const company = options.company || (options.recorded && message.role === 'company');
+    if ('operation' in message) {
+        if (!company || !options.operations)
+            throw new ValidationError('message.operation');
+        message.operation = parseBusinessOperation(message.operation);
+    }
+    if ('approval' in message) {
+        if (company || !options.operations)
+            throw new ValidationError('message.approval');
+        message.approval = parseOperationApproval(message.approval);
+    }
+    if (!['text', 'data', 'context', ...(options.operations ? [company ? 'operation' : 'approval'] : [])].some(key => key in message))
         throw new ValidationError('message.content');
     if ('text' in message)
         string(message.text, 'message.text', false);
@@ -90,20 +121,24 @@ export function parseMessage(value, options = {}) {
     }
     return message;
 }
-export function parseConversationRequest(value) {
+export function parseConversationRequest(value, operations = false) {
     const request = object(value);
     if ('parent_conversation_id' in request)
         id(request.parent_conversation_id, 'parent_conversation_id');
-    return { ...request, message: parseMessage(request.message) };
+    return { ...request, message: parseMessage(request.message, { operations }) };
 }
 export function parseConversationState(value) {
     const state = object(value);
     id(state.conversation_id, 'conversation_id');
-    member(state.status, ['working', 'idle', 'queued', 'closed'], 'status');
-    member(state.responder, ['agent', 'human'], 'responder');
+    string(state.status, 'status');
+    string(state.responder, 'responder');
+    if (!['working', 'idle', 'queued', 'closed'].includes(state.status))
+        state.status = 'working';
+    if (!['agent', 'human'].includes(state.responder))
+        state.responder = 'human';
     return state;
 }
-export function parseEvent(value) {
+export function parseEvent(value, operations = false) {
     const event = object(value, 'event');
     id(event.id, 'event.id');
     string(event.type, 'event.type');
@@ -119,16 +154,18 @@ export function parseEvent(value) {
         throw new ValidationError('event.created_at');
     switch (event.type) {
         case 'message':
-            parseMessage(event.message, { recorded: true });
+            parseMessage(event.message, { recorded: true, operations });
             break;
-        case 'state':
-            member(event.status, ['working', 'idle', 'queued', 'closed'], 'event.status');
-            member(event.responder, ['agent', 'human'], 'event.responder');
+        case 'state': {
+            const state = parseConversationState({ conversation_id: 'state', status: event.status, responder: event.responder });
+            event.status = state.status;
+            event.responder = state.responder;
             break;
+        }
         case 'authorization':
-            member(event.error, ['sign_in_required', 'insufficient_scope'], 'event.error');
-            if (event.error === 'insufficient_scope' || 'scope' in event)
-                string(event.scope, 'event.scope', false);
+            member(event.error, ['insufficient_scope'], 'event.error');
+            if (!/^[\x21\x23-\x5B\x5D-\x7E]+(?: [\x21\x23-\x5B\x5D-\x7E]+)*$/.test(string(event.scope, 'event.scope')))
+                throw new ValidationError('event.scope');
             break;
         case 'user_requested':
             string(event.reason, 'event.reason', false);
@@ -140,11 +177,11 @@ export function parseEvent(value) {
     }
     return event;
 }
-export function parseEventPage(value, requestCursor) {
+export function parseEventPage(value, requestCursor, operations = false) {
     const page = parseConversationState(value);
     if (!Array.isArray(page.events))
         throw new ValidationError('events');
-    page.events.forEach(parseEvent);
+    page.events.forEach(event => parseEvent(event, operations));
     member(page.has_more, [true, false], 'has_more');
     if (page.cursor === null) {
         if (requestCursor !== undefined || page.events.length || page.has_more)
@@ -153,7 +190,7 @@ export function parseEventPage(value, requestCursor) {
     else {
         string(page.cursor, 'cursor');
         const expected = page.events.length ? page.events.at(-1).id : requestCursor;
-        if (expected !== undefined && page.cursor !== expected)
+        if (expected === undefined || page.cursor !== expected)
             throw new ValidationError('cursor');
     }
     return page;
@@ -161,11 +198,17 @@ export function parseEventPage(value, requestCursor) {
 export function parseTokenResponse(value) {
     const token = object(value);
     string(token.access_token, 'access_token');
-    string(token.session_id, 'session_id');
-    string(token.scope, 'scope', false);
-    member(token.token_type, ['DPoP', 'Bearer'], 'token_type');
-    member(token.signed_in, [true, false], 'signed_in');
-    positive(token.expires_in, 'expires_in');
+    if ('scope' in token) {
+        const scope = string(token.scope, 'scope', false);
+        if (scope !== '' && (!/^[\x21\x23-\x5B\x5D-\x7E]+(?: [\x21\x23-\x5B\x5D-\x7E]+)*$/.test(scope) || new Set(scope.split(' ')).size !== scope.split(' ').length))
+            throw new ValidationError('scope');
+    }
+    const type = string(token.token_type, 'token_type').toLowerCase();
+    if (type !== 'bearer' && type !== 'dpop')
+        throw new ValidationError('token_type');
+    token.token_type = type === 'bearer' ? 'Bearer' : 'DPoP';
+    if ('expires_in' in token && (!Number.isSafeInteger(token.expires_in) || token.expires_in < 0))
+        throw new ValidationError('expires_in');
     if ('refresh_token' in token)
         string(token.refresh_token, 'refresh_token');
     if ('refresh_token_expires_in' in token)
@@ -215,6 +258,11 @@ export function parseAssertionClaims(value) {
     const claims = object(value, 'claims');
     for (const key of ['iss', 'sub', 'aud', 'jti'])
         string(claims[key], key);
+    if ('agent_id' in claims) {
+        string(claims.agent_id, 'agent_id');
+        if (claims.agent_id.length > 256)
+            throw new ValidationError('agent_id');
+    }
     // 128 random bits is at least 16 bytes; cap length since jti lands in the replay store. Encoding is not constrained.
     if (claims.jti.length < 16 || claims.jti.length > 256)
         throw new ValidationError('jti');

package/dist/provider-postgres.js

@@ -42,15 +42,15 @@ export class PostgresProviderStore {
                         await lock('user', key);
                         await one('user', key);
                     }
-                    if (selection.kind === 'begin' || selection.kind === 'revoke') {
+                    if (selection.kind === 'begin' || selection.kind === 'delegate' || selection.kind === 'revoke') {
                         const operations = await this.db.query("SELECT id,body FROM poppy_provider.records WHERE ns=$1 AND kind='operation' AND split_part(id,':',1)=$2 ORDER BY id LIMIT 1001", [this.namespace, enrollmentId]);
                         for (const row of operations)
                             rows.set(JSON.stringify(['operation', row.id]), JSON.parse(row.body));
                         if (operations.length > 1000)
                             throw new Error('provider aggregate exceeds retained operation limit');
-                        if (selection.kind === 'begin') {
+                        if (selection.kind === 'begin' || selection.kind === 'delegate') {
                             const states = new Set();
-                            if (selection.stateHash)
+                            if ('stateHash' in selection && selection.stateHash)
                                 states.add(selection.stateHash);
                             for (const row of operations) {
                                 const hash = JSON.parse(row.body).binding?.stateHash;

package/dist/provider-storage.js

@@ -14,8 +14,8 @@ export function scopedProviderTransaction(selection, raw) {
     const states = new Set();
     if (selection.kind === 'callback')
         states.add(selection.stateHash);
-    if (selection.kind === 'begin') {
-        if (selection.stateHash)
+    if (selection.kind === 'begin' || selection.kind === 'delegate') {
+        if ('stateHash' in selection && selection.stateHash)
             states.add(selection.stateHash);
         for (const row of raw.list('operation', `${enrollmentId}:`, 1001))
             if (row.value.binding?.stateHash)
@@ -34,7 +34,7 @@ export function scopedProviderTransaction(selection, raw) {
         else {
             allowed = (kind === 'enrollment' && id === enrollmentId) || (kind === 'user' && id === userKey) || (kind === 'state' && states.has(id));
             if (kind === 'operation')
-                allowed = (selection.kind === 'begin' || selection.kind === 'revoke') ? id.startsWith(`${enrollmentId}:`) : id === `${enrollmentId}:${operationId}`;
+                allowed = (selection.kind === 'begin' || selection.kind === 'delegate' || selection.kind === 'revoke') ? id.startsWith(`${enrollmentId}:`) : id === `${enrollmentId}:${operationId}`;
         }
         if (!allowed)
             throw new TypeError('provider access outside selection');
@@ -44,7 +44,7 @@ export function scopedProviderTransaction(selection, raw) {
         put(kind, id, value) { check(kind, id, true); raw.put(kind, id, value); },
         remove(kind, id) { check(kind, id); raw.remove(kind, id); },
         list(kind, prefix, limit) {
-            if (!['begin', 'revoke'].includes(selection.kind) || kind !== 'operation' || prefix !== `${enrollmentId}:` || !Number.isSafeInteger(limit) || limit < 1 || limit > 1001)
+            if (!['begin', 'delegate', 'revoke'].includes(selection.kind) || kind !== 'operation' || prefix !== `${enrollmentId}:` || !Number.isSafeInteger(limit) || limit < 1 || limit > 1001)
                 throw new TypeError('provider list outside selection');
             return raw.list(kind, prefix, limit);
         },

package/dist/provider.d.ts

@@ -23,6 +23,14 @@ export type ProviderSelection = {
     kind: 'operation';
     enrollmentId: string;
     operationId: string;
+} | {
+    kind: 'delegate';
+    enrollmentId: string;
+    operationId: string;
+    at: number;
+} | {
+    kind: 'metadata';
+    enrollmentId: string;
 } | {
     kind: 'begin';
     enrollmentId: string;
@@ -64,6 +72,10 @@ export interface ProviderOptions {
     store: ProviderStore;
     cipher: ResultCipher;
     metadata: MetadataResolver;
+    /** Publish only for enrollments whose agent has all Operations channels, trusted consent and durable recovery configured. */
+    operations?: {
+        ready(enrollmentId: string): Promise<boolean>;
+    };
     signer: IdentitySigner;
     /** Publish new keys before use and retain retired public keys through assertion expiry + skew. */
     publishedKeys?: () => Promise<Record<string, any>[]>;
@@ -72,13 +84,6 @@ export interface ProviderOptions {
         subject: string;
         allowedCompanies: string[];
     } | null>;
-    /** Required for browser assertions: independently prove session belongs to this client AND derived user. */
-    verifySession?(binding: {
-        clientId: string;
-        userId: string;
-        issuer: string;
-        sessionId: string;
-    }): Promise<boolean>;
     now?: () => number;
     maxEnrollments?: number;
 }
@@ -90,7 +95,7 @@ export declare function createProvider(options: ProviderOptions): {
         callbackUrl: string;
     }>;
     identity(credential: string, input: Row): Promise<{
-        clientId: string;
+        clientId: any;
         userId: string;
     }>;
     begin(credential: string, input: Row): Promise<{
@@ -100,6 +105,10 @@ export declare function createProvider(options: ProviderOptions): {
         assertion: string;
         expiresAt: number;
     }>;
+    delegate(credential: string, input: Row): Promise<{
+        delegation: string;
+        expiresAt: number;
+    }>;
     callback(callbackUrl: string): Promise<{
         status: any;
     }>;
@@ -134,16 +143,23 @@ export declare function createProviderClient(options: {
         assertion: string;
         expiresAt: number;
     }>;
+    delegate: (request: {
+        operationId: string;
+        jwk: import("./protocol/wire.js").JsonObject;
+    }) => Promise<{
+        delegation: string;
+        expiresAt: number;
+    }>;
     beginDirect: (input: {
         operationId: string;
         issuer: string;
-        sessionId: string;
+        sessionKey: string | null;
         state: string;
     }) => Promise<Row>;
     takeResult: (input: {
         operationId: string;
         issuer: string;
-        sessionId: string;
+        sessionKey: string | null;
     }) => Promise<Row>;
     cancel: (operationId: string) => Promise<Row>;
     revokeEnrollment: () => Promise<Row>;

package/dist/provider.js

@@ -1,6 +1,9 @@
+import { importJWK } from 'jose';
+import { parseJson } from './protocol/wire.js';
 /** Optional PoppyKit provider v1. Hosting, human authentication and key custody belong to the operator. */
 import { createHash, randomBytes, createCipheriv, createDecipheriv } from 'node:crypto';
 import { secureUrl } from './network/transport.js';
+import { companyIdentifier } from './network/discovery.js';
 /** Explicit migration aid for existing local synchronous stores; unsuitable for remote I/O. */
 export function adaptLegacyProviderStore(store) {
     return { async transaction(_selection, action) {
@@ -45,7 +48,6 @@ function https(value) { try {
 catch {
     return fail('binding_conflict');
 } }
-function onDomain(value, domain) { const host = https(value).hostname; return host === domain || host.endsWith(`.${domain}`); }
 function publicKey(value) {
     if (value.kty !== 'EC' || value.crv !== 'P-256' || typeof value.x !== 'string' || typeof value.y !== 'string' || 'd' in value || 'k' in value)
         fail('unavailable');
@@ -54,6 +56,7 @@ function publicKey(value) {
 export function createProvider(options) {
     const { store, cipher } = options, now = options.now ?? Date.now;
     const client = https(options.clientId);
+    const enrolledClientId = (enrollmentId) => { const url = new URL(client); url.pathname = url.pathname.replace(/\/$/, '') + '/enrollments/' + enrollmentId; return url.href; };
     if ([options.callbackUrl, options.jwksUri].some(value => https(value).hostname !== client.hostname) || https(options.callbackUrl).search)
         throw new Error('provider metadata endpoints must share client domain; callback cannot contain query');
     function auth(tx, credential, installationId) {
@@ -67,6 +70,8 @@ export function createProvider(options) {
         const row = tx.get('operation', `${enrollment.enrollmentId}:${operationId}`);
         if (!row)
             fail('binding_conflict');
+        if (row.binding.purpose === 'direct' && row.binding.sessionKey !== null && (typeof row.binding.sessionKey !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(row.binding.sessionKey)))
+            fail('binding_conflict');
         if (row.expiresAt <= now())
             fail('expired');
         if (row.status === 'canceled')
@@ -77,7 +82,7 @@ export function createProvider(options) {
     }
     async function verified(domain, issuer) {
         const metadata = await options.metadata.resolveCompany(domain);
-        if (metadata.authorization?.issuer !== issuer)
+        if (companyIdentifier(metadata) !== issuer)
             fail('binding_conflict');
         return metadata;
     }
@@ -121,9 +126,9 @@ export function createProvider(options) {
                 tx.put('capacity', 'enrollments', { count: count + 1 });
                 tx.put('visitor', subjectKey, { id: visitor });
                 const enrollmentId = id(), secret = id();
-                tx.put('enrollment', enrollmentId, { installationId, visitor, verifier: hash(secret), allowedCompanies: [...new Set(human.allowedCompanies)], revoked: false, starts: [] });
+                tx.put('enrollment', enrollmentId, { clientId: enrolledClientId(enrollmentId), installationId, visitor, verifier: hash(secret), allowedCompanies: [...new Set(human.allowedCompanies)], revoked: false, starts: [] });
                 tx.put('enrollmentRequest', key, { enrollmentId });
-                return { enrollmentId, credential: `${enrollmentId}.${secret}`, clientId: options.clientId, callbackUrl: options.callbackUrl };
+                return { enrollmentId, credential: `${enrollmentId}.${secret}`, clientId: enrolledClientId(enrollmentId), callbackUrl: options.callbackUrl };
             });
         },
         async identity(credential, input) {
@@ -134,41 +139,33 @@ export function createProvider(options) {
                 const enrollment = auth(tx, credential, text(input.installationId));
                 if (!enrollment.allowedCompanies.includes(metadata.document.organization.domain))
                     fail('unauthorized');
-                return { clientId: options.clientId, userId: user(tx, enrollment.visitor, input.issuer) };
+                return { clientId: enrollment.clientId ?? options.clientId, userId: user(tx, enrollment.visitor, input.issuer) };
             });
         },
         async begin(credential, input) {
-            exact(input, ['version', 'installationId', 'operationId', 'domain', 'issuer', 'purpose', 'sessionId', 'returnTo', 'state']);
-            if (!['client-authentication', 'session', 'browser', 'direct'].includes(input.purpose))
+            exact(input, ['version', 'installationId', 'operationId', 'domain', 'issuer', 'purpose', 'sessionId', 'sessionKey', 'state']);
+            if (!['client-authentication', 'direct'].includes(input.purpose))
                 fail('binding_conflict');
             text(input.operationId);
             if (input.sessionId !== undefined)
                 text(input.sessionId);
             await authorizeCompany(credential, input);
-            if (input.purpose === 'client-authentication' && (input.sessionId !== undefined || input.returnTo !== undefined))
-                fail('binding_conflict');
-            if (input.purpose !== 'browser' && input.returnTo !== undefined)
+            if (input.purpose === 'client-authentication' && input.sessionId !== undefined)
                 fail('binding_conflict');
             if (input.purpose !== 'direct' && input.state !== undefined)
                 fail('binding_conflict');
-            if (input.purpose === 'direct' && (typeof input.state !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(input.state) || !input.sessionId))
+            if (input.purpose === 'direct' && (typeof input.state !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(input.state) || (input.sessionKey !== null && (typeof input.sessionKey !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(input.sessionKey)))))
                 fail('binding_conflict');
-            if (input.purpose === 'browser' && !input.sessionId)
+            if (input.purpose !== 'direct' && input.sessionKey !== undefined)
                 fail('binding_conflict');
-            if (input.purpose === 'browser')
-                text(input.returnTo);
             const metadata = await verified(text(input.domain), text(input.issuer));
-            if (input.purpose === 'browser' && (!onDomain(input.returnTo, metadata.document.organization.domain) || !metadata.document.web?.browser_session_endpoint))
-                fail('binding_conflict');
             const identity = await store.transaction({ kind: 'identity', enrollmentId: enrollmentId(credential), issuer: input.issuer }, tx => {
                 const enrollment = auth(tx, credential, text(input.installationId));
                 if (!enrollment.allowedCompanies.includes(metadata.document.organization.domain))
                     fail('unauthorized');
                 return { enrollment, userId: user(tx, enrollment.visitor, input.issuer) };
             });
-            if (input.purpose === 'browser' && !await options.verifySession?.({ clientId: options.clientId, userId: identity.userId, issuer: input.issuer, sessionId: input.sessionId }))
-                fail('unauthorized');
-            const binding = { issuer: input.issuer, domain: metadata.document.organization.domain, purpose: input.purpose, sessionId: input.sessionId ?? null, returnTo: input.returnTo ?? null, stateHash: input.state ? hash(input.state) : null, userId: identity.userId, browserEndpoint: metadata.document.web?.browser_session_endpoint ?? null };
+            const binding = { issuer: input.issuer, domain: metadata.document.organization.domain, purpose: input.purpose, sessionKey: input.sessionKey ?? null, sessionId: input.sessionId ?? null, stateHash: input.state ? hash(input.state) : null, userId: identity.userId };
             return store.transaction({ kind: 'begin', enrollmentId: enrollmentId(credential), operationId: input.operationId, issuer: input.issuer, ...(binding.stateHash ? { stateHash: binding.stateHash } : {}), at: now() }, tx => {
                 const enrollment = auth(tx, credential, text(input.installationId)), key = `${enrollment.enrollmentId}:${text(input.operationId)}`, existing = tx.get('operation', key);
                 if (existing) {
@@ -203,19 +200,17 @@ export function createProvider(options) {
             exact(input, ['version', 'installationId', 'operationId', 'purpose']);
             const snapshot = await store.transaction(selectedOperation(credential, input), tx => {
                 const enrollment = auth(tx, credential, text(input.installationId)), op = operation(tx, enrollment, text(input.operationId));
-                if (op.binding.purpose !== input.purpose || !['client-authentication', 'session', 'browser'].includes(input.purpose))
+                if (op.binding.purpose !== input.purpose || input.purpose !== 'client-authentication')
                     fail('binding_conflict');
                 throttle(tx, enrollment);
                 return { enrollment, op };
             });
-            const b = snapshot.op.binding, metadata = await verified(b.domain, b.issuer);
-            if (b.browserEndpoint !== (metadata.document.web?.browser_session_endpoint ?? null))
-                fail('binding_conflict');
-            if (b.purpose === 'browser' && !await options.verifySession?.({ clientId: options.clientId, userId: b.userId, issuer: b.issuer, sessionId: b.sessionId }))
-                fail('unauthorized');
+            const b = snapshot.op.binding;
+            await verified(b.domain, b.issuer);
             const iat = Math.floor(now() / 1000), exp = iat + 60;
-            const claims = { iss: options.clientId, sub: b.purpose === 'client-authentication' ? options.clientId : b.userId, aud: b.purpose === 'browser' ? b.browserEndpoint : b.issuer, iat, exp, jti: id(), ...(b.purpose === 'browser' ? { session_id: b.sessionId, return_to: b.returnTo } : {}) };
-            const header = { alg: 'ES256', kid: options.signer.kid, typ: b.purpose === 'client-authentication' ? 'client-authentication+jwt' : b.purpose === 'browser' ? 'poppy-browser+jwt' : 'JWT' };
+            const signingClientId = snapshot.enrollment.clientId ?? options.clientId;
+            const claims = { iss: signingClientId, sub: signingClientId, aud: b.issuer, iat, exp, jti: id() };
+            const header = { alg: 'ES256', kid: options.signer.kid, typ: 'client-authentication+jwt' };
             const unsigned = `${Buffer.from(JSON.stringify(header)).toString('base64url')}.${Buffer.from(JSON.stringify(claims)).toString('base64url')}`;
             const signature = await options.signer.sign(new TextEncoder().encode(unsigned));
             if (signature.length !== 64)
@@ -224,6 +219,64 @@ export function createProvider(options) {
             await store.transaction(selectedOperation(credential, input), tx => { const enrollment = auth(tx, credential, input.installationId), op = operation(tx, enrollment, input.operationId); tx.put('operation', `${enrollment.enrollmentId}:${input.operationId}`, { ...op, status: 'signed' }); });
             return { assertion: `${unsigned}.${Buffer.from(signature).toString('base64url')}`, expiresAt: exp };
         },
+        async delegate(credential, input) {
+            exact(input, ['version', 'installationId', 'operationId', 'jwk']);
+            const source = object(input.jwk);
+            if (source.kty !== 'EC' || source.crv !== 'P-256' || typeof source.x !== 'string' || typeof source.y !== 'string' || ['d', 'p', 'q', 'dp', 'dq', 'qi', 'oth', 'k'].some(name => name in source))
+                fail('binding_conflict');
+            const jwk = { kty: 'EC', crv: 'P-256', x: source.x, y: source.y };
+            try {
+                await importJWK(jwk, 'ES256');
+            }
+            catch {
+                fail('binding_conflict');
+            }
+            const operationId = text(input.operationId), installationId = text(input.installationId);
+            const selection = { kind: 'delegate', enrollmentId: enrollmentId(credential), operationId, at: now() };
+            const claim = await store.transaction(selection, tx => {
+                const enrollment = auth(tx, credential, installationId);
+                if (!enrollment.clientId || enrollment.allowedCompanies.length !== 1)
+                    fail('binding_conflict'); // Legacy shared-client enrollments cannot release delegated authority.
+                const key = `${enrollment.enrollmentId}:${operationId}`, existing = tx.get('operation', key);
+                const binding = { purpose: 'delegation', jwk };
+                if (existing) {
+                    if (!same(existing.binding, binding) || existing.expiresAt <= now() || existing.status === 'canceled')
+                        fail('binding_conflict');
+                    return { clientId: enrollment.clientId, existing: existing.result ? cipher.open(existing.result) : null, expiresAt: existing.expiresAt };
+                }
+                throttle(tx, enrollment);
+                const rows = tx.list('operation', `${enrollment.enrollmentId}:`, 1001);
+                for (const row of rows)
+                    if (row.value.expiresAt + 30000 <= now()) {
+                        tx.remove('operation', row.id);
+                        if (row.value.binding.stateHash)
+                            tx.remove('state', row.value.binding.stateHash);
+                    }
+                if (rows.filter(row => row.value.expiresAt + 30000 > now()).length >= 1000)
+                    throw new ProviderError('rate_limited', now() + 60000);
+                const expiresAt = (Math.floor(now() / 1800000) * 1800 + 3600) * 1000;
+                tx.put('operation', key, { binding, expiresAt, status: 'pending', result: null, resultHash: null });
+                return { clientId: enrollment.clientId, existing: null, expiresAt };
+            });
+            if (claim.existing)
+                return { delegation: claim.existing, expiresAt: Math.floor(claim.expiresAt / 1000) };
+            const exp = Math.floor(claim.expiresAt / 1000), iat = exp - 3600;
+            const header = { alg: 'ES256', typ: 'pap-delegation+jwt', kid: options.signer.kid };
+            const payload = { iss: claim.clientId, cnf: { jwk }, iat, exp, jti: id() };
+            const unsigned = Buffer.from(JSON.stringify(header)).toString('base64url') + '.' + Buffer.from(JSON.stringify(payload)).toString('base64url');
+            const signature = await options.signer.sign(new TextEncoder().encode(unsigned));
+            if (!(signature instanceof Uint8Array) || signature.length !== 64)
+                fail('unavailable');
+            const delegation = unsigned + '.' + Buffer.from(signature).toString('base64url');
+            return store.transaction({ kind: 'operation', enrollmentId: enrollmentId(credential), operationId }, tx => {
+                const enrollment = auth(tx, credential, installationId), op = operation(tx, enrollment, operationId);
+                if (op.binding.purpose !== 'delegation' || !same(op.binding.jwk, jwk))
+                    fail('binding_conflict');
+                const result = op.result ? cipher.open(op.result) : delegation;
+                tx.put('operation', `${enrollment.enrollmentId}:${operationId}`, { ...op, status: 'signed', result: cipher.seal(result) });
+                return { delegation: result, expiresAt: exp };
+            });
+        },
         async callback(callbackUrl) {
             const url = new URL(callbackUrl), base = new URL(options.callbackUrl);
             if (url.origin !== base.origin || url.pathname !== base.pathname || url.username || url.password || url.hash || ['state', 'iss', 'code', 'error', 'error_description', 'error_uri'].some(key => url.searchParams.getAll(key).length > 1))
@@ -252,10 +305,10 @@ export function createProvider(options) {
             });
         },
         async takeResult(credential, input) {
-            exact(input, ['version', 'installationId', 'operationId', 'issuer', 'sessionId']);
+            exact(input, ['version', 'installationId', 'operationId', 'issuer', 'sessionId', 'sessionKey']);
             return store.transaction(selectedOperation(credential, input), tx => {
                 const enrollment = auth(tx, credential, text(input.installationId)), op = operation(tx, enrollment, text(input.operationId));
-                if (op.binding.issuer !== input.issuer || op.binding.sessionId !== input.sessionId || op.binding.purpose !== 'direct')
+                if (op.binding.issuer !== input.issuer || op.binding.sessionKey !== input.sessionKey || op.binding.purpose !== 'direct')
                     fail('binding_conflict');
                 if (op.status !== 'ready')
                     return { status: 'pending' };
@@ -289,6 +342,18 @@ export function createProvider(options) {
             try {
                 if (request.url === options.clientId && request.method === 'GET')
                     return Response.json({ client_id: options.clientId, client_name: options.clientName, jwks_uri: options.jwksUri, redirect_uris: [options.callbackUrl], token_endpoint_auth_method: 'private_key_jwt' }, { headers });
+                if (request.method === 'GET') {
+                    const prefix = client.pathname.replace(/\/$/, '') + '/enrollments/', requested = new URL(request.url);
+                    if (requested.origin === client.origin && requested.pathname.startsWith(prefix)) {
+                        const enrollmentId = requested.pathname.slice(prefix.length);
+                        if (!/^[A-Za-z0-9_-]{43}$/.test(enrollmentId) || request.url !== enrolledClientId(enrollmentId))
+                            return new Response(null, { status: 404 });
+                        const enrollment = await store.transaction({ kind: 'metadata', enrollmentId }, tx => tx.get('enrollment', enrollmentId));
+                        if (!enrollment || enrollment.revoked || enrollment.clientId !== request.url)
+                            return new Response(null, { status: 404 });
+                        return Response.json({ client_id: request.url, client_name: options.clientName, jwks_uri: options.jwksUri, redirect_uris: [options.callbackUrl], token_endpoint_auth_method: 'private_key_jwt', ...(await options.operations?.ready(enrollmentId) ? { extensions: { operations: { version: '2' } } } : {}) }, { headers });
+                    }
+                }
                 if (request.url === options.jwksUri && request.method === 'GET')
                     return Response.json({ keys: (options.publishedKeys ? await options.publishedKeys() : [{ ...await options.signer.publicJwk(), kid: options.signer.kid }]).map(publicKey) }, { headers });
                 const url = new URL(request.url);
@@ -320,11 +385,11 @@ export function createProvider(options) {
                     finally {
                         await reader.cancel().catch(() => { });
                     }
-                const input = object(JSON.parse(body));
+                const input = object(parseJson(body));
                 if (input.version !== 1)
                     fail('binding_conflict');
                 const action = url.pathname.slice(url.pathname.lastIndexOf('/') + 1), credential = request.headers.get('authorization')?.match(/^Bearer (\S+)$/)?.[1] ?? '';
-                const allowed = ['enroll', 'identity', 'begin', 'assert', 'takeResult', 'cancel', 'revokeEnrollment'];
+                const allowed = ['enroll', 'identity', 'begin', 'assert', 'delegate', 'takeResult', 'cancel', 'revokeEnrollment'];
                 if (!allowed.includes(action))
                     fail('binding_conflict');
                 const result = action === 'enroll' ? await api.enroll(request, input) : await api[action](credential, input);
@@ -362,7 +427,13 @@ export function createProviderClient(options) {
         const value = await call('assert', { operationId: request.operationId, purpose: request.purpose });
         return { assertion: text(value.assertion), expiresAt: value.expiresAt };
     };
-    return { identity, assert, beginDirect: (input) => call('begin', { ...input, domain: options.domain, purpose: 'direct' }),
+    const delegate = async (request) => {
+        const value = await call('delegate', request);
+        if (typeof value.expiresAt !== 'number')
+            throw new ProviderError('invalid_response');
+        return { delegation: text(value.delegation), expiresAt: value.expiresAt };
+    };
+    return { identity, assert, delegate, beginDirect: (input) => call('begin', { ...input, domain: options.domain, purpose: 'direct' }),
         takeResult: (input) => call('takeResult', input),
         cancel: (operationId) => call('cancel', { operationId }), revokeEnrollment: () => call('revokeEnrollment', {}) };
 }