@calimero-network/mero-js 29.7.5 → 29.7.7

package/dist/cloud-v2/client.d.ts

@@ -408,6 +408,13 @@ export interface ServedOrigins {
  */
 export interface SignInOptions {
     origin?: string | null;
+    /**
+     * Closes an open passkey prompt when it aborts (a Cancel button): the
+     * ceremony then rejects as a dismissed prompt does (`NotAllowedError`; in a
+     * sign-up's confirmation, {@link ConfirmCancelled}). Given to the
+     * {@link PasskeyProvider} as `signal`.
+     */
+    signal?: AbortSignal;
 }
 /**
  * {@link SignInOptions} for a sign-up, and the invite it is made with: an
@@ -648,9 +655,21 @@ export declare class CalimeroClient {
      */
     refresh(): Promise<CalimeroSession>;
     private exchangeRefresh;
+    /**
+     * End this session. The client is signed out whether or not the node
+     * answers: the revoke (`POST /auth/logout`) is attempted, and its failure
+     * (the node unreachable, say) is thrown after the session is dropped, so a
+     * caller can say the server may still hold it, but no request after this
+     * one carries its token.
+     */
     signOut(): Promise<void>;
-    /** End every session of the signed-in account, on every device, this one too. */
+    /**
+     * End every session of the signed-in account, on every device, this one
+     * too. Like {@link signOut}, this client is signed out even when the
+     * request fails, and the failure is thrown.
+     */
     signOutEverywhere(): Promise<void>;
+    private signingOut;
     /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
     me(): Promise<MeInfo>;
     /**

package/dist/cloud-v2/client.js

@@ -57,11 +57,13 @@ export function pageDeployment(href) {
 }
 /**
  * The user verification a confirmation asks the passkey for: what the node's
- * `412` details name, if it names one WebAuthn knows, else `required` (the
- * node takes a confirmation only with the user verified).
+ * `412` details name, if it names one WebAuthn knows, else `fallback` (the
+ * flow's own requirement: `required` for a step-up, which the node takes only
+ * with the user verified; `preferred` for the sign-up confirmation, which it
+ * takes with the user present).
  */
-function userVerificationOf(named) {
-    return named === 'required' || named === 'preferred' || named === 'discouraged' ? named : 'required';
+function userVerificationOf(named, fallback) {
+    return named === 'required' || named === 'preferred' || named === 'discouraged' ? named : fallback;
 }
 /**
  * What a failed confirmation prompt means to the caller. The browser or a
@@ -509,8 +511,14 @@ export class CalimeroClient {
         const origin = this.pageOrigin(options);
         const invite = options.invite ? { invite: options.invite } : {};
         const begin = await this.begin('auth/passkey/register/begin', origin === undefined ? { name, ...invite } : { name, origin, ...invite }, origin);
-        const registration = await passkey.create(begin.options);
-        const session = await this.postConfirmed('auth/passkey/register/finish', { challengeId: begin.challengeId, registration, ...invite }, passkey);
+        const signal = options.signal;
+        const registration = await (signal ? passkey.create(begin.options, { signal }) : passkey.create(begin.options));
+        // The node checks the sign-up's confirmation with the user present, not
+        // verified (core `api.rs`: `rp(node)`, `require_uv: false`), as it made
+        // the passkey with `preferred`: asking `required` here would refuse a
+        // security key without a PIN after it has made the passkey, leaving a
+        // passkey with no account.
+        const session = await this.confirmed('POST', 'auth/passkey/register/finish', { challengeId: begin.challengeId, registration, ...invite }, passkey, undefined, 'preferred', signal);
         this.useSession(session);
         return session;
     }
@@ -530,7 +538,10 @@ export class CalimeroClient {
         const origin = this.pageOrigin(options);
         const begin = await this.begin('auth/passkey/login/begin', origin === undefined ? undefined : { origin }, origin);
         const rpId = begin.options.rpId ?? begin.options.rp?.id ?? '';
-        const assertion = await passkey.get(fromB64url(begin.options.challenge), rpId);
+        const challenge = fromB64url(begin.options.challenge);
+        const assertion = await (options.signal
+            ? passkey.get(challenge, rpId, undefined, { signal: options.signal })
+            : passkey.get(challenge, rpId));
         const session = await this.post('auth/passkey/login/finish', {
             challengeId: begin.challengeId,
             assertion,
@@ -610,16 +621,32 @@ export class CalimeroClient {
             this.useSession(session);
         return session;
     }
+    /**
+     * End this session. The client is signed out whether or not the node
+     * answers: the revoke (`POST /auth/logout`) is attempted, and its failure
+     * (the node unreachable, say) is thrown after the session is dropped, so a
+     * caller can say the server may still hold it, but no request after this
+     * one carries its token.
+     */
     async signOut() {
-        await this.post('auth/logout');
-        this.auth = undefined;
-        this.current = undefined;
+        await this.signingOut('auth/logout');
     }
-    /** End every session of the signed-in account, on every device, this one too. */
+    /**
+     * End every session of the signed-in account, on every device, this one
+     * too. Like {@link signOut}, this client is signed out even when the
+     * request fails, and the failure is thrown.
+     */
     async signOutEverywhere() {
-        await this.post('auth/logout-all');
-        this.auth = undefined;
-        this.current = undefined;
+        await this.signingOut('auth/logout-all');
+    }
+    async signingOut(path) {
+        try {
+            await this.post(path);
+        }
+        finally {
+            this.auth = undefined;
+            this.current = undefined;
+        }
     }
     /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
     me() {
@@ -908,7 +935,7 @@ export class CalimeroClient {
     deleteConfirmed(path, passkey, body = {}) {
         return this.confirmed('DELETE', path, body, passkey);
     }
-    async confirmed(method, path, body, passkey, send = (b) => this.json(method, path, b)) {
+    async confirmed(method, path, body, passkey, send = (b) => this.json(method, path, b), userVerification = 'required', signal) {
         try {
             return await send(body);
         }
@@ -918,11 +945,13 @@ export class CalimeroClient {
             const d = error.details;
             let assertion;
             try {
-                // The node takes a confirmation only with the user verified (PIN or
-                // biometric); `preferred` lets a password manager skip it, and the
-                // node then refuses. A requirement the node names itself wins.
+                // A step-up is taken only with the user verified (PIN or biometric);
+                // `preferred` lets a password manager skip it, and the node then
+                // refuses. Only the sign-up confirmation passes `preferred`. A
+                // requirement the node names itself wins.
                 assertion = await passkey.get(fromB64url(d.challenge), d.rpId, d.allowCredentials, {
-                    userVerification: userVerificationOf(d.userVerification),
+                    userVerification: userVerificationOf(d.userVerification, userVerification),
+                    ...(signal ? { signal } : {}),
                 });
             }
             catch (declined) {

package/dist/cloud-v2/index.d.ts

@@ -8,7 +8,7 @@ export { claimedRelease, fetchAttestedKey, freshCollateral, MOCK_QUOTE_HEADER }
 export type { AttestationDoc, CloudPolicy, CloudReleasePolicy } from './attestation.js';
 export { browserPasskey, b64url, fromB64url } from './passkey.js';
 export { MAX_RECOVERY_NONCE_BYTES, RECOVERY_DOMAIN, newRecoverySeed, parseRecoverySeed, recoveryMessage, recoveryPublicKey, recoverySeedText, signRecovery, } from './recovery.js';
-export type { AssertionJSON, PasskeyGetOptions, PasskeyProvider, PasskeyUserVerification, RegistrationJSON, } from './passkey.js';
+export type { AssertionJSON, PasskeyCreateOptions, PasskeyGetOptions, PasskeyProvider, PasskeyUserVerification, RegistrationJSON, } from './passkey.js';
 export { MAX_REPORT_PAGE, RELEASE_VERIFIER, compareVersions, confirmationCode, consentReturn, pageQuery, pendingApprovalsFrom, publisherBindingBytes, publisherBindingMessage, releaseConsent, releaseNotesUrl, stalledBy, upgradeConsent, verifyReleaseUrl, withdrawConsent, } from './approvals.js';
 export type { ActorKind, AppsReport, Authority, ClusterRelease, ConsentReleaseModel, ConsentRequest, ConsentResult, ConsentScope, ConsentStarted, ConsentStatus, OpenConsentOptions, Governance, LastUpgrade, OpsAppsReport, OpsOrgsReport, PageOptions, PendingApprovals, PendingRelease, PendingUpgrade, PublisherBindingInfo, PublisherProof, ReleaseDeadline, ReleaseRules, ReportScope, ReportedApp, ReportedBundle, ReportedRelease, ReportedReplica, UpgradeAuthority, } from './approvals.js';
 export { DEFAULT_ORG_CAPABILITIES, ORG_CAPABILITIES, orgCapabilities } from './capabilities.js';

package/dist/cloud-v2/passkey.d.ts

@@ -19,21 +19,39 @@ export type PasskeyUserVerification = "required" | "preferred" | "discouraged";
 /** What a confirmation asks of the passkey beyond the challenge. */
 export interface PasskeyGetOptions {
     /**
-     * `"required"` for a confirmation (`412 CONFIRM_REQUIRED`): the node
-     * accepts only an assertion with the user-verified flag (PIN or
-     * biometric). Absent for a plain sign-in, where `"preferred"` is enough.
+     * `"required"` for a step-up confirmation (`412 CONFIRM_REQUIRED`): the
+     * node accepts only an assertion with the user-verified flag (PIN or
+     * biometric). `"preferred"` for the sign-up's confirmation, which the node
+     * takes with the user present. Absent for a plain sign-in, where
+     * `"preferred"` is enough.
      */
     userVerification?: PasskeyUserVerification;
+    /**
+     * Closes the open prompt when it aborts (a Cancel button, a page leaving).
+     * The browser provider then rejects as a dismissed prompt does
+     * (`NotAllowedError`), so the caller treats it as a cancel.
+     */
+    signal?: AbortSignal;
+}
+/** What a passkey creation takes beyond the node's options. */
+export interface PasskeyCreateOptions {
+    /** As {@link PasskeyGetOptions.signal}: aborting closes the prompt, rejecting as a cancel (`NotAllowedError`). */
+    signal?: AbortSignal;
 }
 /** Something that holds a passkey. */
 export interface PasskeyProvider {
-    /** Answer `navigator.credentials.create` for the node's options. */
-    create(options: Record<string, unknown>): Promise<RegistrationJSON>;
+    /**
+     * Answer `navigator.credentials.create` for the node's options.
+     * `createOptions.signal` closes the prompt when it aborts; a provider with
+     * no prompt to close may ignore it.
+     */
+    create(options: Record<string, unknown>, createOptions?: PasskeyCreateOptions): Promise<RegistrationJSON>;
     /**
      * Sign `challenge` (an assertion), optionally limited to
      * `allowCredentials`. `options.userVerification` is `"required"` when the
-     * client answers a confirmation; a provider that always verifies the user
-     * may ignore it.
+     * client answers a step-up confirmation (`"preferred"` for the sign-up's);
+     * a provider that always verifies the user may ignore it.
+     * `options.signal` closes the prompt when it aborts.
      */
     get(challenge: Uint8Array, rpId: string, allowCredentials?: string[], options?: PasskeyGetOptions): Promise<AssertionJSON>;
 }

package/dist/cloud-v2/passkey.js

@@ -25,11 +25,22 @@ function cancelled(message) {
     error.name = "NotAllowedError";
     return error;
 }
-async function ask(method, options) {
+async function ask(method, options, signal, what) {
     const container = navigator.credentials;
     const own = globalThis.CredentialsContainer?.prototype?.[method];
     const call = own ?? container[method];
-    return call.call(container, options);
+    try {
+        return await call.call(container, signal ? { ...options, signal } : options);
+    }
+    catch (error) {
+        // An aborted `signal` rejects with its reason (an `AbortError` unless the
+        // caller gave another): the prompt was closed on purpose, so it reads as
+        // a dismissed one.
+        if (signal?.aborted || error?.name === "AbortError") {
+            throw Object.assign(cancelled(`${what} was cancelled`), { cause: error });
+        }
+        throw error;
+    }
 }
 /**
  * The node's algorithms with ES256 alone when it is among them. Some password
@@ -48,7 +59,7 @@ export function es256First(params) {
 /** The platform authenticator (Touch ID, Face ID, Windows Hello, a security key, a synced passkey). */
 export function browserPasskey() {
     return {
-        async create(options) {
+        async create(options, createOptions) {
             const o = options;
             const cred = (await ask("create", {
                 publicKey: {
@@ -64,7 +75,7 @@ export function browserPasskey() {
                     attestation: "none",
                     timeout: o.timeout,
                 },
-            }));
+            }, createOptions?.signal, "passkey creation"));
             if (!cred)
                 throw cancelled("passkey creation was cancelled");
             const r = cred.response;
@@ -84,7 +95,7 @@ export function browserPasskey() {
                         id: buf(fromB64url(id)),
                     })),
                 },
-            }));
+            }, options?.signal, "passkey sign-in"));
             if (!cred)
                 throw cancelled("passkey sign-in was cancelled");
             const r = cred.response;