@comfyorg/account-core 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/core/billing/telemetry/subscriptionCheckoutEvent.d.ts

@@ -0,0 +1,23 @@
+import type { SubscribeResponse } from '@comfyorg/ingest-types';
+import type { BillingDeclineReason } from '../operationState.js';
+import type { BillingCheckoutReceived, BillingFailed, BillingIntent, BillingRecoveredSucceeded, BillingRequestSent, BillingStarted, BillingTimedOut } from './stages.js';
+import type { BillingCycle, PaymentIntentSource, SubscriptionCheckoutTier, SubscriptionCheckoutType } from './vocabulary.js';
+/** The two checkouts billing web serves; the cloud app's events name neither. */
+export type SubscriptionCheckoutUi = 'embedded' | 'full_page';
+export type SubscriptionCheckoutBillingEvent = {
+    operation: 'subscription_checkout';
+    billing_op_id?: string;
+    checkout_attempt_id?: string;
+    tier?: SubscriptionCheckoutTier;
+    cycle?: BillingCycle;
+    checkout_type?: SubscriptionCheckoutType;
+    checkout_ui?: SubscriptionCheckoutUi;
+    payment_intent_source?: PaymentIntentSource;
+    /**
+     * Client-observed end-to-end wall time from this attempt's canonical
+     * `started` event through to this terminal event.
+     */
+    duration_ms?: number;
+} & (BillingIntent | BillingCheckoutReceived<SubscribeResponse['status']> | BillingRequestSent | BillingStarted | BillingRecoveredSucceeded | (BillingFailed & {
+    decline_reason?: BillingDeclineReason;
+}) | BillingTimedOut);

package/dist/core/billing/telemetry/subscriptionCheckoutEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/core/billing/telemetry/topupEvent.d.ts

@@ -0,0 +1,30 @@
+import type { CreateTopupResponse } from '@comfyorg/ingest-types';
+import type { BillingCheckoutReceived, BillingFailed, BillingIntent, BillingRequestSent, BillingStarted, BillingSucceeded } from './stages.js';
+import type { PaymentIntentSource } from './vocabulary.js';
+/** The fixed amounts, in USD, a top-up dialog offers as one-click choices. */
+export declare const TOPUP_AMOUNT_PRESETS_USD: readonly [10, 25, 50, 100];
+/** The preset the customer picked, or `custom` for any typed amount. */
+export type TopupAmountPreset = `${(typeof TOPUP_AMOUNT_PRESETS_USD)[number]}` | 'custom';
+export declare function getTopupAmountPreset(pickedPresetUsd: number | null): TopupAmountPreset;
+type TopupStarted = BillingStarted & {
+    /** The amount being bought, in whole cents. */
+    amount_cents?: number;
+    amount_preset?: TopupAmountPreset;
+};
+export type TopupBillingEvent = {
+    operation: 'topup';
+    billing_op_id?: string;
+    /**
+     * Surface the top-up was opened from. Absent when the caller named none,
+     * exactly as on the subscription rail's events — absent is no claim, never
+     * an implied default. Named `payment_intent_source` to match its siblings
+     * above; the journey's own `entry_source` is a separate, smaller enum.
+     */
+    payment_intent_source?: PaymentIntentSource;
+    /**
+     * Client-observed end-to-end wall time from this attempt's canonical
+     * `started` event through to this terminal event.
+     */
+    duration_ms?: number;
+} & (BillingIntent | BillingCheckoutReceived<CreateTopupResponse['status']> | BillingRequestSent | TopupStarted | BillingSucceeded | BillingFailed);
+export {};

package/dist/core/billing/telemetry/topupEvent.js

@@ -0,0 +1,6 @@
+/** The fixed amounts, in USD, a top-up dialog offers as one-click choices. */
+export const TOPUP_AMOUNT_PRESETS_USD = [10, 25, 50, 100];
+export function getTopupAmountPreset(pickedPresetUsd) {
+    const preset = TOPUP_AMOUNT_PRESETS_USD.find((usd) => usd === pickedPresetUsd);
+    return preset === undefined ? 'custom' : `${preset}`;
+}

package/dist/core/billing/telemetry/vocabulary.d.ts

@@ -0,0 +1,9 @@
+export type BillingTierKey = 'free' | 'standard' | 'creator' | 'pro' | 'founder';
+export type BillingCycle = 'monthly' | 'yearly';
+export type SubscriptionCheckoutType = 'new' | 'change';
+export type SubscriptionCheckoutTier = BillingTierKey | 'team';
+export type ResubscribeSource = 'pricing_dialog' | 'settings_billing_panel' | 'billing_web_subscription';
+/** Mirrors `BillingSource` in `@comfyorg/billing-contract`; a type test there fails when the two drift. */
+export type PaymentIntentSource = 'subscription_required' | 'out_of_credits' | 'top_up_blocked' | 'deep_link' | 'subscribe_to_run' | 'subscribe_now_button' | 'upgrade_to_add_credits' | 'settings_billing_panel' | 'avatar_menu_plans' | 'team_members_panel' | 'invite_member_upsell' | 'upload_model_upgrade' | 'team_upgrade_resume' | 'free_tier_quota' | 'agent_paywall';
+/** Mirrors `BillingIntent` in `@comfyorg/billing-contract`; a type test there fails when the two drift. */
+export type HostedBillingIntent = 'pricing' | 'checkout' | 'top-up' | 'subscription' | 'payment-methods' | 'invoices' | 'result';

package/dist/core/billing/telemetry/vocabulary.js

@@ -0,0 +1 @@
+export {};

package/dist/core/billing/telemetry/webEntryEvent.d.ts

@@ -0,0 +1,27 @@
+import type { HostedBillingIntent, PaymentIntentSource } from './vocabulary.js';
+/** Mirrors `BillingProduct` in `@comfyorg/billing-contract`; a type test there fails when the two drift. */
+export type WebEntryProduct = 'comfyui' | 'platform' | 'workshop' | 'models';
+/** Mirrors `BillingEntryErrorCode` in `@comfyorg/billing-contract`; a type test there fails when the two drift. */
+export type WebEntryErrorCode = 'UNSUPPORTED_VERSION' | 'UNKNOWN_INTENT' | 'UNKNOWN_PRODUCT' | 'UNKNOWN_RETURN_TARGET' | 'INVALID_AMOUNT' | 'INVALID_PLAN' | 'INVALID_CORRELATION_ID' | 'INVALID_WORKSPACE_ID' | 'INVALID_TEAM_CREDIT_STOP_ID' | 'INVALID_PROMOTION_CODE';
+export type WebEntryBounceReason = 'pricing_link' | 'planless_checkout' | 'return_target_rewritten';
+/** A `ReturnTarget` of `@comfyorg/billing-contract` (a type test there pins them) or the host's pricing table. */
+export type WebEntryBounceTarget = 'comfyui_workspace' | 'comfyui_credits' | 'platform_account' | 'platform_billing' | 'pricing_table';
+export type WebEntryBillingEvent = {
+    operation: 'web_entry';
+    outcome: 'pending';
+} & ({
+    stage: 'received';
+    intent: HostedBillingIntent;
+    product: WebEntryProduct;
+    has_plan: boolean;
+    payment_intent_source?: PaymentIntentSource;
+    /** The cloud journey id the entry link carries; links from other products carry none. */
+    correlation_id?: string;
+} | {
+    stage: 'rejected';
+    error_code: WebEntryErrorCode;
+} | {
+    stage: 'bounced';
+    reason: WebEntryBounceReason;
+    to: WebEntryBounceTarget;
+});

package/dist/core/billing/telemetry/webEntryEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/core/billing/telemetry/webHandoffEvent.d.ts

@@ -0,0 +1,11 @@
+import type { HostedBillingIntent, PaymentIntentSource } from './vocabulary.js';
+export type WebHandoffBillingEvent = {
+    operation: 'web_handoff';
+    stage: 'opened';
+    outcome: 'pending';
+    intent: HostedBillingIntent;
+    result: 'opened' | 'blocked';
+    payment_intent_source?: PaymentIntentSource;
+    /** The cloud journey id the entry link carries as `correlation_id`. */
+    correlation_id: string;
+};

package/dist/core/billing/telemetry/webHandoffEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/core/billing/telemetry/webReturnEvent.d.ts

@@ -0,0 +1,8 @@
+/** Back from a checkout step, the frame's close, the finished checkout's close, or the surface's link to the host. */
+export type WebReturnControl = 'back' | 'close' | 'success_close' | 'host_link';
+export type WebReturnBillingEvent = {
+    operation: 'web_return';
+    stage: 'clicked';
+    outcome: 'pending';
+    control: WebReturnControl;
+};

package/dist/core/billing/telemetry/webReturnEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/core/billing/telemetry/webSessionEvent.d.ts

@@ -0,0 +1,17 @@
+import type { SessionErrorCode } from '../../sessionContracts.js';
+export type WebSessionMode = 'session-client' | 'web-session';
+export type WebSessionBillingEvent = {
+    operation: 'web_session';
+    outcome: 'pending';
+} & ({
+    stage: 'signin_required';
+    reason: 'no_session' | 'refused';
+} | {
+    stage: 'established';
+    /** `interactive` once the customer signed in on billing web itself; `restored` when a session was already there. */
+    origin: 'restored' | 'interactive';
+    mode: WebSessionMode;
+} | {
+    stage: 'failed';
+    error_code: SessionErrorCode;
+});

package/dist/core/billing/telemetry/webSessionEvent.js

@@ -0,0 +1 @@
+export {};

package/dist/core/requestTimeout.d.ts

@@ -0,0 +1,7 @@
+export interface TimedSignal {
+    readonly signal: AbortSignal | undefined;
+    /** Disarms the timer; call once the response body has been read. */
+    readonly release: () => void;
+}
+/** Joins the caller's signal with an abort after `timeoutMs`, if one is set. */
+export declare function timedSignal(signal: AbortSignal | undefined, timeoutMs: number | undefined): TimedSignal;

package/dist/core/requestTimeout.js

@@ -0,0 +1,13 @@
+/** Joins the caller's signal with an abort after `timeoutMs`, if one is set. */
+export function timedSignal(signal, timeoutMs) {
+    if (timeoutMs === undefined)
+        return { signal, release: () => undefined };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return {
+        signal: signal
+            ? AbortSignal.any([signal, controller.signal])
+            : controller.signal,
+        release: () => clearTimeout(timer)
+    };
+}

package/dist/core/sessionTokenMint.d.ts

@@ -8,6 +8,8 @@ export interface SessionTokenMintOptions {
     readonly now?: () => number;
     /** Re-mint once a cached token has this long left. Default 60s. */
     readonly refreshBufferMs?: number;
+    /** Caps each mint, body included; a timeout is `SESSION_UNAVAILABLE`. Default: none. */
+    readonly timeoutMs?: number;
 }
 export interface SessionTokenFailure extends WebSessionFailure {
     /** From a 429's `Retry-After`; no request is sent until it passes. */
@@ -30,4 +32,4 @@ export interface SessionTokenMint {
     readonly getWorkspaceToken: (workspaceId?: string) => Promise<string>;
 }
 export declare const DEFAULT_REFRESH_BUFFER_MS = 60000;
-export declare function createSessionTokenMint({ apiBaseUrl, fetchImpl, getSession, now, refreshBufferMs }: SessionTokenMintOptions): SessionTokenMint;
+export declare function createSessionTokenMint({ apiBaseUrl, fetchImpl, getSession, now, refreshBufferMs, timeoutMs }: SessionTokenMintOptions): SessionTokenMint;

package/dist/core/sessionTokenMint.js

@@ -7,6 +7,7 @@
 import { zErrorResponse, zExchangeTokenResponse } from '@comfyorg/ingest-types/zod';
 import { isCredentialFresh } from './credentialCache.js';
 import { COMFY_CLIENT } from './requestAuth.js';
+import { timedSignal } from './requestTimeout.js';
 export class SessionTokenError extends Error {
     failure;
     constructor(failure) {
@@ -21,7 +22,8 @@ const STATUS_RULES = {
     401: {
         byServerCode: {
             session_expired: 'SESSION_EXPIRED',
-            session_revoked: 'SESSION_REVOKED'
+            session_revoked: 'SESSION_REVOKED',
+            TOKEN_REVOKED: 'SESSION_REVOKED'
         },
         fallback: 'NO_SESSION'
     },
@@ -31,6 +33,11 @@ const STATUS_RULES = {
             workspace_access_denied: 'WORKSPACE_ACCESS_DENIED'
         },
         fallback: 'SESSION_REQUEST_REFUSED'
+    },
+    /** The workspace is unknown, deleted, or not the user's: one remedy. */
+    404: {
+        byServerCode: { NOT_FOUND: 'WORKSPACE_ACCESS_DENIED' },
+        fallback: 'SESSION_REQUEST_REFUSED'
     }
 };
 const zServerCode = zErrorResponse.pick({ code: true });
@@ -72,17 +79,17 @@ function codeFor(status, serverCode) {
         return 'SESSION_REQUEST_REFUSED';
     return rule.byServerCode[serverCode ?? ''] ?? rule.fallback;
 }
-async function classifyFailure(response, nowMs) {
+function classifyFailure(response, body, nowMs) {
     const { status } = response;
     if (status === 429)
         return rateLimited(response, nowMs);
     if (status >= 500)
         return failure('SESSION_UNAVAILABLE', status);
-    const parsed = zServerCode.safeParse(await readJson(response));
+    const parsed = zServerCode.safeParse(body);
     const serverCode = parsed.success ? parsed.data.code : undefined;
     return failure(codeFor(status, serverCode), status, serverCode);
 }
-export function createSessionTokenMint({ apiBaseUrl, fetchImpl, getSession, now = Date.now, refreshBufferMs = DEFAULT_REFRESH_BUFFER_MS }) {
+export function createSessionTokenMint({ apiBaseUrl, fetchImpl, getSession, now = Date.now, refreshBufferMs = DEFAULT_REFRESH_BUFFER_MS, timeoutMs }) {
     const tokenUrl = `${apiBaseUrl.replace(/\/+$/, '')}/auth/token`;
     /** Keyed by workspace; every entry belongs to `cacheOwner`. */
     const cache = new Map();
@@ -101,9 +108,9 @@ export function createSessionTokenMint({ apiBaseUrl, fetchImpl, getSession, now
         rateLimit = undefined;
     }
     async function request(session, workspaceId) {
-        let response;
+        const { signal, release } = timedSignal(undefined, timeoutMs);
         try {
-            response = await fetchImpl(tokenUrl, {
+            const response = await fetchImpl(tokenUrl, {
                 method: 'POST',
                 credentials: 'include',
                 headers: {
@@ -114,20 +121,30 @@ export function createSessionTokenMint({ apiBaseUrl, fetchImpl, getSession, now
                         ? {}
                         : { 'X-Comfy-Workspace-ID': workspaceId })
                 },
-                body: JSON.stringify(workspaceId === undefined ? {} : { workspace_id: workspaceId })
+                body: JSON.stringify(workspaceId === undefined ? {} : { workspace_id: workspaceId }),
+                signal
             });
+            const body = await readJson(response);
+            if (signal?.aborted)
+                return failure('SESSION_UNAVAILABLE');
+            return response.ok
+                ? credentialFrom(session, response.status, body)
+                : classifyFailure(response, body, now());
         }
         catch {
             return failure('SESSION_UNAVAILABLE');
         }
-        if (!response.ok)
-            return classifyFailure(response, now());
-        const parsed = zExchangeTokenResponse.safeParse(await readJson(response));
+        finally {
+            release();
+        }
+    }
+    function credentialFrom(session, status, body) {
+        const parsed = zExchangeTokenResponse.safeParse(body);
         const expiresAt = parsed.success
             ? Date.parse(parsed.data.expires_at)
             : Number.NaN;
         if (!parsed.success || parsed.data.token === '' || !(expiresAt > now())) {
-            return failure('SESSION_UNAVAILABLE', response.status);
+            return failure('SESSION_UNAVAILABLE', status);
         }
         return {
             status: 'ok',

package/dist/core/webSession.d.ts

@@ -5,6 +5,8 @@ export interface WebSessionOptions {
     readonly apiBaseUrl: string;
     readonly fetchImpl: typeof fetch;
     readonly signal?: AbortSignal;
+    /** Caps each request, body included; a timeout is `SESSION_UNAVAILABLE`. Default: none. */
+    readonly timeoutMs?: number;
 }
 export declare function readWebSession(options: WebSessionOptions, { expectedUserId }?: {
     readonly expectedUserId?: string;
@@ -19,7 +21,8 @@ export declare function createWebSession(options: WebSessionOptions, getIdentity
 /** Sends no CSRF token: sign-out must work against a dead session. */
 export declare function deleteWebSession(options: WebSessionOptions): Promise<WebSessionCommandResult>;
 /**
- * Signs the user out of every device. Only a body the contract recognises is
- * ok: the caller tells the user every device is signed out on that answer.
+ * Signs the user out of every device with the session cookie alone. Only a
+ * body the contract recognises is ok: the caller tells the user every device
+ * is signed out on that answer.
  */
-export declare function revokeAllWebSessions(options: WebSessionOptions, csrfToken: string, getIdentityProof: () => Promise<string>): Promise<WebSessionCommandResult>;
+export declare function revokeAllWebSessions(options: WebSessionOptions, csrfToken: string): Promise<WebSessionCommandResult>;

package/dist/core/webSession.js

@@ -4,6 +4,8 @@
  * Identity proof is an opaque string from the caller, so no provider leaks in.
  */
 import { zCreateSessionResponse, zDeleteSessionResponse, zErrorResponse, zGetSessionResponse, zRevokeAllSessionsResponse } from '@comfyorg/ingest-types/zod';
+import { COMFY_CLIENT } from './requestAuth.js';
+import { timedSignal } from './requestTimeout.js';
 const UNAUTHORIZED_CODES = {
     no_session: 'NO_SESSION',
     session_expired: 'SESSION_EXPIRED',
@@ -31,12 +33,11 @@ async function readJson(response) {
         return undefined;
     }
 }
-async function classifyFailure(response) {
-    const { status } = response;
+function classifyFailure(status, body) {
     if (status === 429 || status >= 500) {
         return failure('SESSION_UNAVAILABLE', status);
     }
-    const parsed = zErrorResponse.safeParse(await readJson(response));
+    const parsed = zErrorResponse.safeParse(body);
     if (!parsed.success)
         return failure('SESSION_REQUEST_REFUSED', status);
     const serverCode = parsed.data.code;
@@ -48,24 +49,31 @@ async function classifyFailure(response) {
     return failure(byServerCode, status, serverCode);
 }
 async function send(options, path, init) {
-    let response;
+    const { signal, release } = timedSignal(options.signal, options.timeoutMs);
     try {
-        response = await options.fetchImpl(`${options.apiBaseUrl.replace(/\/+$/, '')}${path}`, { ...init, credentials: 'include', signal: options.signal });
+        const response = await options.fetchImpl(`${options.apiBaseUrl.replace(/\/+$/, '')}${path}`, { ...init, credentials: 'include', signal });
+        const body = await readJson(response);
+        if (signal?.aborted)
+            return failure('SESSION_UNAVAILABLE');
+        const { status } = response;
+        return response.ok ? { status, body } : classifyFailure(status, body);
     }
     catch {
         return failure('SESSION_UNAVAILABLE');
     }
-    return response.ok ? { response } : classifyFailure(response);
+    finally {
+        release();
+    }
 }
 export async function readWebSession(options, { expectedUserId } = {}) {
     const sent = await send(options, '/auth/session', {
         method: 'GET',
         cache: 'no-store'
     });
-    if (!('response' in sent))
+    if ('code' in sent)
         return sent;
-    const { status } = sent.response;
-    const parsed = zGetSessionResponse.safeParse(await readJson(sent.response));
+    const { status } = sent;
+    const parsed = zGetSessionResponse.safeParse(sent.body);
     if (!parsed.success)
         return failure('SESSION_UNAVAILABLE', status);
     const { user, csrf_token, expires_at, absolute_expires_at } = parsed.data;
@@ -98,40 +106,40 @@ export async function createWebSession(options, getIdentityProof, { expectedUser
         method: 'POST',
         headers: { Authorization: `Bearer ${proof}` }
     });
-    if (!('response' in sent))
+    if ('code' in sent)
         return sent;
-    const parsed = zCreateSessionResponse.safeParse(await readJson(sent.response));
+    const parsed = zCreateSessionResponse.safeParse(sent.body);
     if (!parsed.success || !parsed.data.success) {
-        return failure('SESSION_UNAVAILABLE', sent.response.status);
+        return failure('SESSION_UNAVAILABLE', sent.status);
     }
     return readWebSession(options, { expectedUserId });
 }
 /** Sends no CSRF token: sign-out must work against a dead session. */
 export async function deleteWebSession(options) {
     const sent = await send(options, '/auth/session', { method: 'DELETE' });
-    if (!('response' in sent))
+    if ('code' in sent)
         return sent;
-    const parsed = zDeleteSessionResponse.safeParse(await readJson(sent.response));
+    const parsed = zDeleteSessionResponse.safeParse(sent.body);
     if (!parsed.success || !parsed.data.success) {
-        return failure('SESSION_UNAVAILABLE', sent.response.status);
+        return failure('SESSION_UNAVAILABLE', sent.status);
     }
     return { status: 'ok' };
 }
 /**
- * Signs the user out of every device. Only a body the contract recognises is
- * ok: the caller tells the user every device is signed out on that answer.
+ * Signs the user out of every device with the session cookie alone. Only a
+ * body the contract recognises is ok: the caller tells the user every device
+ * is signed out on that answer.
  */
-export async function revokeAllWebSessions(options, csrfToken, getIdentityProof) {
-    const proof = await getIdentityProof();
+export async function revokeAllWebSessions(options, csrfToken) {
     const sent = await send(options, '/auth/sessions/revoke-all', {
         method: 'POST',
-        headers: { Authorization: `Bearer ${proof}`, 'X-CSRF-Token': csrfToken }
+        headers: { 'X-Comfy-Client': COMFY_CLIENT, 'X-CSRF-Token': csrfToken }
     });
-    if (!('response' in sent))
+    if ('code' in sent)
         return sent;
-    const parsed = zRevokeAllSessionsResponse.safeParse(await readJson(sent.response));
+    const parsed = zRevokeAllSessionsResponse.safeParse(sent.body);
     if (!parsed.success) {
-        return failure('SESSION_UNAVAILABLE', sent.response.status);
+        return failure('SESSION_UNAVAILABLE', sent.status);
     }
     return { status: 'ok' };
 }

package/dist/core/webSessionFlag.d.ts

@@ -2,8 +2,7 @@
  * `unified_web_session` for a site with no sign-in of its own to ask with.
  * The anonymous `/api/features` document's global `web_session_probe` only
  * decides whether to ask; the answer is the credentialed read's
- * `unified_web_session` (cloud#10689). `web_session_probe` is a backend
- * follow-up to cloud#10689 and not served yet. Every failure is `false`.
+ * `unified_web_session` (cloud#10689). Every failure is `false`.
  */
 export interface FeaturesReadOptions {
     /** Cloud origin, e.g. `https://cloud.comfy.org`. */

package/dist/core/webSessionFlag.js

@@ -2,8 +2,7 @@
  * `unified_web_session` for a site with no sign-in of its own to ask with.
  * The anonymous `/api/features` document's global `web_session_probe` only
  * decides whether to ask; the answer is the credentialed read's
- * `unified_web_session` (cloud#10689). `web_session_probe` is a backend
- * follow-up to cloud#10689 and not served yet. Every failure is `false`.
+ * `unified_web_session` (cloud#10689). Every failure is `false`.
  */
 const DEFAULT_TIMEOUT_MS = 5000;
 function readsLiteralTrue(body, key) {

package/dist/core/webSessionIdentity.d.ts

@@ -136,6 +136,12 @@ export interface WebSessionIdentity {
     /** Only after an interactive sign-in; a token refresh must never call it. */
     signedIn: (getProof: () => Promise<string>) => Promise<WebSessionResult>;
     signOut: () => Promise<WebSessionCommandResult>;
+    /**
+     * Reads the session now, as a heartbeat would, and resolves once the answer
+     * and any restore it starts have settled. Reads nothing unless signed in as
+     * `expectedUserId` (any user when omitted).
+     */
+    refresh: (expectedUserId?: string) => Promise<WebSessionIdentityState>;
     /** Changes with the account; an answer started under an older epoch is stale. */
     getEpoch: () => number;
     /** Cancels timers, ignores answers in flight, and returns to idle. */
@@ -181,8 +187,8 @@ declare const zSharedMessage: z.ZodObject<{
                 name?: string | undefined;
                 signInProvider?: string | undefined;
             };
-            expiresAt: number;
             csrfToken: string;
+            expiresAt: number;
             absoluteExpiresAt: number;
         }, {
             user: {
@@ -192,8 +198,8 @@ declare const zSharedMessage: z.ZodObject<{
                 name?: string | undefined;
                 signInProvider?: string | undefined;
             };
-            expiresAt: number;
             csrfToken: string;
+            expiresAt: number;
             absoluteExpiresAt: number;
         }>;
     }, "strip", z.ZodTypeAny, {
@@ -206,8 +212,8 @@ declare const zSharedMessage: z.ZodObject<{
                 name?: string | undefined;
                 signInProvider?: string | undefined;
             };
-            expiresAt: number;
             csrfToken: string;
+            expiresAt: number;
             absoluteExpiresAt: number;
         };
     }, {
@@ -220,8 +226,8 @@ declare const zSharedMessage: z.ZodObject<{
                 name?: string | undefined;
                 signInProvider?: string | undefined;
             };
-            expiresAt: number;
             csrfToken: string;
+            expiresAt: number;
             absoluteExpiresAt: number;
         };
     }>, z.ZodObject<{
@@ -248,8 +254,8 @@ declare const zSharedMessage: z.ZodObject<{
                 name?: string | undefined;
                 signInProvider?: string | undefined;
             };
-            expiresAt: number;
             csrfToken: string;
+            expiresAt: number;
             absoluteExpiresAt: number;
         };
     } | {
@@ -269,8 +275,8 @@ declare const zSharedMessage: z.ZodObject<{
                 name?: string | undefined;
                 signInProvider?: string | undefined;
             };
-            expiresAt: number;
             csrfToken: string;
+            expiresAt: number;
             absoluteExpiresAt: number;
         };
     } | {

package/dist/core/webSessionIdentity.js

@@ -261,6 +261,7 @@ function createApiKeyIdentity() {
             retryable: false
         }),
         signOut: async () => ({ status: 'ok' }),
+        refresh: async () => state,
         getEpoch: () => 0,
         dispose: () => undefined
     };
@@ -280,6 +281,7 @@ function createAccountIdentity(options, login) {
     let cancelBeat;
     let releaseLeadership;
     let stopWatching = [];
+    let restoring = { epoch, settled: Promise.resolve() };
     function dispatch(event) {
         const next = transitionWebSessionIdentity(state, event);
         const changed = next.state !== state;
@@ -311,7 +313,7 @@ function createAccountIdentity(options, login) {
     function beat() {
         const started = epoch;
         const observed = { type: 'session_observed', from: 'this_tab' };
-        void answer(started, observed, async () => {
+        return answer(started, observed, async () => {
             const result = await readWebSession(options.session);
             const shared = result.status === 'ok' || result.code === 'SESSION_REVOKED';
             if (shared && started === epoch)
@@ -343,7 +345,7 @@ function createAccountIdentity(options, login) {
     }
     function armBeat() {
         cancelBeat = schedule(() => {
-            beat();
+            void beat();
             armBeat();
         }, heartbeat?.intervalMs ?? HEARTBEAT_INTERVAL_MS);
     }
@@ -377,7 +379,7 @@ function createAccountIdentity(options, login) {
         stopWatching = [
             visibility.onChange((visible) => {
                 if (visible && state.phase === 'signed_in')
-                    beat();
+                    void beat();
                 syncLeadership();
             }),
             ...(crossTab ? [crossTab.onCredential(HEARTBEAT_KEY, adopt)] : [])
@@ -400,7 +402,7 @@ function createAccountIdentity(options, login) {
                 void answer(epoch, { type: 'read_answered' }, () => readWebSession(options.session));
                 return;
             case 'restore':
-                void restore(epoch, effect.expectedUserId);
+                restoring = { epoch, settled: restore(epoch, effect.expectedUserId) };
                 return;
             case 'schedule_retry':
                 cancelRetry = schedule(() => {
@@ -477,6 +479,17 @@ function createAccountIdentity(options, login) {
                 publish('sign_out', revoked);
             return result;
         },
+        refresh: async (expectedUserId) => {
+            if (state.phase !== 'signed_in')
+                return state;
+            if ((expectedUserId ?? state.session.user.id) !== state.session.user.id) {
+                return state;
+            }
+            await beat();
+            if (restoring.epoch === epoch)
+                await restoring.settled;
+            return state;
+        },
         getEpoch: () => epoch,
         dispose: () => {
             epoch += 1;

package/dist/signInSchemas.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 /**
  * The exact message keys the schemas emit, so a host wires every one of them
  * or the compiler says which is missing. Both hosts already carry these keys:
- * the app in `src/locales/en/main.json`, the website in its translations map.
+ * the app in `src/locales/en/main.json`, the website in `apps/website/src/locales/en/main.json`.
  */
 export type AuthSchemaMessageKey = 'validation.prefix' | 'validation.length' | 'validation.invalidEmail' | 'validation.required' | 'validation.minLength' | 'validation.maxLength' | 'validation.password.uppercase' | 'validation.password.lowercase' | 'validation.password.number' | 'validation.password.special' | 'validation.password.match';
 export type AuthSchemaTranslate = (key: AuthSchemaMessageKey, params?: Record<string, string | number>) => string;