Remove YouTube Suggestions

Understanding the project layout:

• src/: Contains the core logic.
  • index.js: The server entry point.
  • config.js: Configuration logic.
  • routes/: Express route definitions.
  • services/: Business logic for Stripe, JWT, and email.
  • storage/: File-based storage implementation.
• data/: Local data storage.
  • grandfathered.json: List of donor emails.
  • auth-requests/: Directory for pending authentication requests (auto-created).
  • rate-limits/: Directory for rate limit counters (auto-created).
• tests/: Test suites.
• package.json: Project dependencies and scripts.

server/
├── src/
│   ├── index.js        # Entry point
│   ├── config.js       # Configuration
│   ├── routes/         # Express routes
│   ├── services/       # Stripe, JWT, email
│   └── storage/        # File-based storage
├── data/
│   ├── grandfathered.json   # Donor emails (gitignored)
│   ├── auth-requests/       # Pending auth (auto-created)
│   └── rate-limits/         # Rate limit counters (auto-created)
├── tests/
└── package.json

The extension distinguishes between stored preferences (what the user has toggled in settings) and effective behavior (what the extension actually does based on the user's current subscription tier).

• Stored Preferences: These are the user's actual settings saved in browser.storage.local. They should never be overwritten by tier-based logic (e.g., a downgrade should not delete a user's preference for a premium feature).
• Effective Behavior: This is the in-memory application of settings. If a user is on the free tier, the extension applies a 'slot budget' (e.g., only allowing two premium features to be active) by clamping the settings in memory during the apply/render phase, without modifying the underlying stored data.

This separation ensures that if a user re-upgrades their subscription, their previous premium choices are immediately restored without needing to re-import settings.

Users may experience an intermittent 'reset' where locally stored premium preferences are reverted to defaults. This is caused by a destructive write-back mechanism that occurs when the client's premium tier cannot be verified.

Root Cause

Premium tier status is inferred from a locally cached license JWT which expires every 3 days (LICENSE_TOKEN_LIFETIME_DAYS). If the license token expires and the client cannot immediately refresh it (due to the user not opening the options page, network errors, or transient server issues), the system treats the user as being on a free_signed_in tier.

When this happens, the function enforceSlotBudget(settings, 2) is triggered, which generates a write-back map that persists false for premium settings exceeding the allowed slot budget. This permanently overwrites the user's stored preferences in browser.storage.local.

Key Failure Scenarios

• Expired License + No Refresh: The content script only reads the license; it does not renew it. Only the options page performs a refresh via refreshLicense. If a user browses YouTube for >3 days without opening the options page, the expired token triggers the budget enforcement.
• Options Page Initialization: The options page (src/options/main.js) performs synchronous initialization before the asynchronous refreshLicense(true) can confirm premium status, potentially wiping settings upon opening the page if the token is expired.
• Transient Renewal Failures: If License.checkLicense() encounters a network error, it returns { isPremium: false, error: true }. The UI does not distinguish this from a confirmed free account and proceeds to call pruneToSlotBudget(), persisting the pruned values.
• Session Expiry: When a 30-day session token expires (401 error), updatePremiumUI calls disableAllPremiumFeatures(), which persists false for all premium features.

To fix the bug where tier demotions were overwriting user preferences, the following architectural changes must be implemented to ensure tier enforcement happens only in memory:

1. Content Script (src/content-script/main.js): Keep enforceSlotBudget(settings, limit) but remove the browser.storage.local.set(writeBack) call. This ensures the budget is enforced in the current session without persisting the demotion to storage.
2. Options Page (src/options/main.js): Perform the same change: clamp the local settings copy without writing the returned map back to storage.
3. Slot Pruning (pruneToSlotBudget()): Retain the helper and UI updates, but use updateSetting(id, false, { write: false }) to ensure the change is not persisted.
4. Feature Disabling (disableAllPremiumFeatures()): Retain the helper and its callers, but use updateSetting(id, false, { write: false }) to prevent storage writes.

Key Rule: Tier logic should never write to storage. It should only coerce values (e.g., value === true) in memory during the application of settings.