// copy.jsx — ALL human-readable prose for the vx landing site, in one place.
// Edit any sentence the site shows here. Organized page → section, top-to-bottom.
//
// Plain strings are plain text. Where a sentence carries inline emphasis, code,
// links, or line breaks, the entry is a JSX fragment using:
//   <S>…</S>  emphasis (brighter text)      <C>…</C>  inline code
//   <a className="vx-link" href="…">…</a>   link       <br/>  line break
// These globals come from vx-shared.jsx (S, C) and must load before this file.
//
// NOT here (they're colored code / layout, not prose): the YAML <pre> rule
// samples and all styling live in the components.

window.COPY = {
  // ── Shared site chrome (nav + buttons + footer) ──────────────────────────
  site: {
    nav: {
      docs: 'docs',
      github: 'github',
      download: 'download',
      overview: 'overview',     // docs page back-link to the landing page
    },
    downloadBtn: 'Download for macOS',
    githubBtn: 'View on GitHub',
    footerBuilt: <>built by Tony &middot; tdoot.com</>,
    footerGithub: 'github',
    footerDonate: 'donate',
    footerTwitter: '@tdoot_',
  },

  // ── Landing page (index.html → DirectionDv3) ─────────────────────────────
  landing: {
    // hero
    h1: <>open source, offline dictation for macOS.</>,
    tagline: 'Keep your productiviy up without leaking company data.',
    intro: 'I built this so I could work faster. Typing gets in the way of my stream of consciousness, but back when I wanted to start using dictation tools there was nothing that was purely offline and that didn’t fly with our security team. Now I use this every day. If it helps you too, that’s awesome.',

    // the real pill demo caption
    demoCaption: (
      <>
        Talk while you hold the key, then release. It transcribes on your machine and drops the text where you were typing.
      </>
    ),

    // fast
    fastTitle: <>Fast as hell.</>,
    fastBody: 'Transcription runs on your machine and captures your voice while you talk. We use tiny, local models. Nothing goes over the wire by default, so there’s nothing to wait on.',

    // how it works
    howKicker: 'how it works',
    howTitle: 'It lives in your status bar',
    howBody: (
      <>
        vx is a small status-bar app that runs Whisper models locally. It listens for the hotkey, records you, and pastes the result wherever your cursor is. <S>No window, and no servers of its own.</S>
      </>
    ),

    // rules
    rulesKicker: 'rules',
    rulesTitle: 'It speaks my shorthand',
    rulesBody1: (
      <>
        Raw speech doesn’t match how I write. So before anything is inserted, vx runs the transcript through rule files: plain <S>trigger/replace</S> pairs, matched against what you said. &ldquo;open brace&rdquo; becomes a <C>{'{'}</C>, and &ldquo;brb&rdquo; becomes &ldquo;be right back.&rdquo;
      </>
    ),
    rulesBody2: (
      <>
        There’s a file per mode (plain, email, chat, code, markdown, terminal), plus a global one that applies everywhere. <S>No hidden settings:</S> they’re YAML files in a folder. I keep mine in a GitHub repo so they sync across my machines, like dotfiles.
      </>
    ),
    rulesSampleFilename: 'terminal.yaml',   // label above the YAML sample (the sample itself stays in the component)
    rulesNote: 'Matched case-insensitively against the final transcript. Rules resolve global first, then the mode.',

    // contexts
    contextsKicker: 'contexts',
    contextsTitle: 'Different apps, different modes',
    contextsBody: (
      <>
        vx can watch the frontmost app and switch modes for you. Terminal gets CLI shorthand, Mail gets cleaner punctuation. You can map any app to whichever mode you want. <S>Mostly it means I talk and don’t think about it.</S>
      </>
    ),

    // ai
    aiKicker: <>ai &middot; optional</>,
    aiTitle: 'AI cleanup, if you want it',
    aiBody1: 'Everything above is rule-based and runs on your machine. Turn this on and an optional pass after each dictation cleans up punctuation, drops the um/uh and false starts, and applies your own instructions and dictionary.',
    aiBody2: (
      <>
        <S>You bring your own API key</S>, and it works with whatever provider you like (OpenAI, Anthropic, others). I use Claude Haiku because it’s quick. vx doesn’t ship a key and I never see your text. Your voice is always transcribed on-device; this only sends the text, and only when you turn it on. <S>Off by default.</S>
      </>
    ),

    // close
    close: (
      <>
        vx is something I built for myself and use every day. If it’s useful to you, great. If you want to say thanks, <a className="vx-link" href="https://ko-fi.com/tdoot">a donation</a> is appreciated.
      </>
    ),
    vibeCoded: '(and yeah, this whole page was vibe-coded. I’d rather build the thing than spend my time hand-writing a landing page.)',
  },

  // ── Docs page (docs.html → DocsPage) ─────────────────────────────────────
  docs: {
    title: 'Documentation',
    wipBadge: <>work in progress &middot; you mostly won’t need it</>,

    // sidebar nav: groups → [label, anchor-id]
    sidebar: [
      { group: 'Getting started', items: [['Install', 'install'], ['Basics', 'basics']] },
      { group: 'Dictation', items: [['Modes', 'modes'], ['Writing rules', 'rules'], ['Contexts', 'contexts']] },
      { group: 'AI post-processing', items: [['Setup & providers', 'ai']] },
      { group: 'Reference', items: [['rules.yaml format', 'format'], ['Requirements', 'requirements']] },
    ],

    install: {
      kicker: 'Getting started',
      title: 'Install',
      body: (
        <>
          Grab the latest build from the <a className="vx-link" href="https://github.com/tonydelanuez/vx/releases">releases page</a>, move vx into Applications, and launch it. On first run macOS asks for microphone and accessibility access. Both are required for it to hear you and paste into other apps.
        </>
      ),
    },

    basics: {
      title: 'Basics',
      body: (
        <>
          vx lives in the menu bar. <S>Hold the hotkey, talk, and let go.</S> It transcribes on your machine and pastes the text wherever your cursor is. That’s the whole loop. The recording HUD shows a live level meter while it listens, then flips to <S>Transcribed</S> as the text lands.
        </>
      ),
    },

    modes: {
      kicker: 'Dictation',
      title: 'Modes',
      body: (
        <>
          Every dictation belongs to a mode: <S>Plain Text, Email, Chat, Code, Markdown, or Terminal</S>. Each mode loads its own rules (and Code adds a language-specific profile on top). You can switch modes manually, or let vx pick one automatically (see Contexts).
        </>
      ),
    },

    rules: {
      title: 'Writing rules',
      body: (
        <>
          Rules are <S>trigger/replace</S> pairs in YAML, matched case-insensitively against the transcript before it’s inserted. There’s a file per mode plus a global one that applies everywhere. Edit them from the Rules tab (Open Folder / Reload), and use <S>Try Rules</S> to preview how a transcript transforms before you commit. They’re just files; keep the folder in a git repo to sync across machines.
        </>
      ),
    },

    contexts: {
      title: 'Contexts',
      body: (
        <>
          Turn on <S>automatic context detection</S> and vx watches the frontmost app, switching the mode (and AI instructions) to match: Terminal, Mail, Slack, Xcode, and so on. If it doesn’t know an app, add the bundle ID under App Mappings (find it with <code style={{ fontFamily: VXP.mono, color: VXP.text, fontSize: 14 }}>osascript -e 'id of app "AppName"'</code>).
        </>
      ),
    },

    ai: {
      kicker: 'AI post-processing',
      title: 'Setup & providers',
      body: (
        <>
          Optional. When enabled, a cleanup pass runs after each dictation: punctuation, filler-word removal, and your own per-context instructions and dictionary. <S>Bring your own API key.</S> It’s configurable across providers (OpenAI, Anthropic, and others). Per-context instruction files live in <code style={{ fontFamily: VXP.mono, color: VXP.text, fontSize: 14 }}>~/.vx/prompts/</code>; lines beginning with <code style={{ fontFamily: VXP.mono, color: VXP.text, fontSize: 14 }}>#</code> are comments and aren’t sent to the model. Off by default; leave it off for fully-offline, verbatim transcription.
        </>
      ),
    },

    format: {
      kicker: 'Reference',
      title: 'rules.yaml format',
      body: (
        <>
          Each file is a list of trigger/replace pairs. Rules resolve <S>global first, then the mode</S>. In Code mode, <code style={{ fontFamily: VXP.mono, color: VXP.text, fontSize: 14 }}>code/global.yaml</code> loads first, then the language profile.
        </>
      ),
      sampleFilename: 'terminal.yaml',   // label above the YAML sample (sample stays in the component)
    },

    requirements: {
      title: 'Requirements',
      body: 'macOS 13 or newer. Apple Silicon recommended. No network required for dictation.',
    },
  },
};