@tokenoftrust/storefront-runner 1.3.2 → 1.3.4-rc.2

package/apps/storefront/src/lib/admin/orderClient.ts

@@ -1,5 +1,5 @@
 /**
- * Server-side client for tot-foxycart's order READ API (card 8585 / U2).
+ * Server-side client for the checkout order READ API (card 8585 / U2).
  *
  * Calls `GET /commerce/orders[/:orderId]` with the tenant's per-tenant bearer key
  * (the ToT `partnerApi.apiKey`, held as a Worker secret — NEVER shipped to the
@@ -14,10 +14,10 @@
  * `fetchImpl` is injectable so the client is unit-testable offline.
  */
 import type {
-  FoxyOrderDetail,
-  FoxyOrderDetailResponse,
-  FoxyOrderListFilters,
-  FoxyOrderListResponse,
+  CheckoutOrderDetail,
+  CheckoutOrderDetailResponse,
+  CheckoutOrderListFilters,
+  CheckoutOrderListResponse,
 } from "@tot/public-runtime";
 import type { CustomizationEnv } from "@tot/public-runtime";
 
@@ -50,13 +50,13 @@ export class OrderApiError extends Error {
   }
 }
 
-export interface FoxyOrderClient {
-  listOrders(filters?: FoxyOrderListFilters): Promise<FoxyOrderListResponse>;
-  getOrder(orderId: string): Promise<FoxyOrderDetail>;
+export interface CheckoutOrderClient {
+  listOrders(filters?: CheckoutOrderListFilters): Promise<CheckoutOrderListResponse>;
+  getOrder(orderId: string): Promise<CheckoutOrderDetail>;
 }
 
-export interface FoxyOrderClientConfig {
-  /** tot-foxycart proxy base, e.g. `https://foxycart-test.tokenoftrust.com`. */
+export interface CheckoutOrderClientConfig {
+  /** Checkout order API base URL for the checkout proxy. */
   baseUrl: string;
   /** The tenant, sent as `?appDomain=` (e.g. `sample-store.example`). */
   appDomain: string;
@@ -66,10 +66,10 @@ export interface FoxyOrderClientConfig {
 }
 
 /**
- * Resolve the tot-foxycart proxy base URL for an environment (contract §2).
- * qa runs `NODE_ENV=test` → the `foxycart-test` proxy; `live` → prod. Kept
- * private so it does not collide with U11b's exported `foxyProxyBaseUrl` before
- * the units fold; the integrator can dedup into one shared export.
+ * Resolve the checkout order API base URL for an environment (contract §2).
+ * qa/test use the non-prod proxy; live uses prod. Kept private so it does not
+ * collide with U11b's exported checkout theme base URL before the units fold;
+ * the integrator can dedup into one shared export.
  */
 export function orderApiBaseUrl(env: CustomizationEnv): string {
   return env === "live"
@@ -98,7 +98,7 @@ function toError(status: number, body: string): OrderApiError {
 }
 
 /** Build the list querystring: appDomain (required) + any provided filters. */
-function listQuery(appDomain: string, filters?: FoxyOrderListFilters): string {
+function listQuery(appDomain: string, filters?: CheckoutOrderListFilters): string {
   const p = new URLSearchParams({ appDomain });
   if (filters) {
     if (filters.queue) p.set("queue", filters.queue);
@@ -112,9 +112,9 @@ function listQuery(appDomain: string, filters?: FoxyOrderListFilters): string {
 }
 
 /** Create a per-request order client bound to one tenant + env. */
-export function createFoxyOrderClient(
-  config: FoxyOrderClientConfig,
-): FoxyOrderClient {
+export function createCheckoutOrderClient(
+  config: CheckoutOrderClientConfig,
+): CheckoutOrderClient {
   const doFetch = config.fetchImpl ?? (globalThis.fetch as unknown as FetchLike);
   const base = config.baseUrl.replace(/\/+$/, "");
   const headers = { authorization: `Bearer ${config.bearer}` };
@@ -133,11 +133,11 @@ export function createFoxyOrderClient(
   return {
     async listOrders(filters) {
       const qs = listQuery(config.appDomain, filters);
-      return getJson<FoxyOrderListResponse>(`${base}/commerce/orders?${qs}`);
+      return getJson<CheckoutOrderListResponse>(`${base}/commerce/orders?${qs}`);
     },
     async getOrder(orderId) {
       const qs = new URLSearchParams({ appDomain: config.appDomain }).toString();
-      const { order } = await getJson<FoxyOrderDetailResponse>(
+      const { order } = await getJson<CheckoutOrderDetailResponse>(
         `${base}/commerce/orders/${encodeURIComponent(orderId)}?${qs}`,
       );
       return order;

package/apps/storefront/src/lib/admin/services/mock/{foxyCartSettings.ts → checkoutSettings.ts}

@@ -8,30 +8,29 @@
  * the `TenantResolver` seam via `config/adminTargetTenant`), never looked up from
  * the static tenant map here: `lib/**` stays behind the `tenancy-resolver-fence`
  * so a single-tenant extraction stays a drop-in. A null tenant (or one with no
- * FoxyCart store) renders the panel's inert "no store" state.
+ * checkout store) renders the panel's inert "no store" state.
  *
  * Overrides are read from a mock store here (no live persistence yet — the save
- * hop is the tot-foxycart `/theme/foxy` PUT/refresh + Foxy color PATCH seam). One
- * example override is seeded so the panel demonstrates the theme/override/reset
- * states without a backend.
+ * hop is the commerce service's theme PUT/refresh seam). One example override is
+ * seeded so the panel demonstrates the theme/override/reset states without a backend.
  */
-import { resolveFoxyCommerce } from "@tot/public-runtime";
+import { resolveManagedCheckout } from "@tot/public-runtime";
 import type { TenantConfig } from "@tot/public-runtime";
 import { referenceTheme } from "@/themes/reference";
 import { mergeTheme } from "@/themes/schema";
 import type { AdminTenantEnvelope } from "../../envelope";
 import {
-  buildFoxySettingsFields,
-  deriveFoxyCartSettings,
-  type FoxyCartSettingsOverrides,
-  type FoxySettingsField,
-} from "@/lib/commerce/foxyCartSettings";
+  buildCheckoutSettingsFields,
+  deriveCheckoutSettings,
+  type CheckoutSettingsOverrides,
+  type CheckoutSettingsField,
+} from "@/lib/commerce/checkoutSettings";
 
-export interface FoxyCartSettingsViewModel {
+export interface CheckoutSettingsViewModel {
   targetTenant: string;
-  /** True when the tenant has a FoxyCart store (else the section is inert). */
+  /** True when the tenant has a checkout store (else the section is inert). */
   hasStore: boolean;
-  fields: FoxySettingsField[];
+  fields: CheckoutSettingsField[];
   overrideCount: number;
 }
 
@@ -40,7 +39,7 @@ export interface FoxyCartSettingsViewModel {
  * generic sample tenant so the panel shows a mixed theme/override state out of
  * the box. Real overrides would come from the tenant's saved cart settings.
  */
-const MOCK_OVERRIDES: Record<string, FoxyCartSettingsOverrides> = {
+const MOCK_OVERRIDES: Record<string, CheckoutSettingsOverrides> = {
   "sample-store.example": {
     // Example: the merchant pinned a custom tertiary accent, overriding the
     // theme's --color-sale default — the panel renders this row as "Overridden"
@@ -50,28 +49,28 @@ const MOCK_OVERRIDES: Record<string, FoxyCartSettingsOverrides> = {
 };
 
 /**
- * Build the FoxyCart cart-appearance view model from the resolved TARGET tenant
+ * Build the checkout appearance view model from the resolved TARGET tenant
  * config. `tenant` is the target's resolved `TenantConfig` (or null when no
  * tenant claims the id) — resolved by the caller through the resolver seam.
  */
-export function getFoxyCartSettingsViewModel(
+export function getCheckoutSettingsViewModel(
   envelope: AdminTenantEnvelope,
   tenant: TenantConfig | null,
-): FoxyCartSettingsViewModel {
+): CheckoutSettingsViewModel {
   const { targetTenant } = envelope;
-  const foxy = tenant?.commerce?.foxy ?? null;
+  const checkout = tenant?.commerce?.checkout ?? null;
 
-  if (!tenant || !foxy) {
+  if (!tenant || !checkout) {
     return { targetTenant, hasStore: false, fields: [], overrideCount: 0 };
   }
 
   const theme = mergeTheme(referenceTheme, tenant.theme_tokens);
-  const commerce = resolveFoxyCommerce(foxy);
-  const defaults = deriveFoxyCartSettings(theme, commerce, {
+  const commerce = resolveManagedCheckout(checkout);
+  const defaults = deriveCheckoutSettings(theme, commerce, {
     originBase: `https://${targetTenant}`,
   });
   const overrides = MOCK_OVERRIDES[targetTenant] ?? {};
-  const fields = buildFoxySettingsFields(defaults, overrides);
+  const fields = buildCheckoutSettingsFields(defaults, overrides);
   const overrideCount = fields.filter((f) => f.source === "override").length;
 
   return { targetTenant, hasStore: true, fields, overrideCount };

package/apps/storefront/src/lib/admin/services/mock/index.ts

@@ -4,8 +4,9 @@ export { getCustomersViewModel } from "./customers";
 export { getFulfillmentViewModel } from "./fulfillment";
 export { getReportingViewModel } from "./reporting";
 export { getSettingsViewModel } from "./settings";
-export { getFoxyCartSettingsViewModel } from "./foxyCartSettings";
-export type { FoxyCartSettingsViewModel } from "./foxyCartSettings";
+export { getCheckoutSettingsViewModel } from "./checkoutSettings";
+export type { CheckoutSettingsViewModel } from "./checkoutSettings";
+export { getSubscriptionsViewModel } from "./subscriptions";
 export { getAiWorkflowsViewModel } from "./aiWorkflows";
 export { getEvidenceViewModel } from "./evidence";
 export { SEEDED_TENANTS, tenantProfile } from "./tenants";

package/apps/storefront/src/lib/admin/services/mock/settings.ts

@@ -7,7 +7,7 @@ import type { SettingsAuditEvent, SettingsSection, SettingsViewModel } from "../
 const SECTION_DEFS: Omit<SettingsSection, "riskyChangeReview">[] = [
   { key: "store", label: "Store", summary: "Store profile, branding, and white-label copy." },
   { key: "checkout", label: "Checkout", summary: "Checkout assurance and identity/age verification flow." },
-  { key: "cart_appearance", label: "Cart & checkout appearance", summary: "FoxyCart brand colors and templates, prepopulated from the theme." },
+  { key: "cart_appearance", label: "Cart & checkout appearance", summary: "Hosted checkout colors and templates, prepopulated from the theme." },
   { key: "payments", label: "Payments", summary: "Payment capture timing and gateway configuration." },
   { key: "shipping", label: "Shipping", summary: "Carriers, rates, and shipping restrictions by region." },
   { key: "taxes", label: "Taxes", summary: "Excise and sales tax configuration by jurisdiction." },

package/apps/storefront/src/lib/admin/services/mock/subscriptions.ts

@@ -0,0 +1,398 @@
+import type {
+  ProductPurchaseOption,
+  SubscriptionPurchaseOption,
+} from "@tot/public-runtime";
+import {
+  DEFAULT_ONE_TIME_PURCHASE_OPTION,
+  isSubscriptionFrequency,
+  purchaseOptionPrice,
+} from "@tot/public-runtime";
+import type { AdminTenantEnvelope } from "../../envelope";
+import { memoizeByEnvelope } from "../../memoizeByEnvelope";
+import {
+  MOCK_ANCHOR_ISO,
+  offsetIso,
+  randomInt,
+  seededRandom,
+} from "../../seed";
+import type { CustomerRow } from "../../viewmodels/customers";
+import type { ProductDetail, ProductRow } from "../../viewmodels/products";
+import type {
+  SubscriptionAttentionRow,
+  SubscriptionCheckoutField,
+  SubscriptionEvidenceEvent,
+  SubscriptionProgramDetail,
+  SubscriptionProgramReadiness,
+  SubscriptionProgramRow,
+  SubscriptionRenewalEvent,
+  SubscriptionSubscriberRow,
+  SubscriptionsViewModel,
+} from "../../viewmodels/subscriptions";
+import { getCustomersViewModel } from "./customers";
+import { getProductsViewModel } from "./products";
+
+export interface SubscriptionProductSource {
+  productId: string;
+  productName: string;
+  sellable: boolean;
+  blocker: string | null;
+  basePrice: number;
+  purchaseOptions: ProductPurchaseOption[];
+}
+
+const SUBSCRIPTION_TEMPLATES: SubscriptionPurchaseOption[] = [
+  {
+    id: "monthly",
+    kind: "subscription",
+    label: "Subscribe monthly",
+    description: "Ships every month.",
+    savingsLabel: "Save 15%",
+    priceAdjustment: { type: "percent_off", value: 15 },
+    frequency: "1m",
+  },
+  {
+    id: "every-60-days",
+    kind: "subscription",
+    label: "Every 60 days",
+    description: "A slower refill cadence.",
+    savingsLabel: "Save $5",
+    priceAdjustment: { type: "amount_off", value: 5 },
+    frequency: "60d",
+  },
+  {
+    id: "setup-review",
+    kind: "subscription",
+    label: "Autopilot setup review",
+    description: "Needs a compact checkout interval before launch.",
+    savingsLabel: "Save 10%",
+    priceAdjustment: { type: "percent_off", value: 10 },
+    frequency: "every month",
+  },
+];
+
+function frequencyIsValid(option: SubscriptionPurchaseOption): boolean {
+  return typeof option.frequency === "string" && isSubscriptionFrequency(option.frequency);
+}
+
+function priceAdjustmentLabel(option: SubscriptionPurchaseOption): string | null {
+  const adjustment = option.priceAdjustment;
+  if (!adjustment) return null;
+  if (adjustment.type === "percent_off") return `${adjustment.value}% off`;
+  return `$${adjustment.value.toFixed(2)} off`;
+}
+
+function readinessFor(
+  source: SubscriptionProductSource,
+  option: SubscriptionPurchaseOption,
+): { readiness: SubscriptionProgramReadiness; detail: string } {
+  if (!frequencyIsValid(option)) {
+    return {
+      readiness: "needs_setup",
+      detail: "Subscription interval must use a compact checkout frequency.",
+    };
+  }
+  if (!source.sellable) {
+    return {
+      readiness: "blocked",
+      detail: source.blocker ?? "Product readiness is blocking subscription launch.",
+    };
+  }
+  return { readiness: "ready", detail: "Ready for checkout." };
+}
+
+export function buildSubscriptionProgramRows(
+  sources: SubscriptionProductSource[],
+): SubscriptionProgramRow[] {
+  return sources.flatMap((source) =>
+    source.purchaseOptions
+      .filter((option): option is SubscriptionPurchaseOption => option.kind === "subscription")
+      .map((option) => {
+        const readiness = readinessFor(source, option);
+        const renewalPrice = frequencyIsValid(option)
+          ? purchaseOptionPrice(source.basePrice, option)
+          : source.basePrice;
+        return {
+          id: `sub:${source.productId}:${option.id}`,
+          productId: source.productId,
+          productName: source.productName,
+          optionId: option.id,
+          optionLabel: option.label,
+          frequency: option.frequency,
+          savingsLabel: option.savingsLabel ?? null,
+          priceAdjustmentLabel: priceAdjustmentLabel(option),
+          readiness: readiness.readiness,
+          readinessDetail: readiness.detail,
+          subscriberCount: 0,
+          upcomingRenewalValue: renewalPrice,
+          needsAttentionCount: readiness.readiness === "ready" ? 0 : 1,
+        };
+      }),
+  );
+}
+
+function purchaseOptionsForProduct(
+  index: number,
+  firstSellableIndex: number,
+): ProductPurchaseOption[] {
+  const options: ProductPurchaseOption[] = [DEFAULT_ONE_TIME_PURCHASE_OPTION];
+  const template = SUBSCRIPTION_TEMPLATES[index];
+  if (template) options.push(template);
+  if (index === firstSellableIndex && template?.id !== "monthly") {
+    options.push({ ...SUBSCRIPTION_TEMPLATES[0]!, id: "monthly-ready" });
+  }
+  return options;
+}
+
+function sourceFromProduct(
+  row: ProductRow,
+  detail: ProductDetail,
+  index: number,
+  firstSellableIndex: number,
+): SubscriptionProductSource {
+  return {
+    productId: row.id,
+    productName: row.name,
+    sellable: row.sellable,
+    blocker: row.sellable ? null : `${row.missingExciseCount} catalog readiness gap(s)`,
+    basePrice: detail.variants[0]?.price ?? 0,
+    purchaseOptions: purchaseOptionsForProduct(index, firstSellableIndex),
+  };
+}
+
+function checkoutFieldsFor(
+  option: SubscriptionPurchaseOption,
+): SubscriptionCheckoutField[] {
+  const fields: SubscriptionCheckoutField[] = [
+    { name: "Purchase option", value: option.label },
+    { name: "sub_frequency", value: option.frequency },
+  ];
+  if (option.startDate) fields.push({ name: "sub_startdate", value: option.startDate });
+  if (option.endDate) fields.push({ name: "sub_enddate", value: option.endDate });
+  if (option.savingsLabel) fields.push({ name: "Savings", value: option.savingsLabel });
+  return fields;
+}
+
+function setupAttentionFor(
+  row: SubscriptionProgramRow,
+  source: SubscriptionProductSource,
+): SubscriptionAttentionRow[] {
+  const attention: SubscriptionAttentionRow[] = [];
+  if (!isSubscriptionFrequency(row.frequency)) {
+    attention.push({
+      id: `${row.id}:setup-frequency`,
+      kind: "setup_gap",
+      programId: row.id,
+      productId: row.productId,
+      customerId: null,
+      label: "Subscription interval needs setup",
+      detail: `${row.optionLabel} uses "${row.frequency}". Use a compact interval such as 1m, 60d, or 2w.`,
+      action: "Review purchase option",
+      tone: "amber",
+      blocking: true,
+    });
+  }
+  if (!source.sellable) {
+    attention.push({
+      id: `${row.id}:product-readiness`,
+      kind: "product_blocker",
+      programId: row.id,
+      productId: row.productId,
+      customerId: null,
+      label: "Product readiness blocks subscription",
+      detail: source.blocker ?? "Resolve product readiness before this can sell.",
+      action: "Open product readiness",
+      tone: "red",
+      blocking: true,
+    });
+  }
+  return attention;
+}
+
+function statusForSubscriber(
+  programIndex: number,
+  subscriberIndex: number,
+): SubscriptionSubscriberRow["status"] {
+  if (programIndex === 0 && subscriberIndex === 0) return "payment_attention";
+  if (programIndex === 1 && subscriberIndex === 0) return "verification_hold";
+  return "active";
+}
+
+function subscribersForProgram(
+  targetTenant: string,
+  row: SubscriptionProgramRow,
+  programIndex: number,
+  customers: CustomerRow[],
+  rng: () => number,
+): SubscriptionSubscriberRow[] {
+  if (row.readiness === "needs_setup") return [];
+  const count = Math.min(customers.length, row.readiness === "ready" ? randomInt(rng, 2, 4) : randomInt(rng, 1, 2));
+  return Array.from({ length: count }, (_, index) => {
+    const customer = customers[(programIndex + index) % customers.length]!;
+    const status = statusForSubscriber(programIndex, index);
+    return {
+      id: `sub-instance:${targetTenant}:${row.optionId}:${customer.id}`,
+      programId: row.id,
+      customerId: customer.id,
+      customerName: customer.name,
+      email: customer.email,
+      status,
+      verificationState:
+        status === "verification_hold" ? "pending" : customer.verificationState,
+      paymentState: status === "payment_attention" ? "attention" : "current",
+      nextRenewalAt: offsetIso(MOCK_ANCHOR_ISO, randomInt(rng, 1_440, 35_000)),
+      renewalValue: row.upcomingRenewalValue,
+    };
+  });
+}
+
+function subscriberAttentionFor(
+  row: SubscriptionProgramRow,
+  subscriber: SubscriptionSubscriberRow,
+): SubscriptionAttentionRow | null {
+  if (subscriber.status === "payment_attention") {
+    return {
+      id: `${subscriber.id}:payment`,
+      kind: "payment_attention",
+      programId: row.id,
+      productId: row.productId,
+      customerId: subscriber.customerId,
+      label: "Payment attention",
+      detail: `${subscriber.customerName} needs payment follow-up before the next renewal.`,
+      action: "Open customer",
+      tone: "amber",
+      blocking: true,
+    };
+  }
+  if (subscriber.status === "verification_hold") {
+    return {
+      id: `${subscriber.id}:verification`,
+      kind: "verification_hold",
+      programId: row.id,
+      productId: row.productId,
+      customerId: subscriber.customerId,
+      label: "Verification hold",
+      detail: `${subscriber.customerName} needs age/identity verification before renewal.`,
+      action: "Open customer",
+      tone: "red",
+      blocking: true,
+    };
+  }
+  return null;
+}
+
+function renewalEventsFor(subscribers: SubscriptionSubscriberRow[]): SubscriptionRenewalEvent[] {
+  return subscribers.map((subscriber) => ({
+    id: `renewal:${subscriber.id}`,
+    customerId: subscriber.customerId,
+    customerName: subscriber.customerName,
+    at: subscriber.nextRenewalAt,
+    amount: subscriber.renewalValue,
+    state:
+      subscriber.status === "active"
+        ? "scheduled"
+        : subscriber.status === "payment_attention"
+          ? "attention"
+          : "held",
+  }));
+}
+
+function evidenceFor(
+  row: SubscriptionProgramRow,
+  subscribers: SubscriptionSubscriberRow[],
+): SubscriptionEvidenceEvent[] {
+  const events: SubscriptionEvidenceEvent[] = [
+    {
+      title: "Catalog purchase option detected",
+      detail: `${row.optionLabel} is available on ${row.productName}.`,
+      at: offsetIso(MOCK_ANCHOR_ISO, -18_000),
+    },
+    {
+      title: "Checkout payload reviewed",
+      detail: `Subscription frequency ${row.frequency} is included in the signed cart payload.`,
+      at: offsetIso(MOCK_ANCHOR_ISO, -9_000),
+    },
+  ];
+  if (subscribers.length > 0) {
+    events.push({
+      title: "Subscriber activity imported",
+      detail: `${subscribers.length} customer subscription record(s) linked to this program.`,
+      at: offsetIso(MOCK_ANCHOR_ISO, -1_800),
+    });
+  }
+  return events;
+}
+
+function computeSubscriptionsViewModel(envelope: AdminTenantEnvelope): SubscriptionsViewModel {
+  const { targetTenant } = envelope;
+  const rng = seededRandom(`subscriptions:${targetTenant}`);
+  const products = getProductsViewModel(envelope);
+  const customers = getCustomersViewModel(envelope);
+  const firstSellableIndex = products.rows.findIndex((row) => row.sellable);
+  const sources = products.rows.map((row, index) =>
+    sourceFromProduct(row, products.detailsById[row.id]!, index, firstSellableIndex),
+  );
+  const baseRows = buildSubscriptionProgramRows(sources);
+  const sourceByProgramId = new Map(
+    baseRows.map((row) => [
+      row.id,
+      sources.find((source) => source.productId === row.productId)!,
+    ]),
+  );
+  const optionByProgramId = new Map<string, SubscriptionPurchaseOption>(
+    sources.flatMap((source) =>
+      source.purchaseOptions
+        .filter((option): option is SubscriptionPurchaseOption => option.kind === "subscription")
+        .map((option) => [`sub:${source.productId}:${option.id}`, option] as const),
+    ),
+  );
+
+  const programs: SubscriptionProgramRow[] = [];
+  const detailsById: Record<string, SubscriptionProgramDetail> = {};
+  const allAttention: SubscriptionAttentionRow[] = [];
+
+  baseRows.forEach((baseRow, index) => {
+    const source = sourceByProgramId.get(baseRow.id)!;
+    const option = optionByProgramId.get(baseRow.id)!;
+    const subscribers = subscribersForProgram(targetTenant, baseRow, index, customers.directory, rng);
+    const setupAttention = setupAttentionFor(baseRow, source);
+    const subscriberAttention = subscribers
+      .map((subscriber) => subscriberAttentionFor(baseRow, subscriber))
+      .filter((row): row is SubscriptionAttentionRow => row !== null);
+    const attention = [...setupAttention, ...subscriberAttention];
+    const upcomingRenewals = renewalEventsFor(subscribers);
+    const upcomingRenewalValue = upcomingRenewals
+      .filter((event) => event.state === "scheduled")
+      .reduce((sum, event) => sum + event.amount, 0);
+    const row: SubscriptionProgramRow = {
+      ...baseRow,
+      subscriberCount: subscribers.length,
+      upcomingRenewalValue,
+      needsAttentionCount: attention.length,
+    };
+    programs.push(row);
+    allAttention.push(...attention);
+    detailsById[row.id] = {
+      ...row,
+      checkoutFields: checkoutFieldsFor(option),
+      subscribers,
+      upcomingRenewals,
+      evidenceTimeline: evidenceFor(row, subscribers),
+      attention,
+    };
+  });
+
+  return {
+    targetTenant,
+    summary: {
+      subscriptionProducts: programs.length,
+      activeSubscribers: programs.reduce((sum, row) => sum + row.subscriberCount, 0),
+      upcomingRenewalValue: programs.reduce((sum, row) => sum + row.upcomingRenewalValue, 0),
+      needsAttention: allAttention.length,
+    },
+    programs,
+    detailsById,
+    attention: allAttention.sort((a, b) => Number(b.blocking) - Number(a.blocking)),
+  };
+}
+
+export const getSubscriptionsViewModel = memoizeByEnvelope(computeSubscriptionsViewModel);