@nextcommerce/campaigns-os 1.33.0

package/campaign-spec/dist/rules/checkout-has-success-url.js

@@ -0,0 +1,66 @@
+/**
+ * CheckoutHasSuccessUrl — when the spec includes any upsell page, every
+ * checkout must declare SOME forward route so the runtime knows where to send
+ * the shopper after order placement.
+ *
+ * The check is on the shopper being able to continue, NOT on which field
+ * carried that intent. `success_url` and `next_page` express the same edge, and
+ * twelve pages across ten certified fixtures use `next_page` on their checkout
+ * — warning at those told authors to rename a field they had already filled in
+ * correctly. A
+ * campaign is a free-form journey; the tool has no business having an opinion
+ * about the field name when the route is unambiguous.
+ *
+ * The "any upsell present" precondition is the legacy heuristic for
+ * "this spec needs a multi-step post-checkout flow." Specs without upsells
+ * route to thankyou via the default thankyou path and don't need a
+ * checkout-level forward route declared.
+ *
+ * "Forward route" is whatever campaign-spec/routing.ts resolves — the same
+ * resolver that source intake and the QA topology extractor consume. Narrowing
+ * this rule is only safe because that edge now actually wires; narrowed alone
+ * it would have removed the sole signal on a still-dropped edge.
+ *
+ * The rule ID keeps its original name for consumer stability even though the
+ * condition is now field-agnostic. The violation path points at the page, not
+ * at /success_url, because no single field is the answer any more.
+ *
+ * Warning severity (not error) — preserves legacy classification.
+ */
+import { hasForwardRoute } from "../routing.js";
+function specHasUpsell(spec) {
+    for (const funnel of spec.funnels) {
+        for (const page of funnel.pages ?? []) {
+            if (page.type === 'upsell')
+                return true;
+        }
+    }
+    return false;
+}
+export const CheckoutHasSuccessUrl = {
+    id: 'CheckoutHasSuccessUrl',
+    severity: 'warning',
+    tags: ['fast', 'structure', 'spec-only'],
+    check(spec) {
+        if (!specHasUpsell(spec))
+            return [];
+        const violations = [];
+        spec.funnels.forEach((funnel, funnelIdx) => {
+            const pages = funnel.pages ?? [];
+            pages.forEach((page, pageIdx) => {
+                if (page.type !== 'checkout')
+                    return;
+                if (hasForwardRoute(page))
+                    return;
+                violations.push({
+                    ruleId: 'CheckoutHasSuccessUrl',
+                    severity: 'warning',
+                    message: 'Checkout has no forward route (set success_url or next_page to reach the first upsell).',
+                    path: `/funnels/${funnelIdx}/pages/${pageIdx}`,
+                    data: { pageId: page.id },
+                });
+            });
+        });
+        return violations;
+    },
+};

package/campaign-spec/dist/rules/cycle-detection.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CycleDetection — flags any page whose routing eventually loops back to it.
+ *
+ * DFS with path tracking: distinguishes DAG convergence (two paths into the
+ * same page, fine) from true cycles (a path that revisits a page already in
+ * the current traversal).
+ *
+ * Tags: structure, spec-only. NOT fast — graph traversal can be O(pages * edges)
+ * in pathological specs, so Map Builder skips this in per-keystroke mode.
+ */
+import type { Rule } from '../types.ts';
+export declare const CycleDetection: Rule;

package/campaign-spec/dist/rules/cycle-detection.js

@@ -0,0 +1,141 @@
+/**
+ * CycleDetection — flags any page whose routing eventually loops back to it.
+ *
+ * DFS with path tracking: distinguishes DAG convergence (two paths into the
+ * same page, fine) from true cycles (a path that revisits a page already in
+ * the current traversal).
+ *
+ * Tags: structure, spec-only. NOT fast — graph traversal can be O(pages * edges)
+ * in pathological specs, so Map Builder skips this in per-keystroke mode.
+ */
+import { outgoingEdgeIds } from "../routing.js";
+/**
+ * Outgoing edges come from the shared resolver, which returns the pair the
+ * runtime can actually traverse: the forward link plus the decline branch.
+ * NOT every declared field — a field shadowed by a higher-precedence one, or
+ * one the page type cannot satisfy (`success_url` off a checkout, #234),
+ * contributes no edge, so a loop through it is intentionally not reported.
+ * #233 landed that accuracy-over-breadth decision; this comment claimed the
+ * opposite until #234.
+ *
+ * This used to be a page-type switch that followed only `success_url` on a
+ * checkout. Source intake wires `next_page` on checkouts — twelve pages across
+ * ten certified fixtures do exactly that — so a loop through such an edge
+ * built successfully while staying invisible to this rule.
+ */
+function getNextIds(page) {
+    return outgoingEdgeIds(page);
+}
+function collectPages(spec) {
+    const refs = [];
+    spec.funnels.forEach((funnel, funnelIdx) => {
+        const pages = funnel.pages ?? [];
+        pages.forEach((page, pageIdx) => {
+            refs.push({ page, funnelIdx, pageIdx });
+        });
+    });
+    return refs;
+}
+function buildPageMap(refs) {
+    const map = new Map();
+    for (const ref of refs) {
+        if (ref.page.id && !map.has(ref.page.id)) {
+            // Duplicate page IDs are caught by a separate rule
+            // (PageRouteUniqueness, not yet extracted). Keep the first.
+            map.set(ref.page.id, ref);
+        }
+    }
+    return map;
+}
+/**
+ * Returns the list of page IDs in the cycle reachable from `startId`, or
+ * null if no cycle is reachable. The first element of the returned list is
+ * the page that's revisited (the cycle's entry); subsequent elements are
+ * the cycle's path.
+ */
+function findCycleFrom(startId, pageMap, fullyExplored) {
+    const inPath = [];
+    const inPathSet = new Set();
+    function dfs(id) {
+        if (inPathSet.has(id)) {
+            // Found a cycle. Slice the path from the revisited node.
+            const idx = inPath.indexOf(id);
+            return [...inPath.slice(idx), id];
+        }
+        if (fullyExplored.has(id))
+            return null;
+        inPath.push(id);
+        inPathSet.add(id);
+        const ref = pageMap.get(id);
+        if (ref) {
+            for (const next of getNextIds(ref.page)) {
+                const cycle = dfs(next);
+                if (cycle)
+                    return cycle;
+            }
+        }
+        inPath.pop();
+        inPathSet.delete(id);
+        fullyExplored.add(id);
+        return null;
+    }
+    return dfs(startId);
+}
+export const CycleDetection = {
+    id: 'CycleDetection',
+    severity: 'error',
+    tags: ['structure', 'spec-only'],
+    check(spec) {
+        const refs = collectPages(spec);
+        const pageMap = buildPageMap(refs);
+        const violations = [];
+        // Only nodes whose entire traversal completed without finding a cycle are
+        // memoized. Share these across roots within this check, never across specs.
+        // Cyclic paths keep the existing first-cycle and diagnostic ordering policy.
+        const fullyExplored = new Set();
+        // Two-level dedup: a cycle reached from different starting positions
+        // produces different "entries" (the rotation depends on the starting node)
+        // but the same node SET. Canonicalize by sorted node IDs to dedupe.
+        const reportedSignatures = new Set();
+        // Skip outer iteration over pages already known to be in a reported cycle.
+        const inReportedCycle = new Set();
+        for (const ref of refs) {
+            if (!ref.page.id)
+                continue;
+            if (inReportedCycle.has(ref.page.id))
+                continue;
+            const cycle = findCycleFrom(ref.page.id, pageMap, fullyExplored);
+            if (!cycle || cycle.length === 0)
+                continue;
+            // cycle is [entry, ...path, entry] — drop the trailing duplicate for the signature.
+            const cycleNodes = cycle.slice(0, -1);
+            const signature = [...cycleNodes].sort().join('|');
+            if (reportedSignatures.has(signature)) {
+                for (const id of cycleNodes)
+                    inReportedCycle.add(id);
+                continue;
+            }
+            reportedSignatures.add(signature);
+            for (const id of cycleNodes)
+                inReportedCycle.add(id);
+            const entryId = cycle[0];
+            const entryRef = pageMap.get(entryId);
+            const path = entryRef
+                ? `/funnels/${entryRef.funnelIdx}/pages/${entryRef.pageIdx}`
+                : '/funnels';
+            // Any cycle is release-blocking. Draft UIs can choose to filter or soften
+            // this rule, but exported/compiled specs must not route back to themselves.
+            const isSelfLoop = cycle.length === 2 && cycle[0] === cycle[1];
+            violations.push({
+                ruleId: 'CycleDetection',
+                severity: 'error',
+                message: isSelfLoop
+                    ? `Page "${entryRef?.page.label ?? entryId}" routes to itself.`
+                    : `Circular route detected starting at "${entryRef?.page.label ?? entryId}". Cycle: ${cycle.join(' → ')}`,
+                path,
+                data: { cycle, entryPageId: entryId },
+            });
+        }
+        return violations;
+    },
+};

package/campaign-spec/dist/rules/design-source-shape.d.ts

@@ -0,0 +1,29 @@
+/**
+ * DesignSourceShape — validates the per-page `design_source` block when
+ * present. `design_source` is the pointer used by figma-sections-export
+ * (and future design-tool exporters) to locate prepared HTML; campaigns-os
+ * doctor reads it to distinguish "designer hasn't exported yet" from
+ * generic `collect-inputs` when no source-html manifest is found.
+ *
+ * The block is fully optional — a page without `design_source` is silent
+ * (existing manual handoff workflow keeps working). When `design_source`
+ * IS set, this rule catches authoring drift before doctor sees it:
+ *
+ *   1. `type` must be a non-empty string (warning — currently only
+ *      "figma" has tooling support, but we accept other strings so the
+ *      schema doesn't break ahead of new exporters).
+ *   2. `file_url` must be present and look like a real URL (warning).
+ *   3. For `type: "figma"`, the file_url should be a figma.com URL
+ *      (warning — easy paste mistake).
+ *   4. `breakpoints` should declare at least one of desktop/tablet/mobile
+ *      when present (warning — empty breakpoints object is meaningless).
+ *   5. Each non-empty breakpoint value should look like a URL (warning).
+ *   6. For `type: "figma"`, breakpoint URLs should be figma.com selection
+ *      URLs (warning — same paste-mistake guard as file_url).
+ *
+ * Severity is `warning` across the board: this is authoring guidance, not
+ * a build blocker. The export tool itself is the real validator at handoff
+ * time; this rule keeps Map Builder authors honest while editing.
+ */
+import type { Rule } from '../types.ts';
+export declare const DesignSourceShape: Rule;

package/campaign-spec/dist/rules/design-source-shape.js

@@ -0,0 +1,142 @@
+/**
+ * DesignSourceShape — validates the per-page `design_source` block when
+ * present. `design_source` is the pointer used by figma-sections-export
+ * (and future design-tool exporters) to locate prepared HTML; campaigns-os
+ * doctor reads it to distinguish "designer hasn't exported yet" from
+ * generic `collect-inputs` when no source-html manifest is found.
+ *
+ * The block is fully optional — a page without `design_source` is silent
+ * (existing manual handoff workflow keeps working). When `design_source`
+ * IS set, this rule catches authoring drift before doctor sees it:
+ *
+ *   1. `type` must be a non-empty string (warning — currently only
+ *      "figma" has tooling support, but we accept other strings so the
+ *      schema doesn't break ahead of new exporters).
+ *   2. `file_url` must be present and look like a real URL (warning).
+ *   3. For `type: "figma"`, the file_url should be a figma.com URL
+ *      (warning — easy paste mistake).
+ *   4. `breakpoints` should declare at least one of desktop/tablet/mobile
+ *      when present (warning — empty breakpoints object is meaningless).
+ *   5. Each non-empty breakpoint value should look like a URL (warning).
+ *   6. For `type: "figma"`, breakpoint URLs should be figma.com selection
+ *      URLs (warning — same paste-mistake guard as file_url).
+ *
+ * Severity is `warning` across the board: this is authoring guidance, not
+ * a build blocker. The export tool itself is the real validator at handoff
+ * time; this rule keeps Map Builder authors honest while editing.
+ */
+const FIGMA_URL_PATTERN = /^https:\/\/(?:www\.)?figma\.com\//i;
+const ANY_URL_PATTERN = /^https?:\/\/\S+/i;
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export const DesignSourceShape = {
+    id: 'DesignSourceShape',
+    severity: 'warning',
+    tags: ['fast', 'spec-only'],
+    check(spec) {
+        const violations = [];
+        spec.funnels.forEach((funnel, funnelIdx) => {
+            const pages = funnel.pages ?? [];
+            pages.forEach((page, pageIdx) => {
+                const design = page.design_source;
+                if (!design)
+                    return;
+                const basePath = `/funnels/${funnelIdx}/pages/${pageIdx}/design_source`;
+                const pageLabel = page.label || page.id || '(unnamed page)';
+                // 1. type
+                if (!isNonEmptyString(design.type)) {
+                    violations.push({
+                        ruleId: 'DesignSourceShape',
+                        severity: 'warning',
+                        message: `"${pageLabel}" — design_source.type is missing; expected a string like "figma".`,
+                        path: `${basePath}/type`,
+                        data: { pageId: page.id, check: 'type-missing' },
+                    });
+                }
+                // 2. file_url presence and URL-shape
+                if (!isNonEmptyString(design.file_url)) {
+                    violations.push({
+                        ruleId: 'DesignSourceShape',
+                        severity: 'warning',
+                        message: `"${pageLabel}" — design_source.file_url is missing; expected the design-tool file URL.`,
+                        path: `${basePath}/file_url`,
+                        data: { pageId: page.id, check: 'file-url-missing' },
+                    });
+                }
+                else if (!ANY_URL_PATTERN.test(design.file_url)) {
+                    violations.push({
+                        ruleId: 'DesignSourceShape',
+                        severity: 'warning',
+                        message: `"${pageLabel}" — design_source.file_url does not look like a URL: ${truncate(design.file_url)}`,
+                        path: `${basePath}/file_url`,
+                        data: { pageId: page.id, check: 'file-url-shape', value: design.file_url },
+                    });
+                }
+                else if (design.type === 'figma' && !FIGMA_URL_PATTERN.test(design.file_url)) {
+                    // 3. figma-specific: must be a figma.com URL
+                    violations.push({
+                        ruleId: 'DesignSourceShape',
+                        severity: 'warning',
+                        message: `"${pageLabel}" — design_source.type is "figma" but file_url is not a figma.com URL: ${truncate(design.file_url)}`,
+                        path: `${basePath}/file_url`,
+                        data: { pageId: page.id, check: 'file-url-not-figma', value: design.file_url },
+                    });
+                }
+                // 4 + 5 + 6. breakpoints
+                if (design.breakpoints !== undefined) {
+                    const bps = design.breakpoints;
+                    const known = ['desktop', 'tablet', 'mobile'];
+                    const declared = known.filter((bp) => isNonEmptyString(bps[bp]));
+                    if (declared.length === 0) {
+                        violations.push({
+                            ruleId: 'DesignSourceShape',
+                            severity: 'warning',
+                            message: `"${pageLabel}" — design_source.breakpoints is present but no desktop/tablet/mobile URL is set.`,
+                            path: `${basePath}/breakpoints`,
+                            data: { pageId: page.id, check: 'breakpoints-empty' },
+                        });
+                    }
+                    for (const bp of known) {
+                        const value = bps[bp];
+                        if (value === undefined)
+                            continue;
+                        if (!isNonEmptyString(value)) {
+                            violations.push({
+                                ruleId: 'DesignSourceShape',
+                                severity: 'warning',
+                                message: `"${pageLabel}" — design_source.breakpoints.${bp} is set but empty.`,
+                                path: `${basePath}/breakpoints/${bp}`,
+                                data: { pageId: page.id, check: 'breakpoint-empty', breakpoint: bp },
+                            });
+                            continue;
+                        }
+                        if (!ANY_URL_PATTERN.test(value)) {
+                            violations.push({
+                                ruleId: 'DesignSourceShape',
+                                severity: 'warning',
+                                message: `"${pageLabel}" — design_source.breakpoints.${bp} does not look like a URL: ${truncate(value)}`,
+                                path: `${basePath}/breakpoints/${bp}`,
+                                data: { pageId: page.id, check: 'breakpoint-url-shape', breakpoint: bp, value },
+                            });
+                            continue;
+                        }
+                        if (design.type === 'figma' && !FIGMA_URL_PATTERN.test(value)) {
+                            violations.push({
+                                ruleId: 'DesignSourceShape',
+                                severity: 'warning',
+                                message: `"${pageLabel}" — design_source.type is "figma" but breakpoints.${bp} is not a figma.com URL: ${truncate(value)}`,
+                                path: `${basePath}/breakpoints/${bp}`,
+                                data: { pageId: page.id, check: 'breakpoint-not-figma', breakpoint: bp, value },
+                            });
+                        }
+                    }
+                }
+            });
+        });
+        return violations;
+    },
+};
+function truncate(value, max = 80) {
+    return value.length > max ? value.slice(0, max - 1) + '…' : value;
+}

package/campaign-spec/dist/rules/downsell-without-upsell.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DownsellWithoutUpsell — flags specs with downsell pages but no upsell.
+ * A downsell-only flow is unusual (downsells are typically reached from an
+ * upsell decline path); warn rather than error so the operator can confirm
+ * intent if it's deliberate.
+ *
+ * Warning severity (not error) — preserves legacy classification.
+ * Message text preserved verbatim.
+ */
+import type { Rule } from '../types.ts';
+export declare const DownsellWithoutUpsell: Rule;

package/campaign-spec/dist/rules/downsell-without-upsell.js

@@ -0,0 +1,40 @@
+/**
+ * DownsellWithoutUpsell — flags specs with downsell pages but no upsell.
+ * A downsell-only flow is unusual (downsells are typically reached from an
+ * upsell decline path); warn rather than error so the operator can confirm
+ * intent if it's deliberate.
+ *
+ * Warning severity (not error) — preserves legacy classification.
+ * Message text preserved verbatim.
+ */
+export const DownsellWithoutUpsell = {
+    id: 'DownsellWithoutUpsell',
+    severity: 'warning',
+    tags: ['fast', 'structure', 'spec-only'],
+    check(spec) {
+        let hasDownsell = false;
+        let hasUpsell = false;
+        for (const funnel of spec.funnels) {
+            for (const page of funnel.pages ?? []) {
+                if (page.type === 'downsell')
+                    hasDownsell = true;
+                else if (page.type === 'upsell')
+                    hasUpsell = true;
+                if (hasDownsell && hasUpsell)
+                    return [];
+            }
+        }
+        if (!hasDownsell)
+            return [];
+        if (hasUpsell)
+            return [];
+        return [
+            {
+                ruleId: 'DownsellWithoutUpsell',
+                severity: 'warning',
+                message: 'Downsell pages present but no Upsell pages — intentional?',
+                path: '/funnels',
+            },
+        ];
+    },
+};

package/campaign-spec/dist/rules/exit-intent-validation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ExitIntentValidation — the heaviest single rule in the registry. Validates
+ * everything about per-page `exit_intent` configuration:
+ *
+ *   1. Placement: exit intent on a non-checkout page (warning — 0.4.x
+ *      runtime contract expects checkout-level exit intent)
+ *   2. Presence: enabled but no offer_ref_id (error)
+ *   3. Presence: enabled but no offer_code (error)
+ *   4. Catalog: offer_ref_id not in spec.offers (error)
+ *   5. Catalog: offer_code not in spec.offers (error)
+ *   6. Consistency: ref offer has no `code` field (error — nothing to apply)
+ *   7. Consistency: offer_code doesn't match ref offer's `code` (error)
+ *   8. Catalog: exit intent enabled with no offers in catalog at all (warning)
+ *
+ * Kept as one rule because every check shares the same precondition
+ * (`exit_intent?.enabled`) and the same domain (exit intent integrity).
+ * Splitting would force callers to opt in/out 8 ways for one concept. If a
+ * caller needs to subset, they filter the resulting violations by `data.check`.
+ *
+ * Message text inherited verbatim from the pre-#110 validator at migration time.
+ */
+import type { Rule } from '../types.ts';
+export declare const ExitIntentValidation: Rule;

package/campaign-spec/dist/rules/exit-intent-validation.js

@@ -0,0 +1,147 @@
+/**
+ * ExitIntentValidation — the heaviest single rule in the registry. Validates
+ * everything about per-page `exit_intent` configuration:
+ *
+ *   1. Placement: exit intent on a non-checkout page (warning — 0.4.x
+ *      runtime contract expects checkout-level exit intent)
+ *   2. Presence: enabled but no offer_ref_id (error)
+ *   3. Presence: enabled but no offer_code (error)
+ *   4. Catalog: offer_ref_id not in spec.offers (error)
+ *   5. Catalog: offer_code not in spec.offers (error)
+ *   6. Consistency: ref offer has no `code` field (error — nothing to apply)
+ *   7. Consistency: offer_code doesn't match ref offer's `code` (error)
+ *   8. Catalog: exit intent enabled with no offers in catalog at all (warning)
+ *
+ * Kept as one rule because every check shares the same precondition
+ * (`exit_intent?.enabled`) and the same domain (exit intent integrity).
+ * Splitting would force callers to opt in/out 8 ways for one concept. If a
+ * caller needs to subset, they filter the resulting violations by `data.check`.
+ *
+ * Message text inherited verbatim from the pre-#110 validator at migration time.
+ */
+function isTruthyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function offerDisplayName(offer) {
+    return offer.name || offer.code || String(offer.ref_id) || '(unnamed offer)';
+}
+function buildOfferIndex(offers) {
+    const byRefId = new Map();
+    const byCode = new Map();
+    for (const offer of offers) {
+        byRefId.set(String(offer.ref_id), offer);
+        if (offer.code)
+            byCode.set(String(offer.code).toUpperCase(), offer);
+    }
+    return { byRefId, byCode };
+}
+export const ExitIntentValidation = {
+    id: 'ExitIntentValidation',
+    severity: 'error',
+    tags: ['fast', 'references', 'spec-only'],
+    check(spec) {
+        const catalog = spec.offers ?? [];
+        const index = buildOfferIndex(catalog);
+        const violations = [];
+        spec.funnels.forEach((funnel, funnelIdx) => {
+            const pages = funnel.pages ?? [];
+            pages.forEach((page, pageIdx) => {
+                const exit = page.exit_intent;
+                if (!exit?.enabled)
+                    return;
+                const path = `/funnels/${funnelIdx}/pages/${pageIdx}/exit_intent`;
+                const ref = exit.offer_ref_id;
+                const code = exit.offer_code;
+                const refOffer = ref ? index.byRefId.get(String(ref)) : null;
+                const codeOffer = code ? index.byCode.get(String(code).toUpperCase()) : null;
+                // 1. Placement
+                if (page.type !== 'checkout') {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'warning',
+                        message: `"${page.label}" — Exit intent is configured on a non-checkout page. The 0.4.x runtime contract expects checkout-level exit intent.`,
+                        path,
+                        data: { pageId: page.id, check: 'placement', pageType: page.type },
+                    });
+                }
+                // 2 & 3. Presence
+                if (!ref) {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'error',
+                        message: `"${page.label}" — Exit intent enabled but no offer assigned.`,
+                        path: `${path}/offer_ref_id`,
+                        data: { pageId: page.id, check: 'missing_ref' },
+                    });
+                }
+                if (!code) {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'error',
+                        message: `"${page.label}" — Exit intent enabled but no offer code assigned.`,
+                        path: `${path}/offer_code`,
+                        data: { pageId: page.id, check: 'missing_code' },
+                    });
+                }
+                // 4 & 5. Catalog presence
+                if (catalog.length > 0 && ref && !refOffer) {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'error',
+                        message: `"${page.label}" — Exit intent offer "${ref || code}" is not present in campaign offers. Refresh API data or choose a valid offer.`,
+                        path: `${path}/offer_ref_id`,
+                        data: { pageId: page.id, check: 'ref_not_in_catalog', refId: ref },
+                    });
+                }
+                if (catalog.length > 0 && code && !codeOffer) {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'error',
+                        message: `"${page.label}" — Exit intent offer code "${code}" is not present in campaign offers. Refresh API data or choose a valid offer.`,
+                        path: `${path}/offer_code`,
+                        data: { pageId: page.id, check: 'code_not_in_catalog', code },
+                    });
+                }
+                // 6. Ref offer has no code
+                if (refOffer && !isTruthyString(refOffer.code)) {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'error',
+                        message: `"${page.label}" — Exit intent offer "${offerDisplayName(refOffer)}" has no voucher/code to apply at checkout.`,
+                        path: `${path}/offer_ref_id`,
+                        data: { pageId: page.id, check: 'ref_offer_lacks_code', refId: ref },
+                    });
+                }
+                // 7. Code mismatch
+                if (refOffer &&
+                    isTruthyString(code) &&
+                    isTruthyString(refOffer.code) &&
+                    String(code).toUpperCase() !== String(refOffer.code).toUpperCase()) {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'error',
+                        message: `"${page.label}" — Exit intent offer code "${code}" does not match campaign offer code "${refOffer.code}".`,
+                        path: `${path}/offer_code`,
+                        data: {
+                            pageId: page.id,
+                            check: 'code_ref_mismatch',
+                            providedCode: code,
+                            expectedCode: refOffer.code,
+                        },
+                    });
+                }
+                // 8. Empty catalog
+                if (catalog.length === 0) {
+                    violations.push({
+                        ruleId: 'ExitIntentValidation',
+                        severity: 'warning',
+                        message: `"${page.label}" — Exit intent offer cannot be verified because campaign offers are missing from the spec.`,
+                        path,
+                        data: { pageId: page.id, check: 'empty_catalog' },
+                    });
+                }
+            });
+        });
+        return violations;
+    },
+};

package/campaign-spec/dist/rules/funnel-count.d.ts

@@ -0,0 +1,9 @@
+/**
+ * FunnelCount — enforces the funnel cardinality bounds: at least 1, at most 10.
+ *
+ * Message text inherited verbatim from the pre-#110 validator at migration time. The upper
+ * bound (10) is a soft platform cap; revisit in a separate ADR if a real use
+ * case needs more.
+ */
+import type { Rule } from '../types.ts';
+export declare const FunnelCount: Rule;

package/campaign-spec/dist/rules/funnel-count.js

@@ -0,0 +1,37 @@
+/**
+ * FunnelCount — enforces the funnel cardinality bounds: at least 1, at most 10.
+ *
+ * Message text inherited verbatim from the pre-#110 validator at migration time. The upper
+ * bound (10) is a soft platform cap; revisit in a separate ADR if a real use
+ * case needs more.
+ */
+const MIN_FUNNELS = 1;
+const MAX_FUNNELS = 10;
+export const FunnelCount = {
+    id: 'FunnelCount',
+    severity: 'error',
+    tags: ['fast', 'structure', 'spec-only'],
+    check(spec) {
+        const count = spec.funnels?.length ?? 0;
+        const violations = [];
+        if (count < MIN_FUNNELS) {
+            violations.push({
+                ruleId: 'FunnelCount',
+                severity: 'error',
+                message: 'Spec must define at least 1 funnel.',
+                path: '/funnels',
+                data: { count, min: MIN_FUNNELS },
+            });
+        }
+        else if (count > MAX_FUNNELS) {
+            violations.push({
+                ruleId: 'FunnelCount',
+                severity: 'error',
+                message: `Spec defines ${count} funnels; max is ${MAX_FUNNELS}.`,
+                path: '/funnels',
+                data: { count, max: MAX_FUNNELS },
+            });
+        }
+        return violations;
+    },
+};