@licenseseat/js 0.2.2 → 0.3.1

package/dist/index.js

@@ -51,12 +51,12 @@ var LicenseCache = class {
     }
   }
   /**
-   * Get the device identifier from the cached license
-   * @returns {string|null} Device identifier or null if not found
+   * Get the device ID from the cached license
+   * @returns {string|null} Device ID or null if not found
    */
   getDeviceId() {
     const license = this.getLicense();
-    return license ? license.device_identifier : null;
+    return license ? license.device_id : null;
   }
   /**
    * Clear the cached license data
@@ -66,39 +66,39 @@ var LicenseCache = class {
     localStorage.removeItem(this.prefix + "license");
   }
   /**
-   * Get the cached offline license
-   * @returns {import('./types.js').SignedOfflineLicense|null} Offline license or null if not found
+   * Get the cached offline token
+   * @returns {import('./types.js').OfflineToken|null} Offline token or null if not found
    */
-  getOfflineLicense() {
+  getOfflineToken() {
     try {
-      const data = localStorage.getItem(this.prefix + "offline_license");
+      const data = localStorage.getItem(this.prefix + "offline_token");
       return data ? JSON.parse(data) : null;
     } catch (e) {
-      console.error("Failed to read offline license cache:", e);
+      console.error("Failed to read offline token cache:", e);
       return null;
     }
   }
   /**
-   * Store offline license data in cache
-   * @param {import('./types.js').SignedOfflineLicense} data - Signed offline license to cache
+   * Store offline token data in cache
+   * @param {import('./types.js').OfflineToken} data - Offline token to cache
    * @returns {void}
    */
-  setOfflineLicense(data) {
+  setOfflineToken(data) {
     try {
       localStorage.setItem(
-        this.prefix + "offline_license",
+        this.prefix + "offline_token",
         JSON.stringify(data)
       );
     } catch (e) {
-      console.error("Failed to cache offline license:", e);
+      console.error("Failed to cache offline token:", e);
     }
   }
   /**
-   * Clear the cached offline license
+   * Clear the cached offline token
    * @returns {void}
    */
-  clearOfflineLicense() {
-    localStorage.removeItem(this.prefix + "offline_license");
+  clearOfflineToken() {
+    localStorage.removeItem(this.prefix + "offline_token");
   }
   /**
    * Get a cached public key by key ID
@@ -143,8 +143,6 @@ var LicenseCache = class {
         localStorage.removeItem(key);
       }
     });
-    this.clearOfflineLicense();
-    localStorage.removeItem(this.prefix + "last_seen_ts");
   }
   /**
    * Get the last seen timestamp (for clock tamper detection)
@@ -218,7 +216,7 @@ var CryptoError = class extends Error {
 // src/utils.js
 import CJSON from "canonical-json";
 function parseActiveEntitlements(payload = {}) {
-  const raw = payload.active_ents || payload.active_entitlements || [];
+  const raw = payload.entitlements || payload.active_entitlements || [];
   return raw.map((e) => ({
     key: e.key,
     expires_at: e.expires_at ?? null,
@@ -324,7 +322,9 @@ function getCsrfToken() {
 
 // src/LicenseSeat.js
 var DEFAULT_CONFIG = {
-  apiBaseUrl: "https://licenseseat.com/api",
+  apiBaseUrl: "https://licenseseat.com/api/v1",
+  productSlug: null,
+  // Required: Product slug for API calls (e.g., "my-app")
   storagePrefix: "licenseseat_",
   autoValidateInterval: 36e5,
   // 1 hour
@@ -423,27 +423,33 @@ var LicenseSeatSDK = class {
    * @param {string} licenseKey - The license key to activate
    * @param {import('./types.js').ActivationOptions} [options={}] - Activation options
    * @returns {Promise<import('./types.js').CachedLicense>} Activation result with cached license data
+   * @throws {ConfigurationError} When productSlug is not configured
    * @throws {APIError} When the API request fails
    */
   async activate(licenseKey, options = {}) {
-    const deviceId = options.deviceIdentifier || generateDeviceId();
+    if (!this.config.productSlug) {
+      throw new ConfigurationError("productSlug is required for activation");
+    }
+    const deviceId = options.deviceId || generateDeviceId();
     const payload = {
-      license_key: licenseKey,
-      device_identifier: deviceId,
+      device_id: deviceId,
       metadata: options.metadata || {}
     };
-    if (options.softwareReleaseDate) {
-      payload.software_release_date = options.softwareReleaseDate;
+    if (options.deviceName) {
+      payload.device_name = options.deviceName;
     }
     try {
       this.emit("activation:start", { licenseKey, deviceId });
-      const response = await this.apiCall("/activations/activate", {
-        method: "POST",
-        body: payload
-      });
+      const response = await this.apiCall(
+        `/products/${this.config.productSlug}/licenses/${encodeURIComponent(licenseKey)}/activate`,
+        {
+          method: "POST",
+          body: payload
+        }
+      );
       const licenseData = {
         license_key: licenseKey,
-        device_identifier: deviceId,
+        device_id: deviceId,
         activation: response,
         activated_at: (/* @__PURE__ */ new Date()).toISOString(),
         last_validated: (/* @__PURE__ */ new Date()).toISOString()
@@ -463,25 +469,31 @@ var LicenseSeatSDK = class {
   /**
    * Deactivate the current license
    * @returns {Promise<Object>} Deactivation result from the API
+   * @throws {ConfigurationError} When productSlug is not configured
    * @throws {LicenseError} When no active license is found
    * @throws {APIError} When the API request fails
    */
   async deactivate() {
+    if (!this.config.productSlug) {
+      throw new ConfigurationError("productSlug is required for deactivation");
+    }
     const cachedLicense = this.cache.getLicense();
     if (!cachedLicense) {
       throw new LicenseError("No active license found", "no_license");
     }
     try {
       this.emit("deactivation:start", cachedLicense);
-      const response = await this.apiCall("/activations/deactivate", {
-        method: "POST",
-        body: {
-          license_key: cachedLicense.license_key,
-          device_identifier: cachedLicense.device_identifier
+      const response = await this.apiCall(
+        `/products/${this.config.productSlug}/licenses/${encodeURIComponent(cachedLicense.license_key)}/deactivate`,
+        {
+          method: "POST",
+          body: {
+            device_id: cachedLicense.device_id
+          }
         }
-      });
+      );
       this.cache.clearLicense();
-      this.cache.clearOfflineLicense();
+      this.cache.clearOfflineToken();
       this.stopAutoValidation();
       this.emit("deactivation:success", response);
       return response;
@@ -495,22 +507,33 @@ var LicenseSeatSDK = class {
    * @param {string} licenseKey - License key to validate
    * @param {import('./types.js').ValidationOptions} [options={}] - Validation options
    * @returns {Promise<import('./types.js').ValidationResult>} Validation result
+   * @throws {ConfigurationError} When productSlug is not configured
    * @throws {APIError} When the API request fails and offline fallback is not available
    */
   async validateLicense(licenseKey, options = {}) {
+    if (!this.config.productSlug) {
+      throw new ConfigurationError("productSlug is required for validation");
+    }
     try {
       this.emit("validation:start", { licenseKey });
-      const rawResponse = await this.apiCall("/licenses/validate", {
-        method: "POST",
-        body: {
-          license_key: licenseKey,
-          device_identifier: options.deviceIdentifier || this.cache.getDeviceId(),
-          product_slug: options.productSlug
+      const rawResponse = await this.apiCall(
+        `/products/${this.config.productSlug}/licenses/${encodeURIComponent(licenseKey)}/validate`,
+        {
+          method: "POST",
+          body: {
+            device_id: options.deviceId || this.cache.getDeviceId()
+          }
         }
-      });
+      );
       const response = {
         valid: rawResponse.valid,
-        ...rawResponse.license || {}
+        code: rawResponse.code,
+        message: rawResponse.message,
+        warnings: rawResponse.warnings,
+        license: rawResponse.license,
+        activation: rawResponse.activation,
+        // Extract entitlements from license for easy access
+        active_entitlements: rawResponse.license?.active_entitlements || []
       };
       const cachedLicense = this.cache.getLicense();
       if ((!response.active_entitlements || response.active_entitlements.length === 0) && cachedLicense?.validation?.active_entitlements?.length) {
@@ -550,7 +573,13 @@ var LicenseSeatSDK = class {
       if (error instanceof APIError && error.data) {
         const cachedLicense = this.cache.getLicense();
         if (cachedLicense && cachedLicense.license_key === licenseKey) {
-          this.cache.updateValidation({ valid: false, ...error.data });
+          const errorCode = error.data.error?.code || error.data.code;
+          const errorMessage = error.data.error?.message || error.data.message;
+          this.cache.updateValidation({
+            valid: false,
+            code: errorCode,
+            message: errorMessage
+          });
         }
         if (![0, 408, 429].includes(error.status)) {
           this.stopAutoValidation();
@@ -599,33 +628,50 @@ var LicenseSeatSDK = class {
     return this.checkEntitlement(entitlementKey).active;
   }
   /**
-   * Get offline license data from the server
-   * @returns {Promise<import('./types.js').SignedOfflineLicense>} Signed offline license data
+   * Get offline token data from the server
+   * @param {Object} [options={}] - Options for offline token generation
+   * @param {string} [options.deviceId] - Device ID to bind the token to (required for hardware_locked mode)
+   * @param {number} [options.ttlDays] - Token lifetime in days (default: 30, max: 90)
+   * @returns {Promise<import('./types.js').OfflineToken>} Offline token data
+   * @throws {ConfigurationError} When productSlug is not configured
    * @throws {LicenseError} When no active license is found
    * @throws {APIError} When the API request fails
    */
-  async getOfflineLicense() {
+  async getOfflineToken(options = {}) {
+    if (!this.config.productSlug) {
+      throw new ConfigurationError("productSlug is required for offline token");
+    }
     const license = this.cache.getLicense();
     if (!license || !license.license_key) {
-      const errorMsg = "No active license key found in cache to fetch offline license.";
+      const errorMsg = "No active license key found in cache to fetch offline token.";
       this.emit("sdk:error", { message: errorMsg });
       throw new LicenseError(errorMsg, "no_license");
     }
     try {
-      this.emit("offlineLicense:fetching", { licenseKey: license.license_key });
-      const path = `/licenses/${license.license_key}/offline_license`;
-      const response = await this.apiCall(path, { method: "POST" });
-      this.emit("offlineLicense:fetched", {
+      this.emit("offlineToken:fetching", { licenseKey: license.license_key });
+      const body = {};
+      if (options.deviceId) {
+        body.device_id = options.deviceId;
+      }
+      if (options.ttlDays) {
+        body.ttl_days = options.ttlDays;
+      }
+      const path = `/products/${this.config.productSlug}/licenses/${encodeURIComponent(license.license_key)}/offline_token`;
+      const response = await this.apiCall(path, {
+        method: "POST",
+        body: Object.keys(body).length > 0 ? body : void 0
+      });
+      this.emit("offlineToken:fetched", {
         licenseKey: license.license_key,
         data: response
       });
       return response;
     } catch (error) {
       this.log(
-        `Failed to get offline license for ${license.license_key}:`,
+        `Failed to get offline token for ${license.license_key}:`,
         error
       );
-      this.emit("offlineLicense:fetchError", {
+      this.emit("offlineToken:fetchError", {
         licenseKey: license.license_key,
         error
       });
@@ -633,45 +679,45 @@ var LicenseSeatSDK = class {
     }
   }
   /**
-   * Fetch a public key from the server by key ID
-   * @param {string} keyId - The Key ID (kid) for which to fetch the public key
-   * @returns {Promise<string>} Base64-encoded public key
+   * Fetch a signing key from the server by key ID
+   * @param {string} keyId - The Key ID (kid) for which to fetch the signing key
+   * @returns {Promise<import('./types.js').SigningKey>} Signing key data
    * @throws {Error} When keyId is not provided or the key is not found
    */
-  async getPublicKey(keyId) {
+  async getSigningKey(keyId) {
     if (!keyId) {
-      throw new Error("Key ID is required to fetch a public key.");
+      throw new Error("Key ID is required to fetch a signing key.");
     }
     try {
-      this.log(`Fetching public key for kid: ${keyId}`);
-      const response = await this.apiCall(`/public_keys/${keyId}`, {
+      this.log(`Fetching signing key for kid: ${keyId}`);
+      const response = await this.apiCall(`/signing_keys/${encodeURIComponent(keyId)}`, {
         method: "GET"
       });
-      if (response && response.public_key_b64) {
-        this.log(`Successfully fetched public key for kid: ${keyId}`);
-        return response.public_key_b64;
+      if (response && response.public_key) {
+        this.log(`Successfully fetched signing key for kid: ${keyId}`);
+        return response;
       } else {
         throw new Error(
-          `Public key not found or invalid response for kid: ${keyId}`
+          `Signing key not found or invalid response for kid: ${keyId}`
         );
       }
     } catch (error) {
-      this.log(`Failed to fetch public key for kid ${keyId}:`, error);
+      this.log(`Failed to fetch signing key for kid ${keyId}:`, error);
       throw error;
     }
   }
   /**
-   * Verify a signed offline license client-side using Ed25519
-   * @param {import('./types.js').SignedOfflineLicense} signedLicenseData - The signed license data
+   * Verify a signed offline token client-side using Ed25519
+   * @param {import('./types.js').OfflineToken} offlineTokenData - The offline token data
    * @param {string} publicKeyB64 - Base64-encoded public Ed25519 key
    * @returns {Promise<boolean>} True if verification is successful
    * @throws {CryptoError} When crypto library is not available
    * @throws {Error} When inputs are invalid
    */
-  async verifyOfflineLicense(signedLicenseData, publicKeyB64) {
-    this.log("Attempting to verify offline license client-side.");
-    if (!signedLicenseData || !signedLicenseData.payload || !signedLicenseData.signature_b64u) {
-      throw new Error("Invalid signedLicenseData object provided.");
+  async verifyOfflineToken(offlineTokenData, publicKeyB64) {
+    this.log("Attempting to verify offline token client-side.");
+    if (!offlineTokenData || !offlineTokenData.canonical || !offlineTokenData.signature) {
+      throw new Error("Invalid offline token object provided. Expected format: { token, signature, canonical }");
     }
     if (!publicKeyB64) {
       throw new Error("Public key (Base64 encoded) is required.");
@@ -684,27 +730,20 @@ var LicenseSeatSDK = class {
       throw err;
     }
     try {
-      const payloadString = canonicalJsonStringify(signedLicenseData.payload);
-      const messageBytes = new TextEncoder().encode(payloadString);
+      const messageBytes = new TextEncoder().encode(offlineTokenData.canonical);
+      const signatureBytes = base64UrlDecode(offlineTokenData.signature.value);
       const publicKeyBytes = base64UrlDecode(publicKeyB64);
-      const signatureBytes = base64UrlDecode(signedLicenseData.signature_b64u);
       const isValid = ed.verify(signatureBytes, messageBytes, publicKeyBytes);
       if (isValid) {
-        this.log(
-          "Offline license signature VERIFIED successfully client-side."
-        );
-        this.emit("offlineLicense:verified", {
-          payload: signedLicenseData.payload
-        });
+        this.log("Offline token signature VERIFIED successfully client-side.");
+        this.emit("offlineToken:verified", { token: offlineTokenData.token });
       } else {
-        this.log("Offline license signature INVALID client-side.");
-        this.emit("offlineLicense:verificationFailed", {
-          payload: signedLicenseData.payload
-        });
+        this.log("Offline token signature INVALID client-side.");
+        this.emit("offlineToken:verificationFailed", { token: offlineTokenData.token });
       }
       return isValid;
     } catch (error) {
-      this.log("Client-side offline license verification error:", error);
+      this.log("Client-side offline token verification error:", error);
       this.emit("sdk:error", {
         message: "Client-side verification failed.",
         error
@@ -729,19 +768,19 @@ var LicenseSeatSDK = class {
       if (validation.offline) {
         return {
           status: "offline-invalid",
-          message: validation.reason_code || "License invalid (offline)"
+          message: validation.code || "License invalid (offline)"
         };
       }
       return {
         status: "invalid",
-        message: validation.reason || "License invalid"
+        message: validation.message || validation.code || "License invalid"
       };
     }
     if (validation.offline) {
       return {
         status: "offline-valid",
         license: license.license_key,
-        device: license.device_identifier,
+        device: license.device_id,
         activated_at: license.activated_at,
         last_validated: license.last_validated,
         entitlements: validation.active_entitlements || []
@@ -750,18 +789,19 @@ var LicenseSeatSDK = class {
     return {
       status: "active",
       license: license.license_key,
-      device: license.device_identifier,
+      device: license.device_id,
       activated_at: license.activated_at,
       last_validated: license.last_validated,
       entitlements: validation.active_entitlements || []
     };
   }
   /**
-   * Test server authentication
-   * Useful for verifying API key/session is valid.
-   * @returns {Promise<Object>} Result from the server
-   * @throws {ConfigurationError} When API key is not configured
-   * @throws {APIError} When authentication fails
+   * Test API connectivity
+   * Makes a request to the health endpoint to verify connectivity.
+   * Note: To fully verify API key validity, attempt an actual operation like activate() or validateLicense().
+   * @returns {Promise<{authenticated: boolean, healthy: boolean, api_version: string}>}
+   * @throws {ConfigurationError} If API key is not configured
+   * @throws {APIError} If the health check fails
    */
   async testAuth() {
     if (!this.config.apiKey) {
@@ -771,9 +811,15 @@ var LicenseSeatSDK = class {
     }
     try {
       this.emit("auth_test:start");
-      const response = await this.apiCall("/auth_test", { method: "GET" });
-      this.emit("auth_test:success", response);
-      return response;
+      const response = await this.apiCall("/health", { method: "GET" });
+      const result = {
+        authenticated: true,
+        // API key was included in request
+        healthy: response.status === "healthy",
+        api_version: response.api_version
+      };
+      this.emit("auth_test:success", result);
+      return result;
     } catch (error) {
       this.emit("auth_test:error", { error });
       throw error;
@@ -910,9 +956,9 @@ var LicenseSeatSDK = class {
   startConnectivityPolling() {
     if (this.connectivityTimer)
       return;
-    const heartbeat = async () => {
+    const healthCheck = async () => {
       try {
-        await fetch(`${this.config.apiBaseUrl}/heartbeat`, {
+        await fetch(`${this.config.apiBaseUrl}/health`, {
           method: "GET",
           credentials: "omit"
         });
@@ -929,7 +975,7 @@ var LicenseSeatSDK = class {
       }
     };
     this.connectivityTimer = setInterval(
-      heartbeat,
+      healthCheck,
       this.config.networkRecheckInterval
     );
   }
@@ -948,7 +994,7 @@ var LicenseSeatSDK = class {
   // Offline License Management
   // ============================================================
   /**
-   * Fetch and cache offline license and public key
+   * Fetch and cache offline token and signing key
    * Uses a lock to prevent concurrent calls from causing race conditions
    * @returns {Promise<void>}
    * @private
@@ -960,19 +1006,19 @@ var LicenseSeatSDK = class {
     }
     this.syncingOfflineAssets = true;
     try {
-      const offline = await this.getOfflineLicense();
-      this.cache.setOfflineLicense(offline);
-      const kid = offline.kid || offline.payload?.kid;
+      const offline = await this.getOfflineToken();
+      this.cache.setOfflineToken(offline);
+      const kid = offline.signature?.key_id || offline.token?.kid;
       if (kid) {
         const existingKey = this.cache.getPublicKey(kid);
         if (!existingKey) {
-          const pub = await this.getPublicKey(kid);
-          this.cache.setPublicKey(kid, pub);
+          const signingKey = await this.getSigningKey(kid);
+          this.cache.setPublicKey(kid, signingKey.public_key);
         }
       }
-      this.emit("offlineLicense:ready", {
-        kid: offline.kid || offline.payload?.kid,
-        exp_at: offline.payload?.exp_at
+      this.emit("offlineToken:ready", {
+        kid,
+        exp: offline.token?.exp
       });
       const res = await this.quickVerifyCachedOfflineLocal();
       if (res) {
@@ -1002,39 +1048,40 @@ var LicenseSeatSDK = class {
     );
   }
   /**
-   * Verify cached offline license
+   * Verify cached offline token
    * @returns {Promise<import('./types.js').ValidationResult>}
    * @private
    */
   async verifyCachedOffline() {
-    const signed = this.cache.getOfflineLicense();
+    const signed = this.cache.getOfflineToken();
     if (!signed) {
-      return { valid: false, offline: true, reason_code: "no_offline_license" };
+      return { valid: false, offline: true, code: "no_offline_token" };
     }
-    const kid = signed.kid || signed.payload?.kid;
+    const kid = signed.signature?.key_id || signed.token?.kid;
     let pub = kid ? this.cache.getPublicKey(kid) : null;
     if (!pub) {
       try {
-        pub = await this.getPublicKey(kid);
+        const signingKey = await this.getSigningKey(kid);
+        pub = signingKey.public_key;
         this.cache.setPublicKey(kid, pub);
       } catch (e) {
-        return { valid: false, offline: true, reason_code: "no_public_key" };
+        return { valid: false, offline: true, code: "no_public_key" };
       }
     }
     try {
-      const ok = await this.verifyOfflineLicense(signed, pub);
+      const ok = await this.verifyOfflineToken(signed, pub);
       if (!ok) {
-        return { valid: false, offline: true, reason_code: "signature_invalid" };
+        return { valid: false, offline: true, code: "signature_invalid" };
       }
-      const payload = signed.payload || {};
+      const token = signed.token;
       const cached = this.cache.getLicense();
-      if (!cached || !constantTimeEqual(payload.lic_k || "", cached.license_key || "")) {
-        return { valid: false, offline: true, reason_code: "license_mismatch" };
+      if (!cached || !constantTimeEqual(token.license_key || "", cached.license_key || "")) {
+        return { valid: false, offline: true, code: "license_mismatch" };
       }
       const now = Date.now();
-      const expAt = payload.exp_at ? Date.parse(payload.exp_at) : null;
+      const expAt = token.exp ? token.exp * 1e3 : null;
       if (expAt && expAt < now) {
-        return { valid: false, offline: true, reason_code: "expired" };
+        return { valid: false, offline: true, code: "expired" };
       }
       if (!expAt && this.config.maxOfflineDays > 0) {
         const pivot = cached.last_validated || cached.activated_at;
@@ -1044,24 +1091,24 @@ var LicenseSeatSDK = class {
             return {
               valid: false,
               offline: true,
-              reason_code: "grace_period_expired"
+              code: "grace_period_expired"
             };
           }
         }
       }
       const lastSeen = this.cache.getLastSeenTimestamp();
       if (lastSeen && now + this.config.maxClockSkewMs < lastSeen) {
-        return { valid: false, offline: true, reason_code: "clock_tamper" };
+        return { valid: false, offline: true, code: "clock_tamper" };
       }
       this.cache.setLastSeenTimestamp(now);
-      const active = parseActiveEntitlements(payload);
+      const active = parseActiveEntitlements(token);
       return {
         valid: true,
         offline: true,
         ...active.length ? { active_entitlements: active } : {}
       };
     } catch (e) {
-      return { valid: false, offline: true, reason_code: "verification_error" };
+      return { valid: false, offline: true, code: "verification_error" };
     }
   }
   /**
@@ -1071,40 +1118,40 @@ var LicenseSeatSDK = class {
    * @private
    */
   async quickVerifyCachedOfflineLocal() {
-    const signed = this.cache.getOfflineLicense();
+    const signed = this.cache.getOfflineToken();
     if (!signed)
       return null;
-    const kid = signed.kid || signed.payload?.kid;
+    const kid = signed.signature?.key_id || signed.token?.kid;
     const pub = kid ? this.cache.getPublicKey(kid) : null;
     if (!pub)
       return null;
     try {
-      const ok = await this.verifyOfflineLicense(signed, pub);
+      const ok = await this.verifyOfflineToken(signed, pub);
       if (!ok) {
-        return { valid: false, offline: true, reason_code: "signature_invalid" };
+        return { valid: false, offline: true, code: "signature_invalid" };
       }
-      const payload = signed.payload || {};
+      const token = signed.token;
       const cached = this.cache.getLicense();
-      if (!cached || !constantTimeEqual(payload.lic_k || "", cached.license_key || "")) {
-        return { valid: false, offline: true, reason_code: "license_mismatch" };
+      if (!cached || !constantTimeEqual(token.license_key || "", cached.license_key || "")) {
+        return { valid: false, offline: true, code: "license_mismatch" };
       }
       const now = Date.now();
-      const expAt = payload.exp_at ? Date.parse(payload.exp_at) : null;
+      const expAt = token.exp ? token.exp * 1e3 : null;
       if (expAt && expAt < now) {
-        return { valid: false, offline: true, reason_code: "expired" };
+        return { valid: false, offline: true, code: "expired" };
       }
       const lastSeen = this.cache.getLastSeenTimestamp();
       if (lastSeen && now + this.config.maxClockSkewMs < lastSeen) {
-        return { valid: false, offline: true, reason_code: "clock_tamper" };
+        return { valid: false, offline: true, code: "clock_tamper" };
       }
-      const active = parseActiveEntitlements(payload);
+      const active = parseActiveEntitlements(token);
       return {
         valid: true,
         offline: true,
         ...active.length ? { active_entitlements: active } : {}
       };
     } catch (_) {
-      return { valid: false, offline: true, reason_code: "verification_error" };
+      return { valid: false, offline: true, code: "verification_error" };
     }
   }
   // ============================================================
@@ -1146,11 +1193,14 @@ var LicenseSeatSDK = class {
         });
         const data = await response.json();
         if (!response.ok) {
-          throw new APIError(
-            data.error || "Request failed",
-            response.status,
-            data
-          );
+          const errorObj = data.error;
+          let errorMessage = "Request failed";
+          if (typeof errorObj === "object" && errorObj !== null) {
+            errorMessage = errorObj.message || "Request failed";
+          } else if (typeof errorObj === "string") {
+            errorMessage = errorObj;
+          }
+          throw new APIError(errorMessage, response.status, data);
         }
         if (!this.online) {
           this.online = true;