═══════════════════════════════════════
NON-NEGOTIABLE RULES — ALWAYS APPLY
These rules govern EVERY page, EVERY section, EVERY element.
No page type, section type, or user instruction may override them.
═══════════════════════════════════════

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
OUTPUT FORMAT
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Return ONLY a single valid JSON object. Nothing before it. Nothing after it.
No markdown. No code fences. No explanations. No commentary.
The JSON must follow this EXACT key order:
{ "javascript": "...", "css": "...", "html": "..." }
- javascript key MUST come first, css second, html third.
- html field: body markup only — no <html>, <head>, or <body> tags, no inline styles, no <style> tags.
- css field: ALL styles go here — no <style> tags, no inline styles in html.
- javascript field: ALL scripts go here — no <script> tags in html UNLESS the script must be inline for GrapesJS compatibility (FAQ accordion, hamburger toggle — see section rules for these specific exceptions).

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
BUTTON RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- ALWAYS use <button> for any clickable element that does not navigate (accordion toggles, form submit, modal triggers) — never a styled <div> or <span> pretending to be a button.
- Every navigating/scrolling CTA MUST be a plain <a> tag with btn classes directly on it:
  <a href="#section-id" class="btn btn--primary btn--pulse">Text <i class="fas fa-arrow-right" aria-hidden="true" style="margin-left:0.4em;"></i></a>
- NEVER nest a <button> inside an <a> — this produces a double-button and is forbidden.
- <button> is ONLY for buttons that do NOT navigate or link anywhere: accordion toggles, FAQ expand/collapse, tab switches, modal triggers, and form submit buttons (<button type="submit">).
- Every icon-only <button> must include an aria-label attribute.
- CTA buttons in pricing cards MUST use <a> tags, never <button>.
- FINAL CTA BUTTON CLASS — NON-NEGOTIABLE: The single primary, bottom-of-page closing call-to-action — the main button inside the pricing/offer section or the last conversion-focused CTA on the page (e.g. "Get Instant Access Now", "Join Now", "Complete My Order") — MUST include the additional class `final-cta-btn` alongside the standard `btn btn--primary` classes: <a href="#checkout" class="btn btn--primary final-cta-btn">Get Instant Access Now <i class="fas fa-arrow-right" aria-hidden="true" style="margin-left:0.4em;"></i></a>. Only the ONE final/closing CTA on the page gets this class — do not add it to the hero CTA, nav CTA, or any other secondary button. Do not set margin-bottom on this class yourself; the platform stylesheet supplies it.
- BUTTON-TO-TEXT GAP MUST BE EXACTLY 10PX, NO MORE AND NO LESS, ONLY WHEN TEXT DIRECTLY FOLLOWS A BUTTON — NON-NEGOTIABLE: This applies to ANY button on the page and ANY text element sitting directly below it as its immediate next sibling — not only the named microcopy classes below, but literally any `<p>`, `<span>`, `<div>`, or other text element that is the very next sibling after any `<a class="btn...">` or `<button>`, anywhere on the page. Common cases include trust/disclaimer/microcopy text such as `.pricing__disclaimer`, `.hero-note`, `.form-note`, `.cta-note`, but the rule is not limited to these — it is general. If a button has no such text immediately following it (it's the last element, or the next sibling is a different component entirely), this rule does not apply — do not add anything to create a gap where none is needed. When that immediate text DOES exist, the total visible gap between the bottom of the button and the top of that text must be EXACTLY 10px at every breakpoint — not 8px, not 12px, not "roughly" or "close to" 10px, exactly 10px. Every `.btn`/`button` already receives `margin-bottom: 10px` from the platform stylesheet (platform-owned, do not redeclare it yourself) — this alone produces the correct 10px gap, and it is the ONLY thing that should create that gap. Do NOT set margin-top, padding-top, or a flex/grid `gap` value on any text element that is the immediate next sibling after a button — any of those, even a small value, stacks on top of the button's own margin-bottom and pushes the total gap above 10px. If the text element directly below the button ALSO has its own margin-top, the two values stack and the visible gap becomes noticeably larger than the intended 10px. A confirmed real-world failure: `.pricing__disclaimer` text rendered pushed well below its button because the disclaimer's own margin-top combined with the button's margin-bottom from the platform stylesheet. Before finalizing, check every button on the page for a text sibling immediately below it, and verify that sibling has zero margin-top/padding-top of its own — the button's margin-bottom must be the ONLY source of that 10px, every single time.
- TEXT IMMEDIATELY UNDER A BUTTON MUST BE CENTERED AND BALANCED — NON-NEGOTIABLE: Any text element sitting directly below a button as its immediate next sibling (`.pricing__disclaimer`, `.hero-note`, `.form-note`, `.cta-note`, or similar trust/microcopy text) must always use `text-align: center` and `text-wrap: balance`, regardless of how the rest of the section is aligned — even inside a left-aligned column or card. The platform stylesheet already forces both of these on the recognized class names above, but use these exact class names so that guarantee actually applies, and never override either property back to `left` or remove `text-wrap: balance` in your own CSS for these specific elements.
  - EXCEPTION — THE BUTTON ITSELF IS LEFT-ALIGNED: This rule assumes a button whose own alignment is center (or full-width/block, which reads as centered). If the button itself is specifically left-aligned (e.g. `text-align: left` on its wrapper, or the button is not centered/full-width within a left-aligned layout), do NOT add this kind of trust/microcopy/disclaimer text directly below it at all — omit the note entirely in that case rather than centering it. A confirmed real-world failure: a left-aligned CTA button with centered note text below it (e.g. "🔒 Beginner friendly • $200 commissions • Start immediately") rendered visibly disconnected from the button — the text appeared shifted away to the right of the button it was supposed to belong to, since centering it relative to a left-aligned button's container does not actually place it under the button. This is a specific carve-out from the general rule above, triggered by the BUTTON's own alignment specifically — not by the section's or column's alignment in general (a centered button inside an otherwise left-aligned section/column still follows the general rule and keeps its centered note).
  A SECOND, EQUALLY COMMON WAY THIS DOUBLES UP — FLEX/GRID `gap`: If the button and its note/disclaimer text sit inside a `display:flex` or `display:grid` container, that container's own `gap` property adds space between them independently of either element's own margin — zeroing the note's margin-top does nothing if the parent container still has a non-zero `gap`. The platform's landing-base.css forces `gap:0` on any container holding one of these note classes (`.pricing__disclaimer`, `.pricing-disclaimer`, `.hero-note`, `.form-note`, `.cta-note`) as a direct child, as a safety net — but do not rely on that alone. When you write the CSS for a container whose children include a button followed immediately by one of these note elements, set `gap: 0` on that container yourself rather than a generic spacing value, and let the button's own margin-bottom be the sole source of that gap.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
BUTTON ARROW / ICON RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- NEVER use a plain text arrow character (→, ›, », >, ➜, ➡, ▶, ✈, or ANY Unicode arrow, chevron, or directional glyph) inside a button.
- ALL arrows, chevrons, send icons, play icons, and directional icons in buttons MUST be Font Awesome icons.
- Use the semantically appropriate FA icon: fa-arrow-right for "next/go", fa-paper-plane for "send/submit", fa-play for "watch/play", fa-chevron-right for "continue", fa-external-link-alt for external links.
- Place it after the button text with a small left margin: e.g. Get Instant Access <i class="fas fa-arrow-right" aria-hidden="true" style="margin-left:0.4em;"></i>
- This applies to EVERY button on the page — no exceptions whatsoever.
- Font Awesome 6 Free is already loaded in the page <head>. Reference it only in HTML with <i class="fas fa-..."> or <i class="fab fa-..."> — never @import it in CSS.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
HEADING BOLD RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Every single word in EVERY h1, h2, h3, h4, h5, h6 and ANY element with a class containing "headline", "heading", or "title" MUST render at font-weight: 700 or higher — NO MATTER WHAT COLOR that text is.
- Colored spans, highlighted phrases, gradient text spans, <em>, <i>, <a>, <strong> — every child element inside a heading MUST be bold.
- NEVER set font-weight: 400, normal, 500, or 600 on any heading or any child of a heading.
- If a <span> is used inside a heading for color, gradient, or highlight, it MUST include font-weight: inherit or font-weight: 700 explicitly.
- A yellow heading is bold. An orange heading is bold. A white heading is bold. A gradient heading is bold. Color does NOT exempt a heading from this rule.
- Failure to bold every word of every heading — regardless of color — is a critical rendering error.
- GRADIENT / CLIPPED TEXT FALLBACK: if you style any text with background-clip:text / -webkit-text-fill-color:transparent, you MUST ALSO set a solid color in the SAME visible hue as a fallback. NEVER leave that fallback color as a dark value on a dark background. Set the fallback to the gradient's dominant visible hue.
- HEADING AND SUBHEADING MUST BE SEPARATE ELEMENTS: Never merge a heading and subheading into a single element. The h2 is the heading. The supporting paragraph below it is a separate <p>. They must never be combined into one tag.
- SUBHEADING MAX-WIDTH: The subheading or paragraph immediately following a heading must share the exact same max-width as the heading above it. If the heading has max-width: 1080px, the subheading must also have max-width: 1080px.
- BODY FONT MUST NOT BE NATURALLY BOLD: The body font (var(--font-body)) must be a normal-weight font. Never choose a font whose default/only weight is bold for body text — body text must render at a true 400 weight.
- BOLD USAGE RULE: Bold (font-weight 600+) is reserved for headings and the single most critical piece of information. ALL other body text MUST be normal weight (font-weight: 400). Never bold entire paragraphs or sentences for emphasis.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
HTML STRUCTURE RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Body markup only — no <html>, <head>, or <body> tags.
- No inline styles anywhere in the html field.
- No <style> tags in the html field (except inline scripts required for GrapesJS — see section rules).
- Use semantic HTML5 elements: <header>, <nav>, <main>, <section>, <article>, <aside>, <footer>.
- Give every section a unique id attribute (e.g. id="hero", id="features", id="pricing") for anchor navigation.
- Use reusable BEM-style class names (.section, .section--dark, .card, .card--featured, .btn, .btn--primary, .btn--ghost).
- EVERY BUTTON ON THE PAGE MUST INCLUDE THE CLASS `btn` — NON-NEGOTIABLE: Any clickable button-style element you create — `<a>`, `<button>`, or any other tag styled to look and function as a button (primary CTA, secondary/ghost button, small button, nav CTA, form submit button, etc.) — MUST include the base class `btn` in its class list, in addition to whatever modifier class describes its specific style (`btn--primary`, `btn--sm`, `btn--ghost`, or any other modifier). Never style a button-like element using only a modifier class or a custom class with no `btn` base class present — `landing-base.css` defines shared button layout (display, alignment, min-width, min-height, padding, the mobile margin-bottom fix, and more) on the `.btn, button.btn` selector, and an element missing the `btn` class entirely falls outside all of that platform styling. Example: `<a href="#pricing" class="btn btn--primary">Get Access</a>` — correct. `<a href="#pricing" class="cta-button">Get Access</a>` — incorrect, missing `btn`.
  CONVERSELY — `.nav-toggle` AND `.faq-question` MUST NEVER CARRY THE `btn` CLASS: The hamburger toggle (`<button class="nav-toggle">` per navigation.md) and the FAQ accordion trigger (`<button class="faq-question">` per faq.md) are `<button>` elements used for the GrapesJS-compatibility convention, but they are NOT button-style CTAs — they must never also carry the `btn` class. A confirmed real-world failure: the platform's `.btn, button.btn` rule (min-width:180px, min-height:50px, fixed horizontal padding) was previously written as a bare `button` element selector with no `.btn` requirement, so it applied to EVERY `<button>` tag including the hamburger and FAQ trigger — forcing the mobile hamburger into a 180px-wide pill shape that overflowed/clipped against the nav's fixed 64px height and effectively disappeared from view. The selector is now correctly scoped to `button.btn` only, but this only stays fixed if `.nav-toggle` and `.faq-question` are never given the `btn` class — if you ever add `btn` to either of these for any reason, you will reintroduce this exact failure.
- SPECIFIC CLASS NAMES — NON-NEGOTIABLE: Always use specific, descriptive class names on every element (e.g. .step-number, .feature-card, .pricing-tier, .testimonial-avatar). NEVER rely on generic element selectors or vague class names that would require wildcard/substring matching to target. The platform's injected override rules match on class-name substrings (e.g. anything containing "badge", "stats", "video-wrap") so they can reach elements without knowing your exact naming in advance — but that same substring matching means an unrelated element whose class happens to contain that fragment gets caught too. A `.guarantee-disclaimer` paragraph gets matched by a rule meant for `.guarantee-badge`. A `.video-wrapper-caption` label gets matched by a rule meant for `.video-wrap`. A `.social-proof-eyebrow` gets matched by a rule meant for the `.social-proof` row itself. Avoid this by giving every element ONE clear, specific class for its actual role, and never let an inner label, caption, disclaimer, or note share a class fragment with the name of a different component type it merely sits inside (e.g. name it `.guarantee-fineprint`, not `.guarantee-disclaimer`; `.ticker-label`, not `.ticker-tape-caption`). Every div, span, section, card, icon wrapper, heading, and interactive element must have at least one descriptive, role-specific class.
- Minimize wrapper divs — every element must earn its place.
- Every <img> tag MUST include a descriptive alt attribute for accessibility and SEO.
- NO LOREM IPSUM: Every word of copy must be realistic, relevant, and niche-specific.
- FORMULA: Use PAS (Problem → Agitate → Solution) for problem/solution sections. Use AIDA (Attention → Interest → Desire → Action) for hero and CTA sections.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CSS RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- BUILD AROUND THE PLATFORM BASELINE — MANDATORY: landing-base.css is attached to every page automatically. It defines positioning, sizing, and layout for: .btn, .btn--primary, .btn--sm, .card, .icon-wrap, .icon-row, .eyebrow, .eyebrow-wrap, .form-group, .site-footer, .sticky-cta-bar, .proof-bar, .hero__inner--split, .container, .section, .avatar, .final-cta-btn, the registration form classes (#registration, .reg-inner, .reg-card, .field, .field-inner, #register-form), and the animation classes (.animate-on-scroll, etc). ALSO platform-owned, with real positioning/sizing rules already defined — use these exact names, do not invent synonyms: the nav classes, SCOPED PRECISELY (see exact carve-out below — do NOT assume more is covered than what's listed); the pricing classes (.pricing-box, .pricing-card, .pricing-grid, .pricing__inner, .pricing-cta-wrap); the FAQ classes (.faq-answer, .faq-question, .faq-list, .faq__inner, .faq-content — see the separate .faq-item note below for what's NOT covered); the hero classes (#hero, .hero__inner, .hero-headline/.hero__headline, .hero-subhead, .hero-note); the shared "__inner" container pattern that every major section uses for its content wrapper (.section__inner, .cta__inner, .features__inner, .testimonials__inner, .footer__inner — each gets platform-owned max-width/centering, do not redeclare); the grid containers (.features-grid, .benefits-grid, .testimonials-grid — each has a platform-owned mobile column-stacking override); the form classes (.form-card, .capture-form-wrap, .form-icon, .form-group--icon, .input-icon-wrap); and .urgency-box, .module-card-header, .footer-links. Use these exact class names whenever you're building one of these components — do not invent your own class for something this list already covers. See PLATFORM-OWNED PROPERTIES below for what NOT to redeclare. NOTE ON NAV CLASSES — EXACT SCOPE, DO NOT OVER-EXTEND: `.nav-inner` gets ONLY a structural floor (display:flex; align-items:center). `.nav-links` gets ONLY a desktop horizontal-flex default. `.nav-toggle` gets ONLY display:none-by-default-shown-at-mobile — you may style its background/border/color/font-size/padding yourself, but NEVER include a `display` property on `.nav-toggle` in any rule you write, with or without a media query; see the CONFIRMED REAL-WORLD FAILURE under NAV-TOGGLE APPEARANCE in navigation.md for why an unconditional `display:none` on this class is a same-specificity source-order collision against the platform's own mobile-show rule, capable of hiding the hamburger on real mobile visitors, not just inside the GrapesJS editor. `.nav-cta` gets ONLY a mobile flex-order placement next to the hamburger. `.site-nav`/`.main-nav` itself gets NO positioning at all from the platform — NOT fixed/sticky, NOT top/z-index, NOT the scroll-hide transform. A CONFIRMED REAL-WORLD FAILURE caused by this list previously being too broad: an earlier version of this rule implied `.site-nav`'s positioning was platform-owned, so the model stopped writing `position:fixed; top:0; z-index:900;` and the scroll-hide CSS on it — the sticky nav silently disappeared on a live page because nothing else supplies that CSS. The STICKY BEHAVIOR section in navigation.md (position:fixed, z-index, background/blur, sticky-state CSS) is 100% model-owned, every time, with no exception — write it yourself on `.site-nav`/`.main-nav` on every page that has a nav. Likewise, the hamburger's actual click-to-open behavior is NOT CSS at all — it lives entirely in the required inline `<script>` per NAV INLINE SCRIPT in navigation.md, which must be present verbatim on every page or the hamburger silently does nothing. NOTE: Marquee/ticker/scroller components are model-generated (not platform-owned) — include full CSS whenever you create a marquee component. NOTE ON .faq-item — BEHAVIOR-OWNED ONLY, NOT VISUALLY STYLED: the platform's handling of `.faq-item` (and `.faq-answer`) is limited to accordion collapse/expand mechanics and open-state spacing — it contains NO background, border, border-radius, or box-shadow. Do not treat `.faq-item` as visually covered by the platform the way `.card` or `.btn--primary` are. You are fully responsible for writing your own background/border/border-radius/box-shadow on `.faq-item` so each FAQ row reads as a distinct, styled element rather than bare text — see CSS REQUIRED in faq.md.
- URGENCY BOX — EXACT CLASS NAMES REQUIRED, MODEL-GENERATED (NOT PLATFORM-OWNED) — NON-NEGOTIABLE: Whenever a section needs a callout box listing what the visitor loses/misses out on if they don't act (a "what you lose if you wait" / scarcity box), use these exact class names so the component stays consistent across every generation rather than reinventing a differently-named version each time:
  <div class="urgency-box animate-on-scroll">
    <p class="urgency-box__title"><i class="fas fa-fire" aria-hidden="true"></i> When This Offer Closes, You Lose:</p>
    <ul class="urgency-list">
      <li><i class="fas fa-times-circle" aria-hidden="true"></i> [specific loss item — be concrete: a price increase, a bonus removed, a deadline, etc.]</li>
      <!-- repeat <li> for each loss item, typically 3-6 items -->
    </ul>
  </div>
  This component is NOT styled by the platform's landing-base.css — unlike the components in BUILD AROUND THE PLATFORM BASELINE above, you must write the full CSS for `.urgency-box`, `.urgency-box__title`, and `.urgency-list` yourself, including all responsive/mobile rules (the mobile horizontal spacing ceiling, font-size minimums, and every other universal rule in this document still apply to it like any other model-generated component). Always use `.urgency-box` as the outer wrapper class — never invent alternate names like `.urgency-highlight`, `.urgency-scarcity-box`, `.urgency-callout`, or similar for what is functionally the same component; consistent naming here matters so this component behaves predictably across different generations and page types (urgency sections, CTA sections, pricing sections — anywhere a "don't miss out" callout is used).
  NO FIXED MAX-WIDTH ON THE TEXT INSIDE — ALWAYS 100% — NON-NEGOTIABLE: `.urgency-box__title` and `.urgency-list` must never be given a fixed pixel/rem max-width (e.g. max-width: 600px) — always use max-width: 100% (or simply omit max-width, which defaults to 100% of the available width) so the text's width is always determined by the box's own content area, never by an independent fixed value that could exceed it. A fixed max-width on the text risks being wider than `.urgency-box` itself once the box's own padding is accounted for, causing the text to overflow past the box's edge/border rather than wrapping within it. The text inside must always be sized relative to its container, not to an arbitrary fixed value of its own.
- ALL styles go in the css field — no exceptions.
- Always open the css field with the :root design token block.
- NO !important — ABSOLUTE: NEVER use !important anywhere in the generated CSS. The platform injects its own !important override rules — any !important in generated CSS will conflict and break the layout.
  MANDATORY SELF-CHECK BEFORE FINALIZING — SCAN YOUR ENTIRE CSS OUTPUT FOR THE LITERAL STRING "!important": Before finalizing your css field, search every rule you wrote — every selector, every breakpoint, every media query — for the literal text "!important". If you find even one occurrence, remove it; there is no case where it belongs in your output. This is not a stylistic preference to weigh against other goals (specificity battles, "making sure my rule wins," matching something you saw elsewhere) — it is an absolute prohibition with zero exceptions, the same way other ABSOLUTE rules in this document have zero exceptions.
  WHY THIS MATTERS MORE THAN IT MIGHT SEEM — A CONFIRMED RECURRING FAILURE: The platform's own landing-base.css uses !important specifically and sparingly, on a small set of rules designed to guarantee specific outcomes (mobile spacing ceilings, grid stacking, centering) regardless of what the model writes. When the model's own CSS ALSO uses !important on a competing property, the outcome becomes a coin-flip specificity/source-order battle between two !important declarations instead of a clean, predictable cascade — and a confirmed failure pattern from real generations: the model added !important to its own rule purely to "win" against what it assumed (sometimes incorrectly) was a competing platform rule, when in most cases there was no actual conflict and the !important only made the resulting CSS harder to reason about and more fragile to future platform-side fixes. If you genuinely believe a platform-owned property is fighting your CSS, the correct fix is almost always to simply NOT set that property yourself (see PLATFORM-OWNED PROPERTIES below) — reaching for !important to force your way past the platform is never the right move, even when it seems to "work" in the moment.
- MANDATORY JAVASCRIPT SYNTAX SELF-CHECK BEFORE FINALIZING — NON-NEGOTIABLE: A single typo in hand-written JavaScript (a misspelled keyword, a missing brace, an extra/missing comma) causes the ENTIRE script to fail to parse — not just the broken function, the WHOLE FILE. This is far more damaging than it sounds: this platform's scroll-reveal animation system (`.animate-on-scroll`, `.animate-fade-in`, `.animate-slide-left`, `.animate-slide-right`, `.animate-scale-in` — every element starting at `opacity:0` until an IntersectionObserver adds `.is-visible`) typically lives in the SAME script file as other page behavior (particle effects, FAQ accordions, form validation, sticky bars). A confirmed real-world failure: the model wrote `confunction initParticles() { ... }` instead of `function initParticles() { ... }` — a single misspelled keyword. That syntax error broke parsing for the entire script file, silently killing the IntersectionObserver reveal logic along with it, so EVERY animated element on the page stayed invisible forever — the page rendered almost completely blank except for the one element that didn't depend on that script. Before finalizing your javascript field (and any inline `<script>` blocks in your html field), re-read every function declaration, every closing brace, every comma-separated argument list character-by-character — do not skim. Specifically verify: every function declaration starts with the literal keyword `function` (not a misspelling of it), every opening `{`/`(`/`[` has a matching close, and every statement that should end with `;` has one. A script that "looks right" at a glance is not the same as a script that will actually parse — read it as literally as a JavaScript interpreter would, not as a human skimming for general shape.
- PLATFORM-OWNED PROPERTIES — DO NOT SET: The platform's base stylesheet already fully defines the following, for every page, with no exceptions. NEVER declare ANY of these properties on these selectors in your own CSS — not as a duplicate, not as an override attempt, not even with a "matching" value. Simply omit them entirely; the platform's stylesheet supplies them automatically.
  - `section`, `.section` (excluding `.hero`/`[class*="hero"]`, `footer`/`[class*="footer"]`, `[class*="stats"]`, `[class*="metric"]`, `.section-divider`, `nav`, `header`, `.site-nav`, `.main-nav`, and `[class*="nav"]`): do not set `padding-top`, `padding-bottom`, `border`, `outline`, or `position`. The navigation/header is explicitly excluded because it requires `position: fixed` (see NAVIGATION SECTION RULES — STICKY BEHAVIOR) and must never have its `position` property omitted or treated as platform-owned.
  - `.hero__inner--split`: do not set `display`, `grid-template-columns`, `align-items`, or `gap`. This class is exclusively for the split/side-by-side hero layout (see hero section rules) — never apply grid/column styles to plain `.hero__inner` to fake this layout.
  - `.container`, `[class*="container"]`, `[class$="-inner"]`: do not set `max-width`, `margin`, `padding`, or `width`. CONFIRMED REAL-WORLD FAILURE: a generated page included `{ max-width: var(--container-max) !important; margin: 0 auto !important; padding: 0 2rem !important; }` on a container-style div with no media query at all — this violates PLATFORM-OWNED PROPERTIES (these four properties on a container-type element are never the model's to set), violates NO !important (three separate !important declarations on properties that needed none), and violates MOBILE HORIZONTAL SPACING (the unconditional `padding: 0 2rem` = 32px applies at every breakpoint including mobile, nearly 3x the 10px ceiling, with no override to bring it down). All three rules existed before this failure and all three were broken by one rule block — when you write a container/wrapper-style div's CSS, the correct output is to write NOTHING for these properties at all, not a "matching" or "improved" value.
  - `.btn`: do not set `display`, `align-items`, `justify-content`, `gap`, `border`, `cursor`, `max-width`, or `min-width`. You MAY still set this class's own `font-size`, `border-radius`, color/background, and — since the platform does NOT define a `transition` on `.btn`/`.btn--primary` — any `transition`/`animation` you want for hover states or motion effects. This is intentional: motion effects on buttons are entirely the model's creative responsibility, not the platform's.
  - `.btn--primary`: do not set `padding`.
  - `.btn--sm`: do not set `padding`.
  - `.card`: do not set `padding`. You MAY still set this class's own `border-radius`, color/background, and any `transition`/`animation` for hover or motion effects — the platform does not define a transition for `.card`.
  - `.icon-wrap`: do not set `width`, `height`, `min-width`, `display`, `align-items`, `justify-content`, `flex-shrink`, or `margin-bottom`. You MAY still set this class's own `border-radius`, color/background, and any `transition`/`animation` for hover or motion effects — the platform does not define a transition for `.icon-wrap`.
  - `.icon-row`: do not set `display`, `align-items`, or `gap`.
  - `#registration`: do not set `position`, `width`, `min-height`, `display`, `align-items`, `justify-content`, `padding`, or `overflow`.
  - `.reg-inner`: do not set `position`, `z-index`, `width`, `max-width`, `margin`, `display`, `flex-direction`, `align-items`, or `text-align`.
  - `.reg-card`: do not set `width`, `max-width`, `margin`, `padding`, or `position`. You MAY still set this class's own `border-radius`, background, border, and box-shadow color/branding.
  - `.field`: do not set `position`, `width`, `display`, `margin-bottom`, or `box-sizing`.
  - `.field-inner`: do not set `position`, `width`, or `display`.
  - `#register-form`: do not set `width`, `display`, or `box-sizing`.
  - `#register-form input`: do not set `width`, `text-align`, `padding`, `font-size`, `box-sizing`, or `transition`. You MAY still set this element's own `border-radius`, background, border, and color/branding.
  - `.field-inner > i.fa` (and `.fas`/`.far`/`.fab`/`.fal`/`[class*="fa-"]` variants): do not set `position`, `left`, `top`, `transform`, `pointer-events`, `z-index`, `width`, `height`, `display`, `align-items`, `justify-content`, `line-height`, or `font-size`. You MAY still set this icon's own color.
  - `[data-toggle-password]`: do not set `position`, `right`, `top`, `transform`, `border`, `cursor`, `z-index`, `width`, `height`, `display`, `align-items`, `justify-content`, `padding`, or `line-height`. You MAY still set this element's own `background` and color.
  - `.eyebrow`: do not set `display`, `width`, `max-width`, `padding`, `text-align`, `text-transform`, `letter-spacing`, or `line-height`. You MAY still set this class's own `border-radius` and color/background.
  - `.eyebrow-wrap`: do not set `width` or `margin-bottom`. You MAY still set `text-align` on this wrapper to match your hero/section layout (centered layouts center it, split/two-column layouts left-align it) — this is the one property on this list that stays content-aware rather than fixed.
  - `.form-group`: do not set `width` or `margin-bottom`.
  - `.faq-item`: do not set `padding` or `margin-bottom`. You MAY still set this class's own `border-radius`, color/background, and any `transition`/`animation` for hover or motion effects — the platform does not define a transition for `.faq-item`.
  - `.site-footer`: do not set `text-align` or `padding`.
  - `.proof-bar`: do not set `padding` or `overflow`.
  - `.sticky-cta-bar` — INCLUDING its `.is-visible` state and its `.sticky-cta-bar__inner`/`.sticky-cta-bar__text` sub-elements: do not set `position`, `bottom`, `left`, `right`, `z-index`, `padding`, `transform`, `transition`, `will-change`, `max-width`, `margin`, `display`, `align-items`, `justify-content`, `gap`, or `color` on any of these. The platform fully defines the bar's positioning, its scroll-triggered reveal transform, and its inner layout/text color — write none of it yourself, including the `.is-visible` compound selector. CONFIRMED REAL-WORLD FAILURE: a generation correctly omitted CSS for bare `.sticky-cta-bar` but also dropped `.sticky-cta-bar.is-visible`, `.sticky-cta-bar__inner`, and `.sticky-cta-bar__text` entirely — leaving the bar with no reveal transform at all, so it never became visible on scroll despite the JS correctly toggling the class. Omitting platform-owned properties is correct; omitting the entire selector (including sub-elements/states that were never yours to skip) is not — the bar's HTML structure and JS toggle are still required from you. You ARE still responsible for: `.sticky-cta-bar`'s own background color, border-top color, and box-shadow, hardcoded from the palette.
  - `.final-cta-btn`: do not set `margin-bottom`.
  This list exists so the platform's own stylesheet never has to fight your CSS for these properties — there is nothing for !important to resolve, because you never write a competing rule in the first place. Anything not listed above (colors, fonts, content-specific sizing, layout variants, animations) remains entirely yours to design per niche/brand.
- WHENEVER YOU WRITE CSS FOR A `<button>` ELEMENT, ALSO WRITE IT FOR `<tempbutton>` — NON-NEGOTIABLE: Any time you write a CSS rule that targets a `<button>` element, write the identical rule a second time targeting `<tempbutton>` as well — same declarations, same values. For example, if you write `button { background: ...; }`, also write `tempbutton { background: ...; }`. If you write `button.btn--primary { ... }`, also write `tempbutton.btn--primary { ... }`. Do this every time, for every CSS rule that styles a `<button>` element, with no exceptions.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
LAST-CHILD SPACING RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🚨 NON-NEGOTIABLE

The final visible content in every section must terminate cleanly at the section's intended bottom padding with NO additional whitespace, gap, margin, spacer, wrapper offset, grid gap, flex gap, or padding beneath it.

The ONLY spacing allowed beneath the final content is the section's own bottom padding.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SECTION EDGE CLEANUP RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before outputting HTML:

1. Identify the LAST VISIBLE CONTENT ELEMENT in every section.
2. Trace ALL parent wrappers between that element and the section root.
3. Remove every source of unnecessary bottom spacing from the entire ancestor chain.
4. Continue upward until reaching the section element itself.
5. The final content must sit directly above the section's intended bottom padding.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FORBIDDEN BOTTOM SPACING SOURCES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The following are NOT allowed beneath the final content structure:

* margin-bottom
* padding-bottom
* spacer divs
* empty divs
* empty paragraphs
* <br> tags used for spacing
* invisible spacer elements
* animation wrappers creating bottom space
* transform offsets creating bottom space
* translateY offsets creating bottom space
* pseudo-elements creating bottom space
* min-height creating artificial space
* empty grid rows
* empty flex rows
* unnecessary wrapper containers

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
WRAPPER CHAIN VALIDATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Example:

Section
└─ Container
└─ Grid
└─ Card
└─ CTA

Before returning HTML verify:

* CTA does not create external bottom spacing.
* Card does not create external bottom spacing.
* Grid does not create external bottom spacing.
* Container does not create external bottom spacing.
* Section padding remains intact.

The last visible content MUST terminate cleanly at the section's intended bottom padding.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
VISUAL CONTAINER PROTECTION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

NEVER remove internal spacing from:

* cards
* feature boxes
* pricing tables
* testimonial cards
* CTA panels
* banners
* forms
* alerts
* modals
* statistics blocks
* comparison tables
* any visible content container

Buttons, text, icons, images, and content must NEVER touch the visible edge of a container.

If an element has any of the following:

* background-color
* gradient background
* border
* box-shadow
* backdrop-filter
* glassmorphism styling
* card styling
* CTA styling

it is considered a VISUAL CONTAINER.

VISUAL CONTAINERS MUST RETAIN THEIR INTERNAL PADDING.

Only spacing OUTSIDE the container MAY be removed.

GOOD

Section
└─ Card
├─ Content
└─ padding-bottom: 32px

BAD

Section
└─ Card
├─ Content
└─ padding-bottom: 0

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SECTION BOTTOM RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

GOOD

Section
├─ Final Content
└─ Section Padding (80px)

BAD

Section
├─ Final Content
├─ Extra Grid Gap (40px)
└─ Section Padding (80px)

BAD

Section
├─ Final Content
├─ Wrapper Margin-Bottom (32px)
└─ Section Padding (80px)

BAD

Section
├─ Final Content
├─ Empty Spacer Div
└─ Section Padding (80px)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FINAL QA CHECK
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before returning HTML verify:

✓ No divider exists above the Hero section.
✓ No divider exists before the first section.
✓ No divider exists between the first/hero section and the second section — the first divider on the page, if any, only appears starting at the boundary between the second and third sections.
✓ No whitespace exists beneath final content.
✓ No wrapper creates bottom spacing beneath final content.
✓ No grid creates bottom spacing beneath final content.
✓ No flex container creates bottom spacing beneath final content.
✓ No spacer elements exist beneath final content.
✓ No empty elements exist beneath final content.
✓ Internal card padding remains intact.
✓ Buttons never touch card edges.
✓ Text never touches container edges.
✓ Visual containers retain their internal spacing.
✓ Final content sits directly above the section's intended bottom padding.
✓ Section padding is the ONLY remaining bottom space.

- MOTION / CANVAS / PARTICLE EFFECTS: If a section includes a canvas or particle background, it MUST NOT obscure content. The canvas must be `position: absolute; z-index: 0; pointer-events: none;`. The parent section must be `position: relative; overflow: hidden;`. ALL content inside that section MUST be wrapped in a `position: relative; z-index: 1;` div. NEVER use position:fixed or high z-index for decorative backgrounds.
- ANNOUNCEMENT BAR COMPACTNESS: Any announcement or limited-time-offer bar at the top of the page must be compact. Maximum padding `0.6rem 1rem`. NEVER use min-height with viewport units (vh/dvh) on a bar element. The bar MUST be approx 40-50px tall, never more. If a divider SVG is placed at the bottom of the bar, its height must be max 40px.
- No frameworks, no Bootstrap, no Tailwind — pure custom CSS using design tokens.
- Use var(--...) throughout ALL CSS — never hardcode hex values or px sizes that duplicate a token.
- Mobile-first: write base styles for mobile, use min-width media queries for desktop.
- Breakpoints: 480px (mobile-lg), 768px (tablet), 1024px (desktop), 1280px (desktop-lg).
- Touch targets: all interactive elements minimum 48px height on mobile.
- FOUNDATIONAL SECTION RULE: every section and .section element has: width:100%; max-width:100%; padding-left:0; padding-right:0; box-sizing:border-box. All horizontal spacing must be handled by inner containers.
- SECTION VERTICAL PADDING IS PLATFORM-OWNED — DO NOT WRITE THIS RULE YOURSELF: Every section (except the hero and footer) automatically receives padding-top: 100px; padding-bottom: 100px on desktop, and padding-top: 75px; padding-bottom: 75px on mobile (max-width: 767px), from the platform's own landing-base.css — this matches the PLATFORM-OWNED PROPERTIES rule above, which already lists padding-top/padding-bottom on `section`/`.section` as something you must never set. Do NOT write your own `section { padding-top: ...; padding-bottom: ...; }` rule, with or without a mobile media query, even with matching values — doing so risks a confirmed real-world failure: a model-written desktop-only padding rule with no mobile override can win over the platform's own responsive rule depending on selector specificity and source order, leaving the section stuck at the desktop padding value on mobile and creating a large, unintended gap between sections that should have shrunk to 75px. Simply omit section vertical padding from your CSS entirely and trust the platform to apply it — this is the single safest way to guarantee correct behavior at every breakpoint. NEVER apply section padding to sub-elements like eyebrows, headings, or inner containers either way — it belongs on the `<section>` tag only, and only the platform should be writing that rule. THIS APPLIES TO EVERY SECTION TYPE INCLUDING STATS/RESULTS/METRICS SECTIONS: a confirmed real-world failure had a stats/results section render with NO vertical padding because the model wrote its own zero/tight section padding — its edge-to-edge gradient then had no room to resolve to a flat edge and its content collided with the adjacent scroller and section dividers. Every non-hero/non-footer section, with no exceptions for stats or metrics sections, must keep the platform's uniform 100px/75px padding so gradients have room to resolve to a flat band at each edge and content never touches the section's top or bottom boundary.
- HERO SECTION PADDING: The hero section controls its own vertical padding internally. Do NOT apply the 100px/75px rule to the hero. The hero section's padding-top and padding-bottom are set by its own CSS block.
- HERO / FIRST SECTION TOP GAP — NON-NEGOTIABLE: The first visible content element of the hero (or first section on the page) must sit no more than 50px below whatever element sits directly above it — whether that is a navigation bar, sticky bar, announcement bar, or the top of the viewport. This is a GAP requirement, not a literal padding-top value — they are NOT the same number whenever a fixed/sticky nav is present. If there is NO nav/header on the page, the hero's padding-top IS simply this 50px gap (or less), since there's nothing else to clear. If there IS a fixed/sticky nav, the nav sits outside normal document flow and the hero's padding-top is measured from the very top of the viewport, not from the nav's bottom edge — so the hero's padding-top in that case must equal the nav's own rendered height PLUS this 50px gap (e.g. a 64px-tall nav plus a 50px gap means padding-top ≈ 114px on that specific page — a number well above 50px is CORRECT and expected here, not a violation). See hero.md's NAV/HEADER CLEARANCE rule for the full breakdown of this calculation — that rule and this one describe the same gap requirement, just from different angles, and must not be read as conflicting. Keep the hero's top padding as tight as the math above allows — never add extra padding beyond what's needed to clear the nav (if present) plus the 50px gap.
- BORDERED ELEMENTS: Any element with a visible colored border MUST have equal padding on all four sides, minimum 24px.
- CALLOUT / HIGHLIGHT BOX PADDING: Any callout, highlight box, or bordered element MUST have equal top and bottom padding. Use 25px padding on all sides. NEVER set asymmetric padding (e.g., different top vs. bottom) on a bordered box.
- LAST CHILD SPACING: The very last element inside ANY container with padding, background, border, or box-shadow MUST have margin-bottom:0. Do NOT set padding-bottom:0 on the last child — only zero out margin-bottom.
- VALUE STACK / PRICING BOX WIDTH: Any bordered box listing items with values must set width: fit-content; max-width: 100%; margin-left: auto; margin-right: auto.
- FIT-CONTENT WIDTH ON EVERY WIDE BORDERED/CALLOUT BOX — NON-NEGOTIABLE: This same principle applies to every bordered, background-filled, or visually-distinct box on the page that doesn't need to span the section's full width to hold its content — not just pricing/value-stack boxes. A box stretched to 100% of a wide desktop section, when its actual content (a few lines of text, a short list, a quote) is much narrower than that, creates an awkward, unintentional-looking gap of empty space on both edges of the box at desktop width. Apply `width: fit-content; max-width: 100%; margin-left: auto; margin-right: auto;` (or an equivalent explicit max-width like `max-width: 860px; margin: 0 auto;` sized to the box's actual content) to box types including, but not limited to: the problem/pain-point callout box (`.problem-callout`, `.callout-box`), the urgency box (`.urgency-box`), the guarantee box (`.guarantee-box`), a pull-quote or testimonial-highlight box (`.pull-quote`), a feature-highlight or "bonus module" spotlight box (`.feature-highlight`), the pricing box/card (`.pricing-box`, `.pricing-card`), the optin/lead-capture form card (`.form-card`), and any other box-style component you create that wraps a relatively small, fixed amount of content inside a section that's otherwise full-width. Before finalizing any such box's CSS, ask: does this box's content actually need the section's full width, or would it look more intentional constrained to fit its content (or a sensible fixed max-width) and centered? Default to constraining it unless the content genuinely benefits from spanning the full width (e.g. a multi-column grid of cards, which is a different case governed by CARD GRID COLUMN COUNT elsewhere in this document, not this rule).
- REPEATING PILL/BOX GROUPS — SIZE ALL BOXES TO THE WIDEST ITEM, NEVER EACH TO ITS OWN CONTENT — NON-NEGOTIABLE: This is a distinct case from the single-box rule above and overrides it whenever multiple structurally-identical small boxes/pills appear together as a set — most commonly the pain-point items (`.pain-card`, per the REQUIRED CLASS NAME rule in problem.md) rendered as a 2x2 or 2-column grid of short statements, each with a leading icon, like `"I don't know where to start."` / `"I'm not techy."` / `"I need something different."` / `"I'm ready, but I need guidance."`. A confirmed real-world failure: each `.pain-card` was stretched to fill its full 50%-width grid column regardless of its own much-shorter text, leaving large uneven empty space inside each box, while the actual intent was for every box to look uniform and intentionally sized. `width: fit-content` applied individually per box (the single-box approach above) is WRONG here — it would make each box a different width matched only to its own text, which looks just as inconsistent as full-width stretching. Instead: before writing the CSS, read every item's text in the group and identify the single longest one (by character count). Size every box in the group identically using ONE shared width value — either an explicit `width:` in px/ch sized to comfortably fit that longest item's text plus its icon and padding (e.g. `width: 340px;` applied to the shared pill class, not per-instance), or `width: max-content` combined with `justify-self: start` (or `center`, matching the group's alignment) on a grid where the LONGEST item's cell determines that shared sizing — never use `width: 100%`, `justify-self: stretch` (the grid default), or per-box `fit-content` for this pattern. Do not let the grid's own column-stretching default (`justify-items: stretch`, the implicit default for grid items) silently override this — explicitly set `justify-items: start` (or `center`) on the grid container, or `justify-self` on each item, so every box renders at the shared width regardless of its own shorter text, with no leftover empty space inside any box.
- ASPECT RATIO PROTECTION: Logos, icons, SVGs, step numbers, avatars, badges, and seals must NEVER be compressed or stretched. Always use width:auto with height:auto. Never set width:100% on a logo, icon, step number, or avatar.
- MAX CONTENT GAP — NON-NEGOTIABLE: Keep spacing BETWEEN content elements minimal. This rule governs gap/margin/padding values used for spacing between elements WITHIN a section — e.g. the space between a heading and the paragraph below it, between a card and its neighbor, between a button and the text beneath it — never exceed 50px for this kind of internal/inter-element spacing; 24–40px is usually sufficient. This rule does NOT govern section-level padding-top/padding-bottom (the section's own outer vertical padding, which is either platform-owned at 100px/75px per SECTION VERTICAL PADDING IS PLATFORM-OWNED, or the hero's own padding-top which can legitimately exceed 50px when clearing a fixed nav per HERO / FIRST SECTION TOP GAP above) — do not read this rule as contradicting either of those; they describe a different category of spacing (the section's own outer padding) than this rule (spacing between elements inside that padding).
- SAME-BACKGROUND ADJACENT SECTION PADDING — NON-NEGOTIABLE: Whenever two consecutive `<section>` elements (with no section-divider between them) resolve to the exact same background color or background-image, the bottom section's `padding-bottom` and the top section's `padding-top` MUST each be reduced to exactly 50px — for a combined visible gap of 100px total between their content, not 200px+. Do NOT apply each section's normal/default padding (commonly 100px top and 100px bottom) when backgrounds match; that produces an oversized, disconnected-looking gap and visually merges the two sections into a single block with awkward dead space in the middle. Check every adjacent section pair's resolved background (including any background set via class or inline style) before finalizing padding values. If section A's background equals section B's background: section A gets `padding-bottom: 50px`, section B gets `padding-top: 50px`.
  EXCEPTION — THE HERO/FIRST SECTION TO SECOND SECTION TRANSITION NEVER USES THIS 50px REDUCTION, EVEN WHEN BACKGROUNDS MATCH: This rule applies starting at the SECOND adjacent pair onward (section 2-to-3, section 3-to-4, etc.) — it does NOT apply to the hero/first-section-to-second-section transition, per NO DIVIDER BETWEEN THE HERO/FIRST SECTION AND THE SECOND SECTION below. Even when the hero and the second section share the exact same background, do NOT reduce either side's padding to 50px for this specific transition — the hero keeps its own unconditional padding-bottom:0 (per HERO PADDING AND DIVIDERS in hero.md), and the SECOND SECTION keeps its fully normal, default padding-top (typically 100px via `.section-pad` or the platform's universal section padding) — not 50px. A CONFIRMED REAL-WORLD FAILURE: a section directly after the hero (sharing the hero's exact background) had both its padding-top AND padding-bottom reduced to 50px — incorrectly applying this rule's reduction to the hero-adjacent top edge (which should have kept its normal 100px, per this exception) AND incorrectly applying the same reduction to its bottom edge too, even though the section below THAT was a completely different color with a divider already separating them. Before applying this rule to any pair, first check: is this the hero-to-second-section pair specifically? If yes, skip the reduction entirely on both sides. If no, apply the reduction, but ONLY to the two specific edges that are actually touching the matching-background sections — never let it spread to an edge that's adjacent to a different section entirely.
  This rule does not apply if a section-divider (SVG wave, curve, angle, etc.) sits between the two sections — dividers already provide visual separation regardless of background match.
- WHEN TO USE A SECTION DIVIDER — NON-NEGOTIABLE: A section-divider MUST be placed between every pair of consecutive sections whose resolved backgrounds DIFFER (different color or different gradient) — this is mandatory, not optional, whenever a divider style other than "hard cut" is selected. A section-divider MUST NOT be placed between two consecutive sections whose backgrounds are the EXACT same color or gradient (use the SAME-BACKGROUND ADJACENT SECTION PADDING rule above for those instead). Evaluate every single section-to-section transition on the page against this rule — do not skip transitions arbitrarily or add dividers only at a few "obvious" points. A typical 6–8 section page will usually need a divider at most transitions, since most adjacent sections intentionally alternate background color for visual rhythm. Walk through the page's full section list in order and check each consecutive pair before finalizing. EXCEPTION: this background-difference mandate does NOT override the NO DIVIDER BEFORE THE THIRD SECTION rule directly below — read that rule first, since it removes the hero→section-2 transition from consideration entirely, regardless of whether their backgrounds differ.
- NO DIVIDER BETWEEN THE HERO/FIRST SECTION AND THE SECOND SECTION — EVER. DIVIDERS ONLY BEGIN AT THE THIRD SECTION — NON-NEGOTIABLE, NO EXCEPTIONS: Never place a section-divider between the hero (or whatever the page's first section is) and the second section, under any circumstance — even if their backgrounds differ, even if the WHEN TO USE A SECTION DIVIDER rule above would otherwise mandate one for that specific background-difference reason. This applies regardless of divider style, color plan, or how different the two sections' backgrounds are. The first section-divider on the page, if any, may only appear starting at the boundary between the second and third sections — never any earlier. If the hero and second section have different backgrounds, let that transition be a hard cut (no divider) rather than reaching for a divider to ease it; matching the SAME-BACKGROUND ADJACENT SECTION PADDING rule's reduced-padding treatment is also not required here specifically because no divider rule applies to this transition at all — treat it simply as a hard cut between two sections with their own normal padding.
- COLUMN GAP CAP: Inside any column layout (grid or flex), the gap between elements inside the column must NEVER exceed 25px.
- TEXT OVERFLOW PREVENTION: Every element that contains text must have overflow-wrap:break-word — this is already applied universally via the GLOBAL RESET's `*, *::before, *::after` rule (see MOBILE OPTIMIZATION below), so you do not need to redeclare it per-element. Do NOT add word-break:break-word as well unless that specific element needs to break a genuinely long unbroken string with no natural word-break points (e.g. a raw URL) — word-break:break-word is more aggressive than overflow-wrap and will fracture ordinary short words mid-character whenever a container is narrow, which is a confirmed real-world failure (a card paragraph rendered one syllable per line because of this). overflow-wrap alone is the correct default for ordinary body text, headings, and labels.
- ALL IMAGES ASPECT RATIO: Every <img> must maintain its natural aspect ratio. ALWAYS use object-fit:cover (photos) or object-fit:contain (logos/icons).
- VIDEO ASPECT RATIO: Any video player or iframe MUST be constrained to a 16:9 aspect ratio using aspect-ratio: 16 / 9; width: 100%; height: auto;.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SCROLLER / MARQUEE RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🚨 NON-NEGOTIABLE

Any horizontal scroller, marquee, ticker, logo strip, brand strip, announcement strip, testimonial ticker, or scrolling icon row must function as a seamless infinite loop with NO visible beginning, end, jump, reset, pause, flicker, or empty space.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SCROLLER PLACEMENT RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

* A scroller is ALWAYS a component embedded inside an existing section.
* NEVER wrap a scroller inside its own standalone <section>.
* Scrollers do not create new sections.
* Scrollers are typically placed inside:

  * Hero sections
  * Social proof sections
  * Brand logo areas
  * Testimonial sections
  * Feature sections

GOOD

<section>
    Hero Content
    Scroller
</section>

BAD

<section>
    Hero Content
</section>

<section>
    Scroller
</section>

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FULL WIDTH RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

* Every scroller MUST span the FULL width of its parent section.
* The scroller container must visually extend edge-to-edge within the section layout.
* Width must never shrink to content width.
* Width must never stop at the width of the scrolling items.
* Width must always remain 100% of the available section width.
* No side gaps are allowed.
* No clipping of scrolling content is allowed except at the intentional viewport edges.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SEAMLESS LOOP RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

* The scrolling track MUST contain duplicated content.
* At least TWO complete copies of the scrolling content must exist.
* When the first copy exits one side of the viewport, the duplicate copy must already be entering from the opposite side.
* Users must never be able to identify where the loop restarts.
* The animation must appear endless.
* No visible reset is allowed.
* No snapping back to the beginning is allowed.
* No flash of empty space is allowed.
* No blank area is allowed at either edge during animation.

Required visual behavior:

Copy A → exits left
Copy B → enters from right

OR

Copy A → exits right
Copy B → enters from left

The transition must appear continuous.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ANIMATION RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

* Animation must be linear.
* Animation must be infinite.
* Animation must never pause unless explicitly requested.
* Animation must never reverse direction unless explicitly requested.
* Animation must never bounce.
* Animation must never ease-in.
* Animation must never ease-out.
* Animation speed must remain constant throughout the loop.
* Animation must use transform-based movement for smooth performance.
* Avoid JavaScript-driven animation when CSS transforms can achieve the effect.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TRACK STRUCTURE RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Required structure:

Scroller Viewport
└─ Scroller Track
├─ Content Set A
└─ Content Set B (duplicate)

The duplicate content set must be visually identical.

Examples:

Logo strips
Feature badges
Testimonials
Partner brands
Client logos
Trust indicators
Media mentions

must all duplicate content to guarantee seamless looping.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SPACING RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

* No blank space MAY appear before the first item.
* No blank space MAY appear after the last item.
* No gap MAY appear during loop transitions.
* Content spacing between items must remain consistent throughout the animation.
* Track width must be sufficient to prevent visible empty areas.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ICON + LABEL/HEADING ALIGNMENT
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

- Whenever a card, module, feature, or list item contains both an icon (or icon wrapper) and a text label or heading, the icon and the label/heading MUST appear on the same horizontal row — never stacked vertically with the icon above the text.
- Apply display:flex; flex-direction:row; align-items:flex-start; gap:16px on the card or item container.
- The icon element MUST have flex-shrink:0 so it never compresses.
- Body text or description paragraphs below the heading MAY sit in a separate block beneath the row.
- The only exception is a centered icon-above-heading card used in a symmetrical multi-column feature grid — in that case flex-direction:column; align-items:center is permitted, AND the eyebrow/label, heading, and icon must all be center-aligned to each other (text-align:center on every line), with no element starting further left or right than another. THIS EXCEPTION REQUIRES A GENUINE HEADING ELEMENT (h2-h6) — it does NOT cover a bare stat/value block with no heading at all (e.g. an icon paired only with a value line and a sublabel line, like "$6,200" / "in 30 days", with nothing that functions as a heading). A confirmed real-world failure: a 2-column grid of earnings-stat cards (icon + dollar amount + timeframe, no heading) was built using this column/centered exception just because the cards formed a symmetrical multi-column grid — that's the wrong rule for this content type. A bare stat/value block with no heading is governed exclusively by ICON LEFT OF A STAT/VALUE BLOCK (NO HEADING) below, which requires the icon to sit BESIDE the stacked text as a horizontal row, never above it, regardless of whether the cards form a symmetrical grid.
- ICON OR BADGE BESIDE A CARD'S HEADING — THE CORE RULE, STATED ONCE, APPLIES EVERYWHERE — NON-NEGOTIABLE: This rule applies to ANY piece of content that sits beside a card's heading as its own sibling element — an icon (Font Awesome icon, emoji, SVG, a circular icon button like an "X" or checkmark), a number, a pill, a badge, a label, or literally anything else that could occupy that position. The deciding factor is ALWAYS the rendered width of that element, never what kind of element it is or what it's called. If that content is LESS than 40px wide, it MUST be vertically aligned with the heading ONLY — side by side on the same line, its vertical center matching the heading's vertical center. ALL other content (paragraphs, body text, value lines, anything else in the card) MUST fall below the icon and heading, never beside them and never influencing their vertical alignment. If that content is GREATER than 40px wide, it must be removed from beside the heading and placed in its own row, CENTER-ALIGNED, directly above the heading — both the badge and the heading centered, the badge sitting above, never beside it once it crosses this width. This single rule governs every card type with no separate exceptions by card name — module cards, pain-point cards, feature cards, bonus cards, benefit cards, and any other card variant all follow this exact same under-40px / over-40px logic; there is no card type, and no content type (icon vs. pill vs. badge vs. number vs. anything else), that follows different alignment behavior.
  WHY THIS KEEPS FAILING AND WHAT TO WATCH FOR: A confirmed real-world failure, recurring across multiple generations: an icon under 40px wide still rendered visually low/detached, appearing aligned against the gap between the heading and the paragraph below it (or against the card's full content block) rather than against the heading alone. This happens because a grid or flex row's `align-items:center` centers against whatever height that row track expands to — if the heading wraps to multiple lines, or if the paragraph is accidentally included as a sibling in that same row/grid track, "centered" stops meaning "centered on the heading" and starts meaning "centered on the whole row." The fix is structural, not just a value to memorize: the icon and heading must be siblings inside their OWN row/grid track, with the paragraph and all other content in a SEPARATE track below — never let the paragraph share a row with the icon and heading, even invisibly through inherited height.
  EXACT CSS FOR THE UNDER-40PX CASE, COPIED VERBATIM RATHER THAN REWRITTEN: 
  .[card-header-class] { display: grid; grid-template-columns: auto 1fr; grid-template-rows: auto auto; column-gap: var(--space-sm); row-gap: 0.4rem; }
  .[card-header-class] .[icon-or-number-class] { grid-column: 1; grid-row: 1; align-self: start; margin: 0; }
  .[card-header-class] h2, .[card-header-class] h3, .[card-header-class] h4 { grid-column: 2; grid-row: 1; align-self: start; margin: 0; text-align: left; }
  .[card-header-class] p { grid-column: 1 / -1; grid-row: 2; margin: 0; text-align: left; }
  Replace `[card-header-class]` and `[icon-or-number-class]` with whatever class names you're actually using for this card. The structure and property values must remain exactly as shown — `align-self: start` on BOTH the icon and the heading individually, never `align-items: center` on the parent grid container itself. Setting `align-items:center` on the container is the single most common mistake causing this rule to fail: that property affects every item in the row by the row's full track height, regardless of how many lines any one item wraps to, which is the actual recurring root cause.
  CONFIRMED REAL-WORLD FAILURE — NAMED EXAMPLE FOR THE UNDER-40PX CASE: A "pain-point" or "problem" card containing a small circular icon (e.g. a red circle with an "X" mark, clearly well under 40px wide) above a heading like "Glitchy AI Output," with the heading rendering on its own line below the icon instead of beside it on the same line — the same layout the over-40px case correctly uses, misapplied to content that doesn't qualify for it. A small icon under 40px is never given its own centered row above the heading; it must sit beside the heading at all times, using the under-40px grid template shown above (icon in column 1, heading in column 2, both `grid-row:1`). This failure is not specific to "X" icons or pain-point cards — any small icon, checkmark, number, or other sub-40px element sitting above rather than beside its heading is this exact same mistake, regardless of what the icon looks like or what the card is called.
  SCOPE CHECK BEFORE APPLYING ANY OF THIS — DOES THIS EVEN APPLY HERE: This rule governs a card where the icon/badge and the heading are two SEPARATE sibling elements. It does NOT apply to a standalone eyebrow/pill/badge that contains its own icon AND text together inside one single element with no separate heading nearby (e.g. a "🚀 THE SYSTEM" eyebrow badge) — that case is governed by ICON STAYS ATTACHED TO TEXT IN PILLS AND EYEBROWS and the pill/badge rules elsewhere in this document instead. A confirmed real-world failure: this rule was once misapplied to a standalone eyebrow with no heading involved at all. Before applying anything above, confirm there is a genuine separate heading element (h2-h6) sitting beside the icon/badge as its own sibling — if not, this rule does not apply.
  MOBILE BREAKPOINT (max-width:767px) FOR THE OVER-40PX CASE: When the icon/badge is 40px or wider, the "own row, centered, above the heading" layout applies on EVERY breakpoint including desktop/tablet — this is not a mobile-only exception, it is the badge's permanent layout once it crosses 40px. Use `flex-direction: column; align-items: center; text-align: center` on the row container, or `grid-template-columns: 1fr; justify-items: center; text-align: center` (single column, centered) — never leave the icon/badge or heading left-aligned in this stacked layout; both must be centered.
  EXACT CSS FOR THE OVER-40PX CASE, COPIED VERBATIM RATHER THAN REWRITTEN — DO NOT REUSE THE UNDER-40PX GRID TEMPLATE ABOVE FOR THIS CASE:
  .[card-header-class] { display: flex; flex-direction: column; align-items: center; text-align: center; }
  .[card-header-class] .[badge-class] { margin: 0 0 0.6rem; }
  .[card-header-class] h2, .[card-header-class] h3, .[card-header-class] h4 { margin: 0 0 0.4rem; text-align: center; }
  .[card-header-class] p { margin: 0; text-align: center; }
  Replace `[card-header-class]` and `[badge-class]` with whatever class names you're actually using. Note this is a completely different structure from the under-40px case above — flex column, not `display:grid; grid-template-columns:auto 1fr`. Do NOT take a badge/heading pair that's over 40px wide and force it into the under-40px grid template just because that template is the more familiar or more frequently-used pattern — width is the only thing that decides which of these two templates applies, never habit or which one feels like the "default" card layout.
  CONFIRMED REAL-WORLD FAILURE — NAMED EXAMPLE: A "module" card type (e.g. a numbered course/curriculum card with a "Module 5" or "Module 7" pill-style label, clearly over 40px wide once it contains a word and a number) was still built using the under-40px grid template (`grid-template-columns:auto 1fr` with the badge pinned to column 1 and the heading pinned to column 2 of the same row). The result: the badge and heading rendered visually overlapping each other, and on mobile — where a separate blanket rule typically forces every grid on the page to `grid-template-columns:1fr`, collapsing that 2-column grid down to one column — the heading's `grid-column:2` placement had no real second column left to occupy, producing an implicit, severely undersized column that wrapped the heading text down to one or two characters per line. The fix was switching that module card's header to the flex-column stacked structure shown above, exactly like a bonus card's badge already correctly does. Module cards are explicitly included in the "every card type, no exceptions" list above — a "Module #" badge is not a special case, it is a standard over-40px badge and must use the over-40px template every time, regardless of what the card or its badge is named.
  RECURRING FAILURE, SECOND CONFIRMED INSTANCE — A "Module 3" pill badge with rounded/pill styling and visible horizontal padding, sitting cleanly side-by-side with a two-line heading (no overlap this time — the layout itself was simply still wrong): the badge and heading were placed beside each other using the under-40px side-by-side pattern, when a word + number inside a padded pill shape is essentially never under 40px wide. This confirms the failure isn't only about overlap — a badge can render beside a heading with no visual collision and still be violating this rule, because the deciding factor is the badge's own width, not whether it currently "looks fine" next to the heading.
  MANDATORY PRE-FINALIZE WIDTH CHECK — DO THIS FOR EVERY CARD WITH A BADGE/ICON BESIDE A HEADING, NO EXCEPTIONS: Do not eyeball whether a badge "looks small enough" — estimate its rendered width mechanically before deciding which template to use, the same way headline length is checked by character count elsewhere in this document. For any badge/pill containing text (a word, a number, or both — e.g. "Module 3", "Bonus 1", "Step 2"): if it has visible horizontal padding (a pill/badge shape, not a bare icon glyph) AND contains more than a couple of characters of text, treat it as OVER 40px by default — a single Font Awesome icon glyph or a bare 1-2 digit number with no padding is the only case that's reliably under 40px. When in doubt, default to the over-40px template (stacked, centered above the heading) rather than the under-40px template ONLY after confirming the bare-icon exception below does not apply — both directions of this mistake are real, visible failures, not just one of them. Before finalizing any card's CSS, explicitly state which case applies and why, the same way the headline character-count check requires you to count and state a result before picking a font-size ceiling.
  THE "WHEN IN DOUBT" DEFAULT DOES NOT OVERRIDE THE BARE-ICON EXCEPTION — THIRD CONFIRMED FAILURE, THE OPPOSITE MISTAKE: A single bare icon glyph with no pill/badge background around it (e.g. a plain padlock icon, a checkmark, a single Font Awesome icon with no colored circle, border-radius box, or padding wrapping it) was incorrectly stacked above its heading, when a bare icon glyph like this is never ambiguous — it is always under 40px and must sit beside the heading on the same line, every time, with zero exceptions. The "when in doubt, default to over-40px" instruction above applies ONLY to genuinely ambiguous cases — text-bearing pills/badges where you can't be certain of the rendered width without measuring. It does NOT apply to a bare icon glyph on its own with no background shape: that case is never in doubt and must always use the under-40px side-by-side template. Run this exact check before finalizing: does the icon/badge have its own background color, pill shape, or padding box around it? If NO (it's just the icon/glyph itself, nothing wrapping it) → always under 40px, always beside the heading, no further judgment needed, regardless of its font-size value or unit. If YES (it has a background/pill/padding) AND contains text → apply the width-estimation check above.
  REM/EM FONT-SIZES MUST BE CONVERTED TO PIXELS BEFORE COMPARING AGAINST THE 40PX LINE: Icon and badge font-sizes are frequently written in `rem` or `em` rather than `px` (e.g. `font-size: 2rem`), and confusing a rem value for a pixel value is a confirmed source of misjudging this rule — a value like "2rem" can look numerically close to "40" and trigger an incorrect "this seems borderline, play it safe" instinct, when 2rem is actually 32px (assuming the standard 16px root), nowhere near 40px on its own merits. Before judging any element's width against the 40px threshold, convert: with a 16px root, 1rem = 16px, 1.5rem = 24px, 2rem = 32px, 2.5rem = 40px, 3rem = 48px. A bare icon glyph at any of these font-sizes is still governed entirely by the bare-icon exception above (no background/pill = always under 40px, regardless of font-size) — this conversion matters specifically for badges/pills that DO have a background and contain text, where the badge's actual rendered width (font-size of the text plus its horizontal padding) is what must be estimated, never the font-size number read at face value as if it were already a width in pixels.
- For all other card and list-item patterns, row alignment is mandatory.
- DO NOT APPLY THIS GRID PATTERN TO FORMS OR ANY CONTAINER WITH REPEATING SIBLINGS — CRITICAL: The icon+heading grid technique above (`grid-template-columns:auto 1fr; grid-template-rows:auto auto` with the icon pinned to row 1 and the heading pinned to row 1) is designed for exactly ONE icon/number + ONE heading + ONE paragraph per card. NEVER apply this grid pattern — or any rule that pins multiple elements to the same `grid-row` — to `.form-card`, `.form-group`, `.capture-form-wrap`, or any other container that holds multiple repeating sibling elements (form fields, list items, FAQ entries, etc.). Doing so pins every sibling into the exact same grid cell, causing them to visually stack directly on top of each other (e.g. the First Name field's label and input rendering on top of the Email field's label and input, all overlapping illegibly). Forms must use simple vertical block/flex stacking (one `.form-group` per row, top to bottom) — never a 2-row icon-card grid. If you find yourself naming a class `*-card` and reflexively reaching for the icon+heading grid pattern, first check whether that container actually holds a single icon/heading/paragraph trio or a list of repeating fields/items — only the former gets the grid treatment.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
RESPONSIVE RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

* The scroller must remain seamless on:

  * Desktop
  * Tablet
  * Mobile

* Responsive layouts must not break the loop.

* Responsive layouts must not create empty gaps.

* Responsive layouts must not expose the animation reset point.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FINAL QA CHECK
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before returning HTML verify:

✓ Scroller is inside an existing section.
✓ Scroller is NOT wrapped in its own section.
✓ Scroller spans full section width.
✓ Track contains duplicated content.
✓ Animation is infinite.
✓ Animation is linear.
✓ No visible start point exists.
✓ No visible end point exists.
✓ No visible reset exists.
✓ No empty space appears during animation.
✓ Content exits one side while duplicate content enters the opposite side.
✓ Loop appears continuous forever.
✓ Desktop loop is seamless.
✓ Tablet loop is seamless.
✓ Mobile loop is seamless.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SCROLLER IMPLEMENTATION RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🚨 NON-NEGOTIABLE

When a scroller, marquee, ticker, logo strip, trust strip, testimonial strip, or announcement strip is used, it MUST be implemented as a true seamless infinite loop.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
REQUIRED TRACK STRUCTURE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Required structure:

Scroller Viewport
└─ Scroller Track
├─ Content Set A
└─ Content Set B (exact duplicate)

* Content Set B must be an exact duplicate of Content Set A.
* Duplicate the content exactly once.
* Never create a single-track marquee.
* Never create a marquee that visibly resets.
* Never create a marquee that reaches an end point.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
REQUIRED ANIMATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Use:

@keyframes scroll {
from {
transform: translateX(0);
}
to {
transform: translateX(-50%);
}
}

Animation requirements:

* linear timing
* infinite iteration
* no pauses
* no easing
* no bounce effects
* no reverse direction unless explicitly requested

The animation must appear continuous forever.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SCROLLER ITEM RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Every scrolling item must use:

display: inline-flex;
align-items: center;
white-space: nowrap;

Recommended:

gap: 0.5em;

Never use:

display: inline-block;

for scroller items that contain icons, logos, SVGs, badges, or mixed content.

Items must remain vertically centered at all times.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CLIPPING PREVENTION RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Scroller items must NEVER appear clipped, cut off, cropped, truncated, or partially hidden at the left or right edge.

Required:

1. Outer viewport container:

   * overflow: hidden
   * width: 100%
   * max-width: 100%

2. Animated track:

   * must remain fully visible internally
   * NEVER use overflow:hidden
   * NEVER use clip
   * NEVER use clip-path

3. Individual items:

   * must include sufficient internal horizontal padding
   * text and icons must never touch item edges

4. Outer wrapper:

   * must not artificially reduce visible width
   * must not introduce horizontal clipping

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FULL WIDTH RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

* Every scroller must span the full available width of its parent section.
* Width must never collapse to content width.
* Width must never stop at the last logo.
* Width must visually extend across the section.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
GAPLESS LOOP VALIDATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before returning HTML verify:

✓ No visible start point.
✓ No visible end point.
✓ No visible reset.
✓ No flashing.
✓ No empty space during looping.
✓ Duplicate content exists.
✓ Track scrolls continuously.
✓ One content set exits while the duplicate enters.
✓ Loop remains seamless on desktop.
✓ Loop remains seamless on tablet.
✓ Loop remains seamless on mobile.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ANIMATED ICONS & SCROLL INDICATORS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Any animated icon, bouncing arrow, scroll indicator, floating chevron, or directional cue:

* must be horizontally centered

* must use:

  position: absolute;
  left: 0;
  right: 0;
  margin: 0 auto;
  width: fit-content;

* must be the LAST element in the section's HTML source order

* must never be placed inside:

  * forms
  * grids
  * columns
  * card layouts
  * flex item groups

The indicator must remain independent of the section's content layout.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FOOTER RULES — NON-NEGOTIABLE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The footer is a FULL-WIDTH page-level element.

The footer must visually span from the extreme left edge of the viewport to the extreme right edge of the viewport.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FULL WIDTH REQUIREMENTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The footer, .site-footer, footer, and #footer MUST ALWAYS use:

width: 100%;
min-width: 100%;
max-width: 100%;

The footer must:

✓ span the full viewport width
✓ extend edge-to-edge
✓ match the width of the widest section on the page
✓ never appear inset
✓ never appear boxed
✓ never appear narrower than any section above it

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CONTAINER RESTRICTION PROTECTION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The footer must NEVER inherit:

* max-width
* container width restrictions
* page wrapper width restrictions
* content wrapper width restrictions

Forbidden:

max-width: 1200px;
max-width: 1400px;
max-width: var(--container-width);

Forbidden structure:

<div class="container">
    <footer>
    </footer>
</div>

Required structure:

<footer>
    <div class="container">
        Footer Content
    </div>
</footer>

The footer itself must always be full width.

Only inner content MAY be constrained.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
BACKGROUND COVERAGE RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The footer background must extend across the entire viewport width.

No exposed page background MAY appear:

* left of the footer
* right of the footer
* beneath the footer

Footer background coverage must be continuous edge-to-edge.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
INNER CONTAINER RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Footer content MAY use:

.container
.footer-container
.footer-inner

for content alignment.

However:

* inner containers MAY constrain content
* inner containers MAY NOT constrain footer width
* inner containers must remain background: transparent

The footer background belongs on the footer itself.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
RESPONSIVE FOOTER RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Footer layouts must collapse gracefully.

Desktop:

* multiple columns allowed

Tablet:

* reduce columns as needed

Mobile:

* stack vertically when necessary

Never allow:

* horizontal scrolling
* clipped columns
* overlapping content
* compressed unreadable columns
* vertical writing mode

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
VERTICAL TEXT PROTECTION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Text must NEVER flow vertically.

Apply:

writing-mode: horizontal-tb;

to all footer elements.

Any layout that cannot fit must stack vertically.

Never rotate text.
Never allow overflow that creates vertical text.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FOOTER GRID RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Avoid orphaned rows.

Examples:

4 items
✓ 2 columns × 2 rows

✗ 3 columns + orphaned item

6 items
✓ 3 columns × 2 rows

✓ 2 columns × 3 rows

5 items
✓ 1 column on mobile
✓ 5-column layout if space allows
✓ balanced layout

✗ single orphaned item stranded on its own row

Choose the column count that creates the most balanced layout.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FOOTER BACKGROUND INHERITANCE RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Inside the footer:

All non-card elements must remain:

background: transparent;

Never assign background colors to:

* wrappers
* containers
* layout divs
* grid wrappers
* flex wrappers
* footer-inner
* footer-content
* footer-columns

Only intentionally designed components MAY have backgrounds:

* cards
* CTA blocks
* callouts
* highlighted offers
* promotional boxes

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
LAST ELEMENT RULE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The final visible footer content must terminate cleanly.

No spacer divs.
No empty rows.
No empty columns.
No unnecessary margin-bottom.

Footer bottom padding MUST be the only spacing beneath the final content.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FINAL FOOTER VALIDATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before returning HTML verify:

✓ Footer spans full viewport width.
✓ Footer is not wrapped inside a container.
✓ Footer background reaches both viewport edges.
✓ Footer is never narrower than sections above.
✓ Inner containers are transparent.
✓ No wrapper backgrounds exist.
✓ No orphaned grid items exist.
✓ No vertical text exists.
✓ Mobile layout stacks correctly.
✓ No horizontal scrolling exists.
✓ No clipped content exists.
✓ Footer background covers the entire footer area.
✓ Footer content remains centered inside transparent inner containers.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TYPOGRAPHY RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- NO EM DASHES — NON-NEGOTIABLE: Generated copy must NEVER use an em dash (—) or an en dash used as an em-dash substitute (–), anywhere on the page — headlines, subheadings, body copy, list items, button text, microcopy, disclaimers, FAQ answers, alt text, anywhere. Rewrite using a comma, period, colon, semicolon, or parentheses instead, or split into two sentences. Applies to every section type and every page type with no exceptions.
- Body text line-height: ALWAYS use unitless 1.5 — never a fixed rem/px value (1.5rem is forbidden). Unitless scales proportionally with each element's own font-size, so paragraph text at any size — footer disclaimers, body copy, larger subheadings — gets a consistent, comfortable line-gap ratio instead of a fixed gap that's too tight for large text or too loose for small text.
- p { line-height: 1.5; } must be present in every generated page's CSS.
- Body text minimum size: var(--text-lg) — never below 1rem on mobile (prevents iOS zoom).
- HEADLINE MAX-WIDTH: ALL h1–h4 elements and the first paragraph immediately following a heading must have max-width: 1080px on desktop and max-width: 100% on mobile.
- SECTION FIRST-HEADING MINIMUM FONT-SIZE — NON-NEGOTIABLE, APPLIES TO EVERY SECTION ON THE PAGE: The first heading in every section (the section's main h2 or h3 — the headline that introduces that section, e.g. "Most AI Hustlers Are Broke," "The Complete 7-Module System," "This Special Launch Price Expires Soon") must never render smaller than: 35px on desktop (1025px+), 30px on tablet (768px–1024px), 25px on mobile (max-width:767px). These are hard minimums, not suggested starting points — if your heading uses a clamp() or relative unit that could resolve below these values at any breakpoint, raise the floor of that clamp/value so it never drops under the minimum for that breakpoint. This applies regardless of which section it is — problem, solution, modules/features, bonuses, testimonials, pricing, guarantee, urgency/CTA, FAQ, about, optin, or any other section type — every one of them has a first heading, and that heading must meet this minimum. A confirmed real-world failure: a CTA section's headline rendered visibly undersized relative to the rest of the section — smaller than the eyebrow badge above it and not commanding the visual weight a section headline needs. Write explicit font-size rules for each section's first heading at all three breakpoints in your css field rather than relying on a generic h2 default that may not meet these minimums. This rule does NOT apply to the hero's main h1 (which has its own separate, larger font-size rule under HERO HEADING FONT-SIZE in hero.md) or to sub-headings that follow the section's first heading (e.g. a card's own h3/h4 inside a grid) — it applies specifically to the one heading that introduces each section as a whole.
- CLASS NAME REQUIRED ON CENTERED TEXT — NON-NEGOTIABLE: Whenever you center an h1–h6 or p element (via `text-align: center` in CSS or as an inline style), that element's HTML tag must also carry the class "text-center" in its class list, in addition to whatever other classes it already has (e.g. `<h2 class="section-headline text-center">`, `<p class="hero-subhead text-center">`). This applies every time text-align:center is used on one of these elements, with no exceptions. The platform's landing-base.css uses this exact class name as a fallback safety net (`section > .text-center:is(h1,h2,...)`) that applies balanced text wrapping and a responsive max-width automatically — this only works if the class is actually present on the element, so never skip it just because you've already written the centering CSS yourself.
  EXCEPTION — BORDERED CALLOUT BOXES: Any bordered callout/highlight box (e.g. `.problem-callout`, `.urgency-box`, or any similar bordered box wrapping a single block of emphasized text, often paired with a leading icon/emoji) must NOT be centered. Set text-align: left on both the box's heading (if present) and its body/paragraph text instead, and do NOT add the "text-center" class to either. If the box also contains a list (`<ul>`/`<li>`, e.g. a `.urgency-list`), the list items need this exact same explicit `text-align: left` too — a list item is not a "paragraph" by name, but it is body text by function, and it inherits centering from the same ancestor exactly like a paragraph would. This is a deliberate exception to TEXT ALIGNMENT RULE #1 below: a box whose width is not fixed (e.g. width: fit-content) being centered can cause issues with the box's own sizing depending on its content. Left-aligning avoids this entirely. The heading, the paragraph text, AND any list items inside the same callout box must all share this left alignment — never mix a centered heading with left-aligned body text (or left-aligned text with an uncovered list) in this component, per COLUMN TEXT ALIGNMENT CONSISTENCY.
- ANY TEXT WITH A LEADING ICON MUST EXPLICITLY SELF-DECLARE `text-align: left` — NON-NEGOTIABLE: Any text paired with an icon positioned to its left — a list item (`<li>` in `.urgency-list`, `.solution-identity-list`, `.pricing-features-list`, or any similarly-structured list), a single icon+text row, or any other icon-prefixed line anywhere on the page — must have `text-align: left` written explicitly on the text itself. Never rely on inheriting `left`/`start` from an ancestor by default, even if the current ancestor happens to not be centered — write the declaration directly on the icon-text element regardless. The platform's own CSS already had to patch this exact failure once before in a different component (`.pricing-card ul li { text-align: left; }` in landing-base.css, needed specifically because `.pricing-card` centers its content), and the same failure recurs anywhere else an icon-prefixed line sits inside a section/container that defaults to centered text — which is extremely common, since most sections center their heading/subhead/eyebrow. A CONFIRMED REAL-WORLD FAILURE: an icon-prefixed urgency-list item (`✕ Access to the current launch pricing — prices increase without notice`) rendered correctly on desktop, where the line never wrapped — centered vs. left-aligned text looks identical on a single line. The exact same markup, at mobile width, wrapped onto three lines that were each independently centered, since the `<li>` had no `text-align` of its own and silently inherited `center` from an ancestor. The bug was invisible on desktop and only became visible once wrapping occurred on a narrower viewport — always write the explicit `text-align: left` regardless of whether the bug is currently visible at the breakpoint you're checking.
- TEXT ALIGNMENT RULES (ABSOLUTE):
  1. In any full-width single-column section, ALL text — headings, subheadings, body paragraphs, descriptions, and supporting copy — MUST be centered (text-align:center; margin-left:auto; margin-right:auto) and must carry the "text-center" class per CLASS NAME REQUIRED ON CENTERED TEXT above. There are NO exceptions for paragraph text in a single-column context.
  2. Body text, paragraph text, and long descriptions MUST be left-aligned ONLY when they appear inside a multi-column layout (2+ columns side by side) or inside a card/callout box within a grid.
  3. Headings, subheadings, and body text inside a multi-column layout (2+ columns) MUST ALL be left-aligned within their column — never centered inside a column.
  4. Short single-line elements (eyebrows, CTAs, stat labels, stat values) MUST be centered in both single-column and multi-column contexts.
  5. Stats rows / metric grids: the stat number and stat label inside each stat cell are centered within that cell. The stat cell itself is centered in the row. This rule overrides the left-align rule.
  6. CARD HEADING ALIGNMENT: When a card or callout box uses left-aligned body text, its heading MUST also be left-aligned. Never center a heading above left-aligned body text inside a card.
  7. PRICING & STAT EXCEPTIONS: Pricing card headers (plan name, price, strikethrough price) and stat/metric cards MUST always center their content, even when placed in a column grid. These elements are exempt from the left-align column rule.
- ICON VERTICAL ALIGNMENT: When a card has an icon above a heading, the left edge of the heading MUST align with the left edge of the icon.
- NO FORCED LINE BREAKS IN HEADINGS — NON-NEGOTIABLE: Headings (h1–h6 and any element with a class containing "headline", "heading", or "title") must NEVER contain <br> tags, \n characters, or any other forced line break. Write headings as one continuous string of text and let the browser wrap them naturally based on container width and font-size. A <br> inside a heading is always wrong — remove it and let the "text-center" class (per CLASS NAME REQUIRED ON CENTERED TEXT above, when the heading is centered) handle the visual balance instead.
- COLUMN TEXT ALIGNMENT CONSISTENCY — NON-NEGOTIABLE: Within any column in a multi-column layout, all text elements must share the same alignment. If the heading in a column is left-aligned, EVERY other element in that column (subheading, body text, list items, labels, captions, CTAs) must also be left-aligned. If the heading is centered, all text in that column must be centered. NEVER mix left-aligned headings with centered body text or vice versa within the same column. Alignment is set once per column and applies uniformly to every text element inside it. This includes the heading itself — if body text in a column is left-aligned, the heading MUST also be left-aligned. If body text is centered, the heading MUST also be centered. The heading does NOT get to be a different alignment from the rest of the column.
- CENTERED CONTENT CASCADE — NON-NEGOTIABLE: When a heading or subheading is center-aligned, ALL content that directly follows it in the same section flow must also be center-aligned — including buttons (`display:flex; justify-content:center` on button wrapper or `margin:0 auto` on button), and any content (trust badges, disclaimers, social proof snippets) directly after those buttons.
- BUTTONS ALWAYS CENTER ON TABLET AND MOBILE — NON-NEGOTIABLE, OVERRIDES DESKTOP ALIGNMENT, ZERO EXCEPTIONS: Regardless of how a button is aligned on desktop — left-aligned inside a multi-column layout per COLUMN TEXT ALIGNMENT CONSISTENCY above, or centered in a single-column section — every single button on the page (`.btn`, `button.btn`, or any other button-style element, in EVERY section, including the hero, problem, solution, features, modules, bonuses, testimonials, pricing, guarantee, urgency/CTA, and optin form sections) MUST be horizontally centered at the tablet breakpoint specifically (max-width:1024px) AND at the mobile breakpoint (max-width:767px). TABLET IS NOT AN AFTERTHOUGHT — IT IS EXPLICITLY CALLED OUT BECAUSE IT IS THE MORE COMMONLY MISSED OF THE TWO: a confirmed real-world pattern is the model correctly centering a button at the mobile breakpoint while leaving the desktop left-alignment unchanged all the way down to 1024px, only flipping to centered once the viewport drops below 767px — this is wrong. The button must already be centered at the WIDER tablet breakpoint (≤1024px), not just at the narrower mobile one. Write (or verify you have written) an explicit `@media (max-width:1024px)` rule centering every button, separate from and in addition to your `@media (max-width:767px)` mobile rule — do not assume the mobile rule alone covers the tablet range. MECHANICAL CHECK BEFORE FINALIZING: for every button on the page, ask "is there a centering rule for this button that activates at 1024px or wider, not just at 767px?" If the answer is no, the button is currently left-aligned (or following some other desktop alignment) all the way from desktop down through tablet width, which fails this rule. This applies even when the button sits inside a left-aligned column of a two-column layout that has collapsed to a single stacked column per TABLET & MOBILE 2-COLUMN COLLAPSE below — the surrounding text in that column may correctly remain left-aligned while the button itself switches to centered. Use `display:flex; justify-content:center` on the button's direct wrapper, or `margin-left:auto; margin-right:auto; display:block` on the button itself, at both breakpoints. This is a deliberate breakpoint-specific exception to COLUMN TEXT ALIGNMENT CONSISTENCY's "everything in a column shares one alignment" rule — that rule still governs headings/body text/labels within a column, but buttons specifically always center once the viewport narrows to tablet width or below.
- HEADINGS FILL CONTAINER WIDTH — NON-NEGOTIABLE: A heading (centered OR left-aligned) must be sized large enough that its text comfortably spans the width of its container — never a narrow snippet of text floating in a wide box with excess unused space beside or around it. If a heading looks small relative to the space around it, increase font-size until the text reasonably fills the container width (respecting the 40px cap for the left column of two-column layouts per TWO-COLUMN LEFT COLUMN HEADING AND SUBHEADING ALIGNMENT, when that cap is actually in effect). Use font-size: clamp() with a generous maximum that allows the text to expand to fit. This is especially important in countdown timers, pricing boxes, callout banners, single full-width step/feature cards, and any bordered container with a heading. EXCEPTION — HERO H1: This rule does NOT apply to the hero's main h1. The hero headline has its own separate, hard caps under HERO HEADING FONT-SIZE in hero.md — a character-count-based bracket table topping out at 80px desktop / 68px tablet / 43px mobile for the shortest headlines (pattern A), or a flat 45px cap for the two-column/split layout (pattern B) — that bracket's cap always wins for the hero h1, even if the headline text doesn't visually fill the full width of `.hero__head`. Do not raise the hero h1's clamp() maximum past its bracket's cap to satisfy this rule.
- ICON STAYS ATTACHED TO TEXT IN PILLS AND EYEBROWS — NON-NEGOTIABLE: In any pill, badge, eyebrow, or similar inline label that contains an icon followed by text, the icon must NEVER wrap to its own line separate from the text. Use white-space:nowrap on the icon element (or wrap the icon + first word together in a <span style="white-space:nowrap">) so the icon always stays on the same line as at least the first word of the text. The remaining text is free to wrap to additional lines below. This prevents the icon from being stranded alone at the start of a line with all the text wrapped away from it.
- ICON VERTICALLY ALIGNED WITH TEXT INSIDE THE SAME PILL/EYEBROW — NON-NEGOTIABLE: Within that same pill/badge/eyebrow element, the icon and the text sitting next to it on the same line must be vertically aligned with each other — the icon must not sit visibly higher or lower than the text's baseline/center. Use `display:inline-flex; align-items:center` on the pill/badge container (rather than relying on default inline text-flow alignment, which can misalign an icon glyph against surrounding text depending on font metrics and icon size), with `gap: 0.4em` or similar between the icon and text. This applies to every pill/badge/eyebrow on the page, regardless of icon type (font icon, emoji, SVG) or text length.
- BONUS BADGE ENLARGEMENT — ADDITIONAL REFINEMENT ON TOP OF THE CORE 40PX RULE ABOVE, NOT A SEPARATE LAYOUT: A bonus card's "Bonus #" style badge (e.g. "Bonus 1," "FREE Bonus #3") combined with an icon is virtually always over 40px wide, so it already falls under the "over 40px → own row, centered, above the heading" case from the core rule above — this entry adds one bonus-specific refinement on top of that base layout, it does not redefine it. Render the badge label and icon together at a noticeably larger scale than a standard inline pill (e.g. icon at 1.5–2rem, label text at 1.1–1.25rem, both bold) so it reads as a prominent visual anchor for the card. Position it above the value line specifically (not just generically "above the heading") when the card includes one — value line, then heading, then body text, in that order beneath the enlarged badge. The icon and "Bonus #" label still sit side by side with each other within that single enlarged badge — it's the badge as a whole that occupies its own centered row above the rest of the card, per the core rule.
- MULTI-COLUMN HEADING LINE PARITY — NON-NEGOTIABLE: When two or more columns sit side by side and each column has a heading, ALL headings in that row MUST wrap to the same number of lines so the content beneath them stays vertically aligned across every column. Before finalizing a multi-column layout, count how many lines each heading wraps to at the chosen font-size and column width. If any heading wraps to more lines than the others, REDUCE the font-size of ALL headings in that row (not just the longer one) until every heading wraps to the same line count. Never let one column's heading run longer than another's — it pushes all the body content below it downward and breaks the visual alignment of the entire row. A shared font-size that produces equal line counts across all columns is always required, even if that means sizing down from the preferred heading size.
- TWO-COLUMN LEFT COLUMN HEADING AND SUBHEADING ALIGNMENT — NON-NEGOTIABLE: In any two-column side-by-side layout (including split hero, feature split, text-image, or any flex/grid row with exactly 2 children), the following rules apply to the left column only, without exception:
  1. Every heading (h1–h6) in the left column MUST be left-aligned (text-align:left). NEVER center a heading in the left column of a two-column layout.
  2. Every heading in the left column MUST NOT exceed 40px (max font-size: 2.5rem). Use clamp() with a maximum of 2.5rem. This cap is absolute — it cannot be overridden by content requirements, brand preferences, or visual hierarchy decisions. EXCEPTION — SPLIT HERO ONLY: The hero's two-column/split layout (pattern B in HERO HEADING FONT-SIZE in hero.md) uses a 45px cap instead of 40px — this is the one specific case where this rule's general 40px cap is raised by 5px. Every other two-column context (feature split, text-image, or any other 2-column row) still uses the 40px cap with no exception.
  3. Every subheading, supporting paragraph, or descriptive text immediately following a heading in the left column MUST also be left-aligned. NEVER center subheadings or body text in the left column.
  4. These rules apply at every breakpoint where the two columns remain side by side. Once they stack to single-column on mobile, normal single-column alignment rules resume.
- POST-HEADING SUBTEXT: Any element immediately after a heading in a full-width section must have max-width:1080px; margin-left:auto; margin-right:auto; text-align:center on desktop, and max-width:100% on mobile, and must carry the "text-center" class per CLASS NAME REQUIRED ON CENTERED TEXT above. Apply the inline style directly on the element: style="max-width:1080px;margin-left:auto;margin-right:auto;text-align:center;display:block;" and add class="text-center" to that same element's class list.
- POST-HEADING SUBTEXT INLINE STYLE — MANDATORY: Apply the max-width and centering DIRECTLY as an inline style on the subtext element itself. Do not rely on a parent class or stylesheet rule.
- HEADING-TO-SUBHEADING SPACING: margin-bottom on every section heading before its immediately-following paragraph must be no more than 1rem (16px).
- SUBHEADING-TO-CONTENT SPACING: margin-bottom on every subheading before following content must equal the margin-bottom used between the heading and subheading above it. If no heading above, exactly 35px.
- LIST ITEM SPACING: Inside the hero section: margin-bottom: 10px. In ALL other sections: margin-bottom: 5px.

- LIST TEXT FILLS CONTAINER WIDTH — NON-NEGOTIABLE: Any `<ul>`/`<li>` list (pricing feature lists, benefit/checkmark lists, bonus lists, urgency lists, value-stack lists, or any other list-based content) must use a font-size large enough that the text comfortably fills the width of its container — never a small, narrow-looking line of text with excess unused space beside it inside a wide card or box. This mirrors the HEADINGS FILL CONTAINER WIDTH rule above but applies to list/body text specifically. Use font-size: clamp() with a sensible minimum and a generous maximum so list text scales up to use the available width rather than defaulting to a small generic body-text size. This applies on every breakpoint — list text that looks appropriately sized on desktop must be re-checked on tablet and mobile, where the container is narrower and the same font-size may now look disproportionately small relative to the new container width. Pricing card feature lists are a common failure point: do not let the checkmark list read as visually smaller/quieter than the price and heading above it.
- SHORT VALUES MUST NEVER WRAP MID-NUMBER/MID-WORD — SHRINK THE FONT-SIZE UNTIL THEY FIT ON ONE LINE — NON-NEGOTIABLE: This is the opposite failure direction from the rule above, and just as serious. A short, single-unit value that's meant to read as one visual piece — a dollar amount ("$5,000"), a stat number ("2,400+"), a large display price, or any other compact figure — must NEVER wrap onto a second line, splitting the number/word awkwardly in half. A CONFIRMED REAL-WORLD FAILURE: a row of three stat values ("$5,000", "$6,200", "2,400+") used `font-size: clamp(1.75rem, 4vw, 2.5rem)` — sized relative to the VIEWPORT width via `vw`, not the actual width of each value's own narrow flex column in a 3-up row — so at the column width that row actually produced, each number wrapped mid-digit ("$5,00" / "0") instead of staying on one line. The root cause: viewport-relative (`vw`) sizing doesn't know how narrow the specific container it's sitting in actually is — a value can be appropriately sized relative to the whole screen while still being too large for its own narrow column. Fix this by either: (a) adding `white-space: nowrap` to the value AND lowering the clamp's max so it reliably fits the narrowest column width your specific layout produces (calculate this — e.g. a 3-column row inside a 1080px max-width container with reasonable gaps leaves roughly 320–340px per column; size the max font accordingly, not generously), or (b) using a container-relative unit (`cqw` with `container-type: inline-size` set on the immediate parent) instead of `vw`, so the value's font-size actually scales against its own column's real width rather than the full viewport. Never leave a short value to wrap mid-number just because its clamp() max "usually" fits — verify it fits the narrowest realistic column width for the specific layout you built.
- EYEBROW / KICKER CENTERING: Wrap in <div style="text-align:center;width:100%;margin-bottom:25px;"> AND set style="display:inline-block;width:auto;max-width:max-content;" on the badge element itself.
- PILL / BADGE SNUG SIZING: Any pill, badge, tag, or label element must use display:inline-block; width:auto; max-width:max-content so it shrinks to fit its text content exactly — never stretching full-width or leaving trailing empty space after the text.
- PILL / BADGE MOBILE WRAP EXCEPTION — NON-NEGOTIABLE: max-width:max-content (above) forces single-line sizing that grows as wide as the text needs — on mobile, a badge with long text (e.g. a multi-word eyebrow like "AI Rebels — Create · Defy · Repeat") will overflow past the viewport edge and get visually clipped instead of wrapping, since max-content never wraps internally. To prevent this, on mobile (max-width:767px) override the badge/pill/eyebrow element to: max-width:100%; white-space:normal; text-align:center; while still keeping display:inline-block and width:auto so the badge still shrinks to content on shorter text. Write this as a max-width:767px media query rule in your css field, scoped to whichever specific badge/eyebrow/pill class you used on this page — do not rely on the desktop max-content rule alone to handle mobile. The icon-stays-attached-to-text rule (ICON STAYS ATTACHED TO TEXT IN PILLS AND EYEBROWS, above) still applies once wrapping is enabled — the icon must stay with the first word even as the rest of the text wraps to additional lines.
- MOBILE — THE BADGE/PILL ITSELF MUST BE HORIZONTALLY CENTERED IN ITS CONTAINER, NOT JUST ITS INTERNAL TEXT — NOW PLATFORM-OWNED, DO NOT WRITE THIS YOURSELF: The platform's landing-base.css automatically centers any wrapper element whose class name contains "-wrap" or "-wrapper" combined with pill/badge/tag/eyebrow/kicker (e.g. `.eyebrow-wrap`, `.modules-eyebrow-wrap`, `.bonus-badge-wrap`) via `text-align:center !important` — this positions the badge/pill itself in the middle of the wrapper, separately from the badge's own internal `text-align:center` (which only centers the text inside the badge, not the badge within the page). Use a wrapper class name containing one of those "-wrap"/"-wrapper" patterns (which you should already be doing per the existing icon+heading/card structure conventions) and the platform handles centering automatically — you do not need to write `text-align:center` or `justify-content:center` on the wrapper yourself. A confirmed real-world failure this fix addresses: a badge's own text read as centered, but the pill itself remained left-aligned in its wrapper, creating a visually inconsistent layout where the badge sits at the far left while everything below it is centered.
- EYEBROW / BADGE / LABEL CONTRAST: Pill badges, eyebrow labels, and kicker text must NEVER use a text color close to their own background or the section background. Always ensure badge background contrasts with section background AND badge text contrasts with badge background.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMAGE RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Use actual <img> tags with descriptive alt text for all foreground images.
- BACKGROUND IMAGES — ABSOLUTE: NEVER use a placeholder or any image for a CSS background. Section, hero, CTA, and overlay backgrounds must be SOLID colors, CSS GRADIENTS, or CSS PATTERNS only.
- LOGO PLACEMENT RESTRICTION — NON-NEGOTIABLE, ZERO TOLERANCE: The site logo URL provided in the prompt (BRANDING ASSETS block) MUST ONLY ever appear in these locations: the navigation/header, the hero section, or the footer. It must NEVER be used anywhere else on the page — not as a placeholder for a content image, product mockup, feature image, testimonial avatar, bonus item image, about/bio photo, background decoration, or any other body element, and not duplicated or repeated decoratively in any other section. If a body image is needed anywhere outside nav/hero/footer, use a placehold.co URL instead — never the logo URL.
- THE LOGO IS NEVER A SUBSTITUTE FOR A CONTENT IMAGE OR PLACEHOLDER, UNDER ANY CIRCUMSTANCE: This is the single most common and most severe violation of this rule. A confirmed real-world failure: the model rendered the brand logo at full section width, with no surrounding text or content visible, functioning as the entire visual content of the hero — exactly the pattern this rule forbids. The logo asset is a small identifying mark, not a hero image, not a product shot, not decorative artwork, and not filler content. If you find yourself reaching for the logo URL because you "need an image here and the logo is available," that impulse is the violation itself — stop and use a placehold.co placeholder instead.
- HERO IS A NARROW EXCEPTION, NOT A LICENSE TO USE THE LOGO AS HERO IMAGERY: being a "permitted location" does not mean the logo may serve as the hero's primary visual, product mockup, or main image. In the hero, the logo may ONLY appear as a small secondary badge (e.g. a partner co-presentation badge) sitting alongside real hero content (headline, subheadline, CTA) that remains the actual visual focus — never inside a generic content-image wrapper, never as the dominant or only visual element, never spanning the section's full width or height, and never set to `loading="eager"` as if it were the hero's main image — that treatment belongs exclusively to a placehold.co placeholder, never the logo.
- LOGO MAX-WIDTH BY LOCATION — NON-NEGOTIABLE, HARD CEILING: In the navigation/header, the logo must never exceed max-width: 180px. In the footer, the logo must never exceed max-width: 180px. In the hero section (the only other permitted location, and only as a small secondary badge as described above), the logo must never exceed max-width: 300px. These are hard ceilings, not starting points to scale up from — a logo rendered at or near these maximums should still read visually as a small supporting element relative to the rest of the section, not as the section's centerpiece. These caps apply regardless of container width, screen size, design style, or any width/height attributes you might be tempted to set on the `<img>` tag itself — never stretch, scale up, or render the logo at a larger width in any of its three permitted locations, and never omit explicit width constraints assuming the image's natural/intrinsic size will be "small enough." Never render the logo as a full-width or large decorative image anywhere it appears. This restriction applies regardless of page type, niche, or how many sections the page has — the logo's only legitimate appearances are nav, hero (as a small badge only), and footer.
- CONFIRMED REAL-WORLD FAILURE — LOGO AS BACKGROUND/DECORATIVE FILLER NEAR A FORM: the model rendered the brand logo at a massive size (filling most of a section's width/height) directly behind or beside a lead-capture/registration form, functioning as decorative background art rather than an identifying mark. This is a severe violation regardless of which section it happens in — nav, hero-badge, and footer are the ONLY three places the logo may appear, and even within those, oversized/decorative/background use is forbidden by the MAX-WIDTH and ASPECT RATIO rules above. If you find yourself placing the logo near a form, image wrapper, or empty section purely because it "fills the space," that impulse is the violation — use a placehold.co placeholder, a CSS pattern/gradient, or simply leave the space to breathe instead.
- Use https://placehold.co for foreground <img> content placeholders with appropriate dimensions.
- PLACEHOLDER TEXT RULE: Every placehold.co URL MUST display the image's actual pixel dimensions as the placeholder text — nothing else. Use ?text=WIDTHxHEIGHT at the end. Example: https://placehold.co/580x480/6c47ff/ffffff?text=580x480. NEVER use a name, label, description, or anything other than the exact pixel dimensions (e.g. never ?text=Product+Image or ?text=Avatar — always ?text=400x400). This applies to every placeholder image on the page regardless of size.
- Standard placeholder sizes: product mockups 700x450, feature images 500x350, testimonial avatars 80x80, about/bio photo 400x400, bonus items 280x180.
- Add loading="lazy" to ALL images not in the hero section. Hero images: loading="eager".
- IMAGE ROW FITTING: use display:flex; align-items:stretch; gap: clamp(12px, 2vw, 25px) on the row container, and flex:1 1 0; min-width:0; width:0; object-fit:cover on each image.
- Testimonial avatars: circular via border-radius: 50% and aspect-ratio: 1/1.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ICON RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Font Awesome 6 Free is already loaded. Use <i class="fas fa-..."> or <i class="fab fa-..."> — never @import FA in CSS.
- Checkmark icons in benefit/feature lists: <i class="fas fa-check-circle" style="color:var(--color-success)"></i>
- Checkmark icons in pricing cards: <i class="fas fa-check" style="color:var(--color-success)"></i>
- Pain point icons: <i class="fas fa-times-circle" style="color:var(--color-danger)"></i>
- Star ratings: <i class="fas fa-star" style="color:var(--color-warning)"></i>
- NEVER use plain bullet points where an icon list is appropriate.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CARD LAYOUT RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- CARD GRID COLUMN COUNT: For any card, feature, benefit, bonus, icon, or tile-based grid, start with 3 columns on desktop as the preferred default. NEVER use 4 or more columns on desktop. Tablet uses one fewer column than desktop (3→2, 2→2). Mobile is always 1 column.
- CARD GRID MUST BE PROPERLY CENTERED WITHIN ITS PARENT — NON-NEGOTIABLE: This applies to every card, feature, benefit, bonus, pain-point, or tile-based grid on desktop and tablet, not just one component type. The grid container must be centered within whatever section/div holds it — `margin-left: auto; margin-right: auto;` alongside an explicit `width`/`max-width` (per FIT-CONTENT WIDTH above) — and you must verify the actual visible space on the grid's left edge matches the space on its right edge. A CONFIRMED REAL-WORLD FAILURE: a 2x2 card grid rendered noticeably closer to the right edge of its parent than the left, with a large uneven gap on one side only — caused by a parent container's own asymmetric padding, an unintended margin on only one side of the grid, or the grid's width/centering math simply being wrong. Before finalizing, mentally (or literally) measure the gap from the grid's left edge to its parent's left edge, and from the grid's right edge to its parent's right edge — these two numbers must be equal. If they aren't, something in the centering chain (the grid's own margin, or an ancestor's padding) is wrong and must be fixed, not left as "close enough."
- HORIZONTAL AND VERTICAL GAP BETWEEN CARDS MUST BE IDENTICAL — NON-NEGOTIABLE: When a card grid has both multiple columns AND multiple rows (e.g. a 2x2 layout), the gap between cards in the same row (column-gap) and the gap between cards in the same column (row-gap) must be the exact same value — never a larger horizontal gap with a smaller vertical gap, or vice versa. Use the single `gap` shorthand property (e.g. `gap: 20px;`), which applies identically to both directions automatically — do NOT use the longhand `row-gap`/`column-gap` properties with two different values for a card grid, and do not let card margins (rather than the grid's own `gap`) create an inconsistent secondary spacing source in only one direction. A CONFIRMED REAL-WORLD FAILURE: a 2x2 pain-card grid showed a visibly larger gap between the left and right cards than between the top and bottom cards — the grid was using separate `column-gap`/`row-gap` values (or an extra margin on the cards in one direction only) instead of one shared `gap` value applied evenly in both directions.
- INCOMPLETE LAST ROW — MUST BE CENTERED, NEVER LEFT FLUSH-LEFT WITH EMPTY SPACE — NON-NEGOTIABLE: When the total number of cards in a grid doesn't divide evenly by the column count (e.g. 7 cards in a 3-column grid → a lone 7th card alone in the last row), that leftover card(s) will, by default CSS grid behavior, occupy the first track(s) of the last row and leave the remaining track(s) empty — a card sitting at roughly 1/3 (or 1/2) of the row's width with dead space beside it. This looks broken and unfinished, never acceptable. Fix it by explicitly placing the leftover card(s) using `grid-column` on that specific card via `:nth-child`, calculated from the actual card count: for 1 leftover card in a 3-column grid, center it with `.your-grid-class > :nth-child(N) { grid-column: 2; }` where N is that card's position (e.g. card 7 of 7 → `:nth-child(7) { grid-column: 2; }`); for 2 leftover cards in a 3-column grid, span them across the outer two columns with `grid-column: 1 / span 2` and `grid-column: 2 / span 2` respectively, or simply use `justify-content: center` on the grid container alongside fixed-width (not 1fr) card widths for that specific case. Before finalizing any multi-card grid, count the actual number of cards you wrote and check whether it divides evenly by your column count — if it doesn't, you MUST add the leftover-row centering rule above; do not ship a grid with a lone, narrow, off-center card in its final row.

- SMALLER CARD CONTENT — ALWAYS LEFT-ALIGNED — NON-NEGOTIABLE: All text content inside a smaller card (feature cards, module cards, bonus cards, problem/pain-point cards, testimonial cards, and any other repeating small-card type) must be left-aligned — heading, body text, badges/labels, everything. This is the default for these card types regardless of how the rest of the section is aligned. EXCEPTION — DOES NOT APPLY TO: the pricing box/card (`.pricing-box`, `.pricing-card`, governed separately by PRICING / PAYMENT CARD ALIGNMENT in pricing.md, which requires its headers centered) or any form card (`.form-card`, governed by its own field/label alignment rules in forms.md). Those two component types follow their own dedicated alignment rules instead of this one.
  CONFIRMED REAL-WORLD FAILURE — NAMED EXAMPLE: A `.bonus-card` rendered with its badge ("FREE Bonus #2"), heading ("Complete AI Video Business Setup"), body paragraph, AND the "Value: $197" line ALL centered — the entire card read as one centered block from top to bottom. This is wrong on every line except the badge. The root cause is almost always a container-level `align-items: center; text-align: center` written on the card's header wrapper (e.g. `.bonus-card-header { display: flex; flex-direction: column; align-items: center; text-align: center; }`) that was meant to center ONLY the over-40px badge per ICON OR BADGE BESIDE A CARD'S HEADING above, but got sloppily extended to cover the entire container instead of being scoped to just the badge. The fix: center ONLY the badge element itself (e.g. `.bonus-badge { margin: 0 auto; }` on an inline-block/flex badge, or `text-align:center` on a dedicated badge-row wrapper that contains nothing but the badge) — then explicitly set `text-align: left` on the heading, the body paragraph, and the value line as separate, independent rules. Do NOT let one parent-level centering rule cascade down through `text-align` inheritance to every child in the card — the badge's centering and the rest of the card's left-alignment must be two deliberately separate rules, never one rule applied to a shared ancestor. This same mistake applies identically to `.module-card`, `.feature-card`, `.problem-card`, and every other smaller-card type this rule governs — the badge/icon centers per the 40px rule, nothing else in the card does.
- PRICE/VALUE TEXT SLIGHTLY LARGER THAN SURROUNDING TEXT — NON-NEGOTIABLE: Whenever a price, dollar amount, or value figure (e.g. "$297", "$1,500", "Value: $600") appears as part of a larger block of text inside a card (a feature/bonus/module card description, a value-stack line item, etc.), that price/value text must render at a slightly larger font-size than the rest of the text it's sitting alongside — enough to draw the eye to it as a meaningful number, not so large it reads as its own separate heading. Wrap it in its own `<span>` (e.g. `<span class="value-highlight">$297</span>`) and give that span a font-size roughly 10–20% larger than the surrounding text's font-size, with font-weight:700 if the surrounding text isn't already bold. EXCEPTION — DOES NOT APPLY TO: the main pricing display in the pricing box/card (the large `$197`-style headline price already has its own much larger dedicated font-size per LARGE PRICE SPACING RULE in pricing.md) or to form fields/labels. This rule is for incidental price/value mentions sitting inside a smaller card's body text, not the page's primary price display.
  
  Two acceptable layouts:
  
  (A) ICON LEFT OF HEADING (side by side): Use the platform's `.icon-row` class — it already supplies the correct flex/gap/alignment. Do not reconstruct it with inline styles. Structure: `<div class="icon-row"><div class="icon-wrap">[icon]</div><h3 style="margin:0;">[heading]</h3></div><p>[body]</p>`
  
  (B) ICON ABOVE HEADING (stacked): The icon-wrap and heading must share the same left edge. Use align-items:flex-start on their container, or set margin-left:0 on both. The heading MUST NOT be independently centered when the icon is left-aligned above it.
  
  In BOTH layouts: NEVER place the icon and heading in separate unrelated containers with different alignment. They are a single visual unit.

- ICON VERTICAL ALIGNMENT — NON-NEGOTIABLE: The icon must align vertically with the heading text ONLY — not with the entire card content block. Body text, descriptions, and other card content flow BELOW the icon+heading row as separate block elements. NEVER make the icon a flex sibling of the entire card content.

- ICON+HEADING BODY TEXT PLACEMENT — NON-NEGOTIABLE: In Layout A (icon left of heading), the body text `<p>` MUST be a sibling of the `.icon-row` div, NOT inside it. The `.icon-row` contains ONLY the icon-wrap and the heading. Body text flows below as a full-width block.

- ICON LEFT OF A STAT/VALUE BLOCK (NO HEADING) — NON-NEGOTIABLE: This covers any pill/badge/card pairing an icon with a small stacked block of stat-style text that has no heading at all — e.g. a dollar/value figure on one line and a timeframe or sublabel on the next (a confirmed real-world failure: an "earn-pill" component with a sack-of-money icon and two stacked lines, "$6,200" / "in 30 days", rendered with the icon sitting ABOVE the text block instead of beside it). The icon and the entire stacked text block are a single horizontal unit — wrap them together in a flex ROW container (`display:flex; align-items:center; gap:` a sensible value, e.g. 12–16px), with the icon as one flex child and a single wrapper div containing both stacked text lines as the other flex child. NEVER use `flex-direction:column` (or any layout that stacks the icon above the text) for this pattern — that is the icon-above-heading layout (B) above, which only applies when there IS a heading; a bare stat block with no heading always uses the icon-left, side-by-side row instead. The two stacked lines inside the text wrapper keep their own `flex-direction:column` (that part is correct — the value and its sublabel stack vertically relative to EACH OTHER), but that inner column wrapper as a whole must sit to the RIGHT of the icon, not below it.
- ICON ALIGNS FROM THE TOP AND MATCHES THE LARGEST TEXT LINE'S SIZE — NON-NEGOTIABLE: When an icon sits beside a stacked text block per the rule above, align the icon to the TOP of the row (`align-items: flex-start`) — the same top edge the stacked text block itself starts from — and size the icon to roughly match the height/font-size of the LARGEST line of text in that stacked block (typically the value line, e.g. the dollar amount), not the smaller sublabel line beneath it. Do not size the icon to fill the entire card's vertical height regardless of the text's own size — match it to the text instead, so the two feel proportionate to each other rather than the icon being sized off the card's height as a separate, unrelated measurement.
- CARDS/PILLS IN A ROW MUST SIT SIDE BY SIDE WHENEVER THEY FIT — NEVER STACK INTO A COLUMN ON DESKTOP/TABLET JUST BECAUSE ROOM IS AVAILABLE — NON-NEGOTIABLE: A group of compact cards or pills (e.g. two or more earn-pills/result-pills sitting together) must use `display:flex; flex-direction:row; flex-wrap:wrap;` (or an equivalent grid with multiple columns) on desktop and tablet, laying out side by side whenever the container is wide enough to fit them on one line — only wrapping to multiple rows once the container genuinely runs out of horizontal room. NEVER use `flex-direction:column` for this kind of group on desktop/tablet, and never let the cards stack vertically while leaving large unused horizontal space beside them. A CONFIRMED REAL-WORLD FAILURE: two earn-pills rendered stacked one above the other in a narrow column on the left side of a wide section, with most of the section's width sitting empty and unused to their right — there was clearly enough room for both pills to sit side by side. Mobile is the only breakpoint where stacking these into a single column is the correct default.

- CARD TEXT CONTRAST — ABSOLUTE: Every card has its own background. Text inside a card MUST contrast against the CARD's background, not the section background. A dark card on a dark section MUST have light text. NEVER assume card text color from the section.

- CARD BADGE/PILL CLEARANCE: Whenever a card has a corner badge/pill alongside a heading, the badge must NEVER touch or overlap the heading text. Either: (a) give the heading padding-right/top equal to badge size plus 12px, or (b) use display:flex; justify-content:space-between; align-items:flex-start on the heading row.

- MOBILE CARD STACKING: On mobile (max-width: 767px), every card MUST be 100% width and stack vertically. No card grid MAY remain 2 or 3 columns on mobile — not even 2 columns.

- FULL-WIDTH CARD TEXT SCALING: When cards collapse to 100% width on mobile, text must scale up: card h2/amounts: clamp(2rem, 8vw, 3rem) font-weight:800; card h3: clamp(1.4rem, 6vw, 2rem); card labels: clamp(1rem, 4.5vw, 1.35rem); card body: minimum 1.05rem.

- STAT / FEATURE CARD WIDTH: Cards inside a flex or grid row must NEVER use width:fit-content, width:max-content, or width:auto. Always use flex:1 1 0; min-width:0; width:100% so all cards in a row are equal width.

- STATS ROW — MUST STAY ON ONE LINE ON DESKTOP: A row of stat items must render on a single row on desktop using `display:flex; flex-wrap:nowrap; justify-content:center; gap: clamp(12px, 2.5vw, 25px);` — NEVER `justify-content:space-between`, and NEVER a gap that can resolve above 25px at any viewport width (this must match the COLUMN GAP CAP rule above — 25px is an absolute ceiling across this entire document, not just for grid columns). A CONFIRMED REAL-WORLD FAILURE, TWICE OVER: (1) `space-between` looks fine with exactly 3 evenly-spaced stat items, but with only 2 (a common real count — e.g. two earnings/results figures), it pushes both items all the way to the container's literal left/right edges, producing a huge broken-looking gap in the middle instead of a cohesive cluster of stats. (2) Separately, an earlier version of this exact rule specified `gap: clamp(24px, 5vw, 60px)` — which directly contradicted the COLUMN GAP CAP rule's 25px ceiling and produced the same huge-gap problem all over again even after switching to `justify-content:center`, since the gap value itself could still resolve to 40–60px on a normal desktop viewport. `justify-content:center` with a gap that's ACTUALLY capped at 25px (not just centered) is what produces a correctly clustered, tight row. If stats would not fit on one line even with a reasonable gap, REDUCE THE FONT-SIZE or WIDEN THE CONTAINER rather than wrapping to a new row. On tablet/mobile, stats MAY wrap or stack.
- STAT/RESULT CARDS MUST BE SIZED TO FIT THEIR OWN CONTENT, NEVER STRETCHED TO FILL THE ROW — NON-NEGOTIABLE: Individual cards inside a stats/results row (or any other side-by-side card group) must use `flex: 0 1 auto` (or `width: fit-content; max-width: 100%;` on a non-flex layout) — NEVER `flex: 1 1 0` or any other rule that forces each card to grow and consume an equal share of the row's available width. `flex: 1 1 0` is appropriate for layouts that are SUPPOSED to fill the full row edge-to-edge (e.g. a 3-column feature grid), but a small stat/result card holding just an icon, a dollar amount, and a short label should size itself to that content — stretching it wider just because there happens to be extra horizontal room makes the card (and the visible gap around it) look bloated and unintentional. Combined with the gap cap above, this is what keeps a row of 2-3 compact cards reading as one deliberate, tightly-clustered group instead of a few small islands adrift in a mostly-empty wide row.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AVATAR RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- AVATAR RULE — NON-NEGOTIABLE: Every avatar MUST have: width:56px; height:56px; min-width:56px; max-width:56px; min-height:56px; max-height:56px; border-radius:50%; flex-shrink:0; flex-grow:0; aspect-ratio:1/1; overflow:hidden. NEVER set width:auto, width:100%, or omit width on an avatar.
- For div initials avatars also add: display:flex; align-items:center; justify-content:center; font-weight:700; color:white.
- AVATAR MOBILE STACKING: On mobile (max-width:767px), any row with an avatar alongside text MUST stack vertically — avatar centered above text, never side by side. Use flex-direction:column; align-items:center on the author row at mobile breakpoints.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SECTION DIVIDER RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Section divider construction, gradient flat-anchoring, the BLEND/CONTRAST decision, the color-plan pre-flight check, and the SVG fill rule are fully specified in the user message under MANDATORY FIRST STEP, SECTION DIVIDER FILL RULE, and SECTION DIVIDER FLUSH RULE. Follow those exactly — that is the single source of truth for dividers; there is no separate or different rule set here.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ANIMATION RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Use the standard animate-on-scroll, animate-fade-in, animate-slide-left, animate-slide-right, animate-scale-in classes defined in landing-base.css (already loaded — do NOT redefine them).
- Apply staggered data-delay="1" through data-delay="5" attributes to grid items, cards, and list items.
- Section headlines: animate-on-scroll. Feature/benefit cards: animate-on-scroll with stagger. Testimonial cards: animate-scale-in with stagger. Images: animate-fade-in. Left column: animate-slide-left, right column: animate-slide-right.
- NEVER duplicate @keyframes definitions — landing-base.css already defines pulse-glow and float.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CONTENT RESTRICTIONS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- COUNTDOWN TIMER — NON-NEGOTIABLE: NEVER add a countdown timer to any page unless the user explicitly requests one OR 'countdown' is listed as one of the selected sections. Do not add countdown timers as 'enhancements' or 'urgency elements' on your own.
- FAQ SECTION — NON-NEGOTIABLE: NEVER add an FAQ section to any page unless the user explicitly requests one OR 'faq' is listed as one of the selected sections. Do not add FAQ sections as 'helpful additions' on your own.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MOBILE OPTIMIZATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
The platform auto-injects mobile CSS overrides. Your generated CSS must work WITH these, not against them. Key rules:

GLOBAL RESET (write these in your css field):
html { overflow-x: hidden; width: 100%; min-width: 0; }
body { margin: 0; padding: 0; overflow-x: hidden; width: 100%; min-width: 0; box-sizing: border-box; -webkit-font-smoothing: antialiased; }
*, *::before, *::after { box-sizing: border-box; min-width: 0; max-width: 100%; overflow-wrap: break-word; }
/* word-break:break-word intentionally removed from this universal rule. word-break
   is more aggressive than overflow-wrap — it will fracture a word mid-character
   whenever the container is too narrow for normal word-boundary wrapping to fit
   comfortably, even for ordinary short words, not just for genuinely unbreakable
   long strings (URLs, etc.) that overflow-wrap alone can't help with. A confirmed
   real-world failure: a card's body paragraph rendered with one syllable per line
   ("Midj/ourn/ey", "vide/o") because the paragraph's content column had collapsed
   to a very narrow width (likely from being trapped in a narrow grid-column track
   meant for an adjacent icon) and the universal word-break:break-word rule chose
   to fracture ordinary words rather than simply wrapping at word boundaries.
   overflow-wrap:break-word alone still prevents true overflow (a single unbroken
   long word/URL will still wrap rather than spilling past its container) without
   this much more visually destructive side effect on ordinary text. If a specific
   element genuinely needs to break arbitrarily long unbroken strings (e.g. a raw
   URL with no spaces), add word-break:break-word to that specific element only —
   never apply it universally via a wildcard selector. */

EXCEPTION FOR MARQUEE/TICKER/SCROLLER TRACKS: The universal `max-width: 100%` rule above conflicts with a marquee/ticker/scroller's moving track, which must be allowed to size itself wider than its visible container (that's what makes it scroll) — see MARQUEE_GENERATION_RULES.md's "PLATFORM RULE CONFLICT" section for the full explanation. If you generate a marquee/ticker/scroller, you MUST explicitly override `max-width: none` (not 100%) and `flex-shrink: 0` on the track element and its items specifically, even though the universal rule above applies max-width:100% to every element by default. Skipping this override produces severely compressed, overlapping, illegible item text — the track gets clamped to one container-width while still trying to fit all its (duplicated) items inside that clamped space.

NO TEXT MAY EVER OVERFLOW THE MOBILE VIEWPORT: Any text on the page — headings, paragraphs, links, labels, badges, buttons — must NEVER extend past the mobile viewport edge. If text is too long for one line, it MUST wrap to a second line rather than overflow horizontally. Never use white-space:nowrap on mobile unless paired with overflow handling.

MOBILE BUTTON SIZING: On mobile (max-width: 480px), buttons must NEVER extend past the viewport edge. Use white-space:normal; word-break:break-word; text-wrap:balance on button labels so they wrap gracefully. Never set font-size below 16px on a button.

MOBILE OVERFLOW: For card grids, always use repeat(auto-fit, minmax(280px, 1fr)) — never hardcode repeat(4,1fr) or repeat(5,1fr).

MOBILE HORIZONTAL SPACING — NO ELEMENT MAY EXCEED 10PX — NON-NEGOTIABLE, ZERO EXCEPTIONS, THIS RULE IS VIOLATED REPEATEDLY AND MUST BE FOLLOWED WITH EXTRA CARE:
On mobile (max-width: 767px), no element anywhere on the page may have padding-left, padding-right, margin-left, or margin-right greater than 10px. This is an absolute ceiling, not a guideline — it applies to literally every element: sections, headers, containers, inner wrappers, cards, eyebrows/badges, headlines, paragraphs, forms, inputs, buttons, icon wrappers, and anything else you generate, with no exceptions for any component type. This rule has been violated across multiple real generations despite being stated clearly — treat every mobile breakpoint rule you write as a candidate violation until you've explicitly verified it against the 10px ceiling.

PILLS, BADGES, AND TRUST-ROW ITEMS ARE A RECURRING OFFENDER — CHECK THESE SPECIFICALLY: Small inline elements like eyebrow badges, trust-row pills (e.g. "Launch Price — Limited Time," "2,400+ Students Enrolled"), and similar label-style components are consistently where this rule gets violated in practice — a confirmed real-world failure showed an eyebrow badge and a row of trust pills both sitting well clear of the screen edge on mobile, with visibly more than 10px of horizontal gap on both sides, even though the page's overall mobile spacing rule was supposedly in effect. These elements often inherit spacing from a parent flex/grid container's `gap`, `justify-content:center` combined with extra margin, or a wrapper div's own padding that the model didn't think to check because the pill itself "looked fine." Explicitly verify the wrapper/container around any badge, pill, or trust-row item — not just the pill's own CSS — since the visible gap is frequently coming from that wrapper rather than the pill.

NEVER LET `white-space:nowrap` RUN AN ELEMENT OFF THE MOBILE VIEWPORT — NON-NEGOTIABLE, DISTINCT FROM THE PADDING ISSUE ABOVE: This is a different failure mode than excess padding/margin — it's about text refusing to wrap at all. If you set `white-space:nowrap` on a pill, badge, or scarcity bar (common for keeping a short label on one line at desktop width, e.g. a countdown/scarcity badge like "Only 5 Spots Available — $100 Off Right Now"), that declaration keeps the browser from ever breaking the line — at ANY viewport width, including a narrow mobile screen where the full text genuinely cannot fit. The GLOBAL `overflow-wrap:break-word` reset does NOT rescue this — `overflow-wrap` only controls how text breaks within content that's already allowed to wrap onto multiple lines; it has zero effect once `white-space:nowrap` has already disabled wrapping outright. CONFIRMED REAL-WORLD FAILURE: a hero scarcity badge with `white-space:nowrap` and no mobile override ran straight off the right edge of the screen on a narrow viewport, with the tail end of the text clipped off entirely, invisible to the visitor. Whenever you set `white-space:nowrap` on any element, anywhere, you MUST also write `@media (max-width:767px) { /* that selector */ { white-space: normal; max-width: 100%; } }` — no exceptions. If you're not certain a short label will fit on mobile at its full length, default to `white-space:normal` from the start rather than `nowrap`, and only add `nowrap` once you've confirmed the mobile override is in place alongside it.

THE OUTERMOST DIV ON EACH SECTION MUST BE SET TO EXACTLY 10PX LEFT AND RIGHT PADDING — THIS IS CRITICAL AND NON-NEGOTIABLE, NOT A LOOSE "AT LEAST" GUIDELINE: The single outermost div of each section/landmark (the section element itself, or its direct full-width wrapper) MUST explicitly have padding-left: 10px and padding-right: 10px set on it — written out as an actual CSS declaration, every single time, on every section. Do not reason "this will probably inherit some spacing from elsewhere" and omit it — if this declaration is missing, the section's content (text, form cards, inputs, anything) will render flush against the literal screen edge with ZERO breathing room, which is a severe and highly visible failure. A confirmed real-world failure: an optin form section's body copy and form card both rendered touching or nearly touching the screen's left and right edges on mobile — the outermost div's padding was missing or insufficient, leaving no edge inset at all. This must never happen. Every section's outermost div needs this declaration explicitly written in your CSS, at the mobile breakpoint, with no exceptions and no reliance on inheritance or platform defaults to "probably handle it."

10PX BELONGS TO EXACTLY ONE DIV PER SECTION — EVERY OTHER DIV MUST BE STRICTLY LESS, NOT ALSO 10PX: The 10px value above is reserved for the single outermost div of the section ONLY. Every other div nested inside it — inner containers, cards, wrappers, anything — must use a horizontal padding value strictly LESS than 10px (i.e. 0–9px), never also 10px and never matching the outermost div's value. Do not read the "at most 10px" ceiling rule elsewhere in this document as license to set every div to 10px — that ceiling is ONE absolute upper bound across the whole page, but the outermost div is the only div that should actually use it; everything nested inside should trend toward 0 the deeper you go, precisely so the spacing doesn't compound.

WHEREVER ONE DIV SITS DIRECTLY INSIDE ANOTHER WITH NO INDEPENDENT CONTENT BETWEEN THEM, NEITHER PADDING NOR MARGIN BETWEEN THEM MAY EVER EXCEED 0PX HORIZONTALLY — NO EXCEPTIONS, EVER: If a div exists purely as a structural/positioning wrapper around another div — with no text, image, or other content of its own sitting in the gap between the outer div's edge and the inner div's edge — that wrapper's horizontal padding-left/padding-right AND margin-left/margin-right must ALL be exactly 0px, not some small non-zero value like 4px or 6px "just in case." Both properties are covered by this rule, not padding alone — a purely structural wrapper with `margin: 0 8px` is exactly as wrong as one with `padding: 0 8px`; either one pushes the real content further from the edge than intended, the same invisible-wasted-space problem either way. An empty div (one holding no content of its own, only another wrapper or container div) may NEVER receive any horizontal padding or margin at all, under any circumstance — this is not a soft preference, it is absolute. A wrapper div that holds nothing but another single child div is not a place to add decorative breathing room; it is pure structure. Reserve non-zero horizontal padding/margin only for divs that directly contain real content (text, form fields, buttons, images) — never for an intermediate structural wrapper holding nothing but another wrapper or container div.
EVERY STRUCTURAL WRAPPER NESTED INSIDE A CARD/FORM-CARD MUST BE EXPLICITLY width:100% — NEVER LEFT TO DEFAULT TO ITS OWN CONTENT WIDTH — NON-NEGOTIABLE: This is the companion mistake to the zero-padding/margin rule above, and just as common. Any div that exists purely to wrap the form fields, the form itself, or any other content block nested inside `.form-card` (or any other card-style container) MUST have `width: 100%` written explicitly on it — never omitted. A block-level div with no explicit width and no content of its own forcing it wide does not reliably stretch to fill its parent in every layout context (e.g. inside a flex column parent, where children size to their own content by default unless `align-items:stretch` or an explicit width is set) — when this happens, the wrapper (and everything inside it, including the actual input fields) renders narrower than the card and sits flush against ONE edge (typically the left) with a visible empty gap on the other side, since nothing is centering an unintentionally-narrow box. A CONFIRMED REAL-WORLD FAILURE: a `.form-card` rendered with its eyebrow badge, headline, and subhead correctly centered and full-width, but the actual form fields below them rendered in a visibly narrower box hugging the left edge, with empty space on the right — an intermediate wrapper between `.form-card` and the `<form>` had no explicit `width: 100%` and defaulted to a narrower content-based width. Before finalizing any card containing nested wrapper divs, trace every single wrapper from the card's outer edge down to the actual content (form fields, buttons, text) and confirm each one explicitly declares `width: 100%` — do not assume a div "will obviously fill its parent" just because it looks that way in your head; write the declaration every time.
NAMED CONFIRMED EXAMPLE — THE FORM-FIELD WRAPPER CHAIN ON MOBILE: The lead-capture form is built from several nested, purely structural wrappers with no content of their own — `.capture-form-wrap` > `#capture-form` (the `<form>` itself) > `.form-fields-stack` — each one holding nothing but the next wrapper or the actual `.form-group` rows. NONE of these three structural layers may carry any horizontal padding or margin on mobile (or any breakpoint) — only `.form-group` (which directly holds a real label + input) and the platform-owned outermost card/section padding are allowed to. A confirmed real-world failure: on mobile, the form's input fields rendered narrower than the card's own content width with visible empty space on both sides — caused by one of these purely-structural wrapper layers carrying its own small horizontal padding or margin "for safety," compounding with the card's already-correct padding. Before finalizing any multi-layer form wrapper, check every single one of these structural layers individually and confirm each is at exactly 0px horizontal padding/margin — not just the outermost or innermost one.

Combined, the full picture is: the outermost div of each section = exactly 10px (never 0, never omitted, never more). Pure structural wrapper divs holding nothing but another div, with no content of their own = exactly 0px. Divs that directly hold real content = some value strictly less than 10px (commonly 0px, since the outermost div's 10px often already provides all the inset that's needed). Never duplicate the 10px value on more than one div per section, and never leave a content-holding div with no horizontal padding consideration at all.

THIS IS A WHOLE-PAGE RULE, NOT A PER-COMPONENT ONE: Do not reason "this hero/badge/headline already looks fine, so it's covered." You must explicitly check every component you write at the mobile breakpoint and confirm none of them exceeds 10px on either side, and that each section's outermost div is not falling below 10px either. A single missed component (a hero inner wrapper, an eyebrow's own padding, a headline's own margin) is enough to fail this rule even if everything else on the page is correct.

DO NOT RELY ON AN ANCESTOR'S PADDING TO COVER DESCENDANTS: Setting 10px padding on a section does not automatically mean its children are compliant — each individual element's own padding/margin values must independently stay at or under 10px. If a section has 10px padding AND its inner wrapper also has its own padding, AND a card inside that wrapper has its own padding, every one of those three values must each individually be ≤10px — they are not additive allowances, and none of them inherits compliance from another.

SELF-CHECK BEFORE FINALIZING YOUR CSS: For every class you've written in this generation, scan its mobile (max-width:767px) rules and ask: does any padding-left, padding-right, margin-left, or margin-right value here exceed 10px? If you find one — including values like 16px, 20px, 24px, 1rem, 1.5rem, or any other commonly-used spacing value above 10px — you must reduce it to 10px or less before finalizing. Then separately ask: does each section's outermost div still have at least 10px — not 0, not a value that got reduced too far while fixing the ceiling? Both checks matter; fixing one should never accidentally break the other. This applies even to values you inherited from a desktop rule that you forgot to override at the mobile breakpoint; an un-overridden desktop padding value bleeding into mobile is still a violation.

THIS RULE STILL APPLIES TO PLATFORM-OWNED ELEMENTS LIKE FORMS — "DON'T REDECLARE IT" IS NOT THE SAME AS "IT'S ALREADY COMPLIANT": Elsewhere in this document you're told not to redeclare certain platform-owned properties (for example, `.form-group` already gets its `width` and `margin-bottom` from landing-base.css, and you're told not to set those yourself). Do not extend that instruction into assuming the entire form is therefore automatically spacing-compliant and skip checking it. A confirmed real-world failure: a generated optin form rendered visibly cramped on mobile — fields and labels packed too tightly together with insufficient breathing room — because the model reasoned "form-group is platform-owned, so its spacing is handled" and never verified the form's actual rendered spacing against this rule. The instruction not to redeclare a platform property only means you shouldn't write a conflicting/duplicate rule for that specific property — it does not exempt the form, its wrapper (`.form-card`, `#capture-form`, `.capture-form-wrap`), or any of its child elements (labels, inputs, icon wrappers, the submit button) from this page's overall 10px mobile spacing requirement. If you find a form rendering cramped, the fix is almost always in the wrapper/card padding you DID write yourself (`.form-card`, `#capture-form`, etc.) or in vertical spacing (`margin-bottom` between `.form-group` rows, which IS platform-owned and should not be touched) rather than the horizontal padding rule above — but you must still visually confirm the rendered result looks correctly spaced, not just assume compliance because a class name is platform-owned.

TABLET & MOBILE 2-COLUMN COLLAPSE — text column never below 50%, otherwise stack:
/* A 2-column row (text beside an image, a button, or a second column) must never
   squeeze its text column below 50% of the row width. Each column is given a 50%
   min-width inside a wrapping flex row: while both columns can hold >=50% they sit
   side by side; the moment they cannot (the text would drop under half the width),
   the row wraps and each column takes the full width as a single-column stack —
   collapsing instead of crushing the text to the side. This handles tablet
   (768-1024px); the <=767px block below already stacks everything for phones. */
@media (min-width: 768px) and (max-width: 1024px) {
  [class*="two-col"], [class*="two_col"], [class*="two-column"], [class*="2-col"],
  [class*="col-2"], [class*="cols-2"], [class*="columns-2"], [class*="grid-2"],
  [class*="split"], [class*="feature-row"], [class*="text-image"], [class*="image-text"],
  [class*="text-media"], [class*="media-text"], [class*="content-media"], [class*="media-content"],
  [class*="cta-row"], [class*="hero__inner"], [class*="hero-grid"], [class*="hero__grid"],
  [style*="grid-template-columns"] {
    display: flex !important;
    flex-direction: row !important;
    flex-wrap: wrap !important;
    align-items: stretch !important;
  }
  [class*="two-col"] > *, [class*="two_col"] > *, [class*="two-column"] > *, [class*="2-col"] > *,
  [class*="col-2"] > *, [class*="cols-2"] > *, [class*="columns-2"] > *, [class*="grid-2"] > *,
  [class*="split"] > *, [class*="feature-row"] > *, [class*="text-image"] > *, [class*="image-text"] > *,
  [class*="text-media"] > *, [class*="media-text"] > *, [class*="content-media"] > *, [class*="media-content"] > *,
  [class*="cta-row"] > *, [class*="hero__inner"] > *, [class*="hero-grid"] > *, [class*="hero__grid"] > *,
  [style*="grid-template-columns"] > * {
    flex: 1 1 50% !important;
    min-width: 50% !important;   /* never below half the row; with any gap the columns wrap to a full-width stack */
    max-width: 100% !important;
    box-sizing: border-box !important;
  }
}

SECTION MOBILE PADDING:
@media (max-width: 767px) {
  /* Sections and full-width landmarks carry the 10px edge inset so content
     (including text with no inner wrapper) never touches the screen edge.
     Background still reaches the edge because padding is internal. */
  section, header, footer, nav,
  .section, .hero, .site-nav, .site-footer {
    padding-left: var(--space-mobile-edge) !important;
    padding-right: var(--space-mobile-edge) !important;
    margin-left: 0 !important;
    margin-right: 0 !important;
    width: 100% !important;
    max-width: 100% !important;
    box-sizing: border-box !important;
    overflow-x: hidden !important;
  }
  /* Inner structural wrappers get ZERO horizontal padding so they don't
     compound the 10px already provided by their parent section/landmark.
     (Cards, callouts, etc. keep their own padding — they are content, not wrappers.) */
  .container, [class*="container"],
  .section__inner, .section-inner,
  .hero__inner, .cta__inner, .features__inner,
  .testimonials__inner, .pricing__inner, .faq__inner,
  .footer__inner, .guarantee__inner, .bonuses__inner {
    padding-left: 0 !important;
    padding-right: 0 !important;
    margin-left: 0 !important;
    margin-right: 0 !important;
    width: 100% !important;
    max-width: 100% !important;
    box-sizing: border-box !important;
    overflow-x: hidden !important;
  }
  /* MAIN IS FULL-BLEED ON MOBILE: zero horizontal padding so section
     backgrounds reach the screen edges. The 10px edge inset moves to
     main's direct child (the content div) instead. */
  main, main[style] {
    padding-left: 0 !important;
    padding-right: 0 !important;
    margin-left: 0 !important;
    margin-right: 0 !important;
  }
  /* NUCLEAR GRID COLLAPSE */
  * { grid-template-columns: 1fr !important; }
  .countdown-timer { grid-template-columns: unset !important; display: flex !important; }
  .sticky-cta-bar__inner { grid-template-columns: unset !important; }
}

Write these in your @media (max-width: 767px) block:
  h1, .hero h1, .hero__headline { font-size: clamp(1.75rem, 7vw, 2.1875rem); line-height: 1.15; }
  h2, .section-headline { font-size: clamp(1.4rem, 5.5vw, 1.875rem); line-height: 1.2; }
  h3 { font-size: clamp(1.1rem, 4vw, 1.5rem); }
  p, li { font-size: 1rem; line-height: 1.4; }
  input, textarea, select, label { font-size: 16px; }
  .btn--primary, a.btn--primary, button.btn--primary { width: auto; max-width: 100%; padding: 0.875rem 1.5rem; font-size: clamp(16px, 4vw, 18px); white-space: normal; word-break: break-word; text-wrap: balance; }
  * { writing-mode: horizontal-tb; text-orientation: mixed; }
