# Page construction — the SINGLE source of truth for what the page is built
# from, in order. Astro reads this and renders component-by-component via the
# registry; the framework attributes (data-lpc-*) are derived from the flags
# here, not hardcoded in the components. Turn a component off with `show: false`;
# change its load strategy with `load:`; pass props with `data:`.
#
# load:  inline | lazy | async | seo | eager      (one)
# flags: on: <trigger> · minH · deps · prefetch · dynamic · trigger · tw
# show:  false to drop the component entirely (default true)

# TRANSFORMERS — per-page pipe config (1/1 sa build-framework `build.config.yaml`).
# Bira KOJI transformatori rade, KOJIM redom, sa KOJIM opcijama — grupisano po TIPU
# (css/html/js), kao njihovi `css:/html:/javascript:` pipe-ovi. Default (ovaj blok
# izostavljen) = registry redosled, SVE uključeno. Registrovani transformatori:
#   css:  minify-css · stacked-css
#   html: minify-html · purge-unused-classes · inject-lpc-markers · normalize-lpc-scripts
#   js:   minify-js
# TRI REŽIMA (kao build-framework enabled:true/false + reorder):
#   MERGE (flat)   — ugasi/upali/opcije pojedinačno, overlay na default:
#       transformers: { 8e: { enabled: false }, minify-html: { options: { collapseWhitespace: true } } }
#   OVERRIDE (tip) — zameni CEO pipe datog tipa eksplicitnim redosledom:
#       transformers: { css: [ { name: minify-css }, { name: stacked-css } ] }
# transformers: {}   # prazno/izostavljeno = default (sve uključeno)

# SITE — per-page-tree identity. SSOT: src/config.ts reads `base`+`site` from
# here, and the builder uses `base` for the lang map. `base` = mount path prefix
# (always leading + trailing slash); `site` = canonical origin (for canonical +
# og:image absolute URLs, previously hardcoded in the head components).
base: /dev/
site: https://ltp.ge

# DEV-MODE — when true, the optimizer ALSO preserves each route's COMPLETE original
# (un-optimized, NON-inlined — real separate files) into `<route>/_/_dev/`, beside the
# optimized output and the inlined `_/un.html`. The whole point: both work; the second
# is just optimized. Set false for a production-lean build.
dev: true

# LANGUAGES — this page tree's language set + how an external visitor is routed.
# The default lang is served at `base` (no URL segment); each variant owns
# `base/<code>/`. The builder turns this into functions/_lib/lang.json, which the
# middleware's `lang` stage reads. Remove this block → empty map → NO language
# routing (graceful fallback to nothing). Detection order: persisted JWT lang →
# Accept-Language primary subtag in `accept` → CF country in `countries`.
langs:
  default: en
  variants:
    rs: { accept: [sr, hr, bs, me], countries: [RS] }

# PLUGINS — pluggable optimizer OUTPUT modules (scripts/plugins/<name>.mjs), run
# last in the build by scripts/build-plugins.mjs. Config lives here PER page-tree
# for now; a future global.yml will toggle whole plugins on/off across trees.
# `enabled: false` turns one off; `exclude:` drops routes (dev/build pages out of
# the public sitemap + feeds). Feeds (rss/atom/jsonfeed) currently take the site's
# pages as items — swap the source in scripts/plugins/_feed.mjs when a blog exists.
plugins:
  # lightgraph — SEO/discovery owner (sitemap now; OG/meta later). sitemap config nested.
  lightgraph: { sitemap: { changefreq: weekly, priority: 0.8, exclude: [] } }
  # feeds (rss/atom/jsonfeed) now OWNED by indieweb (its _lib/feed.ts → /iw/{rss,atom,feed});
  # indieweb registers the feed links into lightgraph's graph for autodiscovery.
  # nojs — JS-free fallback: per-URL `0.html` (every component as full inline
  # HTML, all CSS inlined, all JS stripped) + a <noscript> overlay linking to it.
  # Enabled for THIS tree only (/dev/ + its language variants); other page-trees
  # have no page.yml entry → no 0.html. `hide:` drops components from 0.html
  # (capability only — empty for now).
  # Story = <amp-story-player> (needs the AMP runtime JS) — no meaningful no-JS
  # render, so drop it from 0.html (else it leaks a raw "lightpage story" link +
  # overlay). Add other JS-only components here as needed (e.g. ChatPanel).
  nojs:     { enabled: true, hide: [Story] }
  # lightchat — dir plugin (plugins/lightchat/): provides the ChatPanel component
  # (resolved in place) + a /api/lc/chat Workers-AI endpoint + per-page ai.md.
  lightchat: { enabled: true }

# HEAD — EVERYTHING in <head> is a component, in this order. No renderer
# injects head content by hand: the boot preload, scroll-restore, noscript
# fallback and critical CSS are components too (BootPreload is plugin-owned —
# plugins/lightrise/components/). Runtime props (lang, s, canonical) are
# injected by the render loop; `data:` is for static props.
# NOTE: plugin-owned defaults are IMPLIED, not listed here — lightrise
# prepends BootPreload (head) + appends Boot (body end); lightsession appends
# SessionGlobal (body end). Declared in each plugin.mjs `page:` field.
head:
  - { use: ScrollRestore }      # history.scrollRestoration='manual'
  - { use: HeadOptimization }
  - { use: HeadMeta }
  - { use: HeadOg }
  - { use: HeadPwa }
  - { use: HeadFavicons }
  - { use: HeadJsonLd }
  - { use: NoscriptFallback }   # no-JS reveal shim + data-lp-fallback slot
  - { use: CriticalCss }        # <style id=0> — page-level critical CSS

body:
  # Story rail — async, CLICK-TO-PLAY (yellow play-button poster); deps
  # prefetched in <head> at parse so the click activates an already-fetched
  # amp-story-player. (data-lpc-deps is gated by the component's useAmpStory flag.)
  - { use: Story,  load: async, on: click, prefetch: true, show: true }
  # Cover — inline, dynamic-templated brand fields (logo/name) come from data:.
  - { use: Cover,  load: inline, dynamic: true, show: true,
      data: { logo: "⚡", name: "lightpage" } }
  # Header — inline, hand-written CSS (no tailwind utilities).
  - { use: Header, load: inline }
  # Ghost — ASYNC, loads on idle (was wrongly inline after the skins merge).
  - { use: Ghost,  load: async, on: idle, show: false }   # OFF — GhostMain (u main-u) je aktivan
  # lite-cb modal — CSS-only <dialog>, content from the dictionary (s.liteCb).
  # LAZY on the header light-theme toggle's hover (Modal on="hover" →
  # data-lpc-trigger="lite-cb"). Sits right after Ghost, where it was hardcoded.
  - { use: LiteThemeModal }
  # LpBadge — per-component build-profile chip + modal. Reads __lpBuild at
  # runtime; takes no data. Was hardcoded right after the lite-cb modal.
  - { use: LpBadge }
  # LpLayout — STRUCTURAL wrapper COMPONENT (the .lp-layout grid: Sidebar
  # column + <main>). `structural: true` → toLpc() emits NO markers; the
  # optimizer sees a plain div, exactly like when the render loop hand-stitched
  # it. `with:` = the wrapper's slot children — Sidebar sits BESIDE Main.
  - use: LpLayout
    structural: true
    with:
      - { use: Sidebar, load: seo, show: true }
      # GhostMain — VAN maina, odmah iznad: deli main-ovu grid ćeliju
      # (uvek njegova širina/visina), z:-1 ispod grid overlay-a.
      - { use: GhostMain, load: inline }
      - use: Main                   # wraps the ordered content: list in <main>
        load: inline
        show: true
        # CONTENT — the ~17 page sections, in render order, driven entirely from
        # here. Each entry: use + load flags + optional data. Components carry NO
        # hardcoded data-lpc-*; markers all derive from these flags via toLpc().
        content:
          - { use: Hero,          load: inline }
          # DEMO per-asset css: source — dve proste test komponente sa SVOJIM CSS-om.
          # TestCssReq: css:request → njen CSS ide EKSTERNO (_.css); TestCssInj:
          # css:inject → njen CSS ide u FOOTER (inert). Loading NIJE wired → CSS na
          # svom mestu ali se ne renderuje (kutije bez boje). Pozicioniranje = poenta.
          - { use: TestCssReq, load: inline, css: { src: request } }
          - { use: TestCssInj, load: inline, css: { src: inject } }
          # DEMO raw-component discovery: B (sibling .html/.css) + C (dir _/…)
          - { use: TestSibling, load: inline }
          - { use: TestDir, load: inline }
          # StickyActions: real position:sticky bar; async + idle, reserves --hdr-h.
          # Placed right after Hero (1 component) so it glues to the bottom soon
          # after the header sticks, on a little scroll.
          - { use: StickyActions, load: async, on: idle, minH: "var(--hdr-h)" }
          - { use: HeroIncludes,  load: seo }
          - { use: BenchKB,       load: seo }
          - { use: BillGates,     load: seo }
          - { use: Fibonacci,     load: seo, on: click }
          # Newsletter TOP — async, reserves 38.2lvh (matches its .h-382 height).
          - { use: Newsletter, id: newsletter-top, load: async, minH: "38.2lvh", data: { variant: "top" }, noworkscreen: [offline, nojs] }
          - { use: BuiltEco,      load: seo }
          - { use: Principles,    load: seo }
          - { use: Triangle,      load: seo, on: hover }
          - { use: Pricing,       load: async-seo-excerpt, minH: "80lvh" }
          - { use: Mvp,           load: seo }
          - { use: PrinciplesDeep, load: async-seo-excerpt }
          - { use: Course,        load: seo }
          - { use: MobileCourse,  load: seo }
          - { use: EarlyBird,     load: seo }
          - { use: Partner,       load: seo }
          # Newsletter BOTTOM — async, reserves 38.2lvh.
          - { use: Newsletter, id: newsletter-bottom, load: async, minH: "38.2lvh", data: { variant: "bottom" } }
          # EndBar: full-bleed accent bar at end of main; async, reserves --hdr-h.
          # OFF — the sticky bar now self-hides below the footer at journey end
          # (no yellow bar needed as the cover). Flip show:true to bring it back.
          - { use: EndBar,        load: async, minH: "var(--hdr-h)", show: false }
          # NOTE: Soon is intentionally DISABLED — not listed here.
  # ── REMOTE komponente (žive na DRUGOM serveru). OBE load:inline (odmah, ne lazy);
  #    razlika je SOURCE osa (GDE se razrešava). Dve vrste, pred footer: ──
  # SOURCE:self — SERVER (build/optimizer) dovuče remote _.html/_.css/_.js i UBACI
  # ih INLINE u stranu. Finalni HTML = čist inline sadržaj; klijent NE fetuje; nema ro=.
  - { use: Remote, id: rmt-server, remote: "https://lt-components.pages.dev/c/remotebox", load: inline, source: self, minH: "220px" }
  # SOURCE:request — KLIJENT učita preko žice: CSS <link> + JS <script src> (native) +
  # HTML <html-include> (nema native preko-žice HTML include). Bez boota, bez ro=, bez CSR.
  - { use: Remote, id: rmt-client, remote: "https://lt-components.pages.dev/c/remotebox", load: inline, source: request, minH: "220px" }
  # BleedClip — STRUCTURAL wrapper COMPONENT (one overflow-x:clip wrapper shared
  # by SunHero + Footer). The grouping is now DECLARED here, not stitched by a
  # renderer branch; a hidden SunHero simply skips while Footer stays.
  - use: BleedClip
    structural: true
    with:
      # SunHero — BOTH lazy AND async (lazy+async combo), reserves 85.4lvh of flow.
      - { use: SunHero, id: sun-hero, lazy: true, async: true, minH: "85.4lvh", slot: full-bleed, show: false }
      - { use: Footer,  load: async, minH: "14.6lvh" }
  # Chat — native <dialog>; body ASYNC-loaded on hover of the chat button (#44).
  - { use: ChatPanel, id: chat-panel, load: async, on: hover }