oidc-caep-client 0.2.7-next.0 → 0.2.7

package/README.md

@@ -255,7 +255,7 @@ In addition, a replayed `jti` is dropped.
 - A SET is acknowledged only after its handlers ran without throwing. If one throws, the SET is left for the transmitter to send again, up to `maxDeliveryAttempts` times (default 5). After that it is acknowledged and `onError` gets `handler_failed`. Make handlers idempotent: a reload can also bring a handled SET back before its acknowledgement was sent.
 - Only a definitely invalid SET is reported as an error (bad signature, issuer, audience, `typ`, claims). One that couldn't be checked for a reason that may pass is left for redelivery for as long as that lasts, and never reported: a network error fetching the JWKS, or a key the cached JWKS doesn't hold yet.
 - Polls never overlap: `poll()` during a poll shares it, and `pollNow()` during a poll asks for another right after it. A SET whose handlers are still running is never acknowledged by another poll.
-- `stop()` sends the acknowledgements still owed.
+- `stop()` sends the acknowledgements still owed. A handler may await it on its own receiver: it then returns at once, and the poll in flight sends them when it ends.
 - The poll endpoint must use TLS and share an origin with the transmitter (`trustedPollOrigins` adds others), because every poll carries the person's access token.
 - Errors go to `onError`; without one, they are written to `console.error`, so a lost signal always leaves a trace.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oidc-caep-client",
-  "version": "0.2.7-next.0",
+  "version": "0.2.7",
   "description": "In-browser OpenID Connect public client (PKCE, PAR, DPoP, RFC 9207) with token caching/auto-refresh and a Shared Signals (SSF) / CAEP event receiver",
   "homepage": "https://rcbj.github.io/oidc-caep-client/",
   "repository": {

package/src/caep/ssf-receiver.js

@@ -153,6 +153,8 @@ export class SSFReceiver {
   #polling = false;
   /** The poll request in flight, if any: polls never overlap (see poll()). */
   #pollInFlight;
+  /** How many polled SETs' handlers are running now: stop() must not wait for their poll (see stop()). */
+  #pollHandlers = 0;
   /** pollNow() was called while a poll was in flight: poll again as soon as it finishes. */
   #pollAgain = false;
   /** The jtis whose handlers are running now; a redelivery of one of them is left alone. */
@@ -391,18 +393,33 @@ export class SSFReceiver {
 
   /**
    * Stops polling and optionally deletes the stream at the transmitter.
+   *
+   * Resolves once the acknowledgements still owed are sent (and the stream deleted). Called while a polled
+   * SET's handlers are running — from a handler itself, typically on session-revoked — it stops polling and
+   * resolves at once instead: the poll in flight finishes its SETs, then sends the acknowledgements and
+   * deletes the stream, with failures going to `onError` as `phase: 'stop'`.
    * @param {{ deleteStream?: boolean }} [opts]
    */
   async stop({ deleteStream = false } = {}) {
     this.#unwatchPageHide();
     this.#polling = false;
     clearTimeout(this.#pollTimer);
-    // A poll still running may finish handling SETs; their acknowledgements go in the flush below.
-    await this.#pollInFlight?.catch(() => {});
-    await this.#flushAcks();
-    if (deleteStream && this.stream?.stream_id) {
-      await this.deleteStream().catch((err) => this.#emitError(err, { phase: 'stop' }));
+    const finish = async () => {
+      // A poll still running may finish handling SETs; their acknowledgements go in the flush below.
+      await this.#pollInFlight?.catch(() => {});
+      await this.#flushAcks();
+      if (deleteStream && this.stream?.stream_id) {
+        await this.deleteStream().catch((err) => this.#emitError(err, { phase: 'stop' }));
+      }
+    };
+    // The poll in flight is waiting for the handler that is running, so a handler awaiting stop() would
+    // wait for itself: a deadlock. The browser has no way to ask whether THIS call comes from that
+    // handler, so any call made while one runs leaves the rest to the end of the poll.
+    if (this.#pollHandlers > 0) {
+      finish().catch((err) => this.#emitError(err, { phase: 'stop' }));
+      return;
     }
+    await finish();
   }
 
   // ---------------------------------------------------------------------------
@@ -689,7 +706,13 @@ export class SSFReceiver {
       this.#emitError(err, { phase: 'poll', jti });
       return;
     }
-    const handled = await this.#dispatchAll(events);
+    let handled;
+    this.#pollHandlers += 1;
+    try {
+      handled = await this.#dispatchAll(events);
+    } finally {
+      this.#pollHandlers -= 1;
+    }
     if (!handled && this.#attempt(jti) < this.#cfg.maxDeliveryAttempts) {
       // Let the redelivery through the replay check: it is the same SET, not handled yet.
       for (const evt of events) this.#seenJtis.delete(evt.jti);

package/types/caep/ssf-receiver.d.ts

@@ -396,6 +396,11 @@ export declare class SSFReceiver {
     }): Promise<Record<string, any>>;
     /**
      * Stops polling and optionally deletes the stream at the transmitter.
+     *
+     * Resolves once the acknowledgements still owed are sent (and the stream deleted). Called while a polled
+     * SET's handlers are running — from a handler itself, typically on session-revoked — it stops polling and
+     * resolves at once instead: the poll in flight finishes its SETs, then sends the acknowledgements and
+     * deletes the stream, with failures going to `onError` as `phase: 'stop'`.
      * @param {{ deleteStream?: boolean }} [opts]
      */
     stop({ deleteStream }?: {