@buoy-gg/license 7.0.41 → 7.0.42

package/lib/web/chunks/chunk-OPWF6JR6.mjs

@@ -1,1480 +0,0 @@
-"use client";
-
-// ../../scripts/web-environment.js
-var __DEV__ = process.env.NODE_ENV !== "production";
-
-// src/storage.web.ts
-var memory = /* @__PURE__ */ new Map();
-var storage = {
-  async getItem(key) {
-    try {
-      return localStorage.getItem(key) ?? memory.get(key) ?? null;
-    } catch {
-      return memory.get(key) ?? null;
-    }
-  },
-  async setItem(key, value) {
-    memory.set(key, value);
-    try {
-      localStorage.setItem(key, value);
-    } catch {
-    }
-  },
-  async removeItem(key) {
-    memory.delete(key);
-    try {
-      localStorage.removeItem(key);
-    } catch {
-    }
-  }
-};
-async function getLicenseStorage() {
-  return storage;
-}
-
-// src/config.ts
-var KEYGEN_CONFIG = {
-  accountId: "b0eba0e8-e904-4906-b644-38f9aab57bed",
-  /**
-   * The Keygen PRODUCT id, used to check that a validated license belongs to
-   * Buoy (see `isAcceptedValidation`).
-   *
-   * Careful: this field previously held `1037431d-b2fe-48db-aca9-10c5e9c4d944`,
-   * which is not a product at all — it was the ID of a product token.
-   * Verified against the Keygen dashboard (Aug 2026): the account has exactly
-   * one product, "Buoy", and this is its id.
-   */
-  productId: "bf67cb43-eeef-40ca-b308-e6e1b22c0eaa",
-  /**
-   * Buoy's license endpoint. It sits in front of Keygen and answers from a
-   * cache, so the license server hears about a key about once an hour no
-   * matter how many devices hold it; Keygen's response body comes back
-   * unchanged. Device registration goes through it too, which is why no
-   * product token ships in this package any more: the token used to be
-   * embedded here, and anything embedded in an app is public.
-   */
-  apiUrl: "https://buoy.gg/api/license"
-};
-var FREE_TOKEN_PUBLIC_KEY = "3b546fc717a62683f3236c70167899a271bee3ffc04df6ec1eea60a394a2f1e9";
-var KEYGEN_POLICIES = {
-  /** Free tier — issued automatically on first dashboard visit. */
-  free: "394e3351-1249-4f73-807a-703408604c0e",
-  /** Solo (sold as "Pro"; the id predates the Solo/Business split). */
-  solo: "fa5d3c8f-5379-40f1-b63e-ab8a974b2f28",
-  /** Business — an exact clone of the Solo policy. */
-  business: "690c2212-8e54-426f-b4b4-002ee1c0ae2b"
-};
-var LICENSE_CACHE_DURATION = 30 * 24 * 60 * 60 * 1e3;
-var LICENSE_REVALIDATION_INTERVAL = 24 * 60 * 60 * 1e3;
-var LICENSE_STORAGE_KEY = "buoy-gg-license";
-var DEVICE_FINGERPRINT_STORAGE_KEY = "buoy-gg-device-fingerprint";
-var LICENSE_LAUNCH_VALIDATION_TTL = 60 * 60 * 1e3;
-var LICENSE_TRANSIENT_RETRY_DELAYS = [
-  5 * 1e3,
-  20 * 1e3,
-  60 * 1e3,
-  5 * 60 * 1e3,
-  15 * 60 * 1e3
-];
-var LICENSE_RATE_LIMIT_DEFAULT_WAIT = 60 * 1e3;
-var LICENSE_QUOTA_COOLDOWN = 60 * 60 * 1e3;
-var LICENSE_VERDICT_CACHE_DURATION = 24 * 60 * 60 * 1e3;
-var LICENSE_FLEET_MACHINE_THRESHOLD = 50;
-var LICENSE_QUIET_VALIDATION_TTL = LICENSE_CACHE_DURATION;
-var LICENSE_HOLD_STORAGE_KEY = "buoy-gg-license-hold";
-
-// src/api.ts
-var { apiUrl } = KEYGEN_CONFIG;
-var LicenseTransportError = class extends Error {
-  constructor(message, status, retryAfterMs = null) {
-    super(message);
-    /** Discriminator that survives bundling, subclassing and realm boundaries. */
-    this.isTransient = true;
-    this.name = "LicenseTransportError";
-    this.status = status;
-    this.retryAfterMs = retryAfterMs;
-  }
-};
-function isRateLimited(error) {
-  const status = error?.status;
-  return status === 429 || status === 402;
-}
-function backoffAfter(error, quotaCooldown, defaultWait) {
-  if (error.status === 402) return quotaCooldown;
-  return error.retryAfterMs ?? defaultWait;
-}
-function readRetryAfter(response) {
-  const get = (name) => {
-    try {
-      return response.headers?.get?.(name) ?? null;
-    } catch {
-      return null;
-    }
-  };
-  const retryAfter = get("Retry-After");
-  if (retryAfter) {
-    const seconds = Number(retryAfter);
-    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
-    const date = Date.parse(retryAfter);
-    if (Number.isFinite(date)) return Math.max(0, date - Date.now());
-  }
-  const reset = Number(get("X-RateLimit-Reset"));
-  if (Number.isFinite(reset) && reset > 0) return Math.max(0, reset * 1e3 - Date.now());
-  return null;
-}
-function isTransientLicenseError(error) {
-  if (error instanceof LicenseTransportError) return true;
-  if (error instanceof TypeError) return true;
-  return typeof error === "object" && error !== null && error.isTransient === true;
-}
-async function describeFailure(response) {
-  try {
-    const errorData = await response.json();
-    return errorData.errors?.[0]?.detail || `HTTP ${response.status}`;
-  } catch {
-    return `HTTP ${response.status}`;
-  }
-}
-function getBaseHeaders() {
-  return {
-    "Content-Type": "application/vnd.api+json",
-    Accept: "application/vnd.api+json"
-  };
-}
-async function requestValidation(licenseKey, signal) {
-  const url = `${apiUrl}/validate`;
-  const body = {
-    meta: {
-      key: licenseKey
-    }
-  };
-  let response;
-  try {
-    response = await fetch(url, {
-      signal,
-      method: "POST",
-      headers: getBaseHeaders(),
-      body: JSON.stringify(body)
-    });
-  } catch (error) {
-    throw new LicenseTransportError(
-      error instanceof Error ? error.message : "Network request failed",
-      null
-    );
-  }
-  if (!response.ok) {
-    throw new LicenseTransportError(
-      await describeFailure(response),
-      response.status,
-      response.status === 429 ? readRetryAfter(response) : null
-    );
-  }
-  try {
-    const json = await response.json();
-    if (!json || typeof json !== "object" || typeof json.meta?.valid !== "boolean" || typeof json.meta?.code !== "string" || !json.meta.code) throw new Error("Missing license verdict");
-    return json;
-  } catch {
-    throw new LicenseTransportError(
-      "License server returned an unreadable response",
-      response.status
-    );
-  }
-}
-async function validateLicense(key) {
-  const controller = typeof AbortController === "function" ? new AbortController() : null;
-  let timer;
-  try {
-    return await Promise.race([
-      requestValidation(key, controller?.signal),
-      new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          reject(new LicenseTransportError("License verification timed out. Please retry.", null));
-          controller?.abort();
-        }, 15e3);
-      })
-    ]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-function isAcceptedValidation(response) {
-  if (!response.data) return false;
-  const product = response.data.relationships?.product?.data?.id;
-  if (product && product !== KEYGEN_CONFIG.productId) return false;
-  if (response.meta.valid && response.meta.code === "VALID") return true;
-  return [
-    "OVERDUE",
-    "NO_MACHINE",
-    "NO_MACHINES",
-    "TOO_MANY_MACHINES",
-    "TOO_MANY_CORES",
-    "TOO_MANY_PROCESSES",
-    "FINGERPRINT_SCOPE_MISMATCH",
-    "HEARTBEAT_NOT_STARTED",
-    "HEARTBEAT_DEAD"
-  ].includes(response.meta.code);
-}
-function machineCount(response) {
-  const count = response.data?.relationships?.machines?.meta?.count;
-  return typeof count === "number" && Number.isFinite(count) ? count : 0;
-}
-async function activateMachine(licenseId, licenseKey, fingerprint, name, metadata) {
-  const url = `${apiUrl}/machines`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: getBaseHeaders(),
-    body: JSON.stringify({ licenseId, licenseKey, fingerprint, name, metadata: metadata || {} })
-  });
-  if (!response.ok) {
-    const errorData = await response.json();
-    const errorCode = errorData.errors?.[0]?.code;
-    if (errorCode === "FINGERPRINT_TAKEN") {
-      throw new Error("FINGERPRINT_TAKEN");
-    }
-    if (errorCode === "MACHINE_LIMIT_EXCEEDED") {
-      throw new Error("MACHINE_LIMIT_EXCEEDED");
-    }
-    const errorMessage = errorData.errors?.[0]?.detail || `HTTP ${response.status}`;
-    throw new Error(errorMessage);
-  }
-  return response.json();
-}
-function parseValidationResult(response) {
-  const { meta, data } = response;
-  return {
-    valid: meta.valid,
-    code: meta.code,
-    detail: meta.detail,
-    // data can be null for invalid licenses
-    metadata: data?.attributes?.metadata
-  };
-}
-function isFatalLicenseError(code) {
-  return [
-    "NOT_FOUND",
-    "SUSPENDED",
-    "EXPIRED",
-    "BANNED",
-    "PRODUCT_SCOPE_MISMATCH"
-  ].includes(code);
-}
-
-// src/device-info.web.ts
-function generateUUID() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-function isDevBundle() {
-  if (typeof __DEV__ !== "undefined") return __DEV__;
-  try {
-    if (typeof navigator !== "undefined" && /electron/i.test(navigator.userAgent)) return true;
-  } catch {
-  }
-  return typeof process !== "undefined" && process.env.NODE_ENV !== "production";
-}
-function detectPlatform() {
-  if (typeof navigator === "undefined") {
-    return "unknown";
-  }
-  const ua = navigator.userAgent.toLowerCase();
-  const platform = navigator.platform?.toLowerCase() || "";
-  if (ua.includes("electron")) {
-    if (platform.includes("mac") || ua.includes("mac")) {
-      return "electron-macos";
-    }
-    if (platform.includes("win") || ua.includes("win")) {
-      return "electron-windows";
-    }
-    if (platform.includes("linux") || ua.includes("linux")) {
-      return "electron-linux";
-    }
-    return "electron";
-  }
-  if (platform.includes("mac") || ua.includes("mac")) {
-    return "macos";
-  }
-  if (platform.includes("win") || ua.includes("win")) {
-    return "windows";
-  }
-  if (platform.includes("linux") || ua.includes("linux")) {
-    return "linux";
-  }
-  if (/iphone|ipad|ipod/.test(ua)) {
-    return "ios-web";
-  }
-  if (ua.includes("android")) {
-    return "android-web";
-  }
-  return "web";
-}
-function getOSVersion() {
-  if (typeof navigator === "undefined") {
-    return "unknown";
-  }
-  const ua = navigator.userAgent;
-  const macMatch = ua.match(/Mac OS X ([\d_.]+)/);
-  if (macMatch) {
-    return macMatch[1].replace(/_/g, ".");
-  }
-  const winMatch = ua.match(/Windows NT ([\d.]+)/);
-  if (winMatch) {
-    const versions = {
-      "10.0": "10/11",
-      "6.3": "8.1",
-      "6.2": "8",
-      "6.1": "7"
-    };
-    return versions[winMatch[1]] || winMatch[1];
-  }
-  if (ua.includes("Linux")) {
-    return "Linux";
-  }
-  return "unknown";
-}
-function getBrowserInfo() {
-  if (typeof navigator === "undefined") {
-    return { name: "unknown", version: "unknown" };
-  }
-  const ua = navigator.userAgent;
-  const electronMatch = ua.match(/Electron\/([\d.]+)/);
-  if (electronMatch) {
-    return { name: "Electron", version: electronMatch[1] };
-  }
-  const chromeMatch = ua.match(/Chrome\/([\d.]+)/);
-  if (chromeMatch && !ua.includes("Edg")) {
-    return { name: "Chrome", version: chromeMatch[1] };
-  }
-  const edgeMatch = ua.match(/Edg\/([\d.]+)/);
-  if (edgeMatch) {
-    return { name: "Edge", version: edgeMatch[1] };
-  }
-  const firefoxMatch = ua.match(/Firefox\/([\d.]+)/);
-  if (firefoxMatch) {
-    return { name: "Firefox", version: firefoxMatch[1] };
-  }
-  const safariMatch = ua.match(/Version\/([\d.]+).*Safari/);
-  if (safariMatch) {
-    return { name: "Safari", version: safariMatch[1] };
-  }
-  return { name: "unknown", version: "unknown" };
-}
-function getDeviceMetadata() {
-  const metadata = {
-    platform: detectPlatform(),
-    osVersion: getOSVersion(),
-    isSimulator: "false"
-  };
-  const browserInfo = getBrowserInfo();
-  metadata.browser = browserInfo.name;
-  metadata.browserVersion = browserInfo.version;
-  if (typeof window !== "undefined" && window.screen) {
-    metadata.screenResolution = `${window.screen.width}x${window.screen.height}`;
-  }
-  if (typeof navigator !== "undefined" && navigator.language) {
-    metadata.language = navigator.language;
-  }
-  try {
-    metadata.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  } catch {
-  }
-  return metadata;
-}
-function getDefaultDeviceName() {
-  const platform = detectPlatform();
-  const browserInfo = getBrowserInfo();
-  if (platform.startsWith("electron")) {
-    const os = platform.replace("electron-", "").replace("electron", "Desktop");
-    return `${os.charAt(0).toUpperCase() + os.slice(1)} App`;
-  }
-  if (browserInfo.name !== "unknown") {
-    return `${browserInfo.name} Browser`;
-  }
-  return "Web Browser";
-}
-
-// src/cacheSignature.ts
-var SIGNATURE_VERSION = "v2";
-var LEGACY_VERSIONS = ["v1"];
-var SIGNING_SALT = "buoy.gg/pro:9f3c1d7a4b2e:license-cache";
-var FIELD_SEPARATOR = "\0";
-function fnv1a(input, seed) {
-  let hash = seed >>> 0;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619) >>> 0;
-  }
-  return hash >>> 0;
-}
-function canonicalize(cache, version) {
-  const fields = [
-    version,
-    cache.licenseKey,
-    cache.licenseId,
-    cache.isPro ? "1" : "0",
-    cache.expiresAt ?? "",
-    String(cache.cachedAt)
-  ];
-  if (version !== "v1") {
-    fields.push(cache.tier ?? "");
-  }
-  fields.push(SIGNING_SALT);
-  return fields.join(FIELD_SEPARATOR);
-}
-function signatureFor(cache, version) {
-  const input = canonicalize(cache, version);
-  const a = fnv1a(input, 2166136261);
-  const b = fnv1a(input, 2135587861);
-  return `${version}.${a.toString(16)}${b.toString(16)}`;
-}
-function cacheSignature(cache) {
-  return signatureFor(cache, SIGNATURE_VERSION);
-}
-function signCache(cache) {
-  return { ...cache, sig: cacheSignature(cache) };
-}
-function verifyCacheSignature(cache) {
-  if (!cache || typeof cache.sig !== "string" || cache.sig.length === 0) {
-    return false;
-  }
-  if (cache.sig === cacheSignature(cache)) return true;
-  return LEGACY_VERSIONS.some(
-    (version) => cache.sig.startsWith(`${version}.`) && cache.sig === signatureFor(cache, version)
-  );
-}
-
-// src/freeToken.ts
-import nacl from "tweetnacl";
-var FREE_TOKEN_VERSION = 1;
-var FREE_TOKEN_TIER_FREE = 1;
-var FREE_TOKEN_DOMAIN = "buoy-free-token-v1:";
-var PAYLOAD_LENGTH = 22;
-var SIGNATURE_LENGTH = 64;
-var TOKEN_PATTERN = /^BUOY1-([A-Z2-7]+)-([A-Z2-7]+)$/;
-function isBuoyToken(key) {
-  return TOKEN_PATTERN.test(key.trim().toUpperCase());
-}
-var B32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-function base32Decode(text) {
-  const out = [];
-  let bits = 0;
-  let value = 0;
-  for (const char of text) {
-    const index = B32.indexOf(char);
-    if (index === -1) return null;
-    value = value << 5 | index;
-    bits += 5;
-    if (bits >= 8) {
-      out.push(value >>> bits - 8 & 255);
-      bits -= 8;
-    }
-  }
-  return new Uint8Array(out);
-}
-function hexToBytes(hex) {
-  const clean = hex.trim().toLowerCase();
-  const out = new Uint8Array(clean.length / 2);
-  for (let i = 0; i < out.length; i += 1) out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
-  return out;
-}
-function bytesToHex(bytes) {
-  let out = "";
-  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
-  return out;
-}
-function utf8(text) {
-  if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(text);
-  const out = new Uint8Array(text.length);
-  for (let i = 0; i < text.length; i += 1) out[i] = text.charCodeAt(i) & 255;
-  return out;
-}
-function concat(a, b) {
-  const out = new Uint8Array(a.length + b.length);
-  out.set(a, 0);
-  out.set(b, a.length);
-  return out;
-}
-function signedMessage(payload) {
-  return concat(utf8(FREE_TOKEN_DOMAIN), payload);
-}
-var activePublicKey = FREE_TOKEN_PUBLIC_KEY;
-function verifyFreeToken(key, publicKeyHex = activePublicKey) {
-  const match = TOKEN_PATTERN.exec(key.trim().toUpperCase());
-  if (!match) return null;
-  const payload = base32Decode(match[1]);
-  const signature = base32Decode(match[2]);
-  if (!payload || !signature) return null;
-  if (payload.length !== PAYLOAD_LENGTH || signature.length !== SIGNATURE_LENGTH) return null;
-  if (payload[0] !== FREE_TOKEN_VERSION || payload[1] !== FREE_TOKEN_TIER_FREE) return null;
-  try {
-    if (!nacl.sign.detached.verify(signedMessage(payload), signature, hexToBytes(publicKeyHex))) return null;
-  } catch {
-    return null;
-  }
-  const seconds = (payload[2] << 24 >>> 0) + (payload[3] << 16) + (payload[4] << 8) + payload[5];
-  return { tier: "free", issuedAt: seconds * 1e3, accountHash: bytesToHex(payload.slice(6, 22)) };
-}
-
-// src/tier.ts
-function resolveTier(license) {
-  const policyId = license.relationships?.policy?.data?.id;
-  if (policyId === KEYGEN_POLICIES.free) return "free";
-  if (policyId === KEYGEN_POLICIES.solo || policyId === KEYGEN_POLICIES.business) {
-    return "pro";
-  }
-  const plan = license.attributes?.metadata?.plan;
-  if (plan === "free") return "free";
-  return "pro";
-}
-function isRecognizedAccount(license) {
-  if (!license) return false;
-  const product = license.relationships?.product?.data?.id;
-  if (product) return product === KEYGEN_CONFIG.productId;
-  const policy = license.relationships?.policy?.data?.id;
-  return Object.values(KEYGEN_POLICIES).some((id) => id === policy);
-}
-
-// src/accountAccess.ts
-function resolveAccountAccess(input, now = Date.now()) {
-  const validUntil = input.verifiedAt !== null && Number.isFinite(input.verifiedAt) && input.verifiedAt <= now ? input.verifiedAt + LICENSE_CACHE_DURATION : null;
-  if (input.initialized && input.key && input.tierSource !== "none" && validUntil !== null && now < validUntil) {
-    return { status: "admitted", reason: null, validUntil };
-  }
-  if (validUntil !== null && now >= validUntil) {
-    return { status: "locked", reason: "verification_expired", validUntil };
-  }
-  if (!input.initialized || input.validating) {
-    return { status: "initializing", reason: "checking", validUntil };
-  }
-  return {
-    status: "locked",
-    reason: validUntil !== null && now >= validUntil ? "verification_expired" : "account_required",
-    validUntil
-  };
-}
-
-// src/foreground.web.ts
-function subscribeForeground(refresh) {
-  if (typeof window === "undefined" || typeof window.addEventListener !== "function") return () => {
-  };
-  const visible = () => {
-    if (!document.hidden) refresh();
-  };
-  window.addEventListener("focus", refresh);
-  document.addEventListener("visibilitychange", visible);
-  return () => {
-    window.removeEventListener("focus", refresh);
-    document.removeEventListener("visibilitychange", visible);
-  };
-}
-
-// src/LicenseManager.ts
-async function boundedStorage(operation, fallback) {
-  let timer;
-  try {
-    return await Promise.race([operation, new Promise((resolve) => {
-      timer = setTimeout(() => resolve(fallback), 15e3);
-    })]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-function tierOfCache(cached) {
-  if (cached.tier === "pro" || cached.tier === "free") return cached.tier;
-  return cached.isPro ? "pro" : "free";
-}
-var LicenseManagerImpl = class {
-  constructor() {
-    this.state = {
-      isInitialized: false,
-      isValidating: false,
-      isPro: false,
-      tier: "free",
-      tierSource: "none",
-      licenseKey: null,
-      error: null,
-      errorKind: null,
-      expiresAt: null
-    };
-    this.listeners = /* @__PURE__ */ new Set();
-    this.revalidationTimer = null;
-    this.cachedLicense = null;
-    this.fingerprintPromise = null;
-    // Promise for initialization to prevent double-init race condition
-    this.initPromise = null;
-    /**
-     * Bumped whenever the license is deliberately changed or cleared.
-     *
-     * `initialize()` kicks off a background revalidation of the cached key and
-     * does NOT await it, so a `clearLicense()` that lands in between would be
-     * silently undone: the in-flight response re-applies the old tier and
-     * re-persists the cache blob that was just deleted. Removing a key would
-     * then appear to do nothing — Pro comes straight back a moment later.
-     *
-     * Background work captures this value when it starts and drops its result if
-     * it no longer matches.
-     */
-    this.generation = 0;
-    this.persistence = Promise.resolve();
-    this.verifiedAt = null;
-    this.expiryTimer = null;
-    this.removeForegroundListener = null;
-    /**
-     * Pending backoff retry after a transient failure (see
-     * LICENSE_TRANSIENT_RETRY_DELAYS). At most one is ever outstanding, and it
-     * is cancelled by any deliberate credential change or by a success.
-     */
-    this.retryTimer = null;
-    this.retryAttempt = 0;
-    // Device registration callback for UI integration
-    this.deviceRegistrationCallback = null;
-    this.pendingRegistration = null;
-  }
-  /**
-   * Initialize the license manager and load cached license
-   */
-  async initialize() {
-    if (this.initPromise) return this.initPromise;
-    if (this.state.isInitialized) return;
-    this.initPromise = this._doInitialize();
-    return this.initPromise;
-  }
-  /**
-   * Internal initialization logic
-   */
-  async _doInitialize() {
-    if (this.state.isInitialized) return;
-    const startedAt = this.generation;
-    try {
-      const cached = await boundedStorage(this.loadCachedLicense(), null);
-      if (startedAt !== this.generation) {
-        this.state.isInitialized = true;
-        this.emit({ type: "initialized", isPro: this.state.isPro });
-        this.startRevalidationTimer();
-        return;
-      }
-      if (cached && (this.configuredKey === void 0 || cached.licenseKey === this.configuredKey)) {
-        const trusted = verifyCacheSignature(cached);
-        this.cachedLicense = cached;
-        this.state.licenseKey = cached.licenseKey;
-        if (trusted && this.isCacheValid(cached)) this.applyTier(tierOfCache(cached));
-        else this.lock();
-        this.state.expiresAt = cached.expiresAt ? new Date(cached.expiresAt) : null;
-        if (trusted && this.isCacheValid(cached)) this.setVerifiedAt(cached.cachedAt);
-        if (this.configuredKey === void 0 && cached.licenseKey && !(trusted && this.isCacheValid(cached) && this.isCacheFresh(cached))) {
-          this.validateInBackground(cached.licenseKey);
-        }
-      }
-      this.state.isInitialized = true;
-      this.emit({ type: "initialized", isPro: this.state.isPro });
-      this.startRevalidationTimer();
-    } catch (error) {
-      console.warn("[React Buoy] License initialization failed:", error);
-      this.state.isInitialized = true;
-      this.emit({ type: "initialized", isPro: false });
-    }
-  }
-  /** Omitted configuration preserves activation; an explicit blank signs out. */
-  async configure(key) {
-    if (key === void 0) {
-      await this.initialize();
-      return this.hasAccountAccess();
-    }
-    const normalized = key.trim().toUpperCase();
-    const startedAt = ++this.generation;
-    this.cancelRetry();
-    this.configuredKey = normalized || null;
-    if (this.state.licenseKey !== this.configuredKey) this.lock();
-    this.state.licenseKey = this.configuredKey;
-    this.state.isValidating = !!normalized;
-    this.emit({ type: "validating", isPro: this.isPro() });
-    await this.initialize();
-    if (startedAt !== this.generation) return false;
-    if (!normalized) {
-      await this.clearLicense();
-      return false;
-    }
-    return this.setLicenseKey(normalized);
-  }
-  /**
-   * Set and validate a license key.
-   *
-   * Simple validation - just checks if the key is valid.
-   * No device registration or limits - we trust our customers.
-   * Keygen tracks validation calls for usage analytics.
-   */
-  async setLicenseKey(licenseKey, opts) {
-    if (!licenseKey || licenseKey.trim().length === 0) {
-      this.state.error = "License key is required";
-      this.state.errorKind = "verdict";
-      return false;
-    }
-    const normalizedKey = licenseKey.trim().toUpperCase();
-    const startedAt = ++this.generation;
-    this.cancelRetry();
-    if (!opts?.isRetry) this.retryAttempt = 0;
-    if (this.state.licenseKey !== normalizedKey) this.lock();
-    this.state.licenseKey = normalizedKey;
-    this.state.isValidating = true;
-    this.state.error = null;
-    this.state.errorKind = null;
-    this.emit({ type: "validating", isPro: this.isPro() });
-    if (isBuoyToken(normalizedKey)) return this.admitToken(normalizedKey, startedAt);
-    if (!this.cachedLicense) {
-      const cached = await boundedStorage(this.loadCachedLicense(), null);
-      if (startedAt !== this.generation) return false;
-      if (cached?.licenseKey === normalizedKey) {
-        this.cachedLicense = cached;
-        if (verifyCacheSignature(cached) && this.isCacheValid(cached)) {
-          this.applyTier(tierOfCache(cached));
-          this.state.expiresAt = cached.expiresAt ? new Date(cached.expiresAt) : null;
-          this.setVerifiedAt(cached.cachedAt);
-          this.emit({ type: "validating", isPro: this.isPro() });
-        }
-      }
-    }
-    const fresh = this.cachedLicense;
-    if (!opts?.force && fresh && fresh.valid && fresh.licenseKey === normalizedKey && fresh.fingerprint && verifyCacheSignature(fresh) && this.isCacheValid(fresh) && this.isCacheFresh(fresh)) {
-      this.applyTier(tierOfCache(fresh));
-      this.state.licenseKey = normalizedKey;
-      this.state.isValidating = false;
-      this.state.error = null;
-      this.state.errorKind = null;
-      this.state.expiresAt = fresh.expiresAt ? new Date(fresh.expiresAt) : null;
-      this.setVerifiedAt(fresh.cachedAt);
-      this.emit({ type: "validated", isPro: this.state.isPro });
-      return true;
-    }
-    const hold = await boundedStorage(this.loadHold(), null);
-    if (startedAt !== this.generation) return false;
-    const remainingBackoff = (hold?.backoffUntil ?? 0) - Date.now();
-    if (remainingBackoff > 0) {
-      return this.standDown(normalizedKey, startedAt, "License server is rate limited; retrying later.", remainingBackoff);
-    }
-    if (!opts?.force && hold?.key === normalizedKey && hold.verdictAt !== void 0 && Date.now() - hold.verdictAt >= 0 && Date.now() - hold.verdictAt < LICENSE_VERDICT_CACHE_DURATION) {
-      this.lock();
-      this.state.isValidating = false;
-      this.state.error = hold.detail || "License could not be verified";
-      this.state.errorKind = "verdict";
-      this.emit({ type: "error", isPro: false, error: this.state.error });
-      return false;
-    }
-    let response;
-    try {
-      response = await validateLicense(normalizedKey);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Validation failed";
-      if (startedAt !== this.generation) return false;
-      if (isTransientLicenseError(error)) {
-        if (isRateLimited(error)) {
-          const wait = Math.min(
-            backoffAfter(error, LICENSE_QUOTA_COOLDOWN, LICENSE_RATE_LIMIT_DEFAULT_WAIT) * 2 ** this.retryAttempt,
-            LICENSE_QUOTA_COOLDOWN
-          );
-          this.retryAttempt += 1;
-          await this.saveHold({ ...this.hold, backoffUntil: Date.now() + wait });
-          if (startedAt !== this.generation) return false;
-          return this.standDown(normalizedKey, startedAt, errorMessage, wait);
-        }
-        this.state.isValidating = false;
-        if (this.cachedLicense && // The cache can only stand in for the key it was written FOR. Without
-        // this, typing a new (or mistyped) key while the server is
-        // unreachable would "validate" it by serving the old key's cache.
-        this.cachedLicense.licenseKey === normalizedKey && verifyCacheSignature(this.cachedLicense) && this.isCacheValid(this.cachedLicense)) {
-          this.applyTier(tierOfCache(this.cachedLicense));
-          this.state.error = null;
-          this.state.errorKind = null;
-          this.state.expiresAt = this.cachedLicense.expiresAt ? new Date(this.cachedLicense.expiresAt) : null;
-          this.setVerifiedAt(this.cachedLicense.cachedAt);
-          if (!this.isPro()) this.scheduleRetry(normalizedKey);
-          this.emit({ type: "validated", isPro: this.state.isPro });
-          return true;
-        }
-        this.state.error = errorMessage;
-        this.state.errorKind = "transport";
-        this.scheduleRetry(normalizedKey);
-        this.emit({
-          type: "error",
-          isPro: this.state.isPro,
-          error: errorMessage
-        });
-        return false;
-      }
-      this.state.isValidating = false;
-      this.state.error = errorMessage;
-      this.state.errorKind = "verdict";
-      this.emit({ type: "error", isPro: false, error: errorMessage });
-      return false;
-    }
-    try {
-      if (startedAt !== this.generation) return false;
-      const result = parseValidationResult(response);
-      const product = response.data?.relationships?.product?.data?.id;
-      if ((!product || product === KEYGEN_CONFIG.productId) && result.code === "EXPIRED" && (isRecognizedAccount(response.data) || this.cachedLicense?.licenseKey === normalizedKey && verifyCacheSignature(this.cachedLicense) && this.isCacheValid(this.cachedLicense))) {
-        const now2 = Date.now();
-        const saved2 = await this.saveCache({
-          licenseKey: normalizedKey,
-          licenseId: response.data?.id ?? "",
-          valid: true,
-          isPro: false,
-          tier: "free",
-          expiresAt: null,
-          cachedAt: now2,
-          lastValidatedAt: now2,
-          fingerprint: this.cachedLicense?.licenseKey === normalizedKey ? this.cachedLicense.fingerprint : void 0
-        }, startedAt);
-        if (startedAt !== this.generation || !saved2) return false;
-        this.cachedLicense = saved2;
-        this.applyTier("free");
-        this.state.isValidating = false;
-        this.state.expiresAt = null;
-        this.setVerifiedAt(now2);
-        this.emit({ type: "validated", isPro: false });
-        return true;
-      }
-      if (isFatalLicenseError(result.code) || !isAcceptedValidation(response)) {
-        this.lock();
-        this.state.isValidating = false;
-        this.state.error = result.detail || "License could not be verified";
-        this.state.errorKind = "verdict";
-        this.emit({ type: "error", isPro: false, error: this.state.error });
-        await this.clearCachedLicense();
-        await this.saveHold({
-          key: normalizedKey,
-          code: result.code,
-          detail: this.state.error,
-          verdictAt: Date.now()
-        });
-        return false;
-      }
-      if (!response.data) {
-        this.lock();
-        this.state.isValidating = false;
-        this.state.error = result.detail || "License not found";
-        this.state.errorKind = "verdict";
-        this.emit({ type: "error", isPro: false, error: this.state.error });
-        await this.clearCachedLicense();
-        return false;
-      }
-      const tier = resolveTier(response.data);
-      const licenseId = response.data.id;
-      const now = Date.now();
-      const fleet = machineCount(response) >= LICENSE_FLEET_MACHINE_THRESHOLD;
-      const devBundle = isDevBundle();
-      const canRegister = devBundle && !fleet;
-      const quiet = tier === "free" && (fleet || !devBundle);
-      let fingerprint = this.cachedLicense?.fingerprint;
-      let deviceName = this.cachedLicense?.deviceName;
-      let needsRegistration = false;
-      if (!fingerprint) {
-        fingerprint = await boundedStorage(this.getOrCreateDeviceFingerprint(), generateUUID());
-        if (startedAt !== this.generation) return false;
-        deviceName = getDefaultDeviceName();
-        needsRegistration = canRegister;
-      }
-      let deferCaching = false;
-      if (needsRegistration) {
-        if (this.deviceRegistrationCallback) {
-          this.pendingRegistration = {
-            licenseId,
-            licenseKey: normalizedKey,
-            fingerprint
-          };
-          this.deviceRegistrationCallback({
-            fingerprint,
-            defaultName: deviceName
-          });
-          deferCaching = true;
-        } else {
-          this.registerDeviceAsync(licenseId, normalizedKey, fingerprint, deviceName);
-        }
-      }
-      const cached = {
-        licenseKey: normalizedKey,
-        licenseId,
-        valid: true,
-        isPro: tier === "pro",
-        tier,
-        expiresAt: response.data.attributes.expiry ?? null,
-        cachedAt: now,
-        lastValidatedAt: now,
-        // Don't cache fingerprint if we're deferring to UI for registration
-        fingerprint: deferCaching ? void 0 : fingerprint,
-        deviceName: deferCaching ? void 0 : deviceName,
-        quiet: quiet || void 0
-      };
-      const saved = await this.saveCache(cached, startedAt);
-      if (startedAt !== this.generation || !saved) return false;
-      this.cachedLicense = saved;
-      this.applyTier(tier);
-      this.state.isValidating = false;
-      this.state.expiresAt = cached.expiresAt ? new Date(cached.expiresAt) : null;
-      this.setVerifiedAt(now);
-      if (this.hold) await this.saveHold(null);
-      if (startedAt !== this.generation) return false;
-      this.retryAttempt = 0;
-      this.emit({ type: "validated", isPro: this.state.isPro });
-      return true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Validation failed";
-      if (startedAt !== this.generation) return false;
-      this.state.isValidating = false;
-      this.state.error = errorMessage;
-      this.state.errorKind = "verdict";
-      this.emit({ type: "error", isPro: false, error: errorMessage });
-      return false;
-    }
-  }
-  /**
-   * Retry a transiently-failed validation on a short, finite backoff.
-   *
-   * Only ever scheduled when there was nothing cached to fall back on, which
-   * is the one case that leaves a real customer stuck: the key comes in as a
-   * prop, so without this the next attempt is the daily revalidation timer.
-   */
-  scheduleRetry(licenseKey) {
-    this.cancelRetry();
-    const delay = LICENSE_TRANSIENT_RETRY_DELAYS[this.retryAttempt];
-    if (delay === void 0) return;
-    this.retryAttempt += 1;
-    const startedAt = this.generation;
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = null;
-      if (startedAt !== this.generation) return;
-      if (this.state.isValidating) return;
-      void this.setLicenseKey(licenseKey, { force: true, isRetry: true });
-    }, delay);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      globalThis.__LICENSE_MANAGER_RETRY_TIMER__ = this.retryTimer;
-    }
-  }
-  /**
-   * Admit (or reject) a free-tier token. Verification is a signature check
-   * against the public key in config.ts; the cache is written so the next
-   * launch and the account-admission clock see a validated key, and marked
-   * quiet so nothing ever revalidates it against a server.
-   */
-  async admitToken(token, startedAt) {
-    const claims = verifyFreeToken(token);
-    if (startedAt !== this.generation) return false;
-    if (!claims) {
-      this.lock();
-      this.state.isValidating = false;
-      this.state.error = "This key is not valid. Check that it was copied completely.";
-      this.state.errorKind = "verdict";
-      this.emit({ type: "error", isPro: false, error: this.state.error });
-      await this.clearCachedLicense();
-      return false;
-    }
-    const now = Date.now();
-    const fingerprint = this.cachedLicense?.fingerprint ?? await boundedStorage(this.getOrCreateDeviceFingerprint(), generateUUID());
-    if (startedAt !== this.generation) return false;
-    const saved = await this.saveCache({
-      licenseKey: token,
-      licenseId: `token:${claims.accountHash}`,
-      valid: true,
-      isPro: false,
-      tier: "free",
-      expiresAt: null,
-      cachedAt: now,
-      lastValidatedAt: now,
-      fingerprint,
-      deviceName: this.cachedLicense?.deviceName ?? getDefaultDeviceName(),
-      quiet: true
-    }, startedAt);
-    if (startedAt !== this.generation || !saved) return false;
-    this.cachedLicense = saved;
-    this.applyTier("free");
-    this.state.isValidating = false;
-    this.state.expiresAt = null;
-    this.setVerifiedAt(now);
-    this.retryAttempt = 0;
-    this.emit({ type: "validated", isPro: false });
-    return true;
-  }
-  /**
-   * "Don't ask right now": serve the trusted cache if it vouches for this
-   * key, otherwise record why the tier can't move, then try exactly once when
-   * the wait is over. Used for server-set backoffs, both fresh and remembered.
-   */
-  standDown(licenseKey, startedAt, reason, wait) {
-    if (startedAt !== this.generation) return false;
-    this.state.isValidating = false;
-    const cached = this.cachedLicense;
-    if (cached && cached.licenseKey === licenseKey && verifyCacheSignature(cached) && this.isCacheValid(cached)) {
-      this.applyTier(tierOfCache(cached));
-      this.state.error = null;
-      this.state.errorKind = null;
-      this.state.expiresAt = cached.expiresAt ? new Date(cached.expiresAt) : null;
-      this.setVerifiedAt(cached.cachedAt);
-      if (!this.isPro()) this.scheduleRetryIn(licenseKey, wait);
-      this.emit({ type: "validated", isPro: this.state.isPro });
-      return true;
-    }
-    this.state.error = reason;
-    this.state.errorKind = "transport";
-    this.scheduleRetryIn(licenseKey, wait);
-    this.emit({ type: "error", isPro: this.state.isPro, error: reason });
-    return false;
-  }
-  /** One retry at a server-chosen time. Replaces any ladder step pending. */
-  scheduleRetryIn(licenseKey, delay) {
-    this.cancelRetry();
-    const startedAt = this.generation;
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = null;
-      if (startedAt !== this.generation) return;
-      if (this.state.isValidating) return;
-      void this.setLicenseKey(licenseKey, { force: true, isRetry: true });
-    }, Math.max(1, Math.min(delay, 2147483647)));
-    if (typeof __DEV__ !== "undefined" && __DEV__) devTimers.__LICENSE_MANAGER_RETRY_TIMER__ = this.retryTimer;
-  }
-  /** Drop any pending retry — a newer decision has replaced it. */
-  cancelRetry() {
-    if (this.retryTimer) {
-      clearTimeout(this.retryTimer);
-      this.retryTimer = null;
-    }
-  }
-  /**
-   * Clear the current license
-   */
-  async clearLicense() {
-    this.generation += 1;
-    this.cancelRetry();
-    this.retryAttempt = 0;
-    this.configuredKey = null;
-    this.state.licenseKey = null;
-    this.lock();
-    this.state.expiresAt = null;
-    this.state.error = null;
-    this.state.errorKind = null;
-    this.cachedLicense = null;
-    this.pendingRegistration = null;
-    this.state.isValidating = false;
-    this.emit({ type: "deactivated", isPro: false });
-    await this.clearCachedLicense();
-    if (this.hold?.verdictAt !== void 0) {
-      await this.saveHold(this.hold.backoffUntil ? { backoffUntil: this.hold.backoffUntil } : null);
-    }
-  }
-  /**
-   * Set the tier a validated key granted and keep the derived fields in step.
-   *
-   * `isPro` is a mirror of `tier === "pro"` and must never be assigned
-   * directly — that is exactly how a free key would end up granting Pro.
-   */
-  applyTier(tier) {
-    this.state.tier = tier;
-    this.state.tierSource = "key";
-    this.state.isPro = tier === "pro";
-  }
-  /**
-   * Forget whatever the current key had proven. There is no tier for "nothing
-   * validated": the tier falls back to free and `tierSource: "none"` is what
-   * makes `getAccountAccess()` report the manager locked.
-   */
-  lock() {
-    this.state.tier = "free";
-    this.state.tierSource = "none";
-    this.state.isPro = false;
-    this.verifiedAt = null;
-    if (this.expiryTimer) clearTimeout(this.expiryTimer);
-    this.expiryTimer = null;
-  }
-  /**
-   * The current tier. This is what caps should read; whether the tools are
-   * usable at all is `getAccountAccess()`.
-   */
-  getTier() {
-    if (!this.hasAccountAccess()) return "free";
-    if (this.state.expiresAt && Date.now() >= this.state.expiresAt.getTime()) return "free";
-    return this.state.tier;
-  }
-  /**
-   * Check if the user has Pro features
-   */
-  isPro() {
-    return this.getTier() === "pro";
-  }
-  /**
-   * Check if a specific entitlement is available
-   */
-  hasEntitlement(code) {
-    return this.isPro();
-  }
-  /**
-   * Get current license state
-   */
-  getState() {
-    const access = this.getAccountAccess();
-    const tier = this.getTier();
-    return { ...this.state, tier, isPro: tier === "pro", access };
-  }
-  getAccountAccess() {
-    return resolveAccountAccess({
-      initialized: this.state.isInitialized,
-      validating: this.state.isValidating,
-      key: this.state.licenseKey,
-      tierSource: this.state.tierSource,
-      verifiedAt: this.verifiedAt
-    });
-  }
-  hasAccountAccess() {
-    return this.getAccountAccess().status === "admitted";
-  }
-  setVerifiedAt(at) {
-    this.verifiedAt = at;
-    if (this.expiryTimer) clearTimeout(this.expiryTimer);
-    const accountDeadline = at + LICENSE_CACHE_DURATION;
-    const paidDeadline = this.state.expiresAt?.getTime();
-    const nextDeadline = paidDeadline && paidDeadline > Date.now() ? Math.min(accountDeadline, paidDeadline) : accountDeadline;
-    const remaining = nextDeadline - Date.now();
-    this.expiryTimer = setTimeout(() => {
-      this.expiryTimer = null;
-      if (this.verifiedAt !== at) return;
-      this.emit({ type: "validated", isPro: this.isPro() });
-      if (Date.now() < accountDeadline) this.setVerifiedAt(at);
-    }, Math.max(1, Math.min(remaining, 2147483647)));
-    if (typeof __DEV__ !== "undefined" && __DEV__) devTimers.__LICENSE_MANAGER_EXPIRY_TIMER__ = this.expiryTimer;
-  }
-  /**
-   * Subscribe to license events
-   */
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  /**
-   * Subscribe to device registration events
-   * When a new device needs to be registered, the callback is invoked
-   * with the fingerprint and default name suggestion.
-   * Call completeDeviceRegistration() to finish registration with user's chosen name.
-   */
-  onDeviceRegistrationNeeded(callback) {
-    this.deviceRegistrationCallback = callback;
-    return () => {
-      this.deviceRegistrationCallback = null;
-    };
-  }
-  /**
-   * Complete device registration with user-provided name
-   * Call this after onDeviceRegistrationNeeded callback to finish registration
-   */
-  async completeDeviceRegistration(deviceName) {
-    if (!this.pendingRegistration) {
-      console.warn("[Buoy] No pending device registration");
-      return;
-    }
-    const { licenseId, licenseKey, fingerprint } = this.pendingRegistration;
-    const startedAt = this.generation;
-    const name = deviceName.trim() || getDefaultDeviceName();
-    const metadata = getDeviceMetadata();
-    try {
-      await activateMachine(licenseId, licenseKey, fingerprint, name, metadata);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (errorMessage === "FINGERPRINT_TAKEN" || errorMessage === "MACHINE_LIMIT_EXCEEDED") {
-      } else {
-        console.warn("[Buoy] Device registration failed:", errorMessage);
-        throw error;
-      }
-    }
-    if (startedAt !== this.generation) return;
-    if (this.cachedLicense?.licenseKey === licenseKey) {
-      const saved = await this.saveCache({ ...this.cachedLicense, fingerprint, deviceName: name }, startedAt);
-      if (startedAt !== this.generation) return;
-      if (saved) this.cachedLicense = saved;
-    }
-    this.pendingRegistration = null;
-  }
-  // Private methods
-  emit(event) {
-    const listeners = [...this.listeners];
-    listeners.forEach((listener) => {
-      try {
-        listener(event);
-      } catch (error) {
-        console.warn("[React Buoy] License listener error:", error);
-      }
-    });
-  }
-  isCacheValid(cached) {
-    const now = Date.now();
-    const cacheAge = now - cached.cachedAt;
-    if (!cached.valid || !Number.isFinite(cached.cachedAt) || cacheAge < 0 || cacheAge >= LICENSE_CACHE_DURATION) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Whether the cache was validated against Keygen recently enough that a
-   * launch-time revalidation would add nothing (see LICENSE_LAUNCH_VALIDATION_TTL).
-   */
-  isCacheFresh(cached) {
-    const ttl = this.isQuiet(cached) ? LICENSE_QUIET_VALIDATION_TTL : LICENSE_LAUNCH_VALIDATION_TTL;
-    return Date.now() - (cached.lastValidatedAt ?? 0) < ttl;
-  }
-  /**
-   * Whether a cache has anything to learn before it expires. Blobs written
-   * before the flag existed are judged the same way they would be today.
-   */
-  isQuiet(cached) {
-    if (cached.quiet !== void 0) return cached.quiet;
-    return tierOfCache(cached) === "free" && !isDevBundle();
-  }
-  async loadHold() {
-    if (this.hold !== void 0) return this.hold;
-    try {
-      const storage2 = await getLicenseStorage();
-      const raw = await storage2.getItem(LICENSE_HOLD_STORAGE_KEY);
-      const parsed = raw ? JSON.parse(raw) : null;
-      this.hold = parsed && typeof parsed === "object" ? parsed : null;
-    } catch {
-      this.hold = null;
-    }
-    return this.hold;
-  }
-  /** Replace the hold record (null clears it). Never throws: a failed write only costs a request. */
-  async saveHold(record) {
-    this.hold = record;
-    try {
-      const storage2 = await getLicenseStorage();
-      if (record) await storage2.setItem(LICENSE_HOLD_STORAGE_KEY, JSON.stringify(record));
-      else await storage2.removeItem(LICENSE_HOLD_STORAGE_KEY);
-    } catch {
-    }
-  }
-  /**
-   * Write the cache with a fresh checksum. Every write goes through here so a
-   * blob can never land on disk unsigned — an unsigned blob is treated as
-   * untrusted on the next read, which would silently drop a paying customer.
-   */
-  async persistCache(cache) {
-    const signed = signCache(cache);
-    const storage2 = await getLicenseStorage();
-    await storage2.setItem(LICENSE_STORAGE_KEY, JSON.stringify(signed));
-    return signed;
-  }
-  saveCache(cache, startedAt) {
-    const operation = this.persistence.catch(() => {
-    }).then(async () => {
-      if (startedAt !== this.generation) return null;
-      const saved = await this.persistCache(cache);
-      return startedAt === this.generation ? saved : null;
-    });
-    this.persistence = operation;
-    return boundedStorage(operation, signCache(cache));
-  }
-  async loadCachedLicense() {
-    try {
-      await this.persistence.catch(() => {
-      });
-      const storage2 = await getLicenseStorage();
-      const data = await storage2.getItem(LICENSE_STORAGE_KEY);
-      if (!data) return null;
-      const cached = JSON.parse(data);
-      return cached;
-    } catch (error) {
-      console.warn("[Buoy] Error loading cached license:", error);
-      return null;
-    }
-  }
-  /**
-   * The install's stable device fingerprint, created once and persisted under
-   * its own key. Older versions kept the fingerprint only inside the license
-   * blob, so anything that cleared the blob gave the device a new identity —
-   * this adopts a pre-existing blob fingerprint on first read so upgrading
-   * doesn't mint a second machine record for the same install.
-   */
-  getOrCreateDeviceFingerprint() {
-    if (!this.fingerprintPromise) {
-      this.fingerprintPromise = (async () => {
-        const storage2 = await getLicenseStorage();
-        const existing = await storage2.getItem(DEVICE_FINGERPRINT_STORAGE_KEY);
-        if (existing) return existing;
-        const fingerprint = this.cachedLicense?.fingerprint || generateUUID();
-        await storage2.setItem(DEVICE_FINGERPRINT_STORAGE_KEY, fingerprint);
-        return fingerprint;
-      })();
-    }
-    return this.fingerprintPromise;
-  }
-  async clearCachedLicense() {
-    this.cachedLicense = null;
-    const operation = this.persistence.catch(() => {
-    }).then(async () => {
-      const storage2 = await getLicenseStorage();
-      await storage2.removeItem(LICENSE_STORAGE_KEY);
-    });
-    this.persistence = operation;
-    await boundedStorage(operation.catch(() => {
-    }), void 0);
-  }
-  /**
-   * Register device in background for visibility (non-blocking)
-   * Failures don't affect Pro status - this is just for analytics
-   */
-  registerDeviceAsync(licenseId, licenseKey, fingerprint, deviceName) {
-    const metadata = getDeviceMetadata();
-    activateMachine(licenseId, licenseKey, fingerprint, deviceName, metadata).catch((error) => {
-      if (error.message !== "FINGERPRINT_TAKEN" && error.message !== "MACHINE_LIMIT_EXCEEDED") {
-        console.warn("[Buoy] Device registration failed (non-blocking):", error.message);
-      }
-    });
-  }
-  validateInBackground(licenseKey) {
-    void this.setLicenseKey(licenseKey, { force: true, isRetry: true });
-  }
-  refreshAccess() {
-    this.emit({ type: "validated", isPro: this.isPro() });
-  }
-  startRevalidationTimer() {
-    if (!this.removeForegroundListener) {
-      this.removeForegroundListener = subscribeForeground(() => this.refreshAccess());
-      if (typeof __DEV__ !== "undefined" && __DEV__) devTimers.__LICENSE_MANAGER_FOREGROUND_OFF__ = this.removeForegroundListener;
-    }
-    if (this.revalidationTimer) {
-      clearInterval(this.revalidationTimer);
-    }
-    this.revalidationTimer = setInterval(() => {
-      if (!this.state.licenseKey || this.state.isValidating) return;
-      const cached = this.cachedLicense;
-      if (cached && cached.licenseKey === this.state.licenseKey && this.isCacheFresh(cached)) return;
-      this.validateInBackground(this.state.licenseKey);
-    }, LICENSE_REVALIDATION_INTERVAL);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      globalThis.__LICENSE_MANAGER_TIMER__ = this.revalidationTimer;
-    }
-  }
-  /**
-   * Stop the revalidation timer
-   */
-  stopRevalidationTimer() {
-    this.removeForegroundListener?.();
-    this.removeForegroundListener = null;
-    if (this.expiryTimer) clearTimeout(this.expiryTimer);
-    this.expiryTimer = null;
-    if (this.revalidationTimer) {
-      clearInterval(this.revalidationTimer);
-      this.revalidationTimer = null;
-    }
-    this.cancelRetry();
-  }
-  /**
-   * Force re-registration by clearing cached fingerprint
-   * (For debugging/testing - forces device to re-register on next validation)
-   */
-  async forceReregister() {
-    if (this.cachedLicense) {
-      this.cachedLicense.fingerprint = void 0;
-      this.cachedLicense.deviceName = void 0;
-    }
-    this.fingerprintPromise = null;
-    await this.clearCachedLicense();
-    try {
-      const storage2 = await getLicenseStorage();
-      await storage2.removeItem(DEVICE_FINGERPRINT_STORAGE_KEY);
-    } catch {
-    }
-  }
-};
-var LicenseManager = new LicenseManagerImpl();
-var devTimers = globalThis;
-if (typeof __DEV__ !== "undefined" && __DEV__) {
-  devTimers.__LICENSE_MANAGER_FOREGROUND_OFF__?.();
-  devTimers.__LICENSE_MANAGER_FOREGROUND_OFF__ = void 0;
-  if (devTimers.__LICENSE_MANAGER_EXPIRY_TIMER__) clearTimeout(devTimers.__LICENSE_MANAGER_EXPIRY_TIMER__);
-  if (devTimers.__LICENSE_MANAGER_TIMER__) {
-    clearInterval(devTimers.__LICENSE_MANAGER_TIMER__);
-  }
-  if (devTimers.__LICENSE_MANAGER_RETRY_TIMER__) {
-    clearTimeout(devTimers.__LICENSE_MANAGER_RETRY_TIMER__);
-    devTimers.__LICENSE_MANAGER_RETRY_TIMER__ = void 0;
-  }
-}
-
-export {
-  LicenseTransportError,
-  isTransientLicenseError,
-  isBuoyToken,
-  resolveAccountAccess,
-  LicenseManager
-};
-/*!
- * PROPRIETARY — Buoy Pro license enforcement. NOT open source.
- *
- * Copyright (c) Buoy. All rights reserved. Licensed under the Buoy EULA
- * (https://buoy.gg/terms), not an OSS license.
- *
- * This file configures the technological measure that controls access to paid
- * Buoy Pro features. Modifying, patching, aliasing, stubbing, or otherwise
- * altering it — including repointing `apiUrl` at a stand-in license server — so
- * that Pro features unlock without a valid license is a breach of the EULA and,
- * in the United States, circumvention of an access control under 17 U.S.C.
- * § 1201, which applies whether or not any code is copied.
- *
- * Pro is $9/mo, and is free every weekend for anyone holding a key —
- * including a free one (`npx buoy login`). Buy a key at
- * https://buoy.gg or use it free on Saturday and Sunday.
- */
-/*!
- * PROPRIETARY — Buoy Pro license enforcement. NOT open source.
- *
- * Copyright (c) Buoy. All rights reserved. Licensed under the Buoy EULA
- * (https://buoy.gg/terms), not an OSS license.
- *
- * This file is part of the technological measure that controls access to paid
- * Buoy Pro features. Modifying, patching, aliasing, stubbing, or otherwise
- * altering it so that Pro features unlock without a valid license is a breach
- * of the EULA and, in the United States, circumvention of an access control
- * under 17 U.S.C. § 1201 — which applies whether or not any code is copied.
- *
- * Pro is $9/mo, and is free every weekend for anyone holding a key —
- * including a free one (`npx buoy login`). Buy a key at
- * https://buoy.gg or use it free on Saturday and Sunday.
- */
-/*!
- * PROPRIETARY — Buoy Pro license enforcement. NOT open source.
- *
- * Copyright (c) Buoy. All rights reserved. Licensed under the Buoy EULA
- * (https://buoy.gg/terms), not an OSS license.
- */
-/*!
- * PROPRIETARY — Buoy Pro license enforcement. NOT open source.
- *
- * Copyright (c) Buoy. All rights reserved. Licensed under the Buoy EULA
- * (https://buoy.gg/terms), not an OSS license.
- *
- * This file is part of the technological measure that controls access to paid
- * Buoy Pro features: it decides which tier a validated key grants. Modifying,
- * patching, aliasing, stubbing, or otherwise altering it so that Pro features
- * unlock without a valid license is a breach of the EULA and, in the United
- * States, circumvention of an access control under 17 U.S.C. § 1201 — which
- * applies whether or not any code is copied.
- *
- * Pro is $9/mo, and is free every weekend for anyone holding a key —
- * including a free one (`npx buoy login`). Buy a key at
- * https://buoy.gg or use it free on Saturday and Sunday.
- */
-/*!
- * PROPRIETARY — Buoy Pro license enforcement. NOT open source.
- *
- * Copyright (c) Buoy. All rights reserved. Licensed under the Buoy EULA
- * (https://buoy.gg/terms), not an OSS license.
- *
- * This file is the technological measure that controls access to paid Buoy Pro
- * features. Modifying, patching, aliasing, stubbing, or otherwise altering it
- * so that Pro features unlock without a valid license is a breach of the EULA
- * and, in the United States, circumvention of an access control under
- * 17 U.S.C. § 1201 — which applies whether or not any code is copied.
- *
- * Pro is $9/mo, and is free every weekend for anyone holding a key —
- * including a free one (`npx buoy login`). Buy a key at
- * https://buoy.gg or use it free on Saturday and Sunday.
- */