@masterteam/delegations 0.0.56 → 0.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masterteam/delegations",
-  "version": "0.0.56",
+  "version": "0.0.57",
   "publishConfig": {
     "directory": "../../../dist/masterteam/delegations",
     "linkDirectory": false,

package/types/masterteam-delegations.d.ts

@@ -1328,13 +1328,21 @@ declare class StartDelegationSession {
     constructor(delegation: DelegationRow);
 }
 /**
- * Re-mint the session the user was in before they reloaded the page. Dispatched
- * by the state itself from the persisted delegation id — never a token.
+ * Re-mint the session the user was in before they reloaded the page, from the
+ * persisted delegation id — never a token.
+ *
+ * Pass `delegation` when the row is already in hand; otherwise the state loads
+ * the candidates itself, so a host can await this action **before** the
+ * authenticated shell mounts and boot straight into delegated mode instead of
+ * loading everything twice.
+ *
+ * Completes quietly when there is nothing to resume or the delegation is no
+ * longer startable — the user simply stays themselves.
  */
 declare class ResumeDelegationSession {
-    delegation: DelegationRow;
+    delegation: DelegationRow | null;
     static readonly type = "[DelegationSession] Resume";
-    constructor(delegation: DelegationRow);
+    constructor(delegation?: DelegationRow | null);
 }
 /** End the current delegated session. Client-local only (doc 05). */
 declare class EndDelegationSession {
@@ -1376,12 +1384,13 @@ declare class DelegationSessionState {
     static getErrors(state: DelegationSessionStateModel): Record<string, string | null | undefined>;
     loadCandidates(ctx: StateContext<DelegationSessionStateModel>, { page, pageSize, append }: LoadDelegationCandidates): rxjs.Observable<Response<DelegationPage<DelegationRow>>>;
     /**
-     * Re-mints the delegated session the user was in before they reloaded.
+     * Fallback resume for hosts that do not await {@link ResumeDelegationSession}
+     * before mounting their authenticated shell: pick the session back up as soon
+     * as the candidates arrive.
      *
-     * The token itself was never persisted (doc 05); only the delegation id was,
-     * so this is a full `POST .../session` and the backend re-authorizes from
-     * scratch. Attempted at most once per page load — a delegation that has since
-     * expired or been revoked must not retry on every candidate refresh.
+     * Prefer the awaited path — resuming after the shell has already loaded means
+     * every actor-scoped read runs twice, once as the real user and again under
+     * delegated authority.
      */
     private tryResume;
     resume(ctx: StateContext<DelegationSessionStateModel>, { delegation }: ResumeDelegationSession): rxjs.Observable<void>;
@@ -1398,6 +1407,7 @@ declare class DelegationSessionState {
 declare class DelegationSessionFacade {
     private readonly store;
     private readonly promptReceipts;
+    private readonly resumeStore;
     private endInFlight;
     readonly active: _angular_core.Signal<_masterteam_delegations.ActiveDelegationSession | null>;
     readonly candidates: _angular_core.Signal<DelegationRow[]>;
@@ -1420,6 +1430,19 @@ declare class DelegationSessionFacade {
     loadCandidates(page?: number, pageSize?: number, append?: boolean): Observable<void>;
     loadMoreCandidates(): Observable<void>;
     claimPromptCandidates(candidates: DelegationRow[]): Promise<DelegationRow[]>;
+    /**
+     * True when a previous session is waiting to be re-minted after a reload.
+     * Synchronous (a `localStorage` read), so a route guard can check it without
+     * paying for a round-trip on the overwhelmingly common no-delegation boot.
+     */
+    hasPendingResume(): boolean;
+    /**
+     * Re-mints the delegated session the user reloaded out of, and completes when
+     * delegated mode is in force (or when there is nothing to resume). Await this
+     * **before** mounting the authenticated shell so its reads run once, already
+     * delegated.
+     */
+    resumeSession(): Observable<void>;
     startSession(delegation: DelegationRow): Observable<void>;
     switchSession(delegation: DelegationRow): Observable<void>;
     endSession(reason?: DelegationSessionInvalidationReason): Observable<unknown>;