@buoy-gg/shared-ui 7.0.36 → 7.0.38

package/lib/module/license/AccountSetup.web.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import { useState } from "react";
+import { useAccountAccess, LicenseManager } from "@buoy-gg/license";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function AccountSetup() {
+  const access = useAccountAccess();
+  const [open, setOpen] = useState(false);
+  return /*#__PURE__*/_jsxs("div", {
+    style: {
+      position: "fixed",
+      right: 16,
+      bottom: 30,
+      zIndex: 99999,
+      color: "#e2e8f0",
+      fontFamily: "system-ui"
+    },
+    children: [/*#__PURE__*/_jsx("button", {
+      onClick: () => setOpen(!open),
+      style: {
+        background: "#080a0b",
+        color: "#20C997",
+        border: "1px solid #20C997",
+        borderRadius: 24,
+        padding: "12px 16px"
+      },
+      children: access.status === "initializing" ? "BUOY · Checking…" : "BUOY · Sign in"
+    }), open && /*#__PURE__*/_jsxs("section", {
+      "aria-label": "Buoy account setup",
+      style: {
+        position: "absolute",
+        right: 0,
+        bottom: 55,
+        width: 300,
+        maxWidth: "85vw",
+        background: "#080a0b",
+        border: "1px solid #20C997",
+        borderRadius: 12,
+        padding: 20
+      },
+      children: [/*#__PURE__*/_jsx("h3", {
+        children: "Sign in to use Buoy"
+      }), /*#__PURE__*/_jsx("p", {
+        children: "A Free or Pro account is required. Run this command in your project, then reload the app."
+      }), /*#__PURE__*/_jsx("pre", {
+        children: "npx buoy login"
+      }), LicenseManager.getState().error && /*#__PURE__*/_jsx("p", {
+        role: "status",
+        children: LicenseManager.getState().error
+      }), /*#__PURE__*/_jsx("button", {
+        onClick: () => {
+          const key = LicenseManager.getState().licenseKey;
+          if (key) void LicenseManager.setLicenseKey(key, {
+            force: true
+          });
+        },
+        children: "Retry verification"
+      }), /*#__PURE__*/_jsx("p", {
+        children: /*#__PURE__*/_jsx("a", {
+          style: {
+            color: "#20C997"
+          },
+          href: "https://github.com/Buoy-gg/buoy/issues/new/choose",
+          target: "_blank",
+          rel: "noreferrer",
+          children: "Contact support on GitHub"
+        })
+      }), /*#__PURE__*/_jsx("a", {
+        style: {
+          color: "#20C997"
+        },
+        href: "mailto:support@buoy.gg",
+        children: "support@buoy.gg"
+      })]
+    })]
+  });
+}

package/lib/module/license/FeatureGate.js

@@ -12,9 +12,6 @@ import { gameUIColors, buoyColors } from "../ui/gameUI/constants/gameUIColors.js
 import { LockIcon, X, Zap, Shield, Clock, Check } from "../icons/lucide-icons.js";
 import { LicenseEntryModal } from "./LicenseEntryModal.js";
 import { openPricing, isWeb } from "./openPricing.js";
-import { FreeAccountPrompt } from "./FreeAccountPrompt.js";
-import { getUseTier } from "./licenseModule.js";
-import { freeKeyRaises } from "./tierLimits.js";
 import { useIsPro, useLicense, useProAccess } from "@buoy-gg/license";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 // Weekend Pass branding — a distinct violet so it never reads as the gold PRO.
@@ -52,19 +49,14 @@ export const ProBadge = ({
 export const ProUpgradeModal = ({
   visible,
   onClose,
-  featureName = "This feature",
-  limitKey
+  featureName = "This feature"
 }) => {
   // Simple wrapper around UpgradeModal with minimal description and no benefits
   return /*#__PURE__*/_jsx(UpgradeModal, {
     visible: visible,
     onClose: onClose,
-    featureName: featureName
-    // Only meaningful when this upsell is about a LIMIT; without it the
-    // description below (which promises Pro) is the accurate message.
-    ,
-    limitKey: limitKey,
-    description: limitKey ? undefined : `${featureName} requires a Pro subscription.`
+    featureName: featureName,
+    description: `${featureName} requires a Pro subscription.`
   });
 };
 /**
@@ -74,13 +66,9 @@ export const ProUpgradeModal = ({
 export const UpgradePrompt = ({
   featureName,
   onUpgradePress,
-  compact = false,
-  limitKey
+  compact = false
 }) => {
   const [showLicenseModal, setShowLicenseModal] = useState(false);
-  // Only offer the free key when it would actually raise this limit — see
-  // UpgradeModalProps.limitKey.
-  const isAnonymous = getUseTier()() === "anonymous" && limitKey != null && freeKeyRaises(limitKey);
   const handlePress = useCallback(() => {
     if (onUpgradePress) {
       onUpgradePress();
@@ -108,11 +96,7 @@ export const UpgradePrompt = ({
           style: styles.compactText,
           children: "PRO"
         })]
-      }), isAnonymous ? /*#__PURE__*/_jsx(FreeAccountPrompt, {
-        visible: showLicenseModal,
-        onClose: handleCloseModal,
-        featureName: featureName
-      }) : /*#__PURE__*/_jsx(LicenseEntryModal, {
+      }), /*#__PURE__*/_jsx(LicenseEntryModal, {
         visible: showLicenseModal,
         onClose: handleCloseModal
       })]
@@ -129,27 +113,23 @@ export const UpgradePrompt = ({
         })
       }), /*#__PURE__*/_jsx(Text, {
         style: styles.title,
-        children: isAnonymous ? "Get a free key" : "Pro Feature"
+        children: "Pro Feature"
       }), featureName && /*#__PURE__*/_jsx(Text, {
         style: styles.featureName,
         children: featureName
       }), /*#__PURE__*/_jsx(Text, {
         style: styles.description,
-        children: isAnonymous ? "Buoy works without an account, with a small slice of each tool. A free key opens it up." : "Upgrade to React Buoy Pro to unlock this feature and more."
+        children: "Upgrade to React Buoy Pro to unlock this feature and more."
       }), /*#__PURE__*/_jsx(TouchableOpacity, {
         style: styles.upgradeButton,
         onPress: handlePress,
         activeOpacity: 0.8,
         children: /*#__PURE__*/_jsx(Text, {
           style: styles.upgradeButtonText,
-          children: isAnonymous ? "Get a free key" : "Upgrade to Pro"
+          children: "Upgrade to Pro"
         })
       })]
-    }), isAnonymous ? /*#__PURE__*/_jsx(FreeAccountPrompt, {
-      visible: showLicenseModal,
-      onClose: handleCloseModal,
-      featureName: featureName
-    }) : /*#__PURE__*/_jsx(LicenseEntryModal, {
+    }), /*#__PURE__*/_jsx(LicenseEntryModal, {
       visible: showLicenseModal,
       onClose: handleCloseModal
     })]
@@ -328,14 +308,8 @@ export const UpgradeModal = ({
   onClose,
   featureName = "This Feature",
   description,
-  benefits,
-  limitKey
+  benefits
 }) => {
-  // Anonymous users get a different ask — but ONLY when a free key would
-  // actually fix what they just hit. Everything else here is Pro-exclusive,
-  // where a free key changes nothing and offering one would be dishonest.
-  const tier = getUseTier()();
-  const offerFreeKey = tier === "anonymous" && limitKey != null && freeKeyRaises(limitKey);
   const hasBenefits = benefits && benefits.length > 0;
   const [showLicenseModal, setShowLicenseModal] = useState(false);
   const license = useLicense();
@@ -358,13 +332,6 @@ export const UpgradeModal = ({
     onClose();
   }, [onClose]);
   if (!visible) return null;
-  if (offerFreeKey) {
-    return /*#__PURE__*/_jsx(FreeAccountPrompt, {
-      visible: visible,
-      onClose: onClose,
-      featureName: featureName === "This Feature" ? undefined : featureName
-    });
-  }
   return /*#__PURE__*/_jsxs(_Fragment, {
     children: [/*#__PURE__*/_jsx(Modal, {
       visible: visible && !showLicenseModal,

package/lib/module/license/FreeAccountPrompt.js

@@ -1,16 +1,15 @@
 "use strict";
 
 /**
- * The upsell an ANONYMOUS user sees — someone with no key at all.
+ * The account setup sheet — what a locked manager shows instead of the tools.
  *
- * Deliberately not the Pro modal. Their next step is free and takes about
- * thirty seconds, so asking them for money would be asking the wrong question
- * at the wrong moment, and would suppress exactly the signup this exists to
- * produce. Pro is still offered, as a secondary action.
+ * Deliberately not the Pro modal. The next step is a free account and takes
+ * about thirty seconds, so asking for money here would be asking the wrong
+ * question at the wrong moment. Pro is still offered, as a secondary action.
  *
- * The command is shown inline and copyable rather than linked, because there is
- * no grace period: someone who just watched their limits shrink needs the fix
- * in front of them, not a link to a page that has a link to a command.
+ * The command is shown inline and copyable rather than linked, because
+ * someone who cannot open the tools needs the fix in front of them, not a link
+ * to a page that has a link to a command.
  */
 
 import React, { useCallback, useEffect, useRef, useState } from "react";
@@ -19,15 +18,16 @@ import { buoyColors } from "../ui/gameUI/constants/gameUIColors.js";
 import { Check, Copy, X } from "../icons/lucide-icons.js";
 import { copyToClipboard } from "../clipboard/index.js";
 import { openPricing } from "./openPricing.js";
+import { getUseAccountAccess, retryAccountAccess } from "./licenseModule.js";
 import { monoFont } from "../ui/fonts.js";
 /** The one thing a reader has to be able to act on. */
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export const LOGIN_COMMAND = "npx buoy login";
 export const FreeAccountPrompt = ({
   visible,
-  onClose,
-  featureName
+  onClose
 }) => {
+  const access = getUseAccountAccess()();
   const [copied, setCopied] = useState(false);
   const resetTimer = useRef(null);
   useEffect(() => () => {
@@ -65,10 +65,10 @@ export const FreeAccountPrompt = ({
           })
         }), /*#__PURE__*/_jsx(Text, {
           style: styles.title,
-          children: featureName ? `More ${featureName}` : "See more"
+          children: access.status === "initializing" ? "Checking your account…" : "Sign in to use Buoy"
         }), /*#__PURE__*/_jsx(Text, {
           style: styles.subtitle,
-          children: "Buoy runs without an account \u2014 you just get a small slice of each tool. A free key opens it up."
+          children: "A Free or Pro account is required. Run this command in your project, then reload the app to use your account key."
         }), /*#__PURE__*/_jsxs(TouchableOpacity, {
           style: styles.command,
           onPress: handleCopy,
@@ -84,9 +84,32 @@ export const FreeAccountPrompt = ({
             size: 14,
             color: buoyColors.textMuted
           })]
+        }), access.status !== "admitted" && /*#__PURE__*/_jsx(TouchableOpacity, {
+          style: styles.secondary,
+          onPress: () => {
+            void retryAccountAccess();
+          },
+          children: /*#__PURE__*/_jsx(Text, {
+            style: styles.secondaryText,
+            children: "Retry verification"
+          })
         }), /*#__PURE__*/_jsx(Text, {
           style: styles.reassure,
           children: "Free forever. No card. About thirty seconds."
+        }), /*#__PURE__*/_jsx(TouchableOpacity, {
+          style: styles.secondary,
+          onPress: () => openPricing("https://github.com/Buoy-gg/buoy/issues/new/choose"),
+          children: /*#__PURE__*/_jsx(Text, {
+            style: styles.secondaryText,
+            children: "Contact support on GitHub"
+          })
+        }), /*#__PURE__*/_jsx(TouchableOpacity, {
+          style: styles.secondary,
+          onPress: () => openPricing("mailto:support@buoy.gg"),
+          children: /*#__PURE__*/_jsx(Text, {
+            style: styles.secondaryText,
+            children: "Email support@buoy.gg"
+          })
         }), /*#__PURE__*/_jsx(TouchableOpacity, {
           style: styles.secondary,
           onPress: () => openPricing(),

package/lib/module/license/index.js

@@ -6,4 +6,4 @@ export { FreeAccountPrompt, LOGIN_COMMAND } from "./FreeAccountPrompt.js";
 // Lazy license-module access lives in ./licenseModule so tierLimits can use it
 // without an import cycle. Re-exported here to keep the existing surface.
 export { getUseIsPro, getUseLicense, getUseTier } from "./licenseModule.js";
-export { TIER_LIMITS, useLimit, resolveEffectiveTier, freeKeyRaises } from "./tierLimits.js";
+export { TIER_LIMITS, useLimit, resolveEffectiveTier } from "./tierLimits.js";

package/lib/module/license/licenseModule.js

@@ -1,30 +1,30 @@
 "use strict";
 
 /**
- * Centralized lazy loading of `@buoy-gg/license`.
+ * Centralized access of `@buoy-gg/license`.
  *
  * This is the SINGLE place any package resolves license hooks — tools must not
- * `require("@buoy-gg/license")` themselves. Lives in its own module (rather
+ * resolve the license module themselves. Lives in its own module (rather
  * than `./index`) so `tierLimits` can consume it without an import cycle.
  */
 
-/** Access tier. Mirrors BuoyTier in @buoy-gg/license. */
+import * as licenseModule from "@buoy-gg/license";
+
+/** Tier. Mirrors BuoyTier in @buoy-gg/license. */
 
 let _useIsPro = null;
 let _useLicense = null;
 let _useTier = null;
-let _anonymousTierEnabled = null;
 let _licenseLoadAttempted = false;
 function loadLicenseModuleCentral() {
   if (_licenseLoadAttempted) return;
   _licenseLoadAttempted = true;
   try {
-    const mod = require("@buoy-gg/license");
+    const mod = licenseModule;
     if (mod) {
       _useIsPro = mod.useIsPro ?? null;
       _useLicense = mod.useLicense ?? null;
       _useTier = mod.useTier ?? null;
-      _anonymousTierEnabled = typeof mod.ANONYMOUS_TIER_ENABLED === "boolean" ? mod.ANONYMOUS_TIER_ENABLED : null;
     }
   } catch {
     // License package not available - will use fallback
@@ -54,39 +54,54 @@ export function getUseLicense() {
 }
 
 /**
- * Get the useTier hook from @buoy-gg/license.
- *
- * Falls back to `"free"` — NOT `"anonymous"` — when the license package can't
- * be resolved. That deliberately matches the existing `getUseIsPro()` fallback,
- * which yields free-tier behavior today, and it picks the safer failure:
- *
- *  - falling back to "anonymous" would let one bundler quirk silently cut every
- *    legitimate user's limits by ~80%;
- *  - falling back to "free" costs no revenue, because Pro still requires a key
- *    that a live license server validated — this path can never grant Pro.
- *
- * Reaching it at all requires `@buoy-gg/license` to be missing, and it is a
- * hard dependency of `@buoy-gg/core`.
+ * Falls back to "free" without the license package. That grants nothing: a
+ * missing license module also means no account admission, and nothing is
+ * exposed without it.
  */
 export function getUseTier() {
   loadLicenseModuleCentral();
   return _useTier ?? (() => "free");
 }
+const LOCKED = {
+  status: "locked",
+  reason: "account_required",
+  validUntil: null
+};
 
-/**
- * Whether the anonymous tier is switched on.
- *
- * The switch itself lives in @buoy-gg/license (see its config.ts) because the
- * Weekend Pass change has to flip at the same moment as the reduced limits, and
- * those live in different packages. Read through the same lazy loader as the
- * hooks so a missing license package degrades gracefully rather than throwing
- * at module load.
- *
- * Falls back to `false` — the anonymous tier off, everyone on free limits —
- * which matches the `getUseTier()` fallback of "free". A build that cannot
- * resolve the license package must never take limits AWAY from someone.
- */
-export function isAnonymousTierEnabled() {
-  loadLicenseModuleCentral();
-  return _anonymousTierEnabled ?? false;
+// Resolve at the boundary, after module initialization. Do not cache an absent
+// manager during a circular import or grant access for older package versions.
+function accountManager() {
+  try {
+    const manager = licenseModule.LicenseManager;
+    void manager?.initialize?.();
+    return manager;
+  } catch {
+    return null;
+  }
+}
+export function getAccountAccess() {
+  return accountManager()?.getAccountAccess?.() ?? LOCKED;
+}
+export function hasAccountAccess() {
+  return getAccountAccess().status === "admitted";
+}
+export function assertAccountAccess() {
+  if (!hasAccountAccess()) throw new Error("A verified Buoy account is required. Run npx buoy login, then reload your app.");
+}
+export function subscribeAccountAccess(listener) {
+  return accountManager()?.subscribe?.(listener) ?? (() => {});
+}
+export function getUseAccountAccess() {
+  try {
+    return licenseModule.useAccountAccess ?? (() => LOCKED);
+  } catch {
+    return () => LOCKED;
+  }
+}
+export async function retryAccountAccess() {
+  const manager = accountManager();
+  const key = manager?.getState?.().licenseKey;
+  if (key) await manager.setLicenseKey(key, {
+    force: true
+  });else await manager?.initialize?.();
 }

package/lib/module/license/tierLimits.js

@@ -1,103 +1,84 @@
 "use strict";
 
 /**
- * Per-tier numeric limits — the ONLY thing that separates anonymous from free.
+ * Per-tier numeric limits — the ONLY thing that separates free from pro on a
+ * count.
  *
- * Every binary Pro gate (copy-to-clipboard, state editing, storage mutations,
- * navigation) is identical for both: locked. That keeps the tier split to one
- * table instead of scattered conditionals.
- *
- * The governing rule: **the free column never moves.** Anonymous is carved out
- * BELOW today's free tier — nothing is ever added to free in exchange for an
- * account, because that would come straight out of the Pro upgrade.
+ * Binary Pro gates (copy-to-clipboard, state editing, storage mutations,
+ * navigation) live in the tools themselves; this table is only for "how many".
+ * Whether the tools are usable at all is account admission, which is a
+ * separate question from the tier and is never expressed as a limit.
  */
 
-import { getUseIsPro, getUseTier, isAnonymousTierEnabled } from "./licenseModule.js";
+import { getUseIsPro, getUseTier } from "./licenseModule.js";
 const LIMITS = {
   // ── network ───────────────────────────────────────────────────────────────
   "network.requests": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
   "network.saved": {
-    anonymous: 1,
     free: 5,
     pro: 50
   },
-  // Already 1 for free, so 25% would be 0 — which deletes the feature rather
-  // than trialling it. Raising the FREE value to make room is not an option.
   "network.overrideRules": {
-    anonymous: 1,
     free: 1,
     pro: 50
   },
   // ── storage ───────────────────────────────────────────────────────────────
   "storage.events": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
   "storage.keys": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
-  // Same floor-at-1 reasoning as network.overrideRules.
   "storage.mmkvInstances": {
-    anonymous: 1,
     free: 1,
     pro: Infinity
   },
   // ── state tools ───────────────────────────────────────────────────────────
   "redux.actions": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
   "zustand.changes": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
   "jotai.changes": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
   "events.entries": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
   // ── render / navigation ───────────────────────────────────────────────────
   "highlightUpdates.components": {
-    anonymous: 5,
     free: 25,
     pro: Infinity
   },
   "highlightUpdates.historyEvents": {
-    anonymous: 1,
     free: 3,
     pro: Infinity
   },
   "highlightUpdates.detailEvents": {
-    anonymous: 2,
     free: 5,
     pro: Infinity
   },
   "routeEvents.entries": {
-    anonymous: 1,
     free: 3,
     pro: Infinity
   },
+  // One restore point at a time. The floating bar's safety slot is not one
+  // the user chose to keep, so it is not counted against this.
   "timeMachine.snapshots": {
-    anonymous: 1,
-    free: 2,
+    free: 1,
     pro: Infinity
   },
   "perfMonitor.automationCases": {
-    anonymous: 1,
     free: 3,
     pro: Infinity
   },
@@ -106,12 +87,10 @@ const LIMITS = {
   // three-endpoint scenario either runs whole or refuses up front, and is never
   // silently trimmed to one rule mid-run. Enforcement is atomic in pre-flight.
   "scenarios.saved": {
-    anonymous: 1,
     free: 3,
     pro: Infinity
   },
   "scenarios.active": {
-    anonymous: 1,
     free: 1,
     pro: 3
   }
@@ -122,17 +101,11 @@ export const TIER_LIMITS = LIMITS;
  * The tier whose limits actually apply.
  *
  * `hasProAccess` is `useIsPro()`, which is true for a real Pro license OR the
- * free Weekend Pass. Routing the Weekend Pass through here is what keeps
- * today's behavior intact: weekend users get Pro limits, exactly as they do
- * now. When the Weekend Pass is later gated to key-holders, that change lands
- * here for free — no limit call site has to know about it.
+ * Weekend Pass. Routing the Weekend Pass through here is what gives weekend
+ * users Pro limits without any limit call site having to know about it.
  */
 export function resolveEffectiveTier(tier, hasProAccess) {
-  if (hasProAccess) return "pro";
-  // The switch lives in @buoy-gg/license so that this and the Weekend Pass
-  // change flip together — see isAnonymousTierEnabled().
-  if (!isAnonymousTierEnabled() && tier === "anonymous") return "free";
-  return tier;
+  return hasProAccess ? "pro" : tier;
 }
 
 /**
@@ -146,27 +119,4 @@ export function useLimit(key) {
   const hasProAccess = getUseIsPro()();
   const tier = getUseTier()();
   return TIER_LIMITS[key][resolveEffectiveTier(tier, hasProAccess)];
-}
-
-/**
- * Whether claiming a FREE key would actually raise this limit right now.
- *
- * The anonymous upsell must never promise something a free key won't deliver.
- * Two ways it could lie, and this closes both:
- *
- *  - **Pro-exclusive features.** Copy-to-clipboard, state editing, storage
- *    mutations and navigation are locked for anonymous AND free alike. Telling
- *    an anonymous user a free key opens them would be false.
- *  - **Limits that are already equal.** Override rules and MMKV instances sit
- *    at 1 for both tiers, so a key changes nothing there either.
- *
- * It also respects `ANONYMOUS_TIER_ENABLED`: while the anonymous tier is off,
- * an anonymous user is *already* getting the free limits, so there is nothing
- * to claim and this correctly returns false everywhere. That falls out of
- * asking `resolveEffectiveTier` rather than reading the table directly, so the
- * switch and the copy can never disagree.
- */
-export function freeKeyRaises(key) {
-  const limits = TIER_LIMITS[key];
-  return limits[resolveEffectiveTier("anonymous", false)] < limits[resolveEffectiveTier("free", false)];
 }

package/lib/module/storage/devToolsStorageKeys.js

@@ -126,7 +126,14 @@ export const devToolsStorageKeys = {
    */
   timeMachine: {
     root: () => `${devToolsStorageKeys.base}_time_machine`,
-    diffViewerMode: () => `${devToolsStorageKeys.timeMachine.root()}_diff_viewer_mode` // 'split' | 'tree'
+    diffViewerMode: () => `${devToolsStorageKeys.timeMachine.root()}_diff_viewer_mode`,
+    // 'split' | 'tree'
+    /** The restore point the floating restore bar restores on tap (snapshot id). */
+    armedPoint: () => `${devToolsStorageKeys.timeMachine.root()}_armed_point`,
+    /** "1" when the action bar restores in reload mode (storage, then a JS reload). */
+    barReloadMode: () => `${devToolsStorageKeys.timeMachine.root()}_bar_reload_mode`,
+    /** Source ids switched OFF in the Sources strip (JSON string array). */
+    disabledSources: () => `${devToolsStorageKeys.timeMachine.root()}_disabled_sources`
   },
   /**
    * Scenarios storage keys. The library (saved + draft scenarios) and the