@xuda.io/account_module 1.2.2308 → 1.2.2309

package/index.mjs

@@ -542,11 +542,18 @@ export const save_admin_presets = async function (req) {
 };
 
 // Effective entitlements = the membership plan's base quota PLUS the AI-workspace
-// add-on's credits + storage stacked on top. The Free membership tier does NOT
-// stack (it keeps its base only); every paid tier adds whatever ai_workspace plan
-// the account carries. String quotas ("unlimited", e.g. Enterprise T3) short-circuit
-// to Infinity so downstream numeric comparisons never cap. Single source of truth —
-// use for quota checks and any effective-quota display/API.
+// add-on's credits + storage stacked on top, PLUS the Drive plan's own storage.
+// The Free membership tier does NOT stack the workspace add-on (it keeps its base
+// only); every paid tier adds whatever ai_workspace plan the account carries.
+// String quotas ("unlimited", e.g. Enterprise T3) short-circuit to Infinity so
+// downstream numeric comparisons never cap. Single source of truth, use it for
+// quota checks and any effective-quota display or API.
+//
+// UI-113: the Drive plan (drive_* category) is a storage add-on the customer buys
+// on its own, so unlike the workspace it stacks on EVERY membership tier including
+// free. Withholding space that has its own line on the invoice would be selling
+// nothing. The breakdown comes back with it, because a customer looking at a full
+// bar needs to see which of the three plans to move to get more room.
 export const get_effective_entitlements = function (account_doc) {
   const membership = _conf.PLAN_OBJ?.[account_doc?.membership_plan];
   const mf = membership?.features || {};
@@ -554,15 +561,34 @@ export const get_effective_entitlements = function (account_doc) {
   const numOrInf = (v) => (typeof v === 'string' ? Infinity : Number(v) || 0);
   let ai_credits = numOrInf(mf.ai_credits);
   let drive_gb = numOrInf(mf.drive);
+  const membership_drive_gb = drive_gb;
+  let workspace_drive_gb = 0;
+  let plan_drive_gb = 0;
 
   if (account_doc?.membership_plan && account_doc.membership_plan !== 'free') {
     const ws = _conf.PLAN_OBJ?.[account_doc?.ai_workspace_plan];
     if (ws && ws.category === 'ai_workspace') {
       if (Number.isFinite(ai_credits)) ai_credits += Number(ws.ai_credits) || 0;
-      if (Number.isFinite(drive_gb)) drive_gb += (Number(ws.size) || 0) / 1073741824;
+      workspace_drive_gb = (Number(ws.size) || 0) / 1073741824;
+      if (Number.isFinite(drive_gb)) drive_gb += workspace_drive_gb;
     }
   }
-  return { ai_credits, drive_gb };
+
+  const drive_plan = _conf.PLAN_OBJ?.[account_doc?.drive_plan];
+  if (drive_plan && drive_plan.category === 'drive') {
+    plan_drive_gb = Number(drive_plan.flags?.extra_gb) || 0;
+    if (Number.isFinite(drive_gb)) drive_gb += plan_drive_gb;
+  }
+
+  return {
+    ai_credits,
+    drive_gb,
+    drive_breakdown: {
+      membership_gb: membership_drive_gb,
+      workspace_gb: workspace_drive_gb,
+      drive_plan_gb: plan_drive_gb,
+    },
+  };
 };
 
 // ===================================================================
@@ -588,19 +614,58 @@ const _MODULE_SUBSCRIPTIONS = [
   // switched on there as well as here. Both call tickets_set_plan, so the plan
   // is one line item on the consolidated subscription either way.
   { key: 'tickets', scope: 'account', field: 'tickets_plan', default_plan: 'tickets_free' },
+  // UI-104: email is its own product, billed per mailbox tier. Its plan lives on the
+  // account as an OBJECT (`email_plan.tier`), which is why it resolves rather than
+  // reading a field, and `set_email_plan` is what moves it.
+  {
+    key: 'email',
+    scope: 'account',
+    field: 'email_plan',
+    default_plan: 'email_free',
+    resolve: (a) => (a && a.email_plan && a.email_plan.tier ? `email_${a.email_plan.tier}` : ''),
+  },
   // Auto response is the single gate for whether the AI answers, on every channel
   // (chat, the public chat widget, email and the phone). It is account scoped and
   // billed once however many scenarios are written, so it is a plain line item
   // here rather than a per-resource charge like phone or email.
-  { key: 'auto_response', scope: 'account', field: 'auto_response_plan', default_plan: 'auto_response_free' },
+  //
+  // UI-110: "nothing auto-responds before a plan is picked" is the module's own rule
+  // (auto_response_module assert_active), so PICKED is what active means here, Free
+  // included. Judging it on price alone would report an account that deliberately runs
+  // the free tier as switched off, and the menu gate would then hide the screen it uses.
+  {
+    key: 'auto_response',
+    scope: 'account',
+    field: 'auto_response_plan',
+    default_plan: 'auto_response_free',
+    is_active: (a) => !!a.auto_response_plan,
+  },
   // Four-tier ladder since 2026-08-06 (free / external / api / custom rules),
   // chosen on the Bot Protection Manager's Plans tab, which calls
   // bot_protection_set_plan. Free holds no line item at all.
   // No default_plan on purpose: Free is a tier the customer activates, so an
   // account that never chose one reads as not active rather than as Free.
-  { key: 'bot_protection', scope: 'account', field: 'bot_protection_plan', default_plan: '' },
+  { key: 'bot_protection', scope: 'account', field: 'bot_protection_plan', default_plan: '', is_active: (a) => !!a.bot_protection_plan },
   { key: 'static_website', scope: 'resource' },
-  { key: 'profile_phone', scope: 'resource' },
+  // Phone is the one module that is BOTH: an account-wide tier (set_voice_plan, held in
+  // communications.voice_plan) and a per-number charge, because the plan fee rides the
+  // oldest live number's own Stripe subscription rather than the consolidated one. So the
+  // row carries the tier for the switch AND one item per number for the billing card.
+  //
+  // billable is forced true for the same reason: the generic test looks for a Stripe
+  // price_id on a paid tier, and the phone ladder has none by design, its money is on the
+  // number. Left to the generic test the module would read "coming soon" while customers
+  // are being billed for numbers.
+  {
+    key: 'profile_phone',
+    scope: 'resource',
+    billable: true,
+    plan_of: (a) => `profile_phone_${a?.communications?.voice_plan?.tier || 'free'}`,
+    // get_voice_plans' own definition, kept identical on purpose: a number bought before
+    // UI-84 counts as active, so an existing customer is not asked to activate a plan
+    // they already pay for.
+    is_active: (a, items) => !!a?.communications?.voice_plan?.activated_ts || items.length > 0,
+  },
   // UI-96: the hosted resources. Not PLAN_OBJ categories, they are billed per resource
   // from `app_cost` on the app doc, but they are money on the same invoice, so the card
   // that answers "what am I paying for" has to show them.
@@ -614,9 +679,26 @@ const _MODULE_SUBSCRIPTIONS = [
   // so both carry their own `cycle` on each item rather than being assumed monthly.
   { key: 'domain', scope: 'resource' },
   { key: 'ipv4', scope: 'resource' },
-  // Xuda Verify (verify_module) has no PLAN_OBJ category: every check is metered
-  // per call into verify_meter and nothing is charged to the account today.
-  { key: 'trust_center', scope: 'metered' },
+  // Trust Center (verify_module) is sold on the trust_center_* ladder: the tier
+  // buys a capability ceiling and an included volume of live verifications for
+  // the customer's OWN users, and traffic past the allowance still meters per
+  // check into verify_meter. Account scoped since 2026-08-06; it was 'metered'
+  // while the service had no ladder behind it. Xuda's own verification is never
+  // priced by this plan, deliberately: see the note in verify_module.
+  { key: 'trust_center', scope: 'account', field: 'trust_center_plan', default_plan: 'trust_center_free' },
+  // The Marketplace seller ladder: the tier buys live listings, the listing types the
+  // account may sell, and above all the cut Xuda keeps on each sale (20% down to 5%).
+  // is_active on the FIELD rather than on price, like auto response: Free is a tier a
+  // seller picks, and it is the tier that decides their commission, so an account that
+  // deliberately runs Free is switched on and must not read as off.
+  { key: 'marketplace', scope: 'account', field: 'marketplace_plan', default_plan: 'marketplace_free', is_active: (a) => !!a.marketplace_plan },
+  // UI-113: Drive is sold on its own drive_* ladder, storage only. The tier buys space
+  // STACKED on top of what the membership and the AI workspace plan already include
+  // (get_effective_entitlements), which is why the free tier is 0 extra GB rather than
+  // a number: an account that never touched this ladder keeps exactly the space it has
+  // today and owes nothing new. Judged on price, so Free reads as not active, because
+  // here that is the truth: Free adds nothing and holds no line on the invoice.
+  { key: 'drive', scope: 'account', field: 'drive_plan', default_plan: 'drive_free' },
 ];
 
 // app_type -> the row it belongs under. An app type that is not here is not a
@@ -785,30 +867,42 @@ export const get_module_subscriptions = async function (req = {}) {
     const account = ar.data;
     const plans = _conf.PLAN_OBJ || {};
     // A category is only offerable once its paid tiers carry a real Stripe
-    // price, otherwise "activate" would set a plan nobody is billed for.
-    const billable = (key) =>
-      Object.values(plans).some((p) => p.category === key && Number(p.price) > 0 && p.price_id && !/TODO/.test(p.price_id));
+    // price, otherwise "activate" would set a plan nobody is billed for. A module
+    // whose money is NOT a plan line item says so itself (phone), because for those
+    // an absent price_id is the design, not a gap.
+    const billable = (m) =>
+      m.billable === true ||
+      Object.values(plans).some((p) => p.category === m.key && Number(p.price) > 0 && p.price_id && !/TODO/.test(p.price_id));
 
     const resource_items = await _module_resource_items(uid);
 
     const modules = _MODULE_SUBSCRIPTIONS.map((m) => {
-      const base = { key: m.key, scope: m.scope, billable: billable(m.key), items: resource_items[m.key] || [] };
+      const base = { key: m.key, scope: m.scope, billable: billable(m), items: resource_items[m.key] || [] };
       if (m.scope === 'resource' || m.scope === 'metered') {
         const price = base.items.reduce((sum, i) => sum + Number(i.price || 0), 0);
         // UI-97: a row is only yearly when everything in it is (domains). Anything
         // else stays monthly, so a total is never a sum of two different cycles.
         const cycle = base.items.length && base.items.every((i) => i.cycle === 'yr') ? 'yr' : 'mo';
+        // UI-110: a resource row may still sit under an account-wide tier (phone), and
+        // the switch needs that tier, not the sum of the numbers. Everything without a
+        // `plan_of` keeps reporting no plan, exactly as before.
+        const plan_id = m.plan_of ? m.plan_of(account) : '';
+        const plan = plans[plan_id] || {};
         return {
           ...base,
-          active: m.scope === 'metered' || base.items.length > 0,
+          active: m.is_active ? !!m.is_active(account, base.items) : m.scope === 'metered' || base.items.length > 0,
           included: m.scope === 'metered',
-          plan_id: '',
-          plan_name: '',
+          plan_id,
+          plan_name: plan.name || '',
+          plan_price: Number(plan.price) || 0,
           price,
           cycle,
         };
       }
-      const plan_id = account[m.field] || m.default_plan;
+      // UI-104: most modules keep their plan id directly on the account, but email
+      // keeps `{ tier, activated_ts }`, so a module may bring its own resolver rather
+      // than forcing every field into the same shape.
+      const plan_id = (m.resolve ? m.resolve(account) : account[m.field]) || m.default_plan;
       const plan = plans[plan_id] || {};
       // UI-103: a switch-off is a DOWNGRADE, so Stripe schedules it for the end of the
       // period the customer already paid for and the plan field does not move until the
@@ -824,7 +918,10 @@ export const get_module_subscriptions = async function (req = {}) {
         plan_id,
         plan_name: plan.name || plan_id,
         price,
-        active: price > 0,
+        // UI-110: paying is the default proof that a module is on, but a module that
+        // records the customer CHOOSING a tier says so itself, because a deliberate
+        // free tier is switched on and a price of zero cannot tell the two apart.
+        active: m.is_active ? !!m.is_active(account, base.items) : price > 0,
         included: false,
         pending,
         changed_ts: account[`${m.field}_changed`] || null,
@@ -1783,7 +1880,31 @@ export const get_account_data = async function (req) {
         builds_drive_size: acc_obj.builds_drive_size || 0,
         project_data_size: acc_obj.project_data_size || 0,
         total_drive_size: acc_obj.total_drive_size || 0,
+        // UI-113: the QUOTA travels with the usage now. Every surface that drew a
+        // storage bar (the sidenav popover, UsageBar, the Drive plans screen) was
+        // deriving the ceiling from the ai_workspace plan's `size` alone, which
+        // ignored the membership base and would have ignored the Drive plan too, so
+        // a bar could read full while the account had room. This is the same
+        // get_effective_entitlements the overage metering charges on, in bytes.
+        ...(() => {
+          const ent = get_effective_entitlements(acc_obj);
+          const gb = 1073741824;
+          const b = ent.drive_breakdown || {};
+          return {
+            quota_bytes: Number.isFinite(ent.drive_gb) ? Math.round(ent.drive_gb * gb) : 0,
+            quota_unlimited: !Number.isFinite(ent.drive_gb),
+            quota_from: {
+              membership_bytes: Math.round((b.membership_gb === Infinity ? 0 : b.membership_gb || 0) * gb),
+              workspace_bytes: Math.round((b.workspace_gb || 0) * gb),
+              drive_plan_bytes: Math.round((b.drive_plan_gb || 0) * gb),
+            },
+          };
+        })(),
       },
+      // UI-113: the Drive storage ladder the account sits on, for the plans screen
+      // and the Modules card. Absent on an account that never picked one, which the
+      // registry reads as drive_free.
+      drive_plan: acc_obj.drive_plan || 'drive_free',
 
       stripe_connect_account_id: acc_obj?.stripe_connect_account_obj?.id,
       stripe_connect_account_status: acc_obj?.stripe_connect_account_status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/account_module",
-  "version": "1.2.2308",
+  "version": "1.2.2309",
   "description": "Xuda Account Server Module",
   "main": "index.mjs",
   "dependencies": {