@tokenoftrust/storefront-runner 1.4.1 → 2.0.0

package/packages/public-runtime/src/integration-capabilities.ts

@@ -0,0 +1,520 @@
+/**
+ * Integration capability model — the closed, versioned permission vocabulary for
+ * third-party extensibility of the shared multi-tenant renderer.
+ *
+ * This is the crux the CSP compiler, consent broker, compliance obligations,
+ * assurance/audit, and promotion gates all resolve against. It is pure and
+ * edge-safe (no node, no I/O), so the renderer, validators, CLI, and admin
+ * review all read the same source of truth.
+ *
+ * Governing decisions (see docs/architecture/decisions):
+ *   - 0014 charter: four authority tiers (I1), non-waivable regulated floor (G1),
+ *     regulated elevated-parent proof-gated (G2), commerce data minimized (M1/M2),
+ *     dual client/server events (M3), invariant 7 (the ungrantable protected set).
+ *   - 0016 sandbox-first: authority is fixed by a surface × tenant-tier matrix;
+ *     sandbox/broker is the default; generic parent code is prohibited on commerce
+ *     and checkout/payment surfaces; regulated pages take only certified immutable
+ *     pinned code; mutable containers are never regulated-eligible.
+ *   - 0023 legal gates: Q6 prohibits merchant-mutable parent code on regulated and
+ *     commerce surfaces (no acknowledgement path); Q2 approves the outside-guarantee
+ *     record structure for eligible unregulated/external surfaces only, disabled
+ *     until counsel wording is wired; Q3 requires analytics consent for cross-site
+ *     attribution.
+ *
+ * Honesty contract: only adapter, broker (sandboxed iframe + typed postMessage),
+ * and server tiers offer enforceable least-privilege. The elevated-parent tier is
+ * full parent authority and is labeled review-only — its DOM reach is never
+ * described as a sandbox.
+ */
+
+// The four honest authority tiers are the shared browser-integration contract's
+// (`./integration/phases.ts`) — one vocabulary, not a competing spelling. This
+// policy layer decides which tier is grantable on which surface; the contract
+// layer decides the manifest shape. `isExactOrigin` is likewise the shared
+// exact-HTTPS grammar (`./integration/csp.ts`).
+import { EXECUTION_TIERS, type ExecutionTier } from "./integration/phases.js";
+import { isExactOrigin } from "./integration/csp.js";
+
+/** Contract token for the whole model — bump the minor for additive vocabulary, the major for a breaking change (ADR 0006 semver). */
+export const INTEGRATION_CAPABILITY_MODEL = "integration-capability-model@1" as const;
+export type IntegrationCapabilityModel = typeof INTEGRATION_CAPABILITY_MODEL;
+
+// ── Execution tiers (charter I1 / ADR 0016) ─────────────────────────────────
+
+/** Sandbox is the default tier on every surface (ADR 0016). */
+export const DEFAULT_EXECUTION_TIER: ExecutionTier = "sandbox";
+
+export type Enforcement = "enforced" | "review-only";
+
+/**
+ * Whether the platform mechanically enforces the authority of a tier. Adapter,
+ * broker, and server are enforced least-privilege. Elevated-parent is full parent
+ * authority — honestly review-only, never claimed as enforced isolation.
+ */
+export const EXECUTION_TIER_ENFORCEMENT: Record<ExecutionTier, Enforcement> = {
+  "platform-adapter": "enforced",
+  sandbox: "enforced",
+  server: "enforced",
+  "elevated-parent": "review-only",
+};
+
+/** Honest human labels. The elevated-parent line never uses the word sandbox. */
+export const EXECUTION_TIER_LABELS: Record<ExecutionTier, string> = {
+  "platform-adapter":
+    "Platform adapter — versioned, platform-owned configuration for a first-class vendor. Least-privilege and enforced.",
+  sandbox:
+    "Sandbox/broker — target: a null-origin sandboxed iframe (allow-scripts, no allow-same-origin) reaching the page only through the typed postMessage broker. Enforced fail-closed: until that isolating iframe host is wired, a sandbox-tier entry is REFUSED at runtime by the same-origin loader rather than run with parent-document access — the isolation is never faked by importing it into the parent.",
+  server:
+    "Server — server-side destination filtering and semantic events. Least-privilege and enforced; never touches the browser DOM.",
+  "elevated-parent":
+    "Full parent authority — arbitrary parent-document JavaScript. Its DOM reach is NOT enforceably narrow, so it is review-only and can never access separate server-held secrets or forbidden broker scopes. It is not isolation and must not be presented as least-privilege.",
+};
+
+/** Code shape a request ships as — the distinction that decides regulated eligibility (ADR 0016 / 0023 Q6). */
+export const CODE_FORMS = ["brokered", "pinned-immutable", "mutable-container"] as const;
+export type CodeForm = (typeof CODE_FORMS)[number];
+
+// ── Tenant tiers and surfaces (the D-R2 matrix axes) ────────────────────────
+
+/**
+ * Tenant compliance tier, resolved server-side from authoritative tenant state
+ * (charter invariant 4). Regulated tiers carry the non-waivable floor (G1).
+ */
+export const TENANT_TIERS = [
+  "regulated-commerce",
+  "regulated-marketing",
+  "commerce",
+  "unregulated-marketing",
+] as const;
+export type TenantTier = (typeof TENANT_TIERS)[number];
+
+/**
+ * The canonical surface taxonomy an integration attaches to — the single
+ * vocabulary shared with the compliance-authority axis (`ASSURANCE_SURFACES` in
+ * ./integration/assurance.ts, which is this set projected so `checkout-payment`
+ * shares `commerce` authority; see `surfaceAuthority`).
+ *
+ * `checkout-payment` is the strictly-most-protected sub-surface of commerce
+ * (money, signed cart, payment DOM — sandbox-only, parent code prohibited);
+ * `commerce` carries money without the payment DOM; `regulated` carries the
+ * non-waivable compliance floor; `unregulated-marketing` is content, the one
+ * tier where an acknowledged outside-guarantee can admit parent code.
+ */
+export const SURFACES = ["checkout-payment", "commerce", "regulated", "unregulated-marketing"] as const;
+export type Surface = (typeof SURFACES)[number];
+
+/** Elevated-parent disposition for one matrix cell. */
+export type ElevatedParentDisposition = "prohibited" | "cert-required" | "acknowledge";
+
+export interface CellAuthority {
+  /** Highest non-elevated tier grantable on this cell (platform-adapter ≤ sandbox ≤ server). */
+  maxTier: Exclude<ExecutionTier, "elevated-parent">;
+  /** How the elevated-parent tier is treated here. */
+  elevatedParent: ElevatedParentDisposition;
+}
+
+/**
+ * The binding surface × tenant-tier matrix (D-R2). A (tenantTier, surface) pair
+ * absent from a tier's map is unavailable — default deny. Sandbox/broker is the
+ * default tier on every present cell.
+ *
+ * Elevated-parent dispositions encode ADR 0016 + 0023:
+ *   - `prohibited`  — commerce and checkout/payment surfaces: no parent code path.
+ *   - `cert-required` — regulated surfaces: only pinned-immutable code with a
+ *     capability-specific certification; mutable containers are rejected (Q6).
+ *   - `acknowledge` — eligible unregulated marketing: outside-guarantee record,
+ *     disabled until counsel wording is wired (Q2).
+ */
+export const SURFACE_TENANT_TIER_MATRIX: Record<
+  TenantTier,
+  Partial<Record<Surface, CellAuthority>>
+> = {
+  "regulated-commerce": {
+    "checkout-payment": { maxTier: "sandbox", elevatedParent: "prohibited" },
+    commerce: { maxTier: "server", elevatedParent: "prohibited" },
+    regulated: { maxTier: "server", elevatedParent: "cert-required" },
+    "unregulated-marketing": { maxTier: "server", elevatedParent: "cert-required" },
+  },
+  "regulated-marketing": {
+    regulated: { maxTier: "server", elevatedParent: "cert-required" },
+    "unregulated-marketing": { maxTier: "server", elevatedParent: "cert-required" },
+  },
+  commerce: {
+    "checkout-payment": { maxTier: "sandbox", elevatedParent: "prohibited" },
+    commerce: { maxTier: "server", elevatedParent: "prohibited" },
+    "unregulated-marketing": { maxTier: "server", elevatedParent: "acknowledge" },
+  },
+  "unregulated-marketing": {
+    "unregulated-marketing": { maxTier: "server", elevatedParent: "acknowledge" },
+  },
+};
+
+const NON_ELEVATED_ORDER: Exclude<ExecutionTier, "elevated-parent">[] = [
+  "platform-adapter",
+  "sandbox",
+  "server",
+];
+
+/** The concrete non-elevated tiers allowed on a cell (adapter..maxTier). */
+export function allowedTiersForCell(cell: CellAuthority): Exclude<ExecutionTier, "elevated-parent">[] {
+  const top = NON_ELEVATED_ORDER.indexOf(cell.maxTier);
+  return NON_ELEVATED_ORDER.slice(0, top + 1);
+}
+
+/** Resolve the authority for a (tenantTier, surface) cell, or undefined when the surface is unavailable there. */
+export function resolveCellAuthority(
+  tenantTier: TenantTier,
+  surface: Surface,
+): CellAuthority | undefined {
+  return SURFACE_TENANT_TIER_MATRIX[tenantTier]?.[surface];
+}
+
+// ── Capability classes and the grantable registry ───────────────────────────
+
+export type CapabilityClass =
+  | "lifecycle"
+  | "event"
+  | "broker-data"
+  | "broker-action"
+  | "config"
+  | "consent"
+  | "assurance";
+
+/** Whether a whole capability class is mechanically enforced or is review-only metadata. */
+export const CAPABILITY_CLASS_ENFORCEMENT: Record<CapabilityClass, Enforcement> = {
+  lifecycle: "enforced",
+  event: "enforced",
+  "broker-data": "enforced",
+  "broker-action": "enforced",
+  config: "enforced",
+  consent: "enforced",
+  // The eligibility check is enforced; the guarantee itself is a human/legal claim.
+  assurance: "review-only",
+};
+
+/** Consent purposes (ADR 0022 / 0023 Q3). `essential` is always on and cannot be gated. */
+export const CONSENT_PURPOSES = ["essential", "analytics", "marketing", "personalization"] as const;
+export type ConsentPurpose = (typeof CONSENT_PURPOSES)[number];
+
+export interface CapabilityDef {
+  id: string;
+  class: CapabilityClass;
+  enforcement: Enforcement;
+  /** Consent purpose this capability's runtime effect depends on, when any (the broker enforces it). */
+  requiresConsent?: ConsentPurpose;
+  label: string;
+}
+
+function def(
+  id: string,
+  cls: CapabilityClass,
+  label: string,
+  extra: { requiresConsent?: ConsentPurpose } = {},
+): CapabilityDef {
+  return {
+    id,
+    class: cls,
+    enforcement: CAPABILITY_CLASS_ENFORCEMENT[cls],
+    requiresConsent: extra.requiresConsent,
+    label,
+  };
+}
+
+/**
+ * The closed set of grantable capabilities. Anything not here is unknown and fails
+ * closed. None of these can mutate money, signed cart, compliance state/copy,
+ * payment DOM, identity state, warnings, tax internals, or reach unrestricted PII —
+ * those live only in {@link FORBIDDEN_CAPABILITIES} and are asserted disjoint.
+ */
+export const CAPABILITY_REGISTRY: Readonly<Record<string, CapabilityDef>> = Object.freeze(
+  Object.fromEntries(
+    [
+      // Lifecycle contributions — the fixed, non-protected render phases (charter S1/S2).
+      // The compliance phases (boot, compliance-init, consent-default, age-gate,
+      // navigation-complete) are platform-owned and appear only in PROTECTED_PHASES.
+      def("lifecycle:head-late", "lifecycle", "Contribute to the head after platform compliance boot."),
+      def("lifecycle:body-start", "lifecycle", "Contribute at the start of the body."),
+      def("lifecycle:region-product-aside", "lifecycle", "Render into the product aside region."),
+      def("lifecycle:region-home-section", "lifecycle", "Render into a home section region."),
+      def("lifecycle:region-global-footer", "lifecycle", "Render into the global footer region."),
+      def("lifecycle:body-end", "lifecycle", "Contribute at the end of the body."),
+
+      // Semantic events (charter M3) — anonymous and minimal (M2). Analytics/marketing
+      // topics depend on consent (Q3); cross-site attribution is dropped when unconsented.
+      def("event:page.viewed", "event", "A page was viewed.", { requiresConsent: "analytics" }),
+      def("event:product.viewed", "event", "A product was viewed.", { requiresConsent: "analytics" }),
+      def("event:collection.viewed", "event", "A collection was viewed.", { requiresConsent: "analytics" }),
+      def("event:search.performed", "event", "A search was performed.", { requiresConsent: "analytics" }),
+      def("event:cart.viewed", "event", "The cart was viewed.", { requiresConsent: "analytics" }),
+      def("event:cart.updated", "event", "The anonymous cart changed.", { requiresConsent: "analytics" }),
+      def("event:checkout.started", "event", "Checkout started.", { requiresConsent: "analytics" }),
+      def("event:order.completed", "event", "An order completed (unattributed unless analytics-eligible).", {
+        requiresConsent: "analytics",
+      }),
+
+      // Brokered reads (charter M2) — anonymous, minimal, never PII.
+      def("broker:cart.read", "broker-data", "Read anonymous cart line items and totals (read-only)."),
+      def("broker:catalog.read", "broker-data", "Read public catalog data."),
+      def("broker:consent.read", "broker-data", "Read the current consent snapshot."),
+      def("broker:page-context.read", "broker-data", "Read non-PII page context (surface, locale, currency)."),
+
+      // Brokered actions — mediated by the typed broker; never mutate signed totals or checkout.
+      def("broker:cart.add-line", "broker-action", "Request an add-to-cart via the signed loader (platform prices it)."),
+      def("broker:analytics.emit", "broker-action", "Emit a validated analytics event through the broker.", {
+        requiresConsent: "analytics",
+      }),
+      def("broker:navigate", "broker-action", "Request same-tenant relative navigation."),
+
+      // Public configuration — the app's own public namespace only.
+      def("config:public.read", "config", "Read the app's own public configuration."),
+      def("config:public.write", "config", "Write the app's own public configuration."),
+
+      // Consent purpose contributions — declaring a dependent destination for a purpose.
+      def("consent:analytics", "consent", "Depends on analytics consent."),
+      def("consent:marketing", "consent", "Depends on marketing consent."),
+      def("consent:personalization", "consent", "Depends on personalization consent."),
+
+      // Assurance — review-only records, never mechanical enforcement.
+      def(
+        "assurance:outside-guarantee",
+        "assurance",
+        "Outside-guarantee acknowledgement (eligible unregulated/external surfaces only; Q2-gated).",
+      ),
+      def(
+        "assurance:regulated-parent-cert",
+        "assurance",
+        "Regulated elevated-parent certification claim (proof-gated; ADR 0016 / G2).",
+      ),
+    ].map((d) => [d.id, d]),
+  ),
+);
+
+// ── The unreachable set: forbidden capabilities + protected phases ───────────
+
+/**
+ * Capabilities that are UNREACHABLE — they can never be granted at any tier on any
+ * surface. Each maps to a compliance-floor clause / charter invariant 7. They are
+ * kept out of {@link CAPABILITY_REGISTRY} entirely; requesting one is always denied
+ * `forbidden`, not merely `unknown`.
+ */
+export const FORBIDDEN_CAPABILITIES = [
+  "checkout:mutate-total",
+  "signed-cart:mutate",
+  "compliance-state:mutate",
+  "compliance-copy:mutate",
+  "payment-dom:access",
+  "identity-state:mutate",
+  "warnings:mutate",
+  "tax-internals:mutate",
+  "jurisdiction:approve",
+  "age-gate:mutate",
+  "pii:unrestricted",
+] as const;
+export type ForbiddenCapability = (typeof FORBIDDEN_CAPABILITIES)[number];
+
+/**
+ * Platform-owned lifecycle phases. Storefront compliance code initializes before
+ * tenant/vendor code and cannot be reordered (charter invariant 1); no integration
+ * may contribute to these, so they are unreachable exactly like forbidden scopes.
+ */
+export const PROTECTED_PHASES = [
+  "lifecycle:boot",
+  "lifecycle:compliance-init",
+  "lifecycle:consent-default",
+  "lifecycle:age-gate",
+  "lifecycle:navigation-complete",
+] as const;
+export type ProtectedPhase = (typeof PROTECTED_PHASES)[number];
+
+const REGISTRY_IDS: ReadonlySet<string> = new Set(Object.keys(CAPABILITY_REGISTRY));
+const UNREACHABLE_IDS: ReadonlySet<string> = new Set<string>([
+  ...FORBIDDEN_CAPABILITIES,
+  ...PROTECTED_PHASES,
+]);
+
+/** True when an id can never be granted (forbidden capability or protected phase). */
+export function isUnreachableCapability(id: string): boolean {
+  return UNREACHABLE_IDS.has(id);
+}
+
+/** True when an id is in the closed grantable registry. */
+export function isGrantableCapability(id: string): boolean {
+  return REGISTRY_IDS.has(id);
+}
+
+// ── Binding + request/result contract ───────────────────────────────────────
+
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+
+/** Every grant is bound to exactly one tenant, app, and app version (charter invariants 3/4). */
+export interface IntegrationBinding {
+  tenantId: string;
+  appId: string;
+  version: string;
+}
+
+export interface IntegrationCapabilityRequest {
+  binding: IntegrationBinding;
+  tier: ExecutionTier;
+  surface: Surface;
+  codeForm: CodeForm;
+  /** Requested capability ids from {@link CAPABILITY_REGISTRY}. */
+  capabilities: readonly string[];
+  /** Requested exact-HTTPS CSP origins (the compiler expands profiles; here only shape is validated). */
+  origins?: readonly string[];
+}
+
+/** Server-resolved evaluation context. Every enablement gate defaults off, so elevated-parent is disabled by default. */
+export interface IntegrationContext {
+  tenantTier: TenantTier;
+  /** A green capability-specific certification for pinned-immutable regulated code (ADR 0016 / G2 / ext-policy-07). */
+  certifiedImmutable?: boolean;
+  /** The outside-guarantee tier is wired with counsel wording and acknowledged (Q2). */
+  outsideGuaranteeEnabled?: boolean;
+}
+
+export type CapabilityDenialReason =
+  | "unbound"
+  | "unknown"
+  | "forbidden"
+  | "surface-unavailable"
+  | "surface-tier-exceeded"
+  | "elevated-parent-prohibited"
+  | "elevated-parent-uncertified"
+  | "elevated-parent-unacknowledged"
+  | "mutable-parent-prohibited"
+  | "origin-invalid";
+
+export interface CapabilityDenial {
+  reason: CapabilityDenialReason;
+  /** The offending value (capability id, origin, tier, or a binding field), when one applies. */
+  subject?: string;
+}
+
+export interface GrantedCapability {
+  id: string;
+  class: CapabilityClass;
+  enforcement: Enforcement;
+  requiresConsent?: ConsentPurpose;
+}
+
+export type IntegrationCapabilityResult =
+  | {
+      ok: true;
+      model: IntegrationCapabilityModel;
+      binding: IntegrationBinding;
+      tier: ExecutionTier;
+      surface: Surface;
+      /** Honest overall enforcement for the granted tier (elevated-parent → review-only). */
+      enforcement: Enforcement;
+      capabilities: GrantedCapability[];
+      origins: string[];
+    }
+  | { ok: false; code: "capability_denied"; denials: CapabilityDenial[] };
+
+function validateBinding(binding: IntegrationBinding, denials: CapabilityDenial[]): void {
+  if (!binding.tenantId) denials.push({ reason: "unbound", subject: "tenantId" });
+  if (!binding.appId) denials.push({ reason: "unbound", subject: "appId" });
+  if (!binding.version || !VERSION_PATTERN.test(binding.version)) {
+    denials.push({ reason: "unbound", subject: "version" });
+  }
+}
+
+function validateTierAndSurface(
+  request: IntegrationCapabilityRequest,
+  context: IntegrationContext,
+  denials: CapabilityDenial[],
+): void {
+  if (!(EXECUTION_TIERS as readonly string[]).includes(request.tier)) {
+    denials.push({ reason: "unknown", subject: request.tier });
+    return;
+  }
+  const cell = resolveCellAuthority(context.tenantTier, request.surface);
+  if (!cell) {
+    denials.push({ reason: "surface-unavailable", subject: request.surface });
+    return;
+  }
+
+  if (request.tier !== "elevated-parent") {
+    if (!allowedTiersForCell(cell).includes(request.tier)) {
+      denials.push({ reason: "surface-tier-exceeded", subject: request.tier });
+    }
+    return;
+  }
+
+  // Elevated-parent: full parent authority, disabled by default. It is reachable
+  // only via an explicit enablement gate that itself defaults off.
+  switch (cell.elevatedParent) {
+    case "prohibited":
+      denials.push({ reason: "elevated-parent-prohibited", subject: request.surface });
+      return;
+    case "cert-required":
+      if (request.codeForm === "mutable-container") {
+        // Q6: merchant-mutable parent code is never certifiable on
+        // regulated surfaces — rejected, never "certified".
+        denials.push({ reason: "mutable-parent-prohibited", subject: request.surface });
+      } else if (!context.certifiedImmutable) {
+        denials.push({ reason: "elevated-parent-uncertified", subject: request.surface });
+      }
+      return;
+    case "acknowledge":
+      if (!context.outsideGuaranteeEnabled) {
+        denials.push({ reason: "elevated-parent-unacknowledged", subject: request.surface });
+      }
+      return;
+  }
+}
+
+/**
+ * Validate a requested integration grant against the closed model. Fail-closed and
+ * all-or-nothing: any unknown, forbidden, unbound, out-of-matrix, or malformed-origin
+ * element denies the whole request (never a partial grant), mirroring `validateScopes`.
+ */
+export function validateIntegrationCapabilities(
+  request: IntegrationCapabilityRequest,
+  context: IntegrationContext,
+): IntegrationCapabilityResult {
+  const denials: CapabilityDenial[] = [];
+
+  validateBinding(request.binding, denials);
+  validateTierAndSurface(request, context, denials);
+
+  const granted: GrantedCapability[] = [];
+  for (const id of request.capabilities) {
+    if (isUnreachableCapability(id)) {
+      denials.push({ reason: "forbidden", subject: id });
+      continue;
+    }
+    const cap = CAPABILITY_REGISTRY[id];
+    if (!cap) {
+      denials.push({ reason: "unknown", subject: id });
+      continue;
+    }
+    granted.push({
+      id: cap.id,
+      class: cap.class,
+      enforcement: cap.enforcement,
+      requiresConsent: cap.requiresConsent,
+    });
+  }
+
+  const origins = [...(request.origins ?? [])];
+  for (const origin of origins) {
+    if (!isExactOrigin(origin)) denials.push({ reason: "origin-invalid", subject: origin });
+  }
+
+  if (denials.length > 0) {
+    return { ok: false, code: "capability_denied", denials };
+  }
+
+  return {
+    ok: true,
+    model: INTEGRATION_CAPABILITY_MODEL,
+    binding: request.binding,
+    tier: request.tier,
+    surface: request.surface,
+    enforcement: EXECUTION_TIER_ENFORCEMENT[request.tier],
+    capabilities: granted,
+    origins,
+  };
+}

package/packages/public-runtime/src/membership.ts

@@ -1,6 +1,6 @@
 /**
  * Membership + Autopilot (subscription) purchase MECHANICS — the renderer-safe
- * pricing/eligibility engine (F10). This is the real, testable side of the
+ * pricing/eligibility engine. This is the real, testable side of the
  * education-only widgets in `lib/membership` / `lib/subscription`: it computes
  * member-vs-list pricing, composes a member discount with a subscription
  * (Autopilot) discount under a tenant-configurable STACKING policy, and decides
@@ -280,7 +280,7 @@ export interface MemberSignedCartPayloadOptions {
 
 /**
  * Build a signed add-to-cart payload whose price is the MEMBER-ADJUSTED effective
- * price for the resolved shopper (F11b) — never the raw list price. The effective
+ * price for the resolved shopper — never the raw list price. The effective
  * price is computed here, server-side, from {@link priceForPurchaseOption} (the
  * single signed source of truth) using the membership eligibility resolved for
  * this request, then HMAC-signed by {@link buildVariantCartPayload}.

package/packages/public-runtime/src/raw-html-policy.ts

@@ -7,7 +7,7 @@
  * gates remain non-removable.
  */
 import type { TenantConfig } from "./tenant.js";
-import { resolveComplianceObligations } from "./capabilities.js";
+import { isRegulated } from "./compliance-obligations.js";
 
 export interface RawHtmlPolicyDecision {
   allowed: boolean;
@@ -18,9 +18,7 @@ export interface RawHtmlPolicyDecision {
 export function rawHtmlPolicy(
   tenant: Pick<TenantConfig, "siteType" | "compliance">,
 ): RawHtmlPolicyDecision {
-  const obligations = resolveComplianceObligations(tenant);
-  const regulated =
-    obligations.ageVerification.required || obligations.exciseTax.required;
+  const regulated = isRegulated(tenant);
 
   if (regulated) {
     return {