@appfunnel-dev/sdk 2.0.0-canary.5 → 2.0.0-canary.8

package/dist/chunk-VW2HVPR4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/i18n/locale.ts","../src/commerce/money.ts","../src/flow/spine.ts","../src/flow/experiments.ts","../src/manifest/manifest.ts"],"names":[],"mappings":"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","file":"chunk-VW2HVPR4.js","sourcesContent":["/**\n * Pure locale resolution — no React. Split out of {@link ./translation} so the\n * server/tooling entry (`@appfunnel-dev/sdk/manifest`) can resolve a visitor's\n * locale without pulling component code. {@link ./translation} re-exports it.\n */\n\nimport type { FunnelLocales } from '../flow/spine'\n\nexport type Direction = 'ltr' | 'rtl'\n\nconst RTL_LANGS = new Set(['ar', 'he', 'fa', 'ur', 'ps', 'sd', 'dv', 'yi'])\n\n/** Whether a locale is right-to-left (by language subtag). */\nexport function isRtl(locale: string): boolean {\n  return RTL_LANGS.has(locale.split('-')[0])\n}\n\nconst base = (l: string | undefined): string | undefined => l?.split('-')[0]\n\n/**\n * Resolve the active locale: `override` (URL/param) → `detected` (device) →\n * funnel default, each only if supported (matched by exact tag or language\n * subtag). Mirrors doc 05's resolution chain (the geo/header steps happen\n * server-side and arrive via `override`/`detected`).\n */\nexport function resolveLocale(\n  config: FunnelLocales | undefined,\n  detected: string,\n  override?: string,\n): string {\n  const supported = config?.supported ?? (config?.default ? [config.default] : ['en'])\n  const def = config?.default ?? supported[0] ?? 'en'\n  const pick = (l?: string): string | undefined => {\n    if (!l) return undefined\n    if (supported.includes(l)) return l\n    return supported.find((s) => base(s) === base(l))\n  }\n  return pick(override) ?? pick(detected) ?? def\n}\n","/**\n * Pure catalog math — no React, no I/O. Split out of {@link ./catalog} so the\n * server/tooling entry (`@appfunnel-dev/sdk/manifest`) can compile/resolve\n * offerings without pulling react-dom or any component code into its graph.\n * {@link ./catalog} re-exports everything here and adds the React wiring.\n */\n\n// ── Shape ────────────────────────────────────────────────\n\nexport type Interval = 'day' | 'week' | 'month' | 'year' | 'one_time'\n\n/** What the platform hands the funnel per offering (a single provider-resolved price). */\nexport interface OfferingInput {\n  id: string\n  /** The catalog charge KEY this input charges (the slot's assignment). Defaults to `id` (legacy/identity slots). */\n  catalogKey?: string\n  name?: string\n  displayName?: string\n  /** Provider-resolved price in **minor units** (the provider chose the currency). */\n  amount: number\n  /** Currency of `amount`, as the provider resolved it (e.g. `DKK`). */\n  currency: string\n  interval?: Interval\n  intervalCount?: number\n  trialDays?: number\n  /** Trial price in minor units (omit/0 = free trial). */\n  trialAmount?: number\n  /** Settlement provider — opaque to the author, used by the checkout driver. */\n  provider?: string\n}\n\n/** A money value with a locale-formatted string. */\nexport interface Money {\n  /** Major units, e.g. `79`. */\n  amount: number\n  /** Minor units, e.g. `7900`. */\n  minor: number\n  currency: string\n  /** Locale-formatted, e.g. `kr 79,00` / `€9,99` / `$9.99`. */\n  formatted: string\n}\n\n/**\n * The offering with its amounts resolved (currency + period math), **before**\n * locale formatting — what the catalog stores. `useOffering` formats it.\n */\nexport interface ResolvedOffering {\n  id: string\n  /** The catalog charge KEY charged (the CHARGE identity; `id` is the SLOT/display identity). */\n  catalogKey: string\n  name: string\n  displayName: string\n  provider: string\n  currency: string\n  priceMinor: number\n  perDayMinor: number\n  perWeekMinor: number\n  perMonthMinor: number\n  perYearMinor: number\n  period: string\n  periodly: string\n  hasTrial: boolean\n  trialDays: number\n  trialMinor: number\n}\n\n/** Display-ready offering the author reads (every amount locale-formatted). */\nexport interface Offering {\n  id: string\n  /** The catalog charge KEY charged (the CHARGE identity; `id` is the SLOT/display identity). */\n  catalogKey: string\n  name: string\n  displayName: string\n  provider: string\n  price: Money\n  /** e.g. `month`, `quarter`, `one-time`. */\n  period: string\n  /** e.g. `monthly`, `quarterly`, `one-time`. */\n  periodly: string\n  /** Period-normalized prices (for \"just $0.27/day\" style copy). */\n  perDay: Money\n  perWeek: Money\n  perMonth: Money\n  perYear: Money\n  hasTrial: boolean\n  trialDays: number\n  trialPrice: Money | null\n}\n\n// ── Resolve (currency-agnostic) ──────────────────────────\n\n/**\n * The period model: the **day is the canonical unit** and every interval is a\n * consistent number of days — `year = 365`, `month = 365/12` (~30.42),\n * `week = 7`. Consistent means the derived periods are exact multiples of each\n * other: a monthly offering's `perMonthMinor` is its price, its `perYearMinor`\n * is exactly `12×` the price, and a yearly offering's `perMonthMinor` is exactly\n * `price / 12` — no 360-vs-365 drift (the old `month = 30` model made a yearly\n * plan's \"per month\" ~1.4% off).\n */\nconst PERIOD_DAYS: Record<Interval, number> = {\n  day: 1, week: 7, month: 365 / 12, year: 365, one_time: 0,\n}\n\nfunction periodDays(interval: Interval, count: number): number {\n  return PERIOD_DAYS[interval] * count\n}\n\nfunction intervalLabel(interval: Interval, count: number): { period: string; periodly: string } {\n  if (interval === 'one_time') return { period: 'one-time', periodly: 'one-time' }\n  if (interval === 'month' && count === 3) return { period: 'quarter', periodly: 'quarterly' }\n  if (interval === 'month' && count === 6) return { period: '6 months', periodly: 'semiannually' }\n  if (interval === 'week' && count === 2) return { period: '2 weeks', periodly: 'biweekly' }\n  if (count === 1) {\n    const periodly = { day: 'daily', week: 'weekly', month: 'monthly', year: 'yearly' }[interval]\n    return { period: interval, periodly }\n  }\n  return { period: `${count} ${interval}s`, periodly: `every ${count} ${interval}s` }\n}\n\n/**\n * Resolve an {@link OfferingInput} into amounts + period math (no formatting yet).\n * Per-period amounts are **integer minor units** (each derived from the exact\n * daily rate, then rounded — never round-then-multiply, so error doesn't compound).\n */\nexport function resolveOffering(input: OfferingInput): ResolvedOffering {\n  const interval = input.interval ?? 'one_time'\n  const count = input.intervalCount ?? 1\n  const days = periodDays(interval, count)\n  // Derive each period from the exact price/days ratio, rounding each result\n  // independently to whole minor units.\n  const per = (targetDays: number): number =>\n    days > 0 ? Math.round((input.amount * targetDays) / days) : input.amount\n  const label = intervalLabel(interval, count)\n  // A paid trial can be \"N days for X\" OR an intro price with no day count —\n  // a set trialAmount alone still makes it a trial (trialDays: 0 must not\n  // swallow the trial price).\n  const trialDays = input.trialDays ?? 0\n  const trialMinor = input.trialAmount ?? 0\n\n  return {\n    id: input.id,\n    catalogKey: input.catalogKey ?? input.id,\n    name: input.name ?? input.id,\n    displayName: input.displayName ?? input.name ?? input.id,\n    provider: input.provider ?? 'stripe',\n    currency: input.currency,\n    priceMinor: input.amount,\n    perDayMinor: per(1),\n    perWeekMinor: per(7),\n    perMonthMinor: per(365 / 12),\n    perYearMinor: per(365),\n    period: label.period,\n    periodly: label.periodly,\n    hasTrial: trialDays > 0 || trialMinor > 0,\n    trialDays,\n    trialMinor,\n  }\n}\n\n/** Build the id → {@link ResolvedOffering} catalog. Formatting happens at read time. */\nexport function buildCatalog(inputs: OfferingInput[]): Map<string, ResolvedOffering> {\n  return new Map(inputs.map((i) => [i.id, resolveOffering(i)]))\n}\n\n// ── Format (locale-dependent) ────────────────────────────\n\n/** currency code → minor-unit exponent, resolved once via Intl (JPY→0, KWD→3, …). */\nconst EXPONENT_CACHE = new Map<string, number>()\n\n/**\n * The minor-unit exponent for a currency (`USD`→2, `JPY`→0, `KWD`/`BHD`→3),\n * derived from `Intl.NumberFormat(...).resolvedOptions().maximumFractionDigits`\n * with a fallback of 2 for unknown/invalid codes.\n */\nexport function currencyExponent(currency: string): number {\n  const code = currency.toUpperCase()\n  const hit = EXPONENT_CACHE.get(code)\n  if (hit !== undefined) return hit\n  let exp = 2\n  try {\n    exp = new Intl.NumberFormat('en', { style: 'currency', currency: code })\n      .resolvedOptions().maximumFractionDigits ?? 2\n  } catch {\n    exp = 2\n  }\n  EXPONENT_CACHE.set(code, exp)\n  return exp\n}\n\n/** Format minor units of `currency` in `locale` (exponent-aware: 7900 JPY = ¥7,900). */\nexport function formatMoney(minor: number, currency: string, locale: string): Money {\n  const code = currency.toUpperCase()\n  const exp = currencyExponent(code)\n  const amount = minor / 10 ** exp\n  let formatted: string\n  try {\n    formatted = new Intl.NumberFormat(locale, { style: 'currency', currency: code }).format(amount)\n  } catch {\n    formatted = `${code} ${amount.toFixed(exp)}`\n  }\n  return { amount, minor, currency: code, formatted }\n}\n\n/** Format a {@link ResolvedOffering} into a display {@link Offering} in `locale`. */\nexport function formatOffering(r: ResolvedOffering, locale: string): Offering {\n  const m = (minor: number): Money => formatMoney(minor, r.currency, locale)\n  return {\n    id: r.id,\n    catalogKey: r.catalogKey,\n    name: r.name,\n    displayName: r.displayName,\n    provider: r.provider,\n    price: m(r.priceMinor),\n    period: r.period,\n    periodly: r.periodly,\n    perDay: m(r.perDayMinor),\n    perWeek: m(r.perWeekMinor),\n    perMonth: m(r.perMonthMinor),\n    perYear: m(r.perYearMinor),\n    hasTrial: r.hasTrial,\n    trialDays: r.trialDays,\n    trialPrice: r.hasTrial ? m(r.trialMinor) : null,\n  }\n}\n","import type { ComponentType } from 'react'\nimport type { VariableConfig, VariableValue } from '../types'\nimport type { FunnelContext } from '../state/context'\n\n/**\n * The funnel **spine** — the constrained, declarative configuration authored as\n * code (`defineFunnel` / `pageMeta` / `definePage`) yet **dashboard-editable**\n * (static AST parse → pretty UI → codegen) and compiled to the manifest IR.\n *\n * Principle: **presentation = code** (the page components), **configuration =\n * data** (this spine). See docs/platform-v2/06-funnel-project-model.md.\n *\n * Routing is **declarative nodes + code predicates** (decided — doc 06): a\n * page's `next` is an ordered list of {@link Route}s, each with a **static `to`\n * page key** (so the dashboard can draw every possible edge without executing\n * anything) and an optional `when` **gate** that returns true/false. The gate is\n * either a declarative {@link Condition} (one field — UI-editable data) or a code\n * {@link Predicate} (`s => boolean` — the escape hatch, opaque body but the edge\n * is still visible). First matching route wins; a route with no `when` is the\n * fallback. Multiple conditions = multiple routes (or boolean logic in one\n * predicate). Omit `next` entirely for the default linear flow.\n */\n\n// ── Snapshot (what a predicate sees) ─────────────────────\n\n/**\n * Read-only view of every namespace a routing/condition predicate can branch\n * on. `user`/`responses`/`data` are the writable namespaces; `context` is the\n * read-only computed one ({@link FunnelContext}).\n */\nexport interface FunnelSnapshot {\n\tuser: Record<string, VariableValue>\n\tresponses: Record<string, VariableValue>\n\tdata: Record<string, VariableValue>\n\tcontext: FunnelContext\n}\n\n/** A code-predicate gate — `s => s.responses.goal === 'gain'`. */\nexport type Predicate = (s: FunnelSnapshot) => boolean\n\nexport type ConditionOp =\n\t| 'eq'\n\t| 'neq'\n\t| 'in'\n\t| 'gt'\n\t| 'gte'\n\t| 'lt'\n\t| 'lte'\n\t| 'exists'\n\t| 'empty'\n\t| 'contains'\n\n/**\n * A declarative gate over **one** namespaced field — UI-editable data the\n * dashboard renders as a condition row (`field` `op` `value`). `field` is a\n * dotted path into the snapshot: `responses.goal`, `user.country`,\n * `context.device.isMobile`.\n */\nexport interface Condition {\n\tfield: string\n\top: ConditionOp\n\tvalue?: VariableValue | VariableValue[]\n}\n\n/** An edge gate: either declarative data ({@link Condition}) or a {@link Predicate}. */\nexport type Gate = Condition | Predicate\n\n/**\n * One routing edge out of a page. `to` is a **static** target key (the dashboard\n * reads these to draw the flow graph); `when` gates the edge (omit = fallback).\n */\nexport interface Route {\n\tto: string\n\twhen?: Gate\n}\n\n/** Read a dotted path out of the snapshot (flat namespaces + nested `context`). */\nfunction readField(s: FunnelSnapshot, field: string): VariableValue {\n\tlet cur: unknown = s\n\tfor (const part of field.split('.')) {\n\t\tif (cur == null) return undefined\n\t\tcur = (cur as Record<string, unknown>)[part]\n\t}\n\treturn cur as VariableValue\n}\n\n/** Evaluate a declarative {@link Condition} against a snapshot. */\nexport function evaluateCondition(cond: Condition, s: FunnelSnapshot): boolean {\n\tconst val = readField(s, cond.field)\n\tconst { op, value } = cond\n\tswitch (op) {\n\t\tcase 'eq':\n\t\t\treturn val === value\n\t\tcase 'neq':\n\t\t\treturn val !== value\n\t\tcase 'in':\n\t\t\treturn (\n\t\t\t\tArray.isArray(value) &&\n\t\t\t\t(value as VariableValue[]).includes(val as VariableValue)\n\t\t\t)\n\t\tcase 'gt':\n\t\t\treturn (\n\t\t\t\ttypeof val === 'number' &&\n\t\t\t\ttypeof value === 'number' &&\n\t\t\t\tval > value\n\t\t\t)\n\t\tcase 'gte':\n\t\t\treturn (\n\t\t\t\ttypeof val === 'number' &&\n\t\t\t\ttypeof value === 'number' &&\n\t\t\t\tval >= value\n\t\t\t)\n\t\tcase 'lt':\n\t\t\treturn (\n\t\t\t\ttypeof val === 'number' &&\n\t\t\t\ttypeof value === 'number' &&\n\t\t\t\tval < value\n\t\t\t)\n\t\tcase 'lte':\n\t\t\treturn (\n\t\t\t\ttypeof val === 'number' &&\n\t\t\t\ttypeof value === 'number' &&\n\t\t\t\tval <= value\n\t\t\t)\n\t\tcase 'contains':\n\t\t\tif (typeof val === 'string') return val.includes(String(value))\n\t\t\tif (Array.isArray(val))\n\t\t\t\treturn (val as VariableValue[]).includes(value as VariableValue)\n\t\t\treturn false\n\t\tcase 'exists':\n\t\t\treturn val !== undefined && val !== null && val !== ''\n\t\tcase 'empty':\n\t\t\treturn (\n\t\t\t\tval === undefined ||\n\t\t\t\tval === null ||\n\t\t\t\tval === '' ||\n\t\t\t\t(Array.isArray(val) && val.length === 0)\n\t\t\t)\n\t\tdefault:\n\t\t\treturn false\n\t}\n}\n\n/** Evaluate either gate kind to a boolean. */\nexport function evaluateGate(gate: Gate, s: FunnelSnapshot): boolean {\n\treturn typeof gate === 'function' ? gate(s) : evaluateCondition(gate, s)\n}\n\n/**\n * Resolve an ordered list of routes to a target page key, or `undefined` to fall\n * through to the linear next. First route whose gate passes (or has no `when`)\n * wins.\n */\nexport function resolveRoute(\n\troutes: Route[] | undefined,\n\ts: FunnelSnapshot\n): string | undefined {\n\tif (!routes) return undefined\n\tfor (const route of routes) {\n\t\tif (!route.when || evaluateGate(route.when, s)) return route.to\n\t}\n\treturn undefined\n}\n\n// ── Pages ────────────────────────────────────────────────\n\nexport type PageType =\n\t| 'default' // plain content/step page (the baseline)\n\t| 'email-capture' // collects user.email — the mandatory identity step (validated)\n\t| 'paywall' // the offer/pricing page → drives paywall-view + paywall-CR\n\t| 'upsell' // post-purchase one-click → drives Upsell Rate + off-session charge\n\t| 'finish' // terminal success/thank-you page → completion analytics, ends the flow\n\nexport interface PageMeta {\n\t/** Page kind — drives behavior + analytics (e.g. `paywall`, `upsell`). */\n\ttype?: PageType\n\t/** URL slug; defaults to the page key. */\n\tslug?: string\n\t/**\n\t * Ordered routing edges out of this page (first match wins). Each has a static\n\t * `to` key + an optional `when` gate. Omit for the default linear flow.\n\t *\n\t * OPTIONAL per-variant routing: a `@variant` page (`paywall@b`) MAY carry its own\n\t * `next`. When that variant is the one served for its slot, its `next` governs\n\t * routing for that visitor; absent, the variant inherits the slot's routing (the\n\t * default — a pure superset, no behavior change for existing funnels). Assignment,\n\t * exposure, and progress still anchor on the slot; only the next-page lookup\n\t * consults the served variant's routes. See {@link FunnelPage}.\n\t */\n\tnext?: Route[]\n\t/**\n\t * Entry precondition for **deep-link / reload** restoration. When the runtime is\n\t * asked to start *on this page* (not via in-funnel navigation), it restores there\n\t * only if `guard` passes against the restored snapshot — otherwise it falls back\n\t * to the start page. e.g. an upsell page: `guard: s => s.data.purchased === true`.\n\t * Reaching the page via `next()` is unaffected (routing already gated it). Omit =\n\t * always restorable. Same gate kind as routing (`Condition` or predicate).\n\t */\n\tguard?: Gate\n\t/**\n\t * BUILD-TIME PRERENDER OPT-OUT (SSR-isolation Option B, FIX 2). Set `dynamic: true` (alias\n\t * `prerender: false`) on a page whose **structure** (which sections exist — not just their text\n\t * values) depends on the visitor's `sessionValues`. Such a page can't be prerendered flash-free:\n\t * the default-state markup would structurally differ from the value-applied render and reflow\n\t * after hydration. Opting out makes the build SKIP prerendering it, so the renderer serves it via\n\t * live SSR (the same fallback branch a build with no prerender entry already uses) — correct\n\t * first paint, no pop-in. Value-only variation (text/price into a fixed structure) does NOT need\n\t * this: deferred defaults make it flash-free. Omit = prerendered (the default).\n\t */\n\tdynamic?: boolean\n\t/** @see {@link PageMeta.dynamic} — `prerender: false` is the inverse alias (author preference). */\n\tprerender?: boolean\n}\n\n/**\n * Identity helper for a page's co-located metadata.\n * `export const meta = pageMeta({ type: 'paywall', next: s => … })`.\n */\nexport function pageMeta(meta: PageMeta): PageMeta {\n\treturn meta\n}\n\n/**\n * Default entry guard implied by a page **type** — a built-in precondition every\n * funnel inherits. `paywall` and `upsell` require a captured `user.email` (the\n * mandatory identity step), so a deep-link / reload straight into them without\n * email bounces to the start. Authors don't write this; an explicit `meta.guard`\n * **overrides** it (see {@link entryGuard}).\n */\nconst TYPE_GUARDS: Partial<Record<PageType, Gate>> = {\n\tpaywall: { field: 'user.email', op: 'exists' },\n\tupsell: { field: 'user.email', op: 'exists' },\n}\n\n/**\n * The effective entry guard for a page: an explicit `meta.guard` if the author set\n * one, **otherwise** the page-type default (e.g. paywall/upsell need email). The\n * explicit guard fully **overrides** the default — it's not combined. Returns\n * `undefined` when neither applies.\n */\nexport function entryGuard(meta?: PageMeta): Gate | undefined {\n\treturn meta?.guard ?? (meta?.type ? TYPE_GUARDS[meta.type] : undefined)\n}\n\n/**\n * Identity helper for a page component. The page is plain React that reaches the\n * runtime through hooks (`useResponse`, `useNavigation`, …) — there is no `sdk`\n * prop. `export default definePage(function Welcome() { … })`.\n */\nexport function definePage<P extends object = Record<string, never>>(\n\tcomponent: ComponentType<P>\n): ComponentType<P> {\n\treturn component\n}\n\n// ── Flow resolution ──────────────────────────────────────\n\n/** A page in the flow: its key + (optional) co-located meta. */\nexport interface FlowPage {\n\tkey: string\n\tmeta?: PageMeta\n}\n\n/**\n * A page as declared in `funnel.ts` — the key + its metadata, flattened. This is the\n * AUTHORED shape (funnel.ts owns the page list, order, and routing); the build generates\n * the code-split `mount.tsx` from it. Routing (`next`) must stay DECLARATIVE (Route[] with\n * `{ to, when }` conditions, no predicate functions) so the web builder UI can edit it.\n *\n * OPTIONAL variant routing (default off): a served variant's OWN routing is authored by\n * declaring the variant here with its `@` key and a `next`, e.g.\n * `{ key: 'paywall@b', next: [{ to: 'special-offer' }] }`. A variant declared this way keys\n * on the `@` marker, so it still collapses out of the linear flow (it is NOT a linear step);\n * its `next` is consulted only when that variant is the one served for its slot. Omit the\n * declaration (leave the variant an undeclared `pages/<slot>@<v>.tsx` file) to inherit the\n * slot's routing — the existing behavior, unchanged. The slot's control keeps owning\n * assignment/exposure/progress; only the next-page lookup for a branched variant differs.\n */\nexport interface FunnelPage extends PageMeta {\n\tkey: string\n}\n\n/**\n * Decide the next page from `currentKey`:\n *  1. the current page's `next` routes ({@link resolveRoute}), if one matches, else\n *  2. the next page in file order (the default linear flow), else\n *  3. `undefined` (end of funnel / current key not found).\n */\nexport function nextPage(\n\tpages: FlowPage[],\n\tcurrentKey: string,\n\ts: FunnelSnapshot\n): string | undefined {\n\tconst idx = pages.findIndex((p) => p.key === currentKey)\n\tif (idx === -1) return undefined\n\tconst routed = resolveRoute(pages[idx].meta?.next, s)\n\tif (routed) return routed\n\treturn pages[idx + 1]?.key\n}\n\n/**\n * Every page a visitor *could* go to next from `currentKey` — all route targets\n * (regardless of gate, since we don't know which will pass) plus the linear next.\n * Used to **prefetch** the likely-next page chunks; not for navigation.\n */\nexport function outgoingKeys(pages: FlowPage[], currentKey: string): string[] {\n\tconst idx = pages.findIndex((p) => p.key === currentKey)\n\tif (idx === -1) return []\n\tconst out = new Set<string>()\n\tfor (const route of pages[idx].meta?.next ?? []) out.add(route.to)\n\tconst linear = pages[idx + 1]?.key\n\tif (linear) out.add(linear)\n\treturn [...out]\n}\n\n/**\n * The number of pages on the path from `startKey` to a `finish` (or the end of\n * the flow) **given the current state** — the denominator for progress. It walks\n * the actual routing ({@link nextPage}) rather than counting all files, so a\n * branched funnel reaches 100% on whichever path the visitor's answers select.\n * Re-traced per navigation; a visited set guards against routing cycles.\n */\nexport function expectedPathLength(\n\tpages: FlowPage[],\n\tstartKey: string,\n\ts: FunnelSnapshot\n): number {\n\tconst seen = new Set<string>()\n\tlet key: string | undefined = startKey\n\tlet count = 0\n\twhile (key && !seen.has(key)) {\n\t\tseen.add(key)\n\t\tcount++\n\t\tif (pages.find((p) => p.key === key)?.meta?.type === 'finish') break\n\t\tkey = nextPage(pages, key, s)\n\t}\n\treturn count\n}\n\n// ── Funnel definition ────────────────────────────────────\n\nexport interface FunnelLocales {\n\tdefault: string\n\tsupported: string[]\n\tfallback?: string\n\t/**\n\t * When `true`, a visitor with no explicit language in the URL (no `/​<locale>/` path prefix and no\n\t * `?language=`) is served the best match for their **browser** `Accept-Language` among `supported`\n\t * (base-matched, so `en-GB` → `en`); no match falls back to `default`. When `false`/absent (the\n\t * default), an unspecified visitor always gets `default` — the URL is the only way to switch.\n\t */\n\tautoDetectLanguage?: boolean\n}\n\n/**\n * The funnel-level spine. Flow is mostly inferred from page file order + each\n * page's `next`; this holds the funnel-wide config. Stays **thin** — routing\n * lives co-located on pages (doc 06: \"funnel.ts stays thin\").\n */\nexport interface FunnelDefinition {\n\tid: string\n\t/**\n\t * The funnel's pages — order, type, and declarative routing — the source of truth the\n\t * web builder edits and the build generates `mount.tsx` from. Each `key` maps to a\n\t * `pages/<key>.tsx` component. Omit `pages` on hand-written funnels that still ship their\n\t * own `mount.tsx` (back-compat); new/generated funnels declare them here.\n\t */\n\tpages?: FunnelPage[]\n\t/** Which checkout provider the paywall/checkout uses. The build wires the driver. */\n\tcheckout?: 'stripe' | 'paddle'\n\t/** `responses.*` runtime variables (default values). */\n\tresponses?: Record<string, VariableConfig>\n\t/** `data.*` working/scratch variables (default values). */\n\tdata?: Record<string, VariableConfig>\n\t/**\n\t * The catalog offerings this funnel sells, as SLOTS: a local, stable key each PAGE\n\t * references (`useOffering('primary')`, `<Checkout offering=\"primary\">`) → the catalog charge\n\t * KEY it's assigned to. Swap the assignment to change the offer WITHOUT touching page code;\n\t * `null` = a declared-but-unassigned slot. A bare `string[]` is legacy sugar for IDENTITY\n\t * slots (`['pro'] ≡ { pro: 'pro' }`) — every existing funnel keeps working. Prices resolve\n\t * from the project catalog per environment (Live/Test) at render.\n\t */\n\tofferings?: string[] | Record<string, string | null>\n\tlocales?: FunnelLocales\n\t/**\n\t * When `true`, the funnel shows the **geo-specific** currency/price the payment\n\t * provider resolves (Stripe `currency_options`, Paddle preview, Whop, SolidGate,\n\t * …). When `false` (default), a single fixed currency is used. Appfunnel does no\n\t * FX — this only toggles whether the platform asks the provider for the geo\n\t * price; the SDK just displays whatever resolved `{amount, currency}` it's handed.\n\t * (See docs/platform-v2 phase-3 §3.6.)\n\t */\n\tlocationAwareCurrency?: boolean\n}\n\n/** Identity helper for a funnel definition. */\nexport function defineFunnel(def: FunnelDefinition): FunnelDefinition {\n\treturn def\n}\n\n/** A funnel offering SLOT: the local key pages reference → the assigned catalog charge key (null = unassigned). */\nexport interface OfferingSlot {\n\tslot: string\n\tcatalogKey: string | null\n}\n\n/**\n * Normalize `FunnelDefinition.offerings` to a slot list. A legacy `string[]` becomes IDENTITY\n * slots (`['pro'] → [{ slot:'pro', catalogKey:'pro' }]`); a `{ slot: key|null }` map becomes its\n * entries (insertion order preserved, so `useOfferings()` is deterministic).\n */\nexport function normalizeOfferings(\n\tofferings: FunnelDefinition['offerings']\n): OfferingSlot[] {\n\tif (!offerings) return []\n\tif (Array.isArray(offerings))\n\t\treturn offerings.map((k) => ({ slot: k, catalogKey: k }))\n\treturn Object.entries(offerings).map(([slot, catalogKey]) => ({\n\t\tslot,\n\t\tcatalogKey: catalogKey ?? null,\n\t}))\n}\n\n/** The unique, ASSIGNED catalog keys a funnel charges — for the promote gate + catalog reverse-lookup. */\nexport function funnelCatalogKeys(\n\tofferings: FunnelDefinition['offerings']\n): string[] {\n\treturn [\n\t\t...new Set(\n\t\t\tnormalizeOfferings(offerings)\n\t\t\t\t.map((s) => s.catalogKey)\n\t\t\t\t.filter((k): k is string => !!k)\n\t\t),\n\t]\n}\n","/**\n * **Runtime page-level experiments** — A/B/n on a *single page inside one funnel*,\n * resolved at render time (phase-4). No funnel duplication: a slot (e.g. the page\n * `welcome`) has alternate versions filed as siblings (`welcome@b.tsx`), and the\n * runtime shows **one** of them per visitor, collapsing the losers out of the\n * linear flow. The flow keeps stable **slot keys** (the control's key); only the\n * rendered component swaps — so routing, the manifest, and analytics all key on the\n * slot, not the variant.\n *\n * **Where the wiring lives:** the *variant pages* are code (compiled into the\n * bundle). The *experiment wiring* — slot, variant→page map, weights, status — is\n * **operational data the platform owns** (a DB record, edited by the dashboard,\n * changed without recompiling the funnel). The SDK is storage-agnostic: the\n * platform hands the runtime experiment records to `FunnelProvider`, the same way\n * it hands in resolved product prices. This module just resolves them.\n *\n * **The only source-side marker** is the `@` in a variant file's key\n * (`welcome@b`): it tells the *build* (manifest, flow graph) that a page is an\n * off-flow variant of its slot, so the structure is correct without the DB. The\n * label/weight/experiment-id are not in source.\n *\n * Bucketing is a deterministic FNV-1a hash, **namespaced by experiment id** so\n * independent experiments bucket orthogonally (the basis for layering 100+ tests,\n * §4.3). The seed is the durable identity ({@link bucketingSeed}) — never the\n * session/fingerprint — so a returning visitor keeps their variant (landmine #4).\n * Stability across an *add-a-variant* edit is the platform's job: an experiment's\n * variant set is immutable while running (reweighting / adding an arm = a new\n * experiment version), so within one record the assignment never moves.\n *\n * This module is pure (no React, no I/O) → it unit-tests trivially and the\n * dashboard/server can reuse the same assignment math.\n */\n\nimport type { FunnelContext } from '../state/context'\n\n// ── Hashing ──────────────────────────────────────────────\n\n/**\n * FNV-1a 32-bit hash → unsigned int. Deterministic and isomorphic (no `crypto`,\n * runs the same in the browser, a worker, and a build). The same math v0 used,\n * kept because it's sound — only the *seed* changes (identity, not session).\n */\nexport function fnv1a(input: string): number {\n  let h = 0x811c9dc5\n  for (let i = 0; i < input.length; i++) {\n    h ^= input.charCodeAt(i)\n    // h *= 16777619, in uint32, via shift-adds.\n    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0\n  }\n  return h >>> 0\n}\n\n/** Map a seed string to a stable float in `[0, 1)`. */\nexport function hashToUnit(seed: string): number {\n  return fnv1a(seed) / 0x1_0000_0000\n}\n\n/**\n * Pick a variant key by weight from a stable unit position `u ∈ [0,1)`. Variants\n * are walked in declaration order and the first whose cumulative weight band\n * contains `u` wins, so the same `u` always lands in the same variant.\n */\nexport function pickByWeight(weights: Record<string, number>, u: number): string {\n  const entries = Object.entries(weights).filter(([, w]) => w > 0)\n  if (entries.length === 0) return Object.keys(weights)[0] ?? ''\n  const total = entries.reduce((sum, [, w]) => sum + w, 0)\n  const target = u * total\n  let acc = 0\n  for (const [key, w] of entries) {\n    acc += w\n    if (target < acc) return key\n  }\n  return entries[entries.length - 1][0]\n}\n\n/**\n * Deterministically assign a visitor (`seed`) to a variant of one experiment.\n * The hash is **namespaced by `experimentId`** so two experiments on the same\n * traffic don't correlate (orthogonal layering).\n */\nexport function assignVariant(\n  experimentId: string,\n  seed: string,\n  weights: Record<string, number>,\n): string {\n  return pickByWeight(weights, hashToUnit(`${experimentId}:${seed}`))\n}\n\n// ── Seed + slot parsing ──────────────────────────────────\n\n/**\n * The stable bucketing seed: the signed `visitorId`, else the known `customerId`.\n * Never the session id or fingerprint (landmine #4). `null` when neither is known\n * — the caller then serves control instead of bucketing on nothing.\n *\n * visitorId-FIRST (not customerId-first) is deliberate: the customerId injected for an\n * anonymous visitor is minted server-side AFTER the first tracked event, so it is absent on\n * visit 1 and present on visit 2 — seeding on it would flip a returning visitor's arm and\n * count them in two arms of the same version. The signed `af_vid` cookie is the durable\n * identity that's stable from the first pageload, so it seeds; customerId is only the fallback\n * for cookieless SDK embeds. This matches the server-side FUNNEL split, which already seeds on\n * the verified visitorId (resolve.ts). (Cross-device stable bucketing for IDENTIFIED customers\n * is P3's IdentitySDK job, not this anonymous path.)\n */\nexport function bucketingSeed(context: FunnelContext): string | null {\n  return context.identity.visitorId ?? context.identity.customerId ?? null\n}\n\n/** Split a page key into its slot + optional variant: `welcome@b` → `{ slot, variant: 'b' }`. */\nexport function parseSlotKey(key: string): { slot: string; variant?: string } {\n  const at = key.indexOf('@')\n  return at === -1 ? { slot: key } : { slot: key.slice(0, at), variant: key.slice(at + 1) }\n}\n\n/** True if a page key is an off-flow variant (`welcome@b`), by the source-side `@` marker. */\nexport function isVariantKey(key: string): boolean {\n  return parseSlotKey(key).variant !== undefined\n}\n\n// ── Runtime experiment records (platform/DB-sourced) ─────\n\n/** One arm of a running experiment: which page renders, at what weight. */\nexport interface ExperimentArm {\n  /** The page key this arm renders (the slot's control, or a `@variant` sibling). */\n  page: string\n  /** Relative weight in the split (need not sum to 100; zero = paused arm). */\n  weight: number\n}\n\n/**\n * A runtime experiment record — the operational wiring the **platform** owns and\n * hands to the SDK (not authored in the funnel source). Projected from the unified\n * `Experiment`/`ExperimentArm` graph (a RUNNING PAGE experiment + its arms): the\n * experiment's `slot` names the base page, and each arm becomes a `variants` entry\n * `{ page: arm.pageKey, weight: arm.weight }` keyed by `arm.label`. The variant\n * *pages* are code in the LIVE build; this is the live split over them.\n *\n * The serve join only ever hands over RUNNING experiments, and the server's\n * draft-write + serve guards make every active arm's page GUARANTEED present in the\n * LIVE build (an experiment owns its arm pages' lifecycle — you end the experiment to\n * remove a page, you can't drift it away). So there is no lifecycle/winner state and\n * no \"arm page missing\" case to resolve here.\n */\nexport interface RuntimeExperiment {\n  id: string\n  /** The page key holding the flow position (the anchor / the control arm's base page). */\n  slot: string\n  /** label → arm. The control arm's `page` is the `slot`; others are `@variant` siblings. */\n  variants: Record<string, ExperimentArm>\n  /** Primary metric (analytics only; not used for resolution). */\n  metric?: string\n  /** Platform record version (immutable-while-running; reweight = new version). Rides on\n   *  exposure events so results key on (experimentId, version, variant). */\n  version?: number\n}\n\n// ── Flow resolution ──────────────────────────────────────\n\nexport interface ExperimentResolution {\n  /** experiment id → assigned variant label. */\n  assignments: Record<string, string>\n  /** Page keys forming the effective linear flow (variant siblings removed), in order. */\n  activeKeys: string[]\n  /** Slot key → the page key whose component should render there. */\n  render: Record<string, string>\n  /** Variant page key → its slot key. For remapping a route that targets a variant. */\n  slotOf: Record<string, string>\n  /** Slot key → the experiment id it hosts (drives the exposure event). */\n  experimentOf: Record<string, string>\n  /** Experiment id → platform record version (rides on exposure events). */\n  versionOf: Record<string, number>\n}\n\n/**\n * Weights map (label → weight) for one experiment's arms. Exported (via the pure\n * manifest entry) so the server-side FUNNEL split (renderer resolve) projects arms\n * the same way before calling {@link assignVariant}, instead of re-inlining it.\n */\nexport function weightsOf(variants: Record<string, { weight: number }>): Record<string, number> {\n  const out: Record<string, number> = {}\n  for (const [label, v] of Object.entries(variants)) out[label] = v.weight\n  return out\n}\n\n/**\n * Resolve which page version each experiment slot shows for this visitor, and which\n * page keys remain in the linear flow.\n *\n * Variant pages are detected structurally by the `@` in their key, so they collapse\n * out of the linear flow even for a slot with no active experiment. Each served\n * experiment is RUNNING with all its arm pages guaranteed present in the LIVE build\n * (the server draft-write + serve guards enforce the experiment-owned lifecycle\n * invariant), so the visitor is bucketed deterministically on `seed` and the assigned\n * arm's page is swapped in with no presence check. With no `seed` there is nothing\n * stable to bucket on, so every slot renders its own control page.\n */\nexport function resolveExperiments(\n  pages: { key: string }[],\n  experiments: RuntimeExperiment[],\n  seed: string | null,\n): ExperimentResolution {\n  const assignments: Record<string, string> = {}\n  const render: Record<string, string> = {}\n  const experimentOf: Record<string, string> = {}\n  const versionOf: Record<string, number> = {}\n\n  if (seed) {\n    for (const exp of experiments) {\n      const label = assignVariant(exp.id, seed, weightsOf(exp.variants))\n      const arm = exp.variants[label]\n      if (!arm) continue\n      assignments[exp.id] = label\n      experimentOf[exp.slot] = exp.id\n      if (exp.version !== undefined) versionOf[exp.id] = exp.version\n      // Swap in the arm's page when a non-control arm won; the control arm renders the slot itself.\n      if (arm.page !== exp.slot) render[exp.slot] = arm.page\n    }\n  }\n\n  // Variant siblings (`@`) never stand alone in the linear flow (structural, by the\n  // `@` filename marker — independent of any experiment record).\n  const slotOf: Record<string, string> = {}\n  const activeKeys: string[] = []\n  for (const p of pages) {\n    const { slot, variant } = parseSlotKey(p.key)\n    if (variant !== undefined) slotOf[p.key] = slot\n    else activeKeys.push(p.key)\n  }\n\n  return { assignments, activeKeys, render, slotOf, experimentOf, versionOf }\n}\n","/**\n * The **manifest** — the declarative IR a funnel project compiles to (doc 06).\n * It's the machine-readable artifact the platform operates on without executing\n * the funnel: the dashboard draws the flow graph from it, analytics binds to its\n * **stable ids**, validation runs against it, and the renderer reads it to resolve\n * routing.\n *\n * `compileManifest` evaluates the spine (the funnel config + each page's co-located\n * `meta`) into that IR. It's pure — no I/O — so it unit-tests trivially. **It runs\n * server-side**, as the IR step of the publish build over the canonical files in our\n * storage (R2). The client/CLI never produces the authoritative manifest — R2 is the\n * source of truth, the server compiles. (A local dev preview may run it for itself,\n * but that output is never published.)\n *\n * Edge model mirrors the runtime ({@link ../flow/spine}.`nextPage`): a page's\n * `meta.next` routes become **branch** edges (with a serialized condition — a\n * declarative {@link Condition}, or an opaque marker for a code predicate), and the\n * implicit file-order fall-through becomes a **linear** edge (unless an\n * unconditional route already covers it, or the page is a `finish`).\n *\n * Experiments are **not** compiled here. A variant page is recognised structurally\n * by the `@` in its key (`welcome@b`) and tagged `variantOf` + collapsed out of the\n * linear flow; the experiment *wiring* (labels/weights/status) is operational data\n * the platform owns and overlays at render time, not part of the funnel build.\n *\n * Stable ids: the page **key** is the source anchor, so `id === key` here. The\n * durable analytics id is the semantic page name (a slot survives a winner being\n * promoted into it); transient `@variant` pages only ever key analytics by\n * `(experimentId, variant)` in immutable results — a platform concern.\n */\n\nimport type {\n  Condition,\n  FunnelDefinition,\n  FunnelLocales,\n  Gate,\n  PageMeta,\n  PageType,\n} from '../flow/spine'\nimport { normalizeOfferings, funnelCatalogKeys, entryGuard, type OfferingSlot } from '../flow/spine'\nimport { isVariantKey, parseSlotKey } from '../flow/experiments'\nimport type { CheckoutUsageScan } from './offering-refs'\n\nexport interface ManifestPage {\n  id: string\n  key: string\n  type: PageType\n  slug: string\n  index: number\n  /**\n   * Set on a variant page (`welcome@b`) to its **slot** (`welcome`) — a structural\n   * marker that this node is an off-flow alternate, not a linear step. The\n   * experiment *wiring* (label/weight/id) is operational data the platform owns,\n   * not the manifest.\n   */\n  variantOf?: string\n  /**\n   * The page's effective ENTRY guard, serialized (SSR-isolation Option B, FIX 1): a `declarative`\n   * {@link Condition} the renderer can evaluate SERVER-SIDE against the visitor's session snapshot\n   * to pick the right prerendered variant (target vs bounce) without running tenant code, or an\n   * opaque `predicate` marker (author code — the renderer must fall back to live SSR for that\n   * deep-link). Absent = no entry guard (always restorable). Mirrors {@link entryGuard}.\n   */\n  entryGuard?: EdgeCondition\n  /**\n   * BUILD-TIME PRERENDER OPT-OUT (SSR-isolation Option B, FIX 2). True when the page's `meta.dynamic`\n   * (or `prerender: false`) opts it out of prerendering because its STRUCTURE depends on\n   * sessionValues. The prerender stage skips it; the renderer serves it via live SSR.\n   */\n  dynamic?: boolean\n}\n\nexport type EdgeCondition =\n  | { kind: 'declarative'; condition: Condition }\n  /** A code predicate — opaque body; `label` may be supplied later by AST parsing. */\n  | { kind: 'predicate'; label?: string }\n\nexport interface ManifestEdge {\n  from: string\n  to: string\n  kind: 'branch' | 'linear'\n  /** Absent = unconditional (a fallback route, or the linear fall-through). */\n  condition?: EdgeCondition\n  /**\n   * True on a **variant-only branch**: an edge whose `from` is a `@variant` key,\n   * emitted when that served variant carries its OWN `meta.next` (optional divergent\n   * routing). Lets consumers (the editor's Flow canvas) tell a variant's private branch\n   * apart from a normal slot edge. Optional/absent on every non-variant edge.\n   */\n  variant?: true\n}\n\nexport interface ManifestValidation {\n  /**\n   * `ok` = none of the hard errors: the original set (dead ends, unreachable\n   * pages, bad targets, missing email capture) AND the structural errors added\n   * later (duplicate keys, orphan variants, no reachable finish). Slug\n   * collisions are a **warning** — reported but not folded into `ok` (slugs are\n   * display/URL sugar; keys are the routing identity).\n   */\n  ok: boolean\n  /** Page ids you can't proceed from (and that aren't a `finish`). */\n  deadEnds: string[]\n  /** Page ids not reachable from the start. */\n  unreachable: string[]\n  /** Routes whose target page key doesn't exist. */\n  badTargets: { from: string; to: string }[]\n  /** True if the funnel never writes `user.email` (the mandatory identity step). */\n  missingEmailCapture: boolean\n  /** Page keys that appear more than once (keys are the stable ids — hard error). */\n  duplicateKeys: string[]\n  /** Flow pages sharing a slug (URL ambiguity — warning, not folded into `ok`). */\n  slugCollisions: { slug: string; pages: string[] }[]\n  /** Variant pages (`x@b`) whose slot (`x`) doesn't exist as a flow page (hard error). */\n  orphanVariants: string[]\n  /**\n   * True when no `finish` page is reachable from the start — e.g. the flow loops\n   * (a cycle with no exit) or every path stalls before a terminal page. Dead ends\n   * catch pages with no outgoing edge; this catches funnels that *never end* even\n   * though every page can proceed. Hard error.\n   */\n  noReachableFinish: boolean\n  /** Slot names a PAGE references (`useOffering`/`<Checkout offering>`) that the funnel doesn't declare — hard error. */\n  unknownOfferingRefs: string[]\n  /** Declared slots a page references but which have no catalog charge key assigned (map value `null`) — hard error. */\n  unassignedSlots: string[]\n}\n\nexport interface FunnelManifest {\n  id: string\n  pages: ManifestPage[]\n  flow: { start: string | null; nodes: string[]; edges: ManifestEdge[] }\n  /** The unique, ASSIGNED catalog keys the funnel charges (for the promote gate + catalog reverse-lookup). */\n  offerings: string[]\n  /** Offering SLOTS: slot → assigned catalog key|null. `offerings` above is the unique assigned keys. */\n  offeringSlots: OfferingSlot[]\n  /** Slot names PAGES reference (from the build's scan); validated against `offeringSlots`. Absent = no scan ran. */\n  offeringRefs?: string[]\n  /**\n   * The funnel's `checkout:` driver bundle from `funnel.ts` (`FunnelDefinition.checkout`), carried so\n   * the publish gate can cross-validate it against the offerings' RESOLVED provider (§7 item 5 — the\n   * redundant field is never checked today). Absent = the funnel declares no `checkout:`.\n   */\n  checkout?: 'stripe' | 'paddle'\n  /**\n   * Checkout-SURFACE usage the pages express (from `scanOfferingRefs(...).checkout`), carried so the\n   * publish (provider × surface) capability gate can run `validateCheckout`/`validateUpsell`. Absent =\n   * no scan ran (old manifest) → the gate skips capability validation (back-compat, no false blocks).\n   */\n  checkoutRefs?: CheckoutUsageScan\n  locales?: FunnelLocales\n  validation: ManifestValidation\n}\n\nexport interface CompileInput {\n  funnel: FunnelDefinition\n  /** Pages in file order (the default flow); `meta` holds type/slug/next. */\n  pages: { key: string; meta?: PageMeta }[]\n  /** Slot names the funnel's PAGES reference (from `scanOfferingRefs`) — cross-checked against the declared slots. */\n  offeringRefs?: string[]\n  /** Checkout-surface usage the pages express (from `scanOfferingRefs(...).checkout`) — carried onto the manifest for the publish capability gate. */\n  checkoutRefs?: CheckoutUsageScan\n}\n\n/**\n * A **variant** node — a page filed with an `@variant` key (e.g. `welcome@b`).\n * It's an alternate of its slot, not a step in the linear spine, so it gets no\n * linear edge and is excluded from dead-end/reachability checks (the runtime\n * resolves it by bucketing, not by an edge). The `@` is the only source-side\n * signal; the experiment wiring is the platform's operational data. The slot's\n * control (no `@`) stays the flow node. Mirrors {@link resolveExperiments}.\n */\nfunction isVariantNode(page: { key: string }): boolean {\n  return isVariantKey(page.key)\n}\n\n/** Serialize a route gate for the manifest (declarative → data; predicate → opaque). */\nfunction serializeGate(when: Gate | undefined): EdgeCondition | undefined {\n  if (!when) return undefined\n  if (typeof when === 'function') return { kind: 'predicate' }\n  return { kind: 'declarative', condition: when }\n}\n\n/** Compile a funnel's spine into its declarative {@link FunnelManifest} IR. */\nexport function compileManifest(input: CompileInput): FunnelManifest {\n  const { funnel, pages } = input\n  const keys = new Set(pages.map((p) => p.key))\n\n  const manifestPages: ManifestPage[] = pages.map((p, index) => ({\n    id: p.key,\n    key: p.key,\n    type: p.meta?.type ?? 'default',\n    slug: p.meta?.slug ?? p.key,\n    index,\n    variantOf: isVariantKey(p.key) ? parseSlotKey(p.key).slot : undefined,\n    // The effective entry guard (explicit meta.guard, else the page-type default), serialized so\n    // the renderer can evaluate a DECLARATIVE guard server-side (Option B, FIX 1). Predicate guards\n    // serialize to an opaque marker → the renderer falls back to live SSR for that deep-link.\n    entryGuard: serializeGate(entryGuard(p.meta)),\n    // Prerender opt-out: `dynamic: true` OR `prerender: false` (a page whose STRUCTURE depends on\n    // sessionValues — Option B, FIX 2). Undefined stays undefined (prerendered, the default).\n    dynamic: p.meta?.dynamic === true || p.meta?.prerender === false ? true : undefined,\n  }))\n\n  const edges: ManifestEdge[] = []\n  const badTargets: { from: string; to: string }[] = []\n\n  // The next page in file order that is a real flow node (skip `@variant` siblings).\n  const nextAnchor = (from: number) => {\n    for (let j = from + 1; j < pages.length; j++) {\n      if (!isVariantNode(pages[j])) return pages[j]\n    }\n    return undefined\n  }\n\n  pages.forEach((p, i) => {\n    // Variant nodes are alternates of their slot, resolved at runtime by bucketing.\n    // They carry NO linear fall-through (they aren't linear steps) — but a served\n    // variant MAY declare its OWN `meta.next` routes (optional divergent routing).\n    // When present, each route becomes a `branch` edge tagged `variant: true` so the\n    // Flow canvas can draw B's private branch; a variant with no `next` emits nothing\n    // (unchanged behaviour). Targets are validated exactly like a normal route.\n    if (isVariantNode(p)) {\n      for (const route of p.meta?.next ?? []) {\n        if (!keys.has(route.to)) {\n          badTargets.push({ from: p.key, to: route.to })\n          continue\n        }\n        edges.push({ from: p.key, to: route.to, kind: 'branch', variant: true, condition: serializeGate(route.when) })\n      }\n      return\n    }\n\n    const routes = p.meta?.next ?? []\n    let hasUnconditional = false\n    for (const route of routes) {\n      if (!keys.has(route.to)) {\n        badTargets.push({ from: p.key, to: route.to })\n        continue\n      }\n      edges.push({ from: p.key, to: route.to, kind: 'branch', condition: serializeGate(route.when) })\n      if (!route.when) hasUnconditional = true\n    }\n    // Linear fall-through, unless an unconditional route already covers it,\n    // this is a `finish` page, or there is no next page.\n    const next = nextAnchor(i)\n    if (!hasUnconditional && next && p.meta?.type !== 'finish') {\n      edges.push({ from: p.key, to: next.key, kind: 'linear' })\n    }\n  })\n\n  // The start is the first real flow node (a leading variant can't be the entry).\n  const startPage = pages.find((p) => !isVariantNode(p))\n  const start = startPage?.key ?? null\n  const variantKeys = new Set(pages.filter(isVariantNode).map((p) => p.key))\n  const offeringSlots = normalizeOfferings(funnel.offerings)\n  const validation = validate(manifestPages, edges, badTargets, start, variantKeys, offeringSlots, input.offeringRefs)\n\n  return {\n    id: funnel.id,\n    pages: manifestPages,\n    flow: { start, nodes: manifestPages.map((p) => p.id), edges },\n    offerings: funnelCatalogKeys(funnel.offerings),\n    offeringSlots,\n    offeringRefs: input.offeringRefs,\n    // Carry the funnel.ts `checkout:` bundle + the scanned checkout-surface usage for the publish\n    // capability gate. Both are provider-agnostic here (the SDK can't resolve offering→provider);\n    // the API gate combines them with the DB-resolved provider to run the (provider × surface) matrix.\n    checkout: funnel.checkout,\n    checkoutRefs: input.checkoutRefs,\n    locales: funnel.locales,\n    validation,\n  }\n}\n\nfunction validate(\n  pages: ManifestPage[],\n  edges: ManifestEdge[],\n  badTargets: { from: string; to: string }[],\n  start: string | null,\n  variantKeys: Set<string>,\n  slots: OfferingSlot[],\n  offeringRefs: string[] | undefined,\n): ManifestValidation {\n  const outgoing = new Map<string, number>()\n  for (const e of edges) outgoing.set(e.from, (outgoing.get(e.from) ?? 0) + 1)\n\n  // Variant nodes are resolved by bucketing, not edges — they're neither dead\n  // ends nor unreachable in the flow-graph sense, so exclude them from both.\n  const deadEnds = pages\n    .filter((p) => p.type !== 'finish' && !variantKeys.has(p.id) && !(outgoing.get(p.id)! > 0))\n    .map((p) => p.id)\n\n  // Reachability from the start over the edge set.\n  const reachable = new Set<string>()\n  if (start) {\n    const adj = new Map<string, string[]>()\n    for (const e of edges) {\n      const list = adj.get(e.from)\n      if (list) list.push(e.to)\n      else adj.set(e.from, [e.to])\n    }\n    // A variant is reached by BUCKETING from its slot, not by a flow edge — so for\n    // reachability, treat a reachable slot as reaching its variants. Without this, a\n    // page that ONLY a variant's own branch routes to (its slot has no such route)\n    // would be wrongly flagged unreachable; with it, the variant's branch targets\n    // ride the slot's reachability. (Variant keys stay excluded from `unreachable`.)\n    for (const p of pages) {\n      if (p.variantOf === undefined) continue\n      const list = adj.get(p.variantOf)\n      if (list) list.push(p.id)\n      else adj.set(p.variantOf, [p.id])\n    }\n    const stack = [start]\n    while (stack.length) {\n      const id = stack.pop()!\n      if (reachable.has(id)) continue\n      reachable.add(id)\n      for (const to of adj.get(id) ?? []) stack.push(to)\n    }\n  }\n  const unreachable = pages\n    .filter((p) => !variantKeys.has(p.id) && !reachable.has(p.id))\n    .map((p) => p.id)\n\n  // The funnel must capture user.email somewhere (doc 06). We can see the typed\n  // `email-capture` page; deeper detection (any user.email write) is a build-time\n  // AST concern. Treat presence of an `email-capture` page as satisfying it.\n  const missingEmailCapture = !pages.some((p) => p.type === 'email-capture')\n\n  // Duplicate page keys — keys are the stable analytics/routing ids, so two\n  // pages sharing one is a hard error (edges/experiments become ambiguous).\n  const seen = new Set<string>()\n  const duplicateKeys: string[] = []\n  for (const p of pages) {\n    if (seen.has(p.key) && !duplicateKeys.includes(p.key)) duplicateKeys.push(p.key)\n    seen.add(p.key)\n  }\n\n  // Slug collisions among FLOW pages (variants never route by their own slug —\n  // they render under their slot's URL). Warning: keys stay unambiguous.\n  const bySlug = new Map<string, string[]>()\n  for (const p of pages) {\n    if (variantKeys.has(p.id)) continue\n    const list = bySlug.get(p.slug)\n    if (list) list.push(p.id)\n    else bySlug.set(p.slug, [p.id])\n  }\n  const slugCollisions = [...bySlug.entries()]\n    .filter(([, ids]) => ids.length > 1)\n    .map(([slug, ids]) => ({ slug, pages: ids }))\n\n  // Orphan variants — a `x@b` page whose slot `x` doesn't exist as a flow page.\n  // The runtime could never bucket into it (no anchor in the flow) → hard error.\n  const flowKeys = new Set(pages.filter((p) => !variantKeys.has(p.id)).map((p) => p.key))\n  const orphanVariants = pages\n    .filter((p) => p.variantOf !== undefined && !flowKeys.has(p.variantOf))\n    .map((p) => p.id)\n\n  // A funnel must be able to END: at least one `finish` page reachable from the\n  // start. Catches cycles with no exit (every page proceeds — so no dead end —\n  // but no path ever terminates).\n  const noReachableFinish =\n    start !== null && !pages.some((p) => p.type === 'finish' && reachable.has(p.id))\n\n  // Offering-ref validation: a page referencing a slot the funnel doesn't declare (unknown) or one\n  // with no assigned catalog charge key (unassigned) can never resolve → hard error. Only runs when the\n  // build passed a page scan (`offeringRefs`); absent scan = skip (back-compat, no false positives).\n  const declaredSlots = new Set(slots.map((s) => s.slot))\n  const assignedSlots = new Set(slots.filter((s) => s.catalogKey).map((s) => s.slot))\n  const refs = offeringRefs ?? []\n  const unknownOfferingRefs = [...new Set(refs.filter((r) => !declaredSlots.has(r)))]\n  const unassignedSlots = [...new Set(refs.filter((r) => declaredSlots.has(r) && !assignedSlots.has(r)))]\n\n  return {\n    // Original hard errors AND the structural ones; slug collisions stay a warning.\n    ok:\n      deadEnds.length === 0 &&\n      unreachable.length === 0 &&\n      badTargets.length === 0 &&\n      !missingEmailCapture &&\n      duplicateKeys.length === 0 &&\n      orphanVariants.length === 0 &&\n      !noReachableFinish &&\n      unknownOfferingRefs.length === 0 &&\n      unassignedSlots.length === 0,\n    deadEnds,\n    unreachable,\n    badTargets,\n    missingEmailCapture,\n    duplicateKeys,\n    slugCollisions,\n    orphanVariants,\n    noReachableFinish,\n    unknownOfferingRefs,\n    unassignedSlots,\n  }\n}\n"]}

package/dist/{chunk-G44BUG6G.cjs → chunk-Y4YNJ2EX.cjs}

@@ -39,7 +39,7 @@ function intervalLabel(interval, count) {
   }
   return { period: `${count} ${interval}s`, periodly: `every ${count} ${interval}s` };
 }
-function resolveProduct(input) {
+function resolveOffering(input) {
   const interval = input.interval ?? "one_time";
   const count = input.intervalCount ?? 1;
   const days = periodDays(interval, count);
@@ -67,7 +67,7 @@ function resolveProduct(input) {
   };
 }
 function buildCatalog(inputs) {
-  return new Map(inputs.map((i) => [i.id, resolveProduct(i)]));
+  return new Map(inputs.map((i) => [i.id, resolveOffering(i)]));
 }
 var EXPONENT_CACHE = /* @__PURE__ */ new Map();
 function currencyExponent(currency) {
@@ -95,7 +95,7 @@ function formatMoney(minor, currency, locale) {
   }
   return { amount, minor, currency: code, formatted };
 }
-function formatProduct(r, locale) {
+function formatOffering(r, locale) {
   const m = (minor) => formatMoney(minor, r.currency, locale);
   return {
     id: r.id,
@@ -145,7 +145,8 @@ function evaluateCondition(cond, s) {
       return typeof val === "number" && typeof value === "number" && val <= value;
     case "contains":
       if (typeof val === "string") return val.includes(String(value));
-      if (Array.isArray(val)) return val.includes(value);
+      if (Array.isArray(val))
+        return val.includes(value);
       return false;
     case "exists":
       return val !== void 0 && val !== null && val !== "";
@@ -209,13 +210,21 @@ function expectedPathLength(pages, startKey, s) {
 function defineFunnel(def) {
   return def;
 }
-function normalizeProducts(products) {
-  if (!products) return [];
-  if (Array.isArray(products)) return products.map((k) => ({ slot: k, catalogKey: k }));
-  return Object.entries(products).map(([slot, catalogKey]) => ({ slot, catalogKey: catalogKey ?? null }));
+function normalizeOfferings(offerings) {
+  if (!offerings) return [];
+  if (Array.isArray(offerings))
+    return offerings.map((k) => ({ slot: k, catalogKey: k }));
+  return Object.entries(offerings).map(([slot, catalogKey]) => ({
+    slot,
+    catalogKey: catalogKey ?? null
+  }));
 }
-function funnelCatalogKeys(products) {
-  return [...new Set(normalizeProducts(products).map((s) => s.catalogKey).filter((k) => !!k))];
+function funnelCatalogKeys(offerings) {
+  return [
+    ...new Set(
+      normalizeOfferings(offerings).map((s) => s.catalogKey).filter((k) => !!k)
+    )
+  ];
 }
 
 // src/flow/experiments.ts
@@ -260,28 +269,21 @@ function weightsOf(variants) {
   for (const [label, v] of Object.entries(variants)) out[label] = v.weight;
   return out;
 }
-function statusOf(exp) {
-  return exp.status ?? "running";
-}
 function resolveExperiments(pages, experiments, seed) {
   const assignments = {};
   const render = {};
   const experimentOf = {};
   const versionOf = {};
-  const pageKeys = new Set(pages.map((p) => p.key));
-  for (const exp of experiments) {
-    const status = statusOf(exp);
-    let label;
-    if (status === "stopped" && exp.winner) label = exp.winner;
-    else if (status === "running" && seed) label = assignVariant(exp.id, seed, weightsOf(exp.variants));
-    else continue;
-    const arm = exp.variants[label];
-    if (!arm) continue;
-    if (!pageKeys.has(arm.page) || !pageKeys.has(exp.slot)) continue;
-    assignments[exp.id] = label;
-    experimentOf[exp.slot] = exp.id;
-    if (exp.version !== void 0) versionOf[exp.id] = exp.version;
-    if (arm.page !== exp.slot) render[exp.slot] = arm.page;
+  if (seed) {
+    for (const exp of experiments) {
+      const label = assignVariant(exp.id, seed, weightsOf(exp.variants));
+      const arm = exp.variants[label];
+      if (!arm) continue;
+      assignments[exp.id] = label;
+      experimentOf[exp.slot] = exp.id;
+      if (exp.version !== void 0) versionOf[exp.id] = exp.version;
+      if (arm.page !== exp.slot) render[exp.slot] = arm.page;
+    }
   }
   const slotOf = {};
   const activeKeys = [];
@@ -292,55 +294,6 @@ function resolveExperiments(pages, experiments, seed) {
   }
   return { assignments, activeKeys, render, slotOf, experimentOf, versionOf };
 }
-function validateExperiments(experiments, pages) {
-  const errors = [];
-  const warnings = [];
-  const pageKeys = new Set(pages.map((p) => p.key));
-  const seenIds = /* @__PURE__ */ new Set();
-  const slotOwner = /* @__PURE__ */ new Map();
-  for (const exp of experiments) {
-    const err = (code, message) => errors.push({ experimentId: exp.id, code, message });
-    const warn = (code, message) => warnings.push({ experimentId: exp.id, code, message });
-    if (seenIds.has(exp.id)) err("duplicate_id", `Experiment id "${exp.id}" is used more than once.`);
-    seenIds.add(exp.id);
-    if (!pageKeys.has(exp.slot)) err("slot_missing", `Slot "${exp.slot}" is not a page in the funnel.`);
-    if (isVariantKey(exp.slot)) err("slot_is_variant", `Slot "${exp.slot}" is a variant page; a slot must be a real flow page.`);
-    if (slotOwner.has(exp.slot)) {
-      err("slot_conflict", `Slot "${exp.slot}" is already targeted by experiment "${slotOwner.get(exp.slot)}".`);
-    } else {
-      slotOwner.set(exp.slot, exp.id);
-    }
-    const arms = Object.entries(exp.variants);
-    if (arms.length < 2) warn("single_arm", `Experiment "${exp.id}" has fewer than two variants \u2014 nothing to test.`);
-    let hasControl = false;
-    let totalWeight = 0;
-    for (const [label, arm] of arms) {
-      if (!pageKeys.has(arm.page)) {
-        err("variant_page_missing", `Variant "${label}" references page "${arm.page}", which doesn't exist.`);
-      }
-      if (arm.page === exp.slot) hasControl = true;
-      else if (isVariantKey(arm.page) && parseSlotKey(arm.page).slot !== exp.slot) {
-        err("variant_slot_mismatch", `Variant "${label}" page "${arm.page}" belongs to a different slot than "${exp.slot}".`);
-      }
-      if (arm.weight < 0) err("negative_weight", `Variant "${label}" has a negative weight (${arm.weight}).`);
-      totalWeight += arm.weight;
-    }
-    if (!hasControl) err("no_control", `No variant of "${exp.id}" renders the slot "${exp.slot}" itself (the control/baseline).`);
-    if (totalWeight <= 0) err("no_traffic", `Experiment "${exp.id}" has no positive weight \u2014 no traffic would enter it.`);
-    if (statusOf(exp) === "stopped" && exp.winner && !exp.variants[exp.winner]) {
-      err("bad_winner", `Stopped experiment "${exp.id}" names winner "${exp.winner}", which isn't one of its variants.`);
-    }
-  }
-  const running = new Set(experiments.filter((e) => statusOf(e) === "running").flatMap(
-    (e) => Object.values(e.variants).map((v) => v.page)
-  ));
-  for (const p of pages) {
-    if (isVariantKey(p.key) && !running.has(p.key)) {
-      warnings.push({ experimentId: "*", code: "orphan_variant", message: `Variant page "${p.key}" is rendered by no running experiment.` });
-    }
-  }
-  return { ok: errors.length === 0, errors, warnings };
-}
 
 // src/manifest/manifest.ts
 function isVariantNode(page) {
@@ -378,7 +331,16 @@ function compileManifest(input) {
     return void 0;
   };
   pages.forEach((p, i) => {
-    if (isVariantNode(p)) return;
+    if (isVariantNode(p)) {
+      for (const route of p.meta?.next ?? []) {
+        if (!keys.has(route.to)) {
+          badTargets.push({ from: p.key, to: route.to });
+          continue;
+        }
+        edges.push({ from: p.key, to: route.to, kind: "branch", variant: true, condition: serializeGate(route.when) });
+      }
+      return;
+    }
     const routes = p.meta?.next ?? [];
     let hasUnconditional = false;
     for (const route of routes) {
@@ -397,20 +359,25 @@ function compileManifest(input) {
   const startPage = pages.find((p) => !isVariantNode(p));
   const start = startPage?.key ?? null;
   const variantKeys = new Set(pages.filter(isVariantNode).map((p) => p.key));
-  const productSlots = normalizeProducts(funnel.products);
-  const validation = validate(manifestPages, edges, badTargets, start, variantKeys, productSlots, input.productRefs);
+  const offeringSlots = normalizeOfferings(funnel.offerings);
+  const validation = validate(manifestPages, edges, badTargets, start, variantKeys, offeringSlots, input.offeringRefs);
   return {
     id: funnel.id,
     pages: manifestPages,
     flow: { start, nodes: manifestPages.map((p) => p.id), edges },
-    products: funnelCatalogKeys(funnel.products),
-    productSlots,
-    productRefs: input.productRefs,
+    offerings: funnelCatalogKeys(funnel.offerings),
+    offeringSlots,
+    offeringRefs: input.offeringRefs,
+    // Carry the funnel.ts `checkout:` bundle + the scanned checkout-surface usage for the publish
+    // capability gate. Both are provider-agnostic here (the SDK can't resolve offering→provider);
+    // the API gate combines them with the DB-resolved provider to run the (provider × surface) matrix.
+    checkout: funnel.checkout,
+    checkoutRefs: input.checkoutRefs,
     locales: funnel.locales,
     validation
   };
 }
-function validate(pages, edges, badTargets, start, variantKeys, slots, productRefs) {
+function validate(pages, edges, badTargets, start, variantKeys, slots, offeringRefs) {
   const outgoing = /* @__PURE__ */ new Map();
   for (const e of edges) outgoing.set(e.from, (outgoing.get(e.from) ?? 0) + 1);
   const deadEnds = pages.filter((p) => p.type !== "finish" && !variantKeys.has(p.id) && !(outgoing.get(p.id) > 0)).map((p) => p.id);
@@ -422,6 +389,12 @@ function validate(pages, edges, badTargets, start, variantKeys, slots, productRe
       if (list) list.push(e.to);
       else adj.set(e.from, [e.to]);
     }
+    for (const p of pages) {
+      if (p.variantOf === void 0) continue;
+      const list = adj.get(p.variantOf);
+      if (list) list.push(p.id);
+      else adj.set(p.variantOf, [p.id]);
+    }
     const stack = [start];
     while (stack.length) {
       const id = stack.pop();
@@ -451,12 +424,12 @@ function validate(pages, edges, badTargets, start, variantKeys, slots, productRe
   const noReachableFinish = start !== null && !pages.some((p) => p.type === "finish" && reachable.has(p.id));
   const declaredSlots = new Set(slots.map((s) => s.slot));
   const assignedSlots = new Set(slots.filter((s) => s.catalogKey).map((s) => s.slot));
-  const refs = productRefs ?? [];
-  const unknownProductRefs = [...new Set(refs.filter((r) => !declaredSlots.has(r)))];
+  const refs = offeringRefs ?? [];
+  const unknownOfferingRefs = [...new Set(refs.filter((r) => !declaredSlots.has(r)))];
   const unassignedSlots = [...new Set(refs.filter((r) => declaredSlots.has(r) && !assignedSlots.has(r)))];
   return {
     // Original hard errors AND the structural ones; slug collisions stay a warning.
-    ok: deadEnds.length === 0 && unreachable.length === 0 && badTargets.length === 0 && !missingEmailCapture && duplicateKeys.length === 0 && orphanVariants.length === 0 && !noReachableFinish && unknownProductRefs.length === 0 && unassignedSlots.length === 0,
+    ok: deadEnds.length === 0 && unreachable.length === 0 && badTargets.length === 0 && !missingEmailCapture && duplicateKeys.length === 0 && orphanVariants.length === 0 && !noReachableFinish && unknownOfferingRefs.length === 0 && unassignedSlots.length === 0,
     deadEnds,
     unreachable,
     badTargets,
@@ -465,7 +438,7 @@ function validate(pages, edges, badTargets, start, variantKeys, slots, productRe
     slugCollisions,
     orphanVariants,
     noReachableFinish,
-    unknownProductRefs,
+    unknownOfferingRefs,
     unassignedSlots
   };
 }
@@ -483,22 +456,21 @@ exports.evaluateGate = evaluateGate;
 exports.expectedPathLength = expectedPathLength;
 exports.fnv1a = fnv1a;
 exports.formatMoney = formatMoney;
-exports.formatProduct = formatProduct;
+exports.formatOffering = formatOffering;
 exports.funnelCatalogKeys = funnelCatalogKeys;
 exports.hashToUnit = hashToUnit;
 exports.isRtl = isRtl;
 exports.isVariantKey = isVariantKey;
 exports.nextPage = nextPage;
-exports.normalizeProducts = normalizeProducts;
+exports.normalizeOfferings = normalizeOfferings;
 exports.outgoingKeys = outgoingKeys;
 exports.pageMeta = pageMeta;
 exports.parseSlotKey = parseSlotKey;
 exports.pickByWeight = pickByWeight;
 exports.resolveExperiments = resolveExperiments;
 exports.resolveLocale = resolveLocale;
-exports.resolveProduct = resolveProduct;
+exports.resolveOffering = resolveOffering;
 exports.resolveRoute = resolveRoute;
-exports.validateExperiments = validateExperiments;
 exports.weightsOf = weightsOf;
-//# sourceMappingURL=chunk-G44BUG6G.cjs.map
-//# sourceMappingURL=chunk-G44BUG6G.cjs.map
+//# sourceMappingURL=chunk-Y4YNJ2EX.cjs.map
+//# sourceMappingURL=chunk-Y4YNJ2EX.cjs.map