@ideem/zsm-client-sdk 2.5.1 → 2.6.1

package/WebAuthnClientBase.js

@@ -4,6 +4,7 @@ import { uid2iid, iid4uid } from './IdentityIndexing.js';
 import { toObject }         from './Utils.js';
 import {zsmPluginManager}   from './PluginManager.js';
 
+
 eventCoordinator.update('WebAuthnClientBase');
 
 const tracePrimer = (obj=false) => {
@@ -21,7 +22,12 @@ class WebAuthnClientBase {
         // Helper function to standardize URL format (ensuring it's parsable and ends with a '/')
         const cleanURL = (url) => URL.canParse(url) ? new URL(url).origin + '/' : false;
 
-        const baseConfig         = {
+        if(config?.region){
+            config.authenticator_host_url ||= config.authenticator_host = `https://zsm-authenticator-${config.region}.useideem.com/`;
+            config.zsm_host_url           ||= config.zsm_host           = `https://zsm-${config.region}.useideem.com/`;
+        }
+
+        const baseConfig = {
             "application_id"           : "",
             "api_key"                  : "",
             "host_url"                 : "https://zsm-authenticator-demo.useideem.com/",
@@ -29,9 +35,15 @@ class WebAuthnClientBase {
             "log_level"                : 'Debug',
             "request_timeout_ms"       : 300000,
             "retry_count"              : 0,
-            "consumer_id"              : ""
+            "consumer_id"              : "",
+            "use_passkeys"             : true
         };
 
+        if(config?.use_passkeys===false || config?.use_origin===false){
+            delete config.use_passkeys;
+            delete config.use_origin;
+        }
+
         this.zsmApi       = undefined;    // The ZSM API instance (read: WASM-driven Crypto Module)
         this.relyingParty = undefined;    // The Relying Party instance (read: ZSM Authenticator API)
         this.status       = undefined;    // The status of the WebAuthnClientBase
@@ -89,7 +101,7 @@ class WebAuthnClientBase {
      * @param           {Object}                config              The configuration object for ZSM initialization.
      * @returns         {Promise<ZSMAPI>}                           Resolves with the initialized ZSM API.
      */
-    getZsmApi = async (config) => {}
+    async getZsmApi (config) {}
 
     /**
      * @name            primeZsmApi
@@ -98,16 +110,15 @@ class WebAuthnClientBase {
      * @                by the initializeZsm thereafter. Fixes several potential race conditions and improves performance.
      * @returns         {Promise<ZSMAPI>}                           Resolves with the initialized ZSM API.
      */
-    primeZsmApi = async () => (!this.zsmApi) ? (this.zsmApi = await this.getZsmApi(Object.assign({}, GLOBAL.mpcConfig, {consumer_id: await iid4uid(GLOBAL.mpcConfig.consumer_id)}))) : this.zsmApi;
+    async primeZsmApi () { return  (!this.zsmApi) ? (this.zsmApi = await this.getZsmApi(Object.assign({}, GLOBAL.mpcConfig, {consumer_id: await iid4uid(GLOBAL.mpcConfig.consumer_id)}))) : this.zsmApi; }
 
     /**
      * @name            initializeZsm
      * @description     Reconfigures the ZSM API, should the consumer_id change (as after an identity_id is obtained)
      * @returns         {Promise<ZSMAPI>}                           Resolves when the ZSM API is reconfigured.
      */
-    initializeZsm = async () => {
+    async initializeZsm () {
         if(GLOBAL.mpcConfig.consumer_id !== this.MPCConfig.consumer_id) {
-            // console.log('GLOBAL.mpcConfig :', Object.assign({},GLOBAL.mpcConfig));
             await this.zsmApi.configure(GLOBAL.mpcConfig);
             this.MPCConfig = await Object.assign({}, GLOBAL.mpcConfig);
             await uid2iid(this.config.consumer_id, this.MPCConfig.consumer_id);
@@ -126,22 +137,72 @@ class WebAuthnClientBase {
     */
 
     async checkIdentity (userIdentifier, primeEnroll=false) {
+        if(userIdentifier == null 
+            || userIdentifier === '')         return new Error(`[WebAuthnClient] :: checkIdentity :: A userIdentifier String is required! Received: ${userIdentifier}.`);
+        if(userIdentifier && typeof userIdentifier === 'string') this.userIdentifier = userIdentifier;
+        
         try {
-            this.status='CHECKING_IDENTITY_STARTING';
             const resultOfCheck = await this.relyingParty.checkServerSideIdentity(primeEnroll);
+
             if(!resultOfCheck)  throw new Error('Unable to communicate with identity server!');
-            const identityID    = resultOfCheck.identity_id;
+            const identityID    = Array.isArray(resultOfCheck) ? resultOfCheck[0].identity_id : resultOfCheck.identity_id;
+
             if(!identityID)     throw new Error('Unable to acquire identity_id!');
+
             uid2iid(userIdentifier, identityID);
             GLOBAL.mpcConfig.consumer_id = identityID;
-            this.status         = 'CHECKING_IDENTITY_FINISHED';
             return identityID;
         } catch(err) {
-            this.status         = 'CHECKING_IDENTITY_FAILED';
             return Promise.reject(err);
         }
     }
 
+    /**
+     * @name            webauthnCreate
+     * @description     Creates a new WebAuthn credential for the specified userIdentifier.
+     * @param           {string}                  userIdentifier    The user identifier.
+     * @returns         {Promise<Object>}                           Resolves with the created credential.
+     * @throws          {Error}                                     Throws a COUNTED error if unable to retrieve the public key from the Relying Party Server.
+     * @throws          {Error}                                     [MPC] Throws an error if unable to obtain the createResponse from the Crypto Server.
+     * @throws          {Error}                                     [MPC] Throws an error if the createResponse is missing the credential.
+     * @throws          {Error}                                     [MPC] Throws an error if the credential is missing the attestation object.
+     * @throws          {Error}                                     Throws a COUNTED error if unable to verify the credential with the Relying Party Server.
+     */
+    async webauthnCreate (userIdentifier) {
+        if(userIdentifier == null 
+            || userIdentifier === '')         return new Error(`[WebAuthnClient] :: webauthnCreate :: A userIdentifier String is required! Received: ${userIdentifier}.`);
+        if(userIdentifier && typeof userIdentifier === 'string') this.userIdentifier = userIdentifier;
+
+        await this.initializeZsm('webauthnCreate');
+
+
+        const publicKey = await this.relyingParty.registrationStart();
+        if(publicKey instanceof Error)          throw new Error(publicKey);
+        else if (!publicKey)                    throw new Error('[WebAuthnClient] :: webauthnCreate :: Unable to retrieve public key from Relying Party Server!');
+
+        publicKey.user_id = publicKey.user.id;
+        
+        let createResponse = await this.zsmApi.webauthn_create(publicKey, undefined, userIdentifier, tracePrimer());
+        if(!createResponse)                     throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreate :: Unable to obtain response from Crypto Server!');
+
+        
+        createResponse = toObject(createResponse);
+        GLOBAL.dispatchEvent(new CustomEvent("MPCResponse", {bubbles: true, cancelable: false, detail: createResponse }));
+        
+        if(!createResponse?.result)             throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreate :: Unable to obtain credential from Crypto Server!');
+        if(!createResponse?.result?.response)   throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreate :: Unable to acquire attestation object!');
+        
+        const credential = createResponse.result;
+
+        
+        const registrationResult = await this.relyingParty.registrationFinish(credential);
+        if(registrationResult instanceof Error) throw new Error(registrationResult);
+        else if(registrationResult == false)    throw new Error('[WebAuthnClient] :: webauthnCreate :: Unable to verify credential Relying Party Server!');
+
+        
+        return registrationResult;
+    };
+
     /**
      * @name            webauthnCreate
      * @description     Creates a new WebAuthn credential for the specified userIdentifier.
@@ -154,30 +215,28 @@ class WebAuthnClientBase {
      * @throws          {Error}                                     Throws an error if unable to acquire the identity ID from the Relying Party Server.
      * @throws          {Error}                                     Throws an error if the user ID or token is missing from the response body.
      */
-    async webauthnCreate (userIdentifier) {
+    async webauthnCreateMpcThenFinish (userIdentifier, publicKey, pairing_token) {
+        if(userIdentifier == null 
+            || userIdentifier === '')         return new Error(`[WebAuthnClient] :: webauthnCreateMpcThenFinish :: A userIdentifier String is required! Received: ${userIdentifier}.`);
+        if(userIdentifier && typeof userIdentifier === 'string') this.userIdentifier = userIdentifier;
         this.status = 'ENROLLMENT_STARTING';
-        await this.initializeZsm('webauthnCreate');
-
-        // await this.checkIdentity(userIdentifier, true);
+        await this.initializeZsm('webauthnCreateMpcThenFinish');
 
-        const publicKey = await this.relyingParty.registrationStart();
-        if(!publicKey)   throw new Error('[WebAuthnClient] :: webauthnCreate :: Unable to retrieve public key from Relying Party Server!');
-
-        let createResponse = await this.zsmApi.webauthn_create(publicKey, tracePrimer());
-        if(!createResponse) throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreate :: Unable to obtain response from Crypto Server!');
+        let createResponse = await this.zsmApi.webauthn_create(publicKey, pairing_token, userIdentifier, tracePrimer());
+        if(!createResponse) throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreateMpcThenFinish :: Unable to obtain response from Crypto Server!');
 
         createResponse = toObject(createResponse);
         GLOBAL.dispatchEvent(new CustomEvent("MPCResponse", {bubbles: true, cancelable: false, detail: createResponse }));
 
-        if(!createResponse?.result)            throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreate :: Unable to obtain credential from Crypto Server!');
-        if(!createResponse?.result?.response)  throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreate :: Unable to acquire attestation object!');
+        if(!createResponse?.result)            throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreateMpcThenFinish :: Unable to obtain credential from Crypto Server!');
+        if(!createResponse?.result?.response)  throw new Error('[WebAuthnClient - mpc_round] :: webauthnCreateMpcThenFinish :: Unable to acquire attestation object!');
 
         const credential = createResponse.result;
 
         const registrationResult = await this.relyingParty.registrationFinish(credential);
-        if (!registrationResult) throw new Error('[WebAuthnClient] :: webauthnCreate :: Unable to verify credential Relying Party Server!');
+        if (!registrationResult) throw new Error('[WebAuthnClient] :: webauthnCreateMpcThenFinish :: Unable to verify credential Relying Party Server!');
 
-        return registrationResult;
+        return registrationResult.credential;
     };
 
     /**
@@ -186,95 +245,96 @@ class WebAuthnClientBase {
      * @param           {string}                  userIdentifier    The user identifier.
      * @returns         {Promise<ZSMAPI>}                           Resolves with the retrieved credential.
      * @throws          {Error}                                     Throws an error if no credential ID is found.
-     * @throws          {Error}                                     Throws an error if unable to start authentication with the Relying Party Server.
+     * @throws          {Error}                                     Throws a COUNTED error if unable to start authentication with the Relying Party Server.
      * @throws          {Error}                                     Throws an error if unable to retrieve the public key/challenge from the Relying Party Server.
-     * @throws          {Error}                                     Throws an error if unable to obtain the getResponse/credential from the Crypto Server.
+     * @throws          {Error}                                     Throws an error if unable to obtain the mpcResponse/credential from the Crypto Server.
      * @throws          {Error}                                     Throws an error if unable to verify the credential with the Relying Party Server.
      * @throws          {Error}                                     Throws an error if the user ID or token is missing from the response body.
      */
-    webauthnGet = async (userIdentifier) => {
-        this.status = 'AUTHENTICATION_STARTING';
+    async webauthnGet (userIdentifier) {
+        if(userIdentifier == null 
+            || userIdentifier === '')         return new Error(`[WebAuthnClient] :: webauthnGet :: A userIdentifier String is required! Received: ${userIdentifier}.`);
+        if(userIdentifier && typeof userIdentifier === 'string') this.userIdentifier = userIdentifier;
 
         await this.initializeZsm('webauthnGet');
-        await this.webauthnRetrieve(userIdentifier, true)
-
+        const credentialId = await this.webauthnRetrieve(userIdentifier, true);
 
-        if (!this.isEnrolled)                                               throw new Error(`[WebAuthnClient] :: webauthnGet :: Credential is missing for ${userIdentifier}`);
+        if (!this.isEnrolled)                               throw new Error(`[WebAuthnClient] :: webauthnGet :: ${userIdentifier} is not enrolled, lacks a credential, or credential is corrupted!`);
 
-        let authStartResponse = await this.relyingParty.authenticationStart(this.credentialID);
-        if(!authStartResponse)                                              throw new Error('[WebAuthnClient] :: webauthnGet :: Unable to start authentication with Relying Party Server!');
+        let authStartResponse = await this.relyingParty.authenticationStart(credentialId);
 
+        if      (authStartResponse instanceof Error)        throw new Error(authStartResponse);
+        else if (!authStartResponse)                        throw new Error('[WebAuthnClient] :: webauthnGet :: Unable to start authentication with Relying Party Server!');
+        
         authStartResponse = toObject(authStartResponse);
 
-        if(!authStartResponse?.rcr || !authStartResponse?.rcr?.publicKey)   throw new Error('[WebAuthnClient] :: webauthnGet :: Unable to retrieve public key from Relying Party Server!');
-
-        const pubKey = authStartResponse?.rcr?.publicKey;
+        if(!authStartResponse?.rcr?.publicKey?.challenge)   throw new Error('[WebAuthnClient] :: webauthnGet :: Unable to locate public key/challenge inside Relying Party Server response!\nResponse Body: ' + JSON.stringify(authStartResponse));
+        const publicKey = authStartResponse.rcr.publicKey;
 
-        if(!pubKey || !pubKey?.challenge)                                   throw new Error('[WebAuthnClient] :: webauthnGet :: Unable to acquire challenge from public key!');
+        let mpcResponse = await this.zsmApi.webauthn_get(publicKey, undefined, userIdentifier, tracePrimer());
+        
 
-        let getResponse = await this.zsmApi.webauthn_get(pubKey, tracePrimer());
-        if(!getResponse)                                                    throw new Error('[WebAuthnClient - mpc_round] :: webauthnGet :: Unable to obtain getResponse from Crypto Server!');
+        if(!mpcResponse)                                    throw new Error('[WebAuthnClient - mpc_round] :: webauthnGet :: Crypto server did not respond!');
 
-        getResponse = toObject(getResponse);
+        mpcResponse = toObject(mpcResponse);
+        if(!mpcResponse?.result)                            throw new Error('[WebAuthnClient - mpc_round] :: webauthnGet :: Response from Crypto Server did not contain a credential!\nResponse Body: ' + JSON.stringify(mpcResponse));
 
-        if(!getResponse?.result)                                            throw new Error('[WebAuthnClient - mpc_round] :: webauthnGet :: Unable to obtain credential from Crypto Server!');
+        GLOBAL.dispatchEvent(new CustomEvent("MPCResponse", {bubbles: true, cancelable: false, detail: mpcResponse }));
 
-        GLOBAL.dispatchEvent(new CustomEvent("MPCResponse", {bubbles: true, cancelable: false, detail: getResponse }));
-
-        const credential = getResponse.result;
+        const credential = mpcResponse.result;
         let authFinishResponse = await this.relyingParty.authenticationFinish(credential);
 
-        if (!authFinishResponse)                                            throw new Error('[WebAuthnClient] :: webauthnGet :: Unable to verify credential Relying Party Server!');
+        if      (authFinishResponse instanceof Error)       throw new Error(authFinishResponse);
+        else if (!authFinishResponse)                       throw new Error('[WebAuthnClient] :: webauthnGet :: Unable to verify credential from Relying Party Server!');
 
         authFinishResponse = toObject(authFinishResponse)
-
-        if (!authFinishResponse.user_id || !authFinishResponse.token)       throw new Error('[WebAuthnClient] :: webauthnGet :: User ID or token is missing from response body!');
+        if (!authFinishResponse.token)                      throw new Error('[WebAuthnClient] :: webauthnGet :: Token mismatched or missing from Relying Party Server verification attempt!\nResponse Body: '   + JSON.stringify(authFinishResponse));
 
         return {
             signature       : credential.response.signature,
             signedChallenge : credential.response.clientDataJSON,
             user_id         : authFinishResponse.user_id,
             token           : authFinishResponse.token,
-            challenge       : pubKey.challenge,
+            challenge       : publicKey.challenge,
             credential
         };
     };
 
+    
+
     /**
      * @name            webauthnRetrieve
      * @description     Looks up the Identity ID for the specified userIdentifier and retrieves its credential ID (if it exists).
      * @                This is used to make a client-only check to see if a given userIdentifier already has an enrollment on the device.
      * @param           {string}                  userIdentifier    The user identifier.
-     * @param           {boolean}                 silent            Whether to suppress status updates. [default: false]
-     * @returns         {Promise<Boolean>}                          Resolves with the credential ID or `false` if retrieval fails.
-     * @returns         {Promise<String>}                           Resolves with the retrieved rawID for the specified user.
+     * @param           {string}                  targetData        The specific data to retrieve. Options are:
+     * @                                                             - 'id' or omitted: retrieves the ZSM credential ID (default)
+     * @                                                             - 'all': retrieves an object containing all relevant credential data
+     * @                                                             - any other string: retrieves the specified field from the response
+     * @returns         {Promise<Boolean:false>}                    Returns `false` if retrieval fails (no enrollment found).
+     * @returns         {Promise<String>}                           Returns the requested data if found (e.g., ").
+     * @returns         {Promise<Object>}                           Resolves with an object containing all relevant credential data.
+     * @returns         {Promise<Null>}                             Resolves with null if the requested data is not found.
+     * @throws          {Error}                                     Throws an error if an uncaught/unhandled error occurs while retrieving the credential.
      */
-    webauthnRetrieve = async (userIdentifier, silent=false) => {
+    async webauthnRetrieve (userIdentifier) {
+        if(userIdentifier == null 
+            || userIdentifier === '')         return new Error(`[WebAuthnClient] :: webauthnRetrieve :: A userIdentifier String is required! Received: ${userIdentifier}.`);
+        if(userIdentifier && typeof userIdentifier === 'string') this.userIdentifier = userIdentifier;
         this.credentialID = null;
-        if (!silent) {
-            this.status = 'CREDENTIAL_RETRIEVING';
-        }
-
-        try {
-            this.initializeZsm('webauthnRetrieve');
-            let credentialIdentifier     = await iid4uid(userIdentifier);
-            GLOBAL.mpcConfig.consumer_id = credentialIdentifier;
 
-            let response      = await this.zsmApi.webauthn_retrieve(credentialIdentifier);
-                response      = toObject(response);
+        this.initializeZsm('webauthnRetrieve');
+        let credentialIdentifier     = await iid4uid(userIdentifier),
+            requestedData            = {};
+        GLOBAL.mpcConfig.consumer_id = credentialIdentifier;
 
-            if (response.error || !response?.result?.rawId) return false;
+        let response      = await this.zsmApi.webauthn_retrieve(userIdentifier);
+            response      = toObject(response);
 
-            this.credentialID = response.result.rawId;
-            if (!silent) this.status = 'CREDENTIAL_RETRIEVED';
-
-            return this.credentialID;
-        } catch (error) {
-            if(!silent){
-                this.status = 'CREDENTIAL_RETRIEVAL_FAILED';
-                throw error;
-            }
-        }
+        if (response?.error || !response?.result) return false;
+        
+        this.credentialID = response?.result['zsm_credential_id']??null;
+        return this.credentialID || false;
     };
 
     /**
@@ -285,10 +345,13 @@ class WebAuthnClientBase {
      * @throws          {Error}                                    Throws an error if the credential is missing for the userIdentifier provided.
      * @throws          {Error}                                    Throws an error if unable to start authentication with the Relying Party Server.
      * @throws          {Error}                                    Throws an error if unable to retrieve the public key from the Relying Party Server.
-     * @throws          {Error}                                    Throws an error if unable to obtain the getResponse/credential from the Crypto Server.
-     * @emits           {CustomEvent}                              Emits a "MPCResponse" event with the getResponse data.
+     * @throws          {Error}                                    Throws an error if unable to obtain the mpcResponse/credential from the Crypto Server.
+     * @emits           {CustomEvent}                              Emits a "MPCResponse" event with the mpcResponse data.
      */
-    webauthnPartialGet = async (userIdentifier) => {
+    async webauthnPartialGet (userIdentifier) {
+        if(userIdentifier == null 
+            || userIdentifier === '')         return new Error(`[WebAuthnClient] :: webauthnPartialGet :: A userIdentifier String is required! Received: ${userIdentifier}.`);
+        if(userIdentifier && typeof userIdentifier === 'string') this.userIdentifier = userIdentifier;
         this.status = 'AUTHENTICATION_STARTING';
         await this.initializeZsm('webauthnPartialGet');
 
@@ -302,16 +365,16 @@ class WebAuthnClientBase {
         if(!getChallenge?.rcr || !getChallenge.rcr.publicKey) throw new Error('[WebAuthnClient] :: webauthnPartialGet :: Unable to retrieve public key from Relying Party Server!');
         const pubKey = getChallenge.rcr.publicKey;
 
-        let getResponse = await this.zsmApi.webauthn_get(pubKey, tracePrimer());
-        if(!getResponse)         throw new Error('[WebAuthnClient - mpc_round] :: webauthnGet :: Unable to obtain getResponse from Crypto Server!');
+        let mpcResponse = await this.zsmApi.webauthn_get(pubKey, null, userIdentifier, tracePrimer());
+        if(!mpcResponse)         throw new Error('[WebAuthnClient - mpc_round] :: webauthnPartialGet :: Unable to obtain mpcResponse from Crypto Server!');
 
-        getResponse = toObject(getResponse);
+        mpcResponse = toObject(mpcResponse);
 
-        if(!getResponse?.result) throw new Error('[WebAuthnClient - mpc_round] :: webauthnGet :: Unable to obtain credential from Crypto Server!');
+        if(!mpcResponse?.result) throw new Error('[WebAuthnClient - mpc_round] :: webauthnPartialGet :: Unable to obtain credential from Crypto Server!');
 
-        GLOBAL.dispatchEvent(new CustomEvent("MPCResponse", {bubbles: true, cancelable: false, detail: getResponse }));
+        GLOBAL.dispatchEvent(new CustomEvent("MPCResponse", {bubbles: true, cancelable: false, detail: mpcResponse }));
 
-        const getCredential = getResponse.result;
+        const getCredential = mpcResponse.result;
         return {
             signature: getCredential.response.signature,
             signedChallenge: getCredential.response.clientDataJSON,
@@ -330,7 +393,10 @@ class WebAuthnClientBase {
      * @throws          {Error<CredentialError>}                   Throws an CredentialError if the credential is missing for the userIdentifier provided
      * @throws          {Error<UnenrollError>}                     Throws an UnenrollError if a credential matching userIdentifier IS stored on the device, but was unable to be removed.
      */
-    unbindFromDevice = async (userIdentifier) => {
+    async unbindFromDevice (userIdentifier) {
+        if(userIdentifier == null 
+            || userIdentifier === '')         return new Error(`[WebAuthnClient] :: unbindFromDevice :: A userIdentifier String is required! Received: ${userIdentifier}.`);
+        if(userIdentifier && typeof userIdentifier === 'string') this.userIdentifier = userIdentifier;
         this.status = 'UNENROLL_STARTING';
         if(userIdentifier !== this.userIdentifier) return false;
         await this.initializeZsm('unbindFromDevice');
@@ -346,7 +412,11 @@ class WebAuthnClientBase {
                 const cursor = event.target.result;
                 if (cursor) {
                     const { key, value } = cursor;
-                    if (value instanceof Map && value.has("rawId") && value.get("rawId") === rawID) return (store.delete(key), true);
+                    if(
+                        key.includes(userIdentifier) || 
+                        (typeof value === 'string' && value.includes(userIdentifier)) ||
+                        typeof value === 'object' && value?.zsm_credential?.get('rawId') === rawID
+                    )  (store.delete(key), true);
                     cursor.continue();
                 }
             };

package/package.json

@@ -1,23 +1,70 @@
 {
-    "name"            : "@ideem/zsm-client-sdk",
-    "version"         : "2.5.1",
-    "description"     : "ZSM makes 2FA easy and invisible for everyone, all the time, using advanced cryptography like MPC to establish cryptographic proof of the origin of any transaction or login attempt, while eliminating opportunities for social engineering. ZSM has no reliance on specific hardware. Our cryptographic module has completed FIPS 140-3 NIST approved lab testing, is FIDO2-ready, and is on the Modules In Progress (MIP) list. Superior Usability. no opt-in, no codes, no downloads, no authenticator apps. Better Security.",
-    "author"          : "@JJ (Jason Jurusz) <jj@useideem.com>/<nerdy.deeds@done.cheap>",
-    "keywords"        : ["ideem", "zsm", "zsm-client-sdk", "UMFAClient", "FIDO2Client", "library", "UMFA", "FIDO2", "client", "authentication", "javascript", "multi-factor", "webauthn", "authentication", "security", "cryptography", "MPC", "FIPS", "NIST", "FIDO2-ready", "Modules In Progress", "MIP"],
-    "type"            : "module",
-    "main"            : "./ZSMClientSDK.js",
-    "scripts"         : {
-        "start"       : "echo 'This is the Ideem SDK library, not a freestanding application. There is no start script defined. To use, import the library into a browser application.' 1>&2",
-        "version"     : "echo \"$(npm pkg get name | tr -d \\\") current version: $(npm pkg get version | tr -d \\\")\""
-    },
-    "collaborators"   : [ "Joel Teply <joel@useideem.com>", "Todd Decker <todd@useideem.com>", "Brian Koziel <brian@useideem.com>" ],
-    "license"         : "SEE LICENSE IN LICENSE",
-    "repository"      : {
-        "type"        : "git",
-        "url"         : "github : useideem/vHSM"
-    },
-    "homepage"        : "https://useideem.com",
-    "bugs"            : "https://github.com/useideem/vHSM/issues",
-    "files"           : ["./EventCoordinator.js", "./FIDO2Client.js", "./FIDO2ClientBase.js", "./GlobalScoping.js", "./IdentityIndexing.js", "./PluginManager.js", "./RelyingParty.js", "./RelyingPartyBase.js", "./UMFAClient.js", "./UMFAClientBase.js", "./Utils.js", "./WASMRustInterface.js", "./WebAuthnClient.js", "./WebAuthnClientBase.js", "./ZSMClientSDK.js", "./shims/", "./LICENSE", "./README.md", "./CHANGELOG.md"],
-    "sideEffects"     : false
+    "name"          : "@ideem/zsm-client-sdk",
+    "version"       : "2.6.1",
+    "description"   : "ZSM makes 2FA easy and invisible for everyone, all the time, using advanced cryptography like MPC to establish cryptographic proof of the origin of any transaction or login attempt, while eliminating opportunities for social engineering. ZSM has no reliance on specific hardware. Our cryptographic module has completed FIPS 140-3 NIST approved lab testing, is FIDO2-ready, and is on the Modules In Progress (MIP) list. Superior Usability. no opt-in, no codes, no downloads, no authenticator apps. Better Security.",
+    "author"        : "Jason Jurusz <jj@useideem.com>",
+    "keywords"      : [ "ideem", "zsm", "zsm-client-sdk", "umfaclient", "fido2client", "library", "umfa", "fido", "fido2", "client", "javascript", "multifactor", "multi-factor", "webauthn", "authentication", "security", "cryptography", "mpc", "fips", "nist", "mip", "passkeys" ],
+    "type"          : "module",
+    "main"          : "./ZSMClientSDK.js",
+    "exports"       : {
+                        ".": {
+                                "import": "./ZSMClientSDK.js",
+                                "default": "./ZSMClientSDK.js"
+                            }
+                    },
+    "scripts"       : {
+                        "start"       : "echo 'This is the Ideem SDK library, not a freestanding application. There is no start script defined. To use, import the library into a browser application.' 1>&2",
+                        "showVersion" : "echo \"$(npm pkg get name | tr -d \\\") current version: $(npm pkg get version | tr -d \\\")\""
+                    },
+    "collaborators" : [
+                        "Joel Teply <joel@useideem.com>",
+                        "Todd Decker <todd@useideem.com>",
+                        "Brian Koziel <brian@useideem.com>"
+                    ],
+    "license"       : "LicenseRef-Ideem",
+    "repository"    : {
+                        "type" : "git",
+                        "url"  : "git+https://github.com/useideem/vHSM.git"
+                    },
+    "homepage"      : "https://useideem.com",
+    "bugs"          : "https://github.com/useideem/vHSM/issues",
+    "files"         : [
+                        "./shims/",
+                        "./ErrorHandler.js",
+                        "./EventCoordinator.js",
+                        "./FIDO2Client.js",
+                        "./FIDO2ClientBase.js",
+                        "./GlobalScoping.js",
+                        "./IdentityIndexing.js",
+                        "./PluginManager.js",
+                        "./RelyingParty.js",
+                        "./RelyingPartyBase.js",
+                        "./UMFAClient.js",
+                        "./UMFAClientBase.js",
+                        "./Utils.js",
+                        "./WASMRustInterface.js",
+                        "./WebAuthnClient.js",
+                        "./WebAuthnClientBase.js",
+                        "./ZSMClientSDK.js",
+                        "./CHANGELOG.md",
+                        "./LICENSE",
+                        "./README.md"
+                    ],
+    "sideEffects"   : [
+                        "./EventCoordinator.js",
+                        "./FIDO2Client.js",
+                        "./FIDO2ClientBase.js",
+                        "./GlobalScoping.js",
+                        "./IdentityIndexing.js",
+                        "./PluginManager.js",
+                        "./RelyingParty.js",
+                        "./RelyingPartyBase.js",
+                        "./UMFAClient.js",
+                        "./UMFAClientBase.js",
+                        "./Utils.js",
+                        "./WASMRustInterface.js",
+                        "./WebAuthnClient.js",
+                        "./WebAuthnClientBase.js",
+                        "./ZSMClientSDK.js"
+                    ]
 }