prism0x2a 0.6.1 → 0.7.2

package/.next/standalone/components/pricing/BillingToggle.tsx

@@ -0,0 +1,53 @@
+"use client";
+
+interface BillingToggleProps {
+  yearly: boolean;
+  onChange: (yearly: boolean) => void;
+}
+
+export function BillingToggle({ yearly, onChange }: BillingToggleProps) {
+  return (
+    <div className="flex items-center gap-3">
+      <button
+        onClick={() => onChange(false)}
+        className="text-sm font-medium transition-colors"
+        style={{ color: yearly ? "rgba(148,163,184,0.6)" : "rgb(226,232,240)" }}
+      >
+        Monthly
+      </button>
+
+      <button
+        onClick={() => onChange(!yearly)}
+        className="relative w-11 h-6 rounded-full transition-colors"
+        style={{
+          background: yearly ? "rgb(99,102,241)" : "rgba(51,65,85,0.6)",
+          border: "1px solid rgba(71,85,105,0.5)",
+        }}
+        aria-label="Toggle billing period"
+      >
+        <span
+          className="absolute top-0.5 w-5 h-5 rounded-full transition-transform"
+          style={{
+            left: "2px",
+            background: "rgb(226,232,240)",
+            transform: yearly ? "translateX(20px)" : "translateX(0)",
+          }}
+        />
+      </button>
+
+      <button
+        onClick={() => onChange(true)}
+        className="text-sm font-medium transition-colors flex items-center gap-1.5"
+        style={{ color: yearly ? "rgb(226,232,240)" : "rgba(148,163,184,0.6)" }}
+      >
+        Yearly
+        <span
+          className="text-xs px-1.5 py-0.5 rounded-full font-semibold"
+          style={{ background: "rgba(52,211,153,0.15)", color: "rgb(52,211,153)" }}
+        >
+          −17%
+        </span>
+      </button>
+    </div>
+  );
+}

package/.next/standalone/components/pricing/FeatureList.tsx

@@ -0,0 +1,19 @@
+interface FeatureListProps {
+  features: string[];
+  dimmed?: boolean;
+}
+
+export function FeatureList({ features, dimmed }: FeatureListProps) {
+  return (
+    <ul className="flex flex-col gap-2">
+      {features.map((f) => (
+        <li key={f} className="flex items-start gap-2 text-sm" style={{ color: dimmed ? "rgba(148,163,184,0.5)" : "rgb(148,163,184)" }}>
+          <span className="mt-0.5 flex-shrink-0" style={{ color: dimmed ? "rgba(71,85,105,0.5)" : "rgb(71,85,105)" }}>
+            ✦
+          </span>
+          {f}
+        </li>
+      ))}
+    </ul>
+  );
+}

package/.next/standalone/components/pricing/PricingCard.tsx

@@ -0,0 +1,120 @@
+import Link from "next/link";
+import { FeatureList } from "./FeatureList";
+import type { LicenseTier } from "@/lib/prism/license/types";
+
+export interface PricingCardProps {
+  tier: LicenseTier;
+  name: string;
+  tagline: string;
+  monthlyPrice: number;
+  yearlyMonthlyPrice: number;
+  yearly: boolean;
+  unit?: string;
+  checkoutUrl: string | null;
+  features: string[];
+  highlighted?: boolean;
+  isCurrent?: boolean;
+  accentColor: string;
+  accentBg: string;
+  accentBorder: string;
+}
+
+export function PricingCard({
+  name,
+  tagline,
+  monthlyPrice,
+  yearlyMonthlyPrice,
+  yearly,
+  unit,
+  checkoutUrl,
+  features,
+  highlighted,
+  isCurrent,
+  accentColor,
+  accentBg,
+  accentBorder,
+}: PricingCardProps) {
+  const displayPrice = yearly ? yearlyMonthlyPrice : monthlyPrice;
+  const isFree = monthlyPrice === 0;
+
+  return (
+    <div
+      className="relative flex flex-col rounded-2xl p-6 gap-5"
+      style={{
+        background: highlighted ? "var(--surface-elevated)" : "var(--surface-panel)",
+        border: highlighted ? `1px solid ${accentBorder}` : "1px solid var(--border-default)",
+        boxShadow: highlighted
+          ? `0 0 0 1px ${accentBorder}, 0 4px 24px rgba(15,23,42,.2), inset 0 1px 0 rgba(255,255,255,.06)`
+          : "0 1px 2px rgba(15,23,42,.05), 0 4px 16px rgba(15,23,42,.08), inset 0 1px 0 rgba(255,255,255,.04)",
+      }}
+    >
+      {highlighted && (
+        <div
+          className="absolute -top-px left-6 right-6 h-px rounded-full"
+          style={{ background: `linear-gradient(90deg, transparent, ${accentColor}, transparent)` }}
+        />
+      )}
+
+      {isCurrent && (
+        <span
+          className="absolute top-4 right-4 text-xs px-2 py-0.5 rounded-full font-semibold"
+          style={{ background: accentBg, color: accentColor, border: `1px solid ${accentBorder}` }}
+        >
+          Current plan
+        </span>
+      )}
+
+      {/* Header */}
+      <div className="flex flex-col gap-1">
+        <h3 className="text-base font-semibold" style={{ color: accentColor }}>{name}</h3>
+        <p className="text-xs text-slate-500">{tagline}</p>
+      </div>
+
+      {/* Price */}
+      <div className="flex items-end gap-1.5">
+        {isFree ? (
+          <span className="text-3xl font-bold text-slate-100">Free</span>
+        ) : (
+          <>
+            <span className="text-3xl font-bold text-slate-100">€{displayPrice}</span>
+            <span className="text-sm text-slate-500 mb-1">/mo{unit ? ` /${unit}` : ""}</span>
+          </>
+        )}
+      </div>
+      {!isFree && yearly && (
+        <p className="text-xs text-slate-500 -mt-3">
+          billed €{displayPrice * 12}/yr — save €{(monthlyPrice - yearlyMonthlyPrice) * 12}/yr
+        </p>
+      )}
+
+      {/* CTA */}
+      {isFree ? (
+        <div
+          className="text-center py-2 rounded-lg text-sm font-semibold text-slate-500"
+          style={{ background: "rgba(51,65,85,0.2)", border: "1px solid rgba(51,65,85,0.3)" }}
+        >
+          {isCurrent ? "Your current plan" : "No payment needed"}
+        </div>
+      ) : checkoutUrl ? (
+        <Link
+          href={checkoutUrl}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="text-center py-2.5 rounded-lg text-sm font-semibold transition-all"
+          style={{
+            background: isCurrent ? "transparent" : accentBg,
+            color: isCurrent ? accentColor : accentColor,
+            border: `1px solid ${accentBorder}`,
+          }}
+        >
+          {isCurrent ? "Manage subscription →" : "Get started →"}
+        </Link>
+      ) : null}
+
+      {/* Features */}
+      <div className="pt-1 border-t" style={{ borderColor: "var(--border-default)" }}>
+        <FeatureList features={features} />
+      </div>
+    </div>
+  );
+}

package/.next/standalone/docs/strategy/monetization-thinking.md

@@ -593,3 +593,167 @@ Free-trial-limit is per-installation but easily reset by uninstalling. Mitigatio
 - Pro tier removes watermark
 
 Watermark approach is friction-light, doesn't disable feature, drives conversion via embarrassment-factor.
+
+---
+
+## FINAL LOCK 2026-05-18
+
+After multiple iterations, the monetization decisions are locked for v0.7.0 implementation.
+
+### Pricing — LOCKED
+
+| Tier | Price | Annual | Includes |
+|---|---|---|---|
+| **Free** | $0 | $0 | Up to 50k LOC/project, static analysis only, no LLM, watermark, 60-day update delay |
+| **Pro (prism0x2A)** | $39/month | $390/year (save 17%) | Unlimited LOC, monorepo, LLM, no watermark, immediate updates |
+| **Team (prism0x2A)** | $99/dev/month | $990/dev/year (save 17%) | Pro + shared state, CI, team dashboard |
+| **Pro (forge0x2B)** | $29/month | $290/year (save 17%) | Unlimited generations, all asset types |
+| **Spectrum 0x55 Bundle** | $49/month | $490/year (save 17%) | prism0x2A Pro + forge0x2B Pro (save $19/m vs separate) |
+| **Enterprise** | Custom | — | Self-hosted, SLA, revenue-share for $10M+ ARR |
+
+**Free trial for forge0x2B:** 3 free generations per installation.
+
+### Value Justification
+
+- Pro tier: 1:25 to 1:50 value-to-price ratio (saves 10-19h/m at $100/h dev rate)
+- Team tier: 1:6 to 1:12 ratio
+- forge0x2B: 1:22 ratio
+- Bundle: $228/year savings, anchors as "Save 28%"
+
+### Bundle Brand — Spectrum 0x55
+
+**Brand Name:** Spectrum  
+**Hex Identifier:** 0x55 (`0x2A + 0x2B = 0x55`)  
+**Tagline:** "0x55 — for U." (0x55 = ASCII 'U')  
+**Sub-Tagline:** "The full spectrum: prism0x2A + forge0x2B."
+
+**Easter Egg Layer:**
+- 0x55 binary: 01010101 — alternating bit pattern (yin-yang aesthetic)
+- 0x55 ASCII: 'U' — "for you, the developer"
+- Math: prism0x2A (42) + forge0x2B (43) = 85 = 0x55
+
+**Logo Direction (when designed):**
+- Could feature 'U' or '0x55' subtly
+- Binary 01010101 pattern as design element
+- Docs/marketing: "0x2A + 0x2B = 0x55"
+
+### Payment Provider — LOCKED: Lemonsqueezy
+
+**Reasoning:**
+- Merchant-of-Record handles all EU VAT + US Sales Tax compliance
+- Built-in License Keys feature (no DIY server needed)
+- 5% + €0.50 fee vs 2.9% + €0.30 for raw Stripe
+- 2.1% premium = trivial cost for full tax-compliance peace-of-mind
+- Built-in customer portal, subscriptions UI, webhook system
+
+**Lemonsqueezy products to configure:**
+
+1. `prism0x2A Pro` (subscription, variants: monthly $39, yearly $390)
+2. `prism0x2A Team` (subscription, per-seat, variants: monthly $99/seat, yearly $990/seat)
+3. `forge0x2B Pro` (subscription, variants: monthly $29, yearly $290)
+4. `Spectrum 0x55 Bundle` (subscription, variants: monthly $49, yearly $490)
+
+All products have License-Keys enabled. License-Key API validates on activation.
+
+### Implementation Sequence
+
+```
+v0.7.0 — Lemonsqueezy Integration (BIG wave)
+  - Lemonsqueezy account setup (user)
+  - Products configured (user)
+  - License-Key validation in prism0x2A Settings
+  - Online-validation + offline-cache (30 days)
+  - Customer portal integration
+  - Webhook handling for subscription events
+
+v0.7.1 — Pricing-Page (small wave)
+  - /pricing route
+  - Tier comparison table
+  - "Subscribe" buttons → Lemonsqueezy checkout
+  - Free-trial flow for forge0x2B
+
+v0.7.2 — Guided Tour (Phase 2.5 backlog)
+
+v0.8.0 — Marketing Landing
+  - Hero animation (prism-spectrum metaphor)
+  - prism0x2a.dev setup
+  - References pricing-page
+  
+🚀 HN-Launch (with paid tier active)
+
+Post-launch:
+  - forgesmith engine v0.1.0
+  - forge0x2B dashboard v0.1.0
+  - Spectrum 0x55 Bundle marketing push
+```
+
+### Closed Open-Questions (final)
+
+| # | Question | Decision |
+|---|---|---|
+| 1 | Payment provider | Lemonsqueezy (MoR) |
+| 2 | Pricing | $39/$99/$29/$49 confirmed |
+| 3 | Bundle name | Spectrum 0x55 |
+| 4 | Annual discount | 17% (2 months free) |
+| 5 | Free tier limit | 50k LOC/project |
+| 6 | Free trial (forge0x2B) | 3 generations |
+| 7 | License validation | Lemonsqueezy License Keys API + offline cache |
+| 8 | Customer portal | Lemonsqueezy built-in |
+| 9 | Revenue share | Enterprise-only, $10M+ ARR negotiation |
+
+### Anti-Patterns Avoided (final)
+
+- ❌ Free for revenue < $X (charity model) → REJECTED
+- ❌ Pure FOSS (no revenue capture) → REJECTED
+- ❌ Phone-home telemetry → REJECTED
+- ❌ Hard-disable at limits → REJECTED (degraded mode + CTA instead)
+- ❌ Raw Stripe (tax compliance nightmare) → REJECTED in favor of Lemonsqueezy
+
+### Status: LOCKED — Ready for v0.7.0 Implementation
+
+---
+
+## EUR Pricing Adjustment 2026-05-18
+
+### Context
+
+Lemonsqueezy store was configured with EUR as default currency (German legal entity). All pricing now expressed in EUR with same numeric values as original USD spec.
+
+### Rationale: Same numbers, different currency
+
+- Clean numbers (€39 / €99 / €29 / €49)
+- Slight premium for EU market vs USD ($39 ≈ €36 at current FX)
+- Lemonsqueezy auto-converts for non-EU customers
+- US customers see ~$42 (FX-converted by Lemonsqueezy) — fair premium for buying from EU vendor
+
+### Final EUR Pricing (LOCKED)
+
+| Tier | Monthly | Yearly (17% off) |
+|---|---|---|
+| **Free** | €0 | — |
+| **Pro (prism0x2A)** | €39 | €390 |
+| **Team (prism0x2A)** | €99/dev | €990/dev |
+| **Pro (forge0x2B)** | €29 | €290 |
+| **Spectrum 0x55 Bundle** | €49 | €490 |
+
+### Lemonsqueezy Product IDs (Reference)
+
+```
+prism0x2A Pro:        1066633
+prism0x2A Team:       1066653
+forge0x2B Pro:        1066668
+Spectrum 0x55 Bundle: 1066695
+```
+
+Checkout-Variant-UUIDs:
+```
+prism0x2A Pro:        a9097951-5d54-438c-89ef-3e093d88f6c6
+prism0x2A Team:       ddcff26c-303a-4993-a7a7-73129b150a97
+forge0x2B Pro:        21c1146e-9fea-4c32-a4fc-c5a5e64215e7
+Spectrum 0x55 Bundle: 64d25b45-7c4a-410d-b4aa-7504f98ab5f7
+```
+
+Marketing-copy adapts:
+- "Save €19/month with Spectrum 0x55 Bundle" (was: "$19")
+- "starts at €39/month" (was: "$39")
+- Spectrum description: "0x55 = 0x2A + 0x2B (and ASCII U)" unchanged

package/.next/standalone/lib/prism/features.shared.ts

@@ -8,17 +8,27 @@ export interface FeatureDef {
 }
 
 export const FEATURES = {
-  monorepo:                   { tier: "pro" as LicenseTier,        label: "Monorepo support" },
-  aggregate_scan:             { tier: "pro" as LicenseTier,        label: "Aggregate workspace scan" },
-  cross_workspace_insights:   { tier: "pro" as LicenseTier,        label: "Cross-workspace insights" },
-  llm_insights:               { tier: "pro" as LicenseTier,        label: "AI-powered insights" },
+  // Pro-tier features
+  monorepo:                      { tier: "pro" as LicenseTier,        label: "Monorepo support" },
+  aggregate_scan:                { tier: "pro" as LicenseTier,        label: "Aggregate workspace scan" },
+  cross_workspace_insights:      { tier: "pro" as LicenseTier,        label: "Cross-workspace insights" },
+  llm_insights:                  { tier: "pro" as LicenseTier,        label: "AI-powered insights" },
+  custom_queries:                { tier: "pro" as LicenseTier,        label: "Custom GREEN queries" },
+  cross_layer_context:           { tier: "pro" as LicenseTier,        label: "Cross-layer context" },
+  auto_insights:                 { tier: "pro" as LicenseTier,        label: "Auto-generated insights" },
+  // Team-tier features
+  team_sync:                     { tier: "team" as LicenseTier,       label: "Team sync" },
+  ci_integration:                { tier: "team" as LicenseTier,       label: "CI integration" },
+  // forge-pro / Spectrum features
+  forge_unlimited:               { tier: "forge-pro" as LicenseTier,  label: "forge0x2B unlimited" },
+  forge_unlimited_generation:    { tier: "forge-pro" as LicenseTier,  label: "forge0x2B unlimited generation" },
 } satisfies Record<string, FeatureDef>;
 
 export type FeatureName = keyof typeof FEATURES;
 
 export const FREE_TIER_LOC_LIMIT = 50_000;
 
-/** Returns true if the feature should show a Pro badge in the UI (static, no license check). */
+/** Returns true if the feature should show a Pro/upgrade badge in the UI (static, no license check). */
 export function showProBadge(name: FeatureName): boolean {
   return FEATURES[name].tier !== "free";
 }

package/.next/standalone/lib/prism/features.ts

@@ -1,10 +1,9 @@
 import { loadLicense } from "./license/store";
-import { effectiveTier, hasFeatureTier } from "./license/validate";
-import { FEATURES } from "./features.shared";
-import type { LicenseTier, FeatureName } from "./features.shared";
-
+import { effectiveTier, hasFeatureTier, hasForge } from "./license/validate";
 export { FEATURES, FREE_TIER_LOC_LIMIT, showProBadge } from "./features.shared";
 export type { LicenseTier, FeatureDef, FeatureName } from "./features.shared";
+import { FEATURES } from "./features.shared";
+import type { LicenseTier, FeatureName } from "./features.shared";
 
 /** Returns the effective tier for the given target project. */
 export function getCurrentTier(targetPath: string): LicenseTier {
@@ -12,9 +11,14 @@ export function getCurrentTier(targetPath: string): LicenseTier {
   return effectiveTier(license);
 }
 
-/** Returns true if the license at targetPath grants access to the named feature. */
+/** Returns true if the license grants access to the named feature. */
 export function isFeatureAvailable(targetPath: string, name: FeatureName): boolean {
   const license = loadLicense(targetPath);
   const required = FEATURES[name].tier;
   return hasFeatureTier(license, required);
 }
+
+/** Returns true if forge0x2B features are enabled for this target. */
+export function isForgeAvailable(targetPath: string): boolean {
+  return hasForge(loadLicense(targetPath));
+}

package/.next/standalone/lib/prism/hooks/useLicense.ts

@@ -11,13 +11,25 @@ export interface LicenseInfo {
   features: string[];
   isValid: boolean;
   isExpired: boolean;
+  // Lemonsqueezy fields
+  licenseKey: string | null;    // masked (e.g. "LS-A****-B")
+  instanceId: string | null;
+  productName: string | null;
+  subscriptionStatus: "active" | "cancelled" | "expired" | "paused" | null;
+  validatedAt: number | null;
+  revalidationDue: number | null;
+  gracePeriodEnd: number | null;
+  activationLimit: number | null;
+  activationUsage: number | null;
+  cacheStatus: "valid" | "grace" | "expired" | "no-cache";
+  daysSinceValidation: number | null;
 }
 
 export interface UseLicenseResult {
   license: LicenseInfo | null;
   ready: boolean;
   refresh: () => void;
-  /** True when tier is pro/team/enterprise and license is valid. */
+  /** True when tier is pro/spectrum/team/enterprise and license is valid. */
   isPro: boolean;
 }
 
@@ -29,6 +41,17 @@ const FREE_INFO: LicenseInfo = {
   features: [],
   isValid: false,
   isExpired: false,
+  licenseKey: null,
+  instanceId: null,
+  productName: null,
+  subscriptionStatus: null,
+  validatedAt: null,
+  revalidationDue: null,
+  gracePeriodEnd: null,
+  activationLimit: null,
+  activationUsage: null,
+  cacheStatus: "no-cache",
+  daysSinceValidation: null,
 };
 
 export function useLicense(tq: string): UseLicenseResult {
@@ -46,7 +69,8 @@ export function useLicense(tq: string): UseLicenseResult {
 
   const refresh = useCallback(() => setTick((t) => t + 1), []);
 
-  const isPro = !!license && license.tier !== "free" && license.isValid && !license.isExpired;
+  const isPro = !!license && license.tier !== "free" && license.tier !== "forge-pro"
+    && license.isValid && !license.isExpired && license.cacheStatus !== "expired";
 
   return { license, ready, refresh, isPro };
 }

package/.next/standalone/lib/prism/lemonsqueezy/client.ts

@@ -0,0 +1,162 @@
+/**
+ * Lemonsqueezy License Keys API — raw fetch client.
+ *
+ * License key endpoints are unauthenticated (they use the key itself, not bearer auth).
+ * The public API key (LEMONSQUEEZY_API_KEY) is for store-management endpoints only,
+ * not needed here. We keep it available for future store-level calls.
+ *
+ * Docs: https://docs.lemonsqueezy.com/api/license-keys
+ */
+
+const LS_BASE = "https://api.lemonsqueezy.com/v1/licenses";
+
+// ─── Typed errors ────────────────────────────────────────────────────────────
+
+export type LsErrorCode =
+  | "invalid_key"       // key not found in LS (404)
+  | "activation_limit"  // max instances reached (409)
+  | "not_activated"     // instance not found for validate/deactivate (404)
+  | "api_error"         // LS returned unexpected error (502)
+  | "network_error";    // fetch failed entirely
+
+export class LsApiError extends Error {
+  constructor(
+    message: string,
+    public readonly code: LsErrorCode,
+    public readonly httpStatus?: number,
+  ) {
+    super(message);
+    this.name = "LsApiError";
+  }
+}
+
+/** Map LS error strings to typed error codes. */
+function classifyLsError(message: string, httpStatus: number): LsErrorCode {
+  const m = message.toLowerCase();
+  if (m.includes("does not exist") || m.includes("not found") || httpStatus === 404) return "invalid_key";
+  if (m.includes("activation limit") || m.includes("reached its activation") || httpStatus === 422) return "activation_limit";
+  if (m.includes("instance") && (m.includes("not found") || m.includes("does not exist"))) return "not_activated";
+  return "api_error";
+}
+
+// ─── Response shapes ──────────────────────────────────────────────────────────
+
+export interface LsLicenseKey {
+  id: number;
+  status: "active" | "inactive" | "expired" | "disabled";
+  key: string;
+  activation_limit: number | null;
+  activation_usage: number;
+  created_at: string;
+  expires_at: string | null;
+}
+
+export interface LsInstance {
+  id: string;
+  name: string;
+  created_at: string;
+}
+
+export interface LsMeta {
+  store_id: number;
+  order_id: number;
+  order_item_id: number;
+  product_id: number;
+  product_name: string;
+  variant_id: number;
+  variant_name: string;
+  customer_id: number;
+  customer_name: string;
+  customer_email: string;
+}
+
+export interface LsActivateResponse {
+  activated: boolean;
+  error: string | null;
+  license_key: LsLicenseKey;
+  instance: LsInstance;
+  meta: LsMeta;
+}
+
+export interface LsValidateResponse {
+  valid: boolean;
+  error: string | null;
+  license_key: LsLicenseKey;
+  instance: LsInstance | null;
+  meta: LsMeta;
+}
+
+export interface LsDeactivateResponse {
+  deactivated: boolean;
+  error: string | null;
+  license_key: LsLicenseKey;
+  meta: LsMeta;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+async function lsPost<T>(endpoint: string, params: Record<string, string>): Promise<T> {
+  const body = new URLSearchParams(params);
+  let res: Response;
+  try {
+    res = await fetch(`${LS_BASE}/${endpoint}`, {
+      method: "POST",
+      headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString(),
+    });
+  } catch (cause) {
+    throw new LsApiError(
+      `Network error reaching Lemonsqueezy API: ${cause instanceof Error ? cause.message : String(cause)}`,
+      "network_error",
+    );
+  }
+  const json = await res.json() as T & { error?: string | null };
+  return { _status: res.status, ...json } as T;
+}
+
+// ─── API calls ───────────────────────────────────────────────────────────────
+
+export async function lsActivate(
+  licenseKey: string,
+  instanceName: string,
+): Promise<LsActivateResponse> {
+  const json = await lsPost<LsActivateResponse & { _status: number }>("activate", {
+    license_key: licenseKey,
+    instance_name: instanceName,
+  });
+  if (!json.activated) {
+    const msg = json.error ?? "Lemonsqueezy activation failed";
+    throw new LsApiError(msg, classifyLsError(msg, json._status), json._status);
+  }
+  return json;
+}
+
+export async function lsValidate(
+  licenseKey: string,
+  instanceId: string,
+): Promise<LsValidateResponse> {
+  const json = await lsPost<LsValidateResponse & { _status: number }>("validate", {
+    license_key: licenseKey,
+    instance_id: instanceId,
+  });
+  if (!json.valid) {
+    const msg = json.error ?? "Lemonsqueezy validation failed";
+    throw new LsApiError(msg, classifyLsError(msg, json._status), json._status);
+  }
+  return json;
+}
+
+export async function lsDeactivate(
+  licenseKey: string,
+  instanceId: string,
+): Promise<LsDeactivateResponse> {
+  const json = await lsPost<LsDeactivateResponse & { _status: number }>("deactivate", {
+    license_key: licenseKey,
+    instance_id: instanceId,
+  });
+  if (!json.deactivated) {
+    const msg = json.error ?? "Lemonsqueezy deactivation failed";
+    throw new LsApiError(msg, classifyLsError(msg, json._status), json._status);
+  }
+  return json;
+}

package/.next/standalone/lib/prism/lemonsqueezy/tierMapping.ts

@@ -0,0 +1,26 @@
+import type { LicenseTier } from "../license/types";
+
+export class ProductNotRecognizedError extends Error {
+  constructor(productName: string) {
+    super(`Unrecognized Lemonsqueezy product: "${productName}". Add it to PRODUCT_TIER_MAP.`);
+    this.name = "ProductNotRecognizedError";
+  }
+}
+
+const PRODUCT_TIER_MAP: Record<string, LicenseTier> = {
+  "prism0x2A Pro":         "pro",
+  "prism0x2A Team":        "team",
+  "forge0x2B Pro":         "forge-pro",
+  "Spectrum 0x55":         "spectrum",
+  "Spectrum 0x55 Bundle":  "spectrum",
+};
+
+/** Maps Lemonsqueezy product_name to internal LicenseTier. Throws if unrecognized. */
+export function mapProductNameToTier(productName: string): LicenseTier {
+  const tier = PRODUCT_TIER_MAP[productName];
+  if (!tier) throw new ProductNotRecognizedError(productName);
+  return tier;
+}
+
+/** All recognized product names (for validation). */
+export const RECOGNIZED_PRODUCTS = Object.keys(PRODUCT_TIER_MAP);