import { brandConfig, mplSourceUrl, openSourceRepoUrl, publicDocsUrl, releaseNotesUrl } from './site-config'

export const heroMetrics = [
  { label: 'Main simulator', value: 'Native Unreal' },
  { label: 'Advanced puzzle families', value: '120‑cell + 5D' },
  { label: 'Website companion', value: 'Accounts + downloads' },
  { label: 'Windows build status', value: 'Validated build' },
] as const

export const capabilityPillars = [
  {
    title: 'Recognition to reconstruction',
    description: 'Move from scrambled cube observations into reconstruction, correction, and guided solves without leaving the HyperTwist flow.',
  },
  {
    title: 'Replay, coaching, and analytics',
    description: 'Review replays, revisit sessions, follow guided practice, and keep your progress visible instead of trapped inside a timer alone.',
  },
  {
    title: 'Higher-dimensional seriousness',
    description: 'HyperTwist goes far beyond the classic cube with dedicated 120‑cell, 5D, and non-Euclidean study experiences.',
  },
  {
    title: 'Desktop-first distribution',
    description: 'The website gets you started, while the fidelity, performance, and full simulator depth stay in the downloadable Unreal app.',
  },
  {
    title: 'Companion systems that go deeper',
    description: 'Speech capture, continuity, and advanced review tools are already present for people who want a richer training routine.',
  },
] as const

export const deliverySurfaceCards = [
  {
    title: 'Public website',
    description: 'Use the website to learn what HyperTwist does, create an account, compare plans, read release notes, and get help.',
    bullets: [
      'Explains the current web-and-desktop product clearly for new players, teams, and buyers.',
      'Carries public docs, release notes, desktop build details, and legal links.',
      'Keeps anonymous pages informative while signed-in routes handle actual downloads.',
    ],
  },
  {
    title: 'Signed-in dashboard',
    description: 'Use the dashboard when your account, subscription, billing, or desktop pairing state matters.',
    bullets: [
      'Shows account, auth, billing, and release status.',
      'Generates desktop-link tokens for safe website-to-desktop pairing.',
      'Keeps plan-gated download access tied to your signed-in account.',
    ],
  },
  {
    title: 'Desktop simulator',
    description: 'Use the desktop build for the real simulator, verified training maps, and higher-dimensional execution.',
    bullets: [
      'Owns recognition, replay, coaching, and packaged training behavior.',
      'Owns the current higher-dimensional 120‑cell and 5D runtime experiences.',
      'Owns the device integrations the public website does not claim.',
    ],
  },
  {
    title: 'Future browser-only simulator',
    description: 'A full browser simulator would be a separate future product branch, not the current downloadable simulator.',
    bullets: [
      'Not the current training surface.',
      'Does not displace the current desktop-first simulator.',
      'Would need its own runtime quality, backend contract, and product proof before launch.',
    ],
  },
] as const

export const browserDesktopRealityCards = [
  {
    title: 'Why the website exists',
    posture: 'Website and account hub',
    description: 'The website is the easiest place to discover HyperTwist, create your account, compare plans, stay current, and unlock the desktop app.',
    bullets: [
      'Use it for product story, account access, pricing, release notes, help, and download handoff.',
      'Use the signed-in dashboard for plan status, private downloads, and desktop pairing without exposing your password inside the app.',
      'That keeps HyperTwist welcoming and easy to navigate before you ever open the simulator.',
    ],
    action: {
      to: '/docs',
      label: 'Open public manual',
    },
  },
  {
    title: 'Why the desktop app exists',
    posture: 'Desktop training experience',
    description: 'The desktop app is where HyperTwist becomes a place to practice, study, and return to every day.',
    bullets: [
      'This is where recognition, replay, coaching, analytics, and session continuity already feel like one connected training flow.',
      'This is also where Magic120Cell and MagicCube5D already become real, explorable sessions instead of abstract promises.',
      'If you want the full HyperTwist experience, this is the product surface that delivers it.',
    ],
    action: {
      to: '/download',
      label: 'Open download center',
    },
  },
  {
    title: 'Why the website feels fast and focused',
    posture: 'Clear product split',
    description: 'The website stays focused so getting in, buying, learning, and staying updated feel effortless instead of buried inside a heavy training tool.',
    bullets: [
      'It does not pretend to be the full simulator, the advanced puzzle room, or the device-heavy practice surface.',
      'Fast controls, richer visuals, deeper puzzle rendering, and future XR growth stay on the native side where they belong.',
      'That split keeps sign-in, billing, downloads, and legal details easy to understand.',
      'You get a clean front door on the web and a much stronger training room on desktop.',
    ],
    action: {
      to: '/app',
      label: 'Open dashboard',
    },
  },
  {
    title: 'Controls and device support today',
    posture: 'What you can use today',
    description: 'Keyboard and mouse are already a real, satisfying way to use HyperTwist today, while broader headset support remains clearly marked as still in validation.',
    bullets: [
      'Classic keyboard play, pointer control, orbit, zoom, camera settings, immersive presets, and dedicated-family selectors are already live.',
      'Magic120Cell and MagicCube5D already carry real session, scene, projection, persistence, and state ownership inside the desktop runtime.',
      'Broader headset and controller rollout still needs packaged device proof before HyperTwist should market it as a finished cross-device VR lane.',
    ],
    action: {
      to: '/features',
      label: 'Open feature atlas',
    },
  },
] as const

export type ProductSurfaceMatrixRow = {
  title: string
  posture: string
  description: string
  owns: readonly string[]
  doesNotClaim: readonly string[]
  nextStep: string
}

export const productSurfaceMatrixRows = [
  {
    title: 'Public website',
    posture: 'Public website',
    description: 'This is the public front door for product discovery, account entry, release notes, and onboarding.',
    owns: [
      'Public docs, pricing, release notes, legal pages, and the first step into downloads.',
      'The clearest place to compare plans, understand the product, and decide whether to create an account.',
      'A trustworthy overview of what ships today without exposing private downloads on an anonymous page.',
    ],
    doesNotClaim: [
      'The native Unreal simulator runtime.',
      'The packaged higher-dimensional sessions or device-heavy practice flow.',
      'A live full-browser simulator edition.',
    ],
    nextStep: 'Start here when you are evaluating HyperTwist, reading the manual, or getting ready to open your account.',
  },
  {
    title: 'Signed-in dashboard',
    posture: 'Account dashboard',
    description: 'This is the signed-in website experience for account health, billing, private downloads, and desktop pairing.',
    owns: [
      'Live session, billing, plan status, and private download context.',
      'Desktop-link token issuance so the app can pair cleanly with your account.',
      'Signed-in launch and access guidance that should not live on public pages.',
      'Account-facing notices, release details, and pairing tools.',
    ],
    doesNotClaim: [
      'The simulator execution loop itself.',
      'Higher-dimensional packaged runtime behavior.',
      'A replacement for the desktop training room.',
    ],
    nextStep: 'Open this once your plan, downloads, pairing, or account status starts to matter.',
  },
  {
    title: 'Embedded simulator web tools',
    posture: 'In-app web tools',
    description: 'These are the web-powered tools that live inside the desktop app itself, not on the public site.',
    owns: [
      'The current MagicTile host and the browser-assisted recognition helper.',
      'Focused runtime diagnostics that stay attached to the native training surfaces.',
      'A first-party browser bridge inside the desktop app instead of a separate public-web simulator claim.',
    ],
    doesNotClaim: [
      'Public auth, pricing, checkout, or legal pages.',
      'Standalone full-browser simulator parity.',
      'A reopened native renderer path for MagicTile.',
    ],
    nextStep: 'Think of this as an in-product companion surface when a desktop session needs web-powered help or diagnostics.',
  },
  {
    title: 'Native Unreal desktop runtime',
    posture: 'Desktop simulator',
    description: 'This remains the real center of HyperTwist for practice, replay, recognition, coaching, and higher-dimensional study.',
    owns: [
      'Recognition, correction, replay, coaching, analytics, and the actual training loop.',
      'Dedicated Magic120Cell and MagicCube5D runtime-state, session, projection, and persistence ownership.',
      'The device, package, and runtime lane the website deliberately does not absorb.',
    ],
    doesNotClaim: [
      'Anonymous public distribution and marketing duties.',
      'Billing or plan management.',
      'A fully finished cross-device VR/controller lane beyond the current bounded keyboard, mouse, and settings ownership.',
    ],
    nextStep: 'Use this when it is time to actually train, review a solve, or open the deeper puzzle families.',
  },
  {
    title: 'Optional full-browser simulator branch',
    posture: 'Future branch',
    description: 'This is a deliberately separate future branch so the current product is never misread.',
    owns: [
      'A documented future possibility only after a separate runtime and backend contract is deliberately reopened.',
      'Planning material that keeps the browser-client lane disciplined instead of vague.',
      'A clear boundary against accidental overclaim.',
    ],
    doesNotClaim: [
      'Current shipping simulator truth.',
      'Permission to displace the current desktop-first model.',
      'Any current production browser parity for higher-dimensional execution.',
    ],
    nextStep: 'Keep it visible as a future branch, but do not send today’s users there as if it already exists.',
  },
] satisfies readonly ProductSurfaceMatrixRow[]

export const featureRegistryTierCards = [
  {
    title: 'Available today',
    description: 'These are live product features and it is safe to describe them as available now on public pages.',
    bullets: [
      'Use this tier for the desktop runtime, browser dashboard, release status, and shipped higher-dimensional lanes.',
      'These are the experiences players, teams, and buyers can actually rely on today.',
      'Public copy should treat this tier as present, not aspirational.',
    ],
  },
  {
    title: 'Coming next',
    description: 'These are real planned capabilities, but not something the public site should describe as already available.',
    bullets: [
      'Use this tier for real product direction that still needs first-party release evidence.',
      'Public wording can describe it as planned, upcoming, or deliberately deferred.',
      'It should never be blurred into live simulator capability.',
    ],
  },
  {
    title: 'Future branch',
    description: 'These are future decision paths that remain intentionally outside current product claims.',
    bullets: [
      'Use this tier for optional full-browser simulator or renderer-widening branches that remain outside the current product.',
      'Keep the branch visible so advanced users understand the difference.',
      'Do not market these paths as available until they are deliberately reopened and revalidated.',
    ],
  },
] as const

export const featureAtlasCurrentTracks = [
  {
    title: 'Native training and coaching core',
    description: 'The heart of HyperTwist is the desktop simulator: fast, focused, and built for repeat practice.',
    bullets: [
      'Native Unreal training, coaching panels, and the guided first-run launch flow are already part of the product.',
      'Classic-cube timing, drill sessions, and repeatable practice loops are already live.',
      'This is the place HyperTwist is designed to feel fast, focused, and worth coming back to.',
    ],
  },
  {
    title: 'Recognition, replay, and progress review',
    description: 'HyperTwist already turns analysis into something you can actually use after a solve.',
    bullets: [
      'Browser-assisted recognition, correction closure, and solve-guidance readout are already shipped.',
      'Replay, analytics, local leaderboards, and native diagnostics are already part of the live training lane.',
      'The website helps you reach these tools cleanly, but the actual analysis and review still happen in the desktop app.',
    ],
  },
  {
    title: 'Higher-dimensional and topology ownership',
    description: 'Serious higher-dimensional study is already part of the product, not a teaser for later.',
    bullets: [
      'Dedicated Magic120Cell and MagicCube5D packaged runtime-state, projection, and persistence ownership are already live.',
      'MagicTile already ships through the in-app browser host with state-bridge and native behavior proof.',
      'Any future renderer widening or full browser edition remains clearly separate until it is genuinely ready.',
    ],
  },
  {
    title: 'Website account, release, and distribution shell',
    description: 'The website is part of the product because it makes access, guidance, releases, and billing easy without turning the simulator into a storefront.',
    bullets: [
      'Shared auth, billing status, private download access, desktop-link pairing, and launch-readiness status already ship.',
      'Public docs, pricing, legal pages, and release surfaces are deliberate product tools, not brochure filler.',
      'The public site stays genuinely useful while keeping the desktop app as the main training surface.',
    ],
  },
] as const

export const advancedOperatorAdjunctTracks = [
  {
    title: 'Speech, voice, and capture companions',
    description: 'HyperTwist already includes voice-aware companion systems that make longer training sessions and review work richer.',
    bullets: [
      'Live microphone capture, permission/readiness workflows, and native capture-route control already ship in bounded first-party form.',
      'Downloadable speech-model custody, transcript envelopes, faster-whisper orchestration, local narration, and advanced voice-model review already exist as companion features.',
      'These deepen the training routine without changing the desktop-first simulator boundary.',
    ],
  },
  {
    title: 'Provider routing, BYOK, and usage governance',
    description: 'The product already includes serious service and provider controls instead of assuming one hidden backend forever.',
    bullets: [
      'Provider-neutral speech and vision contracts, BYOK/profile custody, custom-endpoint routing, and workflow-policy surfaces are already implemented.',
      'Usage and cost dashboards, history/export, receipt review, settlement, and exception handoff already exist as first-party management surfaces.',
      'This keeps external-service status inspectable without confusing account work with simulator execution.',
    ],
  },
  {
    title: 'Continuity, memory, and provenance',
    description: 'HyperTwist also ships continuity-oriented surfaces so your work can accumulate instead of vanishing between sessions.',
    bullets: [
      'Session continuity, workspace recall, chronicle, notes, knowledge, and derived memory families are already in the live feature registry.',
      'Provenance-aware replay or publication state plus ledger-style continuity are part of the owned reference model.',
      'These families support serious study and coaching workflows around the simulator rather than replacing it.',
    ],
  },
] as const

export const shippingNowCards = [
  'A native Unreal simulator with a guided launch menu, coaching surfaces, and a real daily practice flow',
  'Classic-cube timing, drills, local leaderboards, and replay recording',
  'Recognition-assisted reconstruction with correction and solve guidance',
  'An in-app browser companion for live status, pairing, and focused web-powered tools',
  'MagicTile with its current desktop-hosted browser runtime and native behavior proof',
  'Dedicated 120‑cell and 5D runtime ownership with projection and persistence controls',
  'Speech capture, narration, and downloadable speech-model support',
  'Continuity, notes, and workflow support around the simulator',
] as const

export const roadmapHonestyCards = [
  'The website is a polished companion experience, not a pretend replacement for the simulator. The deepest training still lives in the desktop app.',
  'MagicTile currently runs through the embedded browser host inside the desktop app, and that stays true until a stronger native path is truly ready.',
  'Pricing and checkout stay tied to account-backed delivery so subscriptions, notices, and source links remain clear.',
  'Desktop distribution is still the main product model. The website handles account access, release updates, support, and download handoff.',
] as const

export const operatorManualTracks = [
  {
    title: '1. Start on the website',
    description: 'Begin with the public site so your account, plan, and release status are clear before you install anything.',
    steps: [
      'Review the current launch status, release notes, and plan options.',
      'Create or sign in to your HyperTwist account.',
      'Use the dashboard to confirm your plan, billing, and download access.',
    ],
  },
  {
    title: '2. Open the signed-in download path',
    description: 'The public site explains the release, while the actual build stays in the signed-in download area.',
    steps: [
      'Choose the target platform from the public download page.',
      'Carry that platform choice through sign-in.',
      'Download the package once your account access is resolved.',
    ],
  },
  {
    title: '3. Pair the installed desktop runtime',
    description: 'Your website account and desktop app connect through a desktop-link handoff instead of password reuse.',
    steps: [
      'Generate a desktop-link token inside the dashboard.',
      'Open the installed desktop runtime and verify through the token handoff.',
      'Keep release notes and the first-run guide close at hand during the first launch.',
    ],
  },
  {
    title: '4. Use the simulator for real training',
    description: 'Classic-cube practice, replay, diagnostics, and higher-dimensional study all live in the desktop app.',
    steps: [
      'Use the desktop runtime for recognition, replay, coaching, and guided practice.',
      'Treat higher-dimensional training as a native desktop experience, not a browser claim.',
      'Use release notes and package proof to confirm the exact build you are running.',
    ],
  },
  {
    title: '5. Return to the website when needed',
    description: 'Come back to the website when you need support, launch updates, billing, or another download.',
    steps: [
      'Use the dashboard for account, billing, and launch-readiness review.',
      'Use pricing, legal, and support pages for purchase and distribution questions.',
      'Use docs and resources pages for clear explanations of what ships today.',
    ],
  },
] as const

export const desktopWorkflowTracks = [
  {
    title: '1. Run a classic-cube training session',
    description: 'Use the desktop app when the goal is real practice, not product orientation.',
    steps: [
      'Launch the classic-cube training experience from the installed desktop app and confirm the HUD, timer, and scramble state first.',
      'Use the shipped classic control setup for turns, orbit, zoom, hint, fresh-attempt restart, and hold-to-talk behavior during the solve.',
      'Treat this as the real packaged practice loop rather than trying to reproduce it through the public website.',
    ],
  },
  {
    title: '2. Run a recognition and correction workflow',
    description: 'Use the desktop app when you need the real cube-state intake, correction, and solve-guidance flow.',
    steps: [
      'Calibrate and observe the cube through the bounded classic-cube recognition workflow in the desktop app.',
      'Use the browser-assisted recognition helper, then resolve any manual corrections and accepted closure steps inside the native training flow.',
      'Read the reconstruction and solve-guidance output as desktop-app truth, not as a claim that the public website itself performs the recognition job.',
    ],
  },
  {
    title: '3. Review replay, coaching, and analytics',
    description: 'Use the packaged desktop app when the session needs replay continuity, coaching review, and outcome evidence in one place.',
    steps: [
      'Finish or import the training session, then open replay, coaching, and leaderboard or diagnostics surfaces inside the desktop app.',
      'Use the current analytics and review surfaces to inspect timing, progression, and coaching output before escalating or exporting anything outward.',
      'Return to the website only when account, release, entitlement, or support status becomes the next real concern.',
    ],
  },
  {
    title: '4. Open the higher-dimensional families',
    description: 'Use the packaged dedicated-family maps when training moves beyond the classic cube.',
    steps: [
      'Launch the dedicated Magic120Cell or MagicCube5D map from the desktop app instead of expecting browser parity.',
      'Use the shipped selector, focus, projection, symmetry or stereo, and visibility settings that the native surfaces already own explicitly.',
      'Use selector recall when a valid generated-mode launch history exists, while treating broader XR and controller rollout as a future device-proof step.',
    ],
  },
  {
    title: '5. Return to the website when the session is over',
    description: 'Use the website after or around sessions when the next job is commercial, account-related, or release-facing rather than simulator-facing.',
    steps: [
      'Use the signed-in dashboard for plan, access, website-to-desktop pairing, and release-manifest review.',
      'Use public or signed-in launch-status, notices, pricing, and release-notes pages when rollout, legal, or distribution status changes.',
      'Keep website access issues separate from desktop-app issues so support and rollout work stay attached to the correct surface.',
    ],
  },
] as const

export const operatorDesktopQuickstartCards = [
  {
    title: '1. Resolve access and choose the right build',
    description: 'The website should settle identity, access, release status, and target platform before the simulator ever launches.',
    bullets: [
      'Use the public download page to choose your target platform and review package proof before install.',
      'Preserve that target through sign-in and confirm private download access in the dashboard.',
      'Treat launch status, release notes, and legal details as part of the install decision rather than later paperwork.',
    ],
  },
  {
    title: '2. Pair the installed runtime without password reuse',
    description: 'HyperTwist keeps website identity narrow and hands it to the desktop app through a desktop-link token.',
    bullets: [
      'Generate a desktop-link token from the signed-in dashboard after sign-in succeeds.',
      'Use the token during first launch so the installed app inherits the correct account and release status.',
      'Return to the website later when account, plan, or release state changes.',
    ],
  },
  {
    title: '3. Verify the first native training session',
    description: 'The first serious simulator check should confirm classic-cube execution, replay, coaching, and the shipped control roster.',
    bullets: [
      'Open the classic-cube experience and confirm timing, replay, guidance, and desktop HUD behavior.',
      'Use the shipped classic profile `classic-wca-keyboard/v1` together with click, touch, orbit, zoom, hint, and hold-to-talk behavior.',
      'Treat the public and signed-in website surfaces as coordination layers around the app, not as substitutes for it.',
    ],
  },
  {
    title: '4. Open the higher-dimensional families and read the control boundary honestly',
    description: 'The native desktop app already owns real 120‑cell and 5D execution, but it still keeps broader XR and controller rollout behind an explicit boundary.',
    bullets: [
      'Launch the dedicated `Magic120Cell` and `MagicCube5D` training maps from the packaged app.',
      'Use the current projection, focus, visibility, selector, and persisted selector-recall ownership as the current first-party settings model.',
      'Do not mistake project-level controller groundwork for finished headset rollout; that branch still needs packaged device validation.',
    ],
  },
] as const

export const degradedStateRecoveryTracks = [
  {
    title: 'Browser auth degraded or mixed',
    description: 'Treat browser sign-in as recoverable account continuity when shared auth is temporarily degraded, not as a silent claim that every release surface is final.',
    steps: [
      'Continue with sign-in or registration only when you need bounded account, release, or rollout orientation.',
      'Use the protected dashboard to inspect what still works and what remains intentionally withheld.',
      'Use the protected dashboard and support lanes for account-aware follow-through if live auth status needs human review.',
    ],
  },
  {
    title: 'Release authority temporarily unavailable',
    description: 'When the live release manifest is unavailable, HyperTwist keeps rollout information visible without turning local reference data into raw package-delivery authority.',
    steps: [
      'Use local reference metadata, packaged proof, and notices for orientation while release authority recovers.',
      'Keep raw package delivery withheld until live release authority returns.',
      'Refresh the protected release lane first, then escalate to support if rollout or entitlement work remains blocked.',
    ],
  },
  {
    title: 'Desktop-first continuity during recovery',
    description: 'Even when browser auth or release authority is degraded, the simulator topology stays the same: browser surfaces coordinate, desktop runtime executes.',
    steps: [
      'Use public and protected browser surfaces for support, account, release, and rollout context.',
      'Use the desktop runtime for simulator execution, packaged proof, and serious training work.',
      'Keep release notes plus packaged proof visible before redistributing or escalating a build.',
    ],
  },
] as const

export const simulatorManualCards = [
  {
    title: 'Classic-cube recognition and correction',
    description: 'Use the desktop runtime when you want the real recognition-to-reconstruction flow instead of just reading about it.',
    bullets: [
      'Calibrate and observe the cube through the bounded classic-cube capture workflow.',
      'Use browser-assisted recognition, manual correction closure, and solve-guidance readout from the native training lane.',
      'Treat this as a desktop training workflow, not a claim that the public website performs the reconstruction job itself.',
    ],
  },
  {
    title: 'Replay, coaching, and analytics',
    description: 'Use the desktop runtime when practice needs timing, replay, coaching, and progress review in one place.',
    bullets: [
      'Run drill and timing sessions, then review replay and coaching outputs inside the native training surface.',
      'Use the local leaderboard and diagnostics surfaces as part of the packaged runtime, not as detached web widgets.',
      'Return to the browser dashboard only when release, entitlement, or rollout status matters.',
    ],
  },
  {
    title: 'Higher-dimensional runtime ownership',
    description: 'Use the packaged Unreal maps for the serious hypercubing lane.',
    bullets: [
      'Launch the dedicated-family 120‑cell and 5D training maps from the desktop runtime.',
      'Use the bounded visible-slice and projection ownership already landed for higher-dimensional exploration.',
      'Keep the public website language honest: it can describe this lane, but it does not replace the packaged runtime that executes it.',
    ],
  },
  {
    title: 'Operator diagnostics and release proof',
    description: 'Use both surfaces together when rollout confidence matters.',
    bullets: [
      'Use the browser dashboard for auth, billing, desktop-link pairing, and release-lane status.',
      'Use the desktop runtime for browser-runtime diagnostics, simulator execution, and package-validated behavior.',
      'Use package proof, release notes, and notices together before any public-facing rollout or team distribution.',
    ],
  },
] as const

export const higherDimensionalRuntimeGuideCards = [
  {
    title: 'Magic120Cell packaged runtime',
    description: 'Use the packaged native training lane when you want real 120‑cell space to study, rotate, and learn inside a serious simulator.',
    bullets: [
      'Launch the dedicated Magic120Cell training map from the desktop runtime.',
      'Use the current symmetry, focus, and logical-visibility settings as the authoritative first-party runtime owner.',
      'The native training surfaces also expose the dedicated session, scene, persistence, and family-state semantics for this lane explicitly.',
      'The same native surfaces can recall the latest persisted generated-mode selector state for this family when it exists.',
      'Treat the public website as documentation and launch support, not as the runtime that executes this family.',
    ],
  },
  {
    title: 'MagicCube5D packaged runtime',
    description: 'Use the packaged native training lane when you want real 5D projection, stereo, focus, and face-visibility study.',
    bullets: [
      'Launch the dedicated MagicCube5D training map from the desktop runtime.',
      'Use the current projection-distance, stereo, and visibility defaults as the bounded first-party runtime settings.',
      'The native training surfaces also expose the dedicated session, scene, persistence, and family-state seams for this lane explicitly.',
      'The same native surfaces can recall the latest persisted generated-mode selector state for this family instead of forcing a blind restart.',
      'Keep this lane described honestly as packaged native behavior rather than browser simulator parity.',
    ],
  },
  {
    title: 'MagicTile embedded-browser runtime',
    description: 'Use the embedded browser lane for the current non-Euclidean tiling host while deeper renderer expansion remains a future product decision.',
    bullets: [
      'Treat the embedded browser/CEF shell as the current shipped host for the live MagicTile interaction lane.',
      'Keep shared scramble normalization, timer transport, and state-bridge ownership attached to the first-party native shell and bridge.',
      'Do not describe a separate native renderer port as live unless a later product packet proves it and ships it.',
    ],
  },
] as const

export const inputAndDevicePostureCards = [
  {
    title: 'Keyboard and mouse ship today',
    description: 'Classic-cube play and bounded keyboard-driven higher-dimensional interaction are already real current product lanes.',
    bullets: [
      'Classic-cube runtime input already includes click, touch, orbit, zoom, and bounded keyboard move intent.',
      'The current classic keyboard profile is the shipped `classic-wca-keyboard/v1` mapping.',
      'Treat this as real simulator input ownership, not as browser-only ornamentation.',
    ],
  },
  {
    title: 'Higher-dimensional view controls are already owned',
    description: 'Magic120Cell and MagicCube5D already carry first-party projection, focus, symmetry or stereo, visibility defaults, and visible native settings ownership in the packaged runtime.',
    bullets: [
      'Magic120Cell keeps symmetry, logical-visibility depth, and center-cell focus settings explicit.',
      'MagicCube5D keeps projection-distance, stereo, face-visibility, and focus settings explicit.',
      'The desktop operator and training lane now also surfaces these dedicated-family view owners together with exact session-surface, interactive-scene, persistence-boundary, and state-semantics ownership.',
      'That same native lane now also keeps bounded camera-export continuity and immersive session-local recall visible instead of implying that continuity only through softer prose.',
      'The same native surfaces now expose selector recall from the latest persisted generated-mode launch request when that launch history exists.',
      'These controls belong to the dedicated-family desktop runtime lanes, not to the public website.',
    ],
  },
  {
    title: 'XR groundwork exists, but the full VR lane is not finished',
    description: 'EnhancedInput, bounded OpenXR runtime ownership, and first-party controller settings/rebinding now exist, but HyperTwist does not market a fully finished cross-device VR/runtime lane without packaged device proof.',
    bullets: [
      'Project config already carries EnhancedInput plus Vive, Oculus Touch, Mixed Reality, and Valve Index axis groundwork.',
      'The current shipping branch enables the bounded OpenXR plugin stack, first-party runtime-owner substrate, and first-party controller settings/rebinding ownership while keeping broad headset/controller rollout tied to packaged device validation.',
      'Current product truth should not overclaim packaged controller proof or broader finished cross-device VR completion.',
      'The current host decision remains desktop-first for broader native OpenXR/controller rollout until Windows packaged controller validation with controller truth is complete.',
    ],
  },
] as const

export const runtimeControlGuideCards = [
  {
    title: 'Classic-cube desktop session',
    description: 'This is the current practical control model for the packaged classic-cube runtime.',
    bullets: [
      'Use left click or touch to drive face interaction in the live training lane.',
      'Use middle-mouse drag to orbit and scroll-wheel zoom to reframe the active cube during practice or replay review.',
      'The current desktop HUD truth is literal: LMB clockwise, RMB counter-clockwise, touch clockwise, MMB drag orbit, wheel zoom, R scramble, H hint, Enter submit, F mode, V hold-to-talk, C cycle voice.',
      'Use the shipped fresh-attempt, hint, and hold-to-talk shortcuts when you want restart, guidance, or bounded voice interaction from the native runtime.',
    ],
  },
  {
    title: 'Higher-dimensional desktop session',
    description: 'This is the current practical control model for the dedicated Magic120Cell and MagicCube5D runtime families.',
    bullets: [
      'Launch the dedicated-family desktop maps instead of expecting the public website to host the serious runtime lane.',
      'Use the current keyboard-driven slice, layer, or rotation interaction together with the family-owned projection and focus defaults.',
      'Use the native operator/training inspect surfaces to confirm when the latest persisted generated-mode selector state is available for recall.',
      'Treat symmetry, stereo, visibility, and focus settings as current packaged runtime ownership rather than as a fully generalized preferences suite.',
    ],
  },
  {
    title: 'Native diagnostics check',
    description: 'Use the native training panel or coach dashboard to confirm the runtime you are actually operating before longer sessions, support escalation, or rollout review.',
    bullets: [
      'Read the active higher-dimensional selection line to confirm the current activation, view-context, session, and displayed scene ids instead of inferring them from the launched map alone.',
      'Read the profile continuity line to confirm the shipped camera-export artifact `artifact/camera-export-json`, immersive recall boundary `immersive-training-session-recall-boundary`, and the current recall-scope and preference-field counts when bounded continuity is available.',
      'Use the same native surfaces to verify the current XR/controller boundary before assuming broad headset-runtime or controller-rebinding support.',
      'If behavior and rollout status disagree, capture the native diagnostics first and then move into the protected browser support or release lanes with the exact runtime state in hand.',
    ],
  },
  {
    title: 'Current control boundary',
    description: 'This keeps the manual useful by being explicit about what is supported now and what remains outside current packaged device proof.',
    bullets: [
      'Use keyboard and mouse as the current strong operator-facing control lane.',
      'Treat current camera, immersive, and dedicated-family view settings ownership as real, including bounded camera-export continuity and session-local immersive recall, but still bounded.',
      'Do not assume a finished headset-specific VR onboarding, packaged controller proof, or broad cross-device XR rollout has already landed.',
      'Treat the current controller settings/rebinding ownership as bounded native runtime truth, not as proof that the broader XR/controller widening gate is already open.',
      'Treat any future XR/controller/settings widening as a deliberate product step above the current desktop-first device-proof boundary, not as something the public website should overclaim today.',
    ],
  },
] as const

export const controlProfileRosterCards = [
  {
    title: 'Shipped classic control profile',
    description: 'The current desktop runtime exposes a concrete shipped control profile rather than vague “keyboard support” language.',
    bullets: [
      'The native operator and training surfaces currently expose the shipped classic profile as `classic-wca-keyboard/v1` with 18 active bindings.',
      "The shipped move roster is explicit too: I/K = R/R', J/F = U/U', H/G = F/F', D/E = L/L', S/L = D/D', W/O = B/B', T/Y = x/x', N/B = y/y', and P/Q = z/z'.",
      'Classic-cube interaction already combines that keyboard profile with click, touch, orbit, zoom, hint, and hold-to-talk behavior in the live desktop lane.',
      'Treat this roster as native simulator ownership, not as something delegated to the browser shell.',
    ],
  },
  {
    title: 'Selectable immersive and family-specific settings',
    description: 'Current settings ownership already goes beyond one camera toggle, but it stays bounded to the real shipped family lanes and scenic presets.',
    bullets: [
      'The current scenic immersive roster includes 3 immersive-intensity presets and 3 reduced-distraction presets.',
      'Magic120Cell currently exposes 4 selector options alongside its symmetry, focus, and visibility owners.',
      'MagicCube5D currently exposes 4 selector options alongside its projection-distance, stereo, focus, and visibility owners.',
      'Both higher-dimensional families now also surface their dedicated session, interactive-scene, persistence-boundary, and state-semantics ownership directly in the native diagnostics lane, and the live roster surface keeps the currently displayed scene id visible too.',
    ],
  },
  {
    title: 'Persistence and boundary truth',
    description: 'Current continuity is real, but it is still narrower than a finished global preferences and controller-rebinding suite.',
    bullets: [
      'The native operator and training surfaces can recall the latest persisted generated-mode selector state when a structurally valid launch request exists.',
      'Those same native surfaces now also keep the shipped camera-export artifact and immersive session-recall boundary explicit together with recall-scope and preference-field counts, so bounded local continuity is no longer implied only through summary prose.',
      'Those same native surfaces now also prove which family-specific persistence boundary and state-semantics contract currently owns the higher-dimensional settings lane.',
      'Viewer camera settings and immersive-presence settings are already first-party owned in the desktop runtime.',
      'First-party controller settings/rebinding now also exist inside the bounded desktop OpenXR lane, while packaged headset/controller proof and broader VR onboarding remain a future validation step.',
    ],
  },
  {
    title: 'XR reopen requirements',
    description: 'The current desktop-first XR boundary is not vague. HyperTwist already owns the bounded runtime-owner and controller-settings pieces, and it knows the remaining proof required before broader native XR/controller widening can be marketed honestly.',
    bullets: [
      'The bounded desktop runtime already owns dedicated runtime owners for live OpenXR/controller execution inside the current training lane.',
      'The native simulator now also owns first-party user-facing controller settings, layout presets, and rebinding truth for the exact shipped XR input ids.',
      'The remaining reopen requirement is Windows packaged controller validation with controller truth on the shipping lane rather than only editor-time or config-only confidence.',
      'Until that packaged proof exists, keep reading the current shipped lane as keyboard, mouse, camera, immersive, dedicated-family settings ownership, and bounded XR ownership rather than a finished cross-device VR/controller product branch.',
    ],
  },
] as const

export const deploymentReadinessTracks = [
  {
    title: '1. Identity and access status',
    steps: [
      'Confirm shared browser auth is live before inviting operators into the protected release lane.',
      'Treat login/register visibility above decorative auth backdrops as a launch-readiness invariant, not a cosmetic preference.',
      'Use the protected dashboard to resolve plan, entitlement, and desktop-link token status.',
      'Keep browser-to-desktop handoff explicit so the installed app never depends on password reuse.',
    ],
  },
  {
    title: '2. Release and package status',
    steps: [
      'Publish release-manifest truth for the active desktop targets before widening any public launch language.',
      'Keep package validation proof visible beside download guidance so rollout remains evidence-backed.',
      'Differentiate browser-shell changes from simulator/package changes in release notes and support guidance.',
    ],
  },
  {
    title: '3. Legal and source follow-through',
    steps: [
      'Keep notices and corresponding-source links visible anywhere pricing, checkout, or downloads are exposed.',
      'Treat public pricing/download surfaces as part of the distributed product, not detached brochure pages.',
      'Do not let launch copy outrun the actual checkout, release, or source-availability configuration.',
    ],
  },
] as const

export const publicDocumentationPrinciples = [
  {
    title: 'Feature-registry-backed wording only',
    description: 'Public documentation should describe shipped capability, retained capability, and spec-only branches with the same discipline used in the internal feature registry.',
  },
  {
    title: 'Browser shell and simulator kept separate',
    description: 'Account access, pricing, and download guidance belong to the website. Recognition, replay, coaching, and higher-dimensional execution belong to the desktop runtime.',
  },
  {
    title: 'Launch and legal readiness stay visible',
    description: 'Pricing, download, and notices pages remain part of one release story so package proof and corresponding-source duties do not disappear during rollout.',
  },
] as const

export const operatorPlaybooks = [
  {
    title: 'Operator onboarding',
    steps: [
      'Sign in through the browser shell before requesting a desktop package.',
      'Confirm package proof and release references before first install.',
      'Use desktop-link pairing so the installed app inherits the right account status.',
    ],
  },
  {
    title: 'Studio rollout',
    steps: [
      'Validate checkout, download, notices, and corresponding-source follow-through together.',
      'Treat package proof as part of launch readiness rather than as a separate afterthought.',
      'Keep the browser dashboard for coordination and the desktop build for actual simulator execution.',
    ],
  },
  {
    title: 'Support and compliance',
    steps: [
      'Route account, entitlement, and rollout issues through support-safe browser surfaces.',
      'Keep pricing/download/notices links aligned for any public distribution event.',
      'Do not describe the full-browser simulator branch as live while it remains a future validation branch.',
    ],
  },
  {
    title: 'Recovery and account authority',
    steps: [
      'Use degraded browser auth or release-manifest recovery for orientation, not as a false claim of final release authority.',
      'Keep raw package delivery withheld until protected release authority recovers.',
      'Separate account, package, runtime, and compliance follow-through before escalating.',
    ],
  },
] as const

export const releaseStoryCards = [
  {
    title: 'Desktop package hardening',
    description: 'Release notes should foreground the native simulator lane: packaged validation, dedicated training maps, replay proof, and higher-dimensional runtime closure.',
    bullets: [
      'Call out the Windows packaged-validation lane when it is the strongest current proof.',
      'Differentiate simulator/runtime changes from browser-shell or billing changes.',
      'Keep package proof, release notes, and distribution guidance linked together.',
    ],
  },
  {
    title: 'Browser operator hardening',
    description: 'Website change notes should explain auth, entitlement, launch-readiness, and dashboard behavior without implying browser simulator parity.',
    bullets: [
      'Summarize account, checkout, and desktop-link changes in operator language.',
      'Keep public early-access-versus-launch status visible when values are not fully live.',
      'Treat browser improvements as operator/distribution work around the desktop runtime.',
    ],
  },
  {
    title: 'Legal and release discipline',
    description: 'Distribution-facing changes are product changes, not footer trivia, because they affect whether the release lane is truthful and launchable.',
    bullets: [
      'Record corresponding-source, notices, and pricing/download status when they change.',
      'Make release chronology readable for studios evaluating rollout risk.',
      'Keep public legal surfaces synchronized with actual downloadable status.',
    ],
  },
] as const

export const distributionDoctrineCards = [
  {
    title: 'Public pages are distribution surfaces',
    description: 'Pricing, checkout, release, and download pages are part of the distributed product story whenever they sell or deliver downloadable builds.',
    bullets: [
      'Treat those pages as release-facing surfaces, not detached marketing copy.',
      'Keep open-source notices and corresponding-source links reachable from them.',
      'Do not let launch copy outrun the actual package and legal follow-through.',
    ],
  },
  {
    title: 'Package proof stays visible',
    description: 'The legal and release lane stays more trustworthy when package validation evidence remains visible alongside download guidance.',
    bullets: [
      'Show validation summaries where public audiences assess readiness.',
      'Preserve the link between build proof, release notes, and distribution guidance.',
      'Use the protected dashboard for access control, not to hide release truth.',
    ],
  },
  {
    title: 'Browser and desktop remain distinct',
    description: 'Notices and legal guidance should reinforce that the website governs distribution while the simulator remains a native runtime.',
    bullets: [
      'Do not imply that a legal-ready website means the browser is now the simulator.',
      'Keep device/runtime obligations tied to the downloadable product lane.',
      'Describe any future full-browser client as a separate branch until reopened.',
    ],
  },
] as const

export const privacyBoundaryCards = [
  {
    title: 'Browser identity and billing boundary',
    description: 'The public/protected browser shell should retain only the account, session, entitlement, and billing data needed for access control and release delivery.',
    bullets: [
      'Keep sign-in, plan access, and desktop-link issuance inside the browser account lane.',
      'Avoid claiming browser ownership over native simulator telemetry by default.',
      'Use the browser shell for narrow rollout/account state, not for universal runtime state capture.',
    ],
  },
  {
    title: 'Desktop simulator boundary',
    description: 'The desktop runtime owns the simulator and training behavior, so privacy wording should not collapse those runtime facts into generic website claims.',
    bullets: [
      'Treat native training, replay, and diagnostics as desktop concerns first.',
      'Describe pair-up and access transfer truthfully without advertising password reuse.',
      'Keep browser-to-desktop token handoff as the bounded identity bridge.',
    ],
  },
  {
    title: 'Support and compliance boundary',
    description: 'Support flows should collect the smallest useful operator context while keeping legal and account duties intact.',
    bullets: [
      'Route billing, entitlement, and rollout issues through support-safe browser surfaces.',
      'Keep public documentation explicit about what data belongs to release access versus simulator use.',
      'Preserve legal-distribution disclosure without broadening into unrelated tracking claims.',
    ],
  },
] as const

export const termsBoundaryCards = [
  {
    title: 'Access model',
    description: 'Terms should match the actual product topology: public pages, protected dashboard access, and native desktop delivery.',
    bullets: [
      'Browser access covers public information, account, entitlement, and release coordination.',
      'Protected downloads remain tied to account and plan status.',
      'Native runtime use remains subject to release, notice, and distribution rules.',
    ],
  },
  {
    title: 'Simulator boundary',
    description: 'Terms should not pretend the current website has replaced the native simulator lane.',
    bullets: [
      'Keep the desktop-first simulator model explicit.',
      'Treat any later full-browser simulator work as a separate branch until reopened.',
      'Avoid vague “all features available on the web” language while that is untrue.',
    ],
  },
  {
    title: 'Operational obligations',
    description: 'Commercial and rollout terms should stay aligned with the same legal and package-proof duties visible elsewhere on the site.',
    bullets: [
      'Keep notices and corresponding-source status reachable from access and download surfaces.',
      'Preserve release-note and support references for operator-grade deployment.',
      'Bind the commercial lane to the actual shipped release status, not a speculative future branch.',
    ],
  },
] as const

export const digitalDeliveryCards = [
  {
    title: 'Release selection before install',
    description: 'Digital delivery begins on the website so you can review platform, account access, and release status before opening the desktop app.',
    bullets: [
      'Choose the platform from the public download surface.',
      'Carry that selection into the protected dashboard.',
      'Confirm release notes, package proof, and notices before distribution.',
    ],
  },
  {
    title: 'Private download handoff',
    description: 'The signed-in website keeps private downloads tied to your account without placing sensitive delivery links on anonymous public pages.',
    bullets: [
      'Use account state to unlock the real package handoff.',
      'Use desktop-link pairing to hand identity over to the installed app.',
      'Keep public pages informative while preserving private release access.',
    ],
  },
  {
    title: 'After-install rhythm',
    description: 'Delivery is only complete when the installed app and your website account stay aligned.',
    bullets: [
      'Use the website dashboard for account, billing, and release guidance.',
      'Use the desktop app for simulator execution, diagnostics, and higher-dimensional training.',
      'Return to notices, pricing, and support pages when release or compliance status changes.',
    ],
  },
] as const

export const resourceCollections = [
  {
    title: 'What HyperTwist really includes',
    items: [
      'A full tour of what is live right now',
      'A clear website-versus-desktop guide',
      'A real first-session path from first visit to first solve',
      'A launch-status page for early access and wider rollout visibility',
      'A help center for setup, controls, and troubleshooting',
      'A feature atlas for puzzle depth, training workflows, and account access',
      'Clear separation between what ships now and what is still in validation',
      'Release notes that explain what changed in plain language',
      'A desktop-first simulator model with a polished website companion',
      'Practical guides for classic cubes, replay, recognition, and higher-dimensional study',
      'Manual coverage for voice, provider, and continuity companion systems',
    ],
  },
  {
    title: 'Download and release',
    items: [
      'Desktop download instructions and release channels',
      'Desktop-link handoff for website-to-desktop sign-in',
      'Legal notices and source-link guidance for public distribution',
      'Build verification proof and release-readiness guidance',
    ],
  },
  {
    title: 'Training depth',
    items: [
      'Classic-cube recognition and correction workflows',
      'Step-by-step desktop workflows for practice, review, and higher-dimensional sessions',
      'Replay, coaching, analytics, and build-readiness updates',
      'Higher-dimensional family overviews and where each experience lives today',
      '120‑cell and 5D family overviews',
      'Speech capture, narration, and downloadable-model status',
    ],
  },
  {
    title: 'Advanced companion systems',
    items: [
      'Bring-your-own-key routing, profile custody, and custom-endpoint status',
      'Usage and cost dashboards, export history, receipts, settlement, and exception handoff',
      'Continuity, notes, memory, and provenance-aware replay or publication state',
      'Companion systems that deepen the simulator instead of distracting from it',
    ],
  },
  {
    title: 'Deployment readiness',
    items: [
      'Shared sign-in and website-to-desktop pairing status',
      'Build verification proof and release-manifest interpretation',
      'Pricing, checkout, notices, and corresponding-source coordination',
      'Launch-readiness distinctions between early access, signed-in access, and wider public rollout',
    ],
  },
  {
    title: 'Recovery and escalation',
    items: [
      'Sign-in recovery and mixed-mode guidance',
      'Release-status recovery without exposing private package delivery',
      'Direct contact routes for access, rollout, pricing, and legal follow-through',
      'Account, build, app, and compliance issue separation',
      'Clear next steps when website services are temporarily degraded',
    ],
  },
] as const

export const browserPurposeCards = [
  {
    title: 'Use the website for access, updates, and your account',
    description: 'The website is at its best when the job is discovery, account access, release updates, or buying and downloading the app.',
    bullets: [
      'Open the public pages for product story, pricing, release notes, legal details, and launch status.',
      'Use the signed-in dashboard for plan access, billing, private downloads, and desktop-link pairing.',
      'Keep buying, account, and legal follow-through on the website so the simulator never has to become a storefront or login screen.',
    ],
  },
  {
    title: 'Use the website for guidance and onboarding',
    description: 'The web experience shines when the job is explanation, orientation, or team coordination rather than live puzzle play.',
    bullets: [
      'Use docs, help, resources, and support as your manual and getting-started guide.',
      'Review first-launch guidance, control expectations, build proof, and support routes before deeper training work.',
      'Use the website when a buyer, coach, teacher, or team needs to understand what is real today without opening the desktop app first.',
    ],
  },
  {
    title: 'Come back to the website after install when account state changes',
    description: 'The website remains part of the product after install, but for very specific reasons.',
    bullets: [
      'Return to the website for account changes, plan changes, desktop-link refresh, private notices, release-manifest review, and support escalation.',
      'Keep website issues separated from desktop-app issues so support can diagnose the right surface quickly.',
      'Treat the website as the account and delivery layer around the simulator, not as a hidden second simulator.',
    ],
  },
] as const

export const browserLimitCards = [
  {
    title: 'What still belongs to the desktop app',
    description: 'The website is intentionally narrower because the richest parts of HyperTwist need the native downloadable.',
    bullets: [
      'It does not run the full simulator, the replay room, or the dedicated higher-dimensional family maps.',
      'It does not offer the same low-latency input, device access, or deep Unreal behavior that powers the desktop app.',
      'It does not yet claim finished packaged controller support or a complete XR experience; that work stays on the native side for now.',
    ],
  },
  {
    title: 'Why the desktop app is where HyperTwist comes alive',
    description: 'The desktop app stays primary because that is where practice starts to feel rich, responsive, and worth returning to every day.',
    bullets: [
      'The desktop app owns recognition, correction, replay, coaching, analytics, and genuine session continuity.',
      'It owns the current dedicated `Magic120Cell` and `MagicCube5D` experiences, including projection, persistence, and packaged training-map execution.',
      'It is also where build proof, native diagnostics, control truth, and serious study sessions are easiest to trust.',
    ],
  },
  {
    title: 'When the website is exactly the right tool',
    description: 'The website stays valuable because it helps you choose, unlock, and support the product without making you install first.',
    bullets: [
      'Use it for product evaluation, account access, signed-in release status, billing, legal pages, help, and launch-readiness review.',
      'Use it when a team needs a clear explanation, public references, or rollout coordination without opening the simulator.',
      'Use it as the clean bridge into the desktop app rather than as a lesser substitute for the simulator itself.',
    ],
  },
] as const

export const browserWorkflowTracks = [
  {
    title: '1. Start on the web before you install anything',
    description: 'The first job is understanding release status and choosing the right path into the product.',
    steps: [
      'Review launch status, pricing, and download guidance on the public site.',
      'Open docs, help, or resources if you want the product story, controls, or puzzle lineup explained before install.',
      'Choose the right platform and plan status before you move into your signed-in account area.',
    ],
  },
  {
    title: '2. Use the signed-in website for account-aware follow-through',
    description: 'The website becomes stronger after sign-in, but it still stays focused on account, download, and release work.',
    steps: [
      'Sign in, review account and access status, and generate a desktop-link token when needed.',
      'Use private downloads and legal details instead of expecting anonymous public pages to expose raw delivery links.',
      'Keep the website focused on release, billing, pairing, and delivery status rather than simulator execution.',
    ],
  },
  {
    title: '3. Hand off to the downloadable for the real simulator',
    description: 'The website flow succeeds when it leads cleanly into the desktop app instead of pretending to replace it.',
    steps: [
      'Install the verified desktop build and complete the website-to-desktop handoff.',
      'Use the desktop app for actual training, higher-dimensional work, replay, and diagnostics.',
      'Return to the website later only when account, legal, release, or support context becomes the next real concern.',
    ],
  },
] as const

export const puzzleCatalogCards = [
  {
    title: 'Classic-cube practice and timing',
    description: 'The desktop app already owns the day-to-day solving experience for serious training.',
    bullets: [
      'Classic timing, scramble flow, hints, mode switching, voice shortcuts, and replay-aware practice already ship.',
      'The current control story is concrete today: the shipped `classic-wca-keyboard/v1` profile plus click or touch, orbit, zoom, hint, and hold-to-talk behavior.',
      'This is the fastest way to feel that a fresh install matches the promise of the website.',
    ],
  },
  {
    title: 'Recognition, reconstruction, and solve guidance',
    description: 'HyperTwist already turns physical-cube intake and correction into a real first-party workflow.',
    bullets: [
      'Use the desktop app for capture, browser-assisted recognition, manual correction, and solve-guidance readout.',
      'The website helps you reach this workflow, but the actual reconstruction work stays inside the desktop app.',
      'This keeps physical practice and analytical follow-through inside one coherent training system.',
    ],
  },
  {
    title: 'Replay, coaching, and analytics',
    description: 'The downloadable also owns session review, training continuity, and evidence-rich feedback.',
    bullets: [
      'Replay capture, coaching review, local leaderboard persistence, and diagnostics already ship.',
      'These tools live inside the desktop app, not in detached browser widgets pretending to be full simulator parity.',
      'This is one of the clearest reasons the downloadable remains much more powerful than the web experience.',
    ],
  },
  {
    title: 'Magic120Cell packaged runtime',
    description: 'HyperTwist already ships a real dedicated higher-dimensional family inside the downloadable.',
    bullets: [
      'The desktop app owns live `Magic120Cell` scenes, symmetry and focus settings, and saved selector continuity.',
      'Players and coaches can inspect the current scene, session, and persistence details directly in native diagnostics.',
      'This experience is described on the public site, but it is only executed in the downloadable app.',
    ],
  },
  {
    title: 'MagicCube5D packaged runtime',
    description: 'The downloadable already carries real 5D depth instead of broad capability claims.',
    bullets: [
      'Use the dedicated `MagicCube5D` map for projection distance, stereo, focus, and face-visibility study inside the desktop app.',
      'Native diagnostics already expose the current scene, session, and persistence details for this family too.',
      'The website can document and coordinate this experience, but it does not replace the downloadable that executes it.',
    ],
  },
  {
    title: 'MagicTile inside the desktop app',
    description: 'HyperTwist also carries a non-Euclidean experience, and it is intentionally hosted inside the desktop product.',
    bullets: [
      'The current live `MagicTile` experience runs through the embedded browser host inside Unreal rather than through the public website.',
      'State bridge, scramble normalization, and timer continuity are already first-party owned around that host.',
      'A deeper native renderer path remains a future decision, so the public product story stays honest about where this experience currently lives.',
    ],
  },
] as const

export const audienceFitCards = [
  {
    title: 'New solvers',
    description: 'The product already supports a guided early-training lane instead of only expert tooling.',
    bullets: [
      'Use classic timing, hints, solve guidance, and replay-backed review to build confidence from the start.',
      'The website can explain the first-session path before the downloadable takes over for the real practice loop.',
    ],
  },
  {
    title: 'Serious daily trainers',
    description: 'This is the current core audience for the desktop runtime.',
    bullets: [
      'Recognition, replay, coaching, diagnostics, and continuity are already designed to support repeated deliberate practice.',
      'The browser lane stays useful around that work for release status, account access, and support-safe coordination.',
    ],
  },
  {
    title: 'Hypercubers and topology-focused learners',
    description: 'HyperTwist is already unusual in that it treats higher-dimensional work as a real shipping experience.',
    bullets: [
      'Dedicated `Magic120Cell`, `MagicCube5D`, and bounded `MagicTile` lanes are public, truthful, and source-backed today.',
      'The downloadable remains essential here because the higher-dimensional runtime ownership is not a browser claim.',
    ],
  },
  {
    title: 'Studios, educators, and rollout owners',
    description: 'The website matters most for teams that need distribution, launch, and support clarity before training sessions begin.',
    bullets: [
      'Pricing, notices, support, launch status, docs, help, and browser-to-desktop handoff all matter before a team adopts the software.',
      'This is one of the strongest reasons the browser experience is still worth keeping even though the desktop app remains the main product.',
    ],
  },
] as const

export const helpCenterCards = [
  {
    title: 'Account, access, and private downloads',
    description: 'Use the help center when the next task is getting into the right account area or download path safely.',
    bullets: [
      'Choose the right public route, preserve the requested platform through sign-in, and use the signed-in dashboard for account-aware delivery.',
      'Keep sign-in, release, and desktop-link questions attached to the website instead of flattening them into simulator bugs.',
    ],
  },
  {
    title: 'First launch and desktop verification',
    description: 'The help center should also explain what a good first packaged session looks like.',
    bullets: [
      'Verify package proof, release notes, the shipped control roster, and the classic-cube lane before broader rollout.',
      'Confirm the higher-dimensional family you plan to use instead of inferring readiness from broad marketing copy alone.',
    ],
  },
  {
    title: 'Controls, settings, and current XR truth',
    description: 'The current input story is strong, but it is bounded and should be taught honestly.',
    bullets: [
      'Keyboard, mouse, touch, camera, immersive settings, selector continuity, and dedicated-family view ownership are already real.',
      'Broader headset and controller rollout still waits for packaged Windows proof; the underlying OpenXR groundwork and first-party controller settings are already there, but the final claim is intentionally held back.',
    ],
  },
  {
    title: 'Launch, pricing, notices, and release details',
    description: 'Help is not only for app bugs. It is also for clean digital delivery.',
    bullets: [
      'Use pricing, launch status, legal pages, and source-availability guidance together when a team is evaluating a release.',
      'Keep commercial, legal, release, and simulator questions separated so people can move faster with less confusion.',
    ],
  },
] as const

export const contactChannelCards = [
  {
    title: 'Account and access support',
    description: 'Use this when a real user session is blocked by account, plan, or release-access issues.',
    bullets: [
      `Contact ${brandConfig.contact.email} for access, release enablement, desktop-link pairing trouble, or signed-in website follow-through.`,
      'Include the exact route, plan status, requested platform, and whether the problem is public, signed-in, or inside the desktop app.',
    ],
  },
  {
    title: 'Desktop app issue reporting',
    description: 'Use this when the downloadable itself behaves unexpectedly.',
    bullets: [
      'Name the affected experience: classic cube, recognition, replay or coaching, `Magic120Cell`, `MagicCube5D`, or `MagicTile`.',
      'Include build or channel context, control state, and whether the issue is a real shipped regression or an unfinished headset or controller expectation.',
    ],
  },
  {
    title: 'Studio and commercial contact',
    description: 'Use this when the question is deployment, pricing, or broader team readiness rather than one person’s session.',
    bullets: [
      'Bundle plan, platform, launch status, legal details, and release expectations together so commercial follow-through stays attached to real package truth.',
      'Use this lane for training programs, deployment review, and release-safe distribution planning.',
    ],
  },
] as const

export const publicManualRouteAtlasCards = [
  {
    title: 'Home',
    route: '/',
    description: 'Start here when you need the shortest truthful overview of the product, the browser-versus-desktop split, and the current release status.',
    bullets: [
      'Summarizes what HyperTwist already ships today.',
      'Shows live public launch-readiness and packaged-proof context.',
      'Points people toward getting started, pricing, downloads, and the signed-in dashboard without overclaiming browser parity.',
    ],
  },
  {
    title: 'Browser access guide',
    route: '/browser',
    description: 'Open this route when you want the clearest public explanation of what the website is great at, what the desktop app adds, and when to move into the downloadable.',
    bullets: [
      'Explains the website as a real account, support, and delivery hub instead of a half-promised simulator.',
      'Shows what the website does well, what the desktop app adds, and why the downloadable remains the primary product.',
      'Keeps account, protected dashboard, and desktop handoff decisions visible in one place.',
    ],
  },
  {
    title: 'Feature atlas',
    route: '/features',
    description: 'Open this page when you need a concrete feature map instead of vague pitch language.',
    bullets: [
      'Separates implemented now, retained, and future validation branches.',
      'Maps the public website, signed-in dashboard, embedded browser tools, desktop app, and optional future browser-client scope.',
      'Surfaces higher-dimensional depth, control choices, and release maturity in one place.',
    ],
  },
  {
    title: 'About',
    route: '/about',
    description: 'Use this route when you want the product rationale and the higher-dimensional ambition explained in plain language.',
    bullets: [
      'Frames why HyperTwist keeps both browser and desktop surfaces.',
      'Explains the real end-to-end session story instead of flattening the product into one vague promise.',
      'Keeps current control, XR, and release-maturity truth attached to the narrative.',
    ],
  },
  {
    title: 'Resources',
    route: '/resources',
    description: 'Use this route as the public reference portal once you are comparing rollout, simulator, and training surfaces more deliberately.',
    bullets: [
      'Aggregates public-safe operator playbooks, support lanes, simulator-use guidance, and higher-dimensional references.',
      'Links directly to the strongest route for each common public research task.',
      'Keeps release proof and reference-bundle follow-through attached to the portal.',
    ],
  },
  {
    title: 'Getting started',
    route: '/getting-started',
    description: 'Open this route when you need the canonical first-session manual from browser access into the native runtime.',
    bullets: [
      'Explains access resolution, protected release handoff, desktop pairing, and first launch.',
      'Keeps simulator-use guidance and the current control or XR boundary on the same page.',
      'Acts as the shortest handoff-friendly onboarding surface on the public site.',
    ],
  },
  {
    title: 'Help Center',
    route: '/help',
    description: 'Open this route when you need product-safe troubleshooting, onboarding guidance, control truth, or rollout-safe answers before escalating into support.',
    bullets: [
      'Collects first-launch, controls, browser-to-desktop handoff, and release-surface guidance into one knowledge-base style route.',
      'Separates help-center guidance from direct support escalation so operators can self-serve first without losing product truth.',
      'Connects questions back to docs, support, download, and the protected dashboard when a live next step exists.',
    ],
  },
  {
    title: 'Launch status',
    route: '/launch-status',
    description: 'Use this route when rollout truth, blockers, or early-access-versus-public status need one canonical authority page.',
    bullets: [
      'Shows the current launch-readiness checklist and hardening tracks.',
      'Keeps packaged desktop proof and release references attached to rollout status.',
      'Connects launch blockers to the real next public or protected help lane.',
    ],
  },
  {
    title: 'Docs',
    route: '/docs',
    description: 'Use this route as the public manual when you need the most complete product-safe explanation of current HyperTwist usage.',
    bullets: [
      'Collects the feature-backed manual, recovery guidance, simulator-use guide, and control roster.',
      'Explains browser-versus-desktop boundaries and degraded-state operation directly.',
      'Ends with the same release references, notices, and proof lanes needed for real rollout follow-through.',
    ],
  },
  {
    title: 'Support',
    route: '/support',
    description: 'Open this route when an operator needs help choosing the correct recovery or escalation lane.',
    bullets: [
      'Separates launch, access, rollout, package, runtime, and compliance questions.',
      'Keeps current release status and packaged proof visible beside the help lanes.',
      'Mirrors the same browser-versus-desktop split so support does not soften product truth.',
    ],
  },
  {
    title: 'Contact',
    route: '/contact',
    description: 'Open this route when a human contact path, escalation expectation, or issue-report packet is the next real step.',
    bullets: [
      'Provides the direct operator contact lane alongside what information to include for faster diagnosis.',
      'Keeps runtime, rollout, account, and legal/commercial contacts separated instead of flattening them together.',
      'Links back to support topics, download guidance, and public/protected route ownership as needed.',
    ],
  },
  {
    title: 'Pricing',
    route: '/pricing',
    description: 'Use this route when plan comparison or billing status matters but the product topology still needs to stay honest.',
    bullets: [
      'Keeps plan language aligned with the desktop-first delivery model.',
      'Shows launch status, package proof, and current auth-method lineup before checkout.',
      'Explains the path from browser entitlement into the protected release lane and native runtime.',
    ],
  },
  {
    title: 'Download',
    route: '/download',
    description: 'Open this route when you need platform targets, release status, and the desktop handoff explained without exposing raw entitlement URLs.',
    bullets: [
      'Shows supported targets, package proof, and release-manifest status.',
      'Explains protected delivery, desktop-link pairing, and first native launch follow-through.',
      'Keeps notices, distribution doctrine, and release references attached to install decisions.',
    ],
  },
  {
    title: 'Release notes',
    route: '/changelog',
    description: 'Use this route when you need the current shipping chronology in operator-facing language.',
    bullets: [
      'Separates browser-shell work, native runtime work, and distribution hardening.',
      'Keeps rollout checklist and packaged proof attached to the release feed.',
      'Makes recent manual, control-boundary, and launch-authority changes easier to audit.',
    ],
  },
  {
    title: 'Open-source notices',
    route: '/open-source-notices',
    description: 'Open this route when legal-distribution and corresponding-source follow-through matter for downloadable builds.',
    bullets: [
      'Lists key public notices and the current corresponding-source status.',
      'Keeps the legal lane tied to current release proof instead of abstract compliance prose.',
      'Connects notices work back to download, release notes, and launch-readiness context.',
    ],
  },
  {
    title: 'Privacy',
    route: '/privacy',
    description: 'Use this route when browser-account data handling and the desktop-runtime boundary need to be read together.',
    bullets: [
      'Explains what belongs to browser identity, what belongs to the simulator, and what stays in support/compliance lanes.',
      'Keeps privacy wording grounded in the live product topology.',
      'Connects privacy concerns back to package proof, release references, and escalation guidance.',
    ],
  },
  {
    title: 'Terms',
    route: '/terms',
    description: 'Open this route when you need the access model, protected-download boundary, and desktop delivery model expressed as product terms.',
    bullets: [
      'Keeps access, simulator, and redistribution obligations separated clearly.',
      'Explains why the current browser shell does not equal simulator parity.',
      'Connects terms language back to package proof and notices follow-through.',
    ],
  },
  {
    title: 'Shipping & payment',
    route: '/shipping-payment',
    description: 'Use this route when you need the digital-delivery model and payment status explained operationally rather than cosmetically.',
    bullets: [
      'Clarifies that HyperTwist is digitally delivered through browser account and desktop-release surfaces.',
      'Explains the handoff from checkout into protected entitlement and native runtime delivery.',
      'Keeps payment language attached to package proof, notices, and desktop-first truth.',
    ],
  },
] as const

export const releasePacketCards = [
  {
    date: 'July 1, 2026',
    version: 'Bounded XR controller-settings ownership packet',
    category: 'Desktop XR truth and operator diagnostics',
    notes: [
      'Added first-party controller settings and rebinding ownership above the bounded OpenXR runtime-owner seam, including exact shipped XR input ids, layout presets, and user-visible settings tags.',
      'Projected that ownership through native training/operator diagnostics and current public/manual wording so the same desktop XR truth appears across Unreal and the web shell.',
      'Kept the broader desktop-hosted XR/controller widening branch explicitly closed until Windows packaged controller validation with controller truth exists on the shipping lane.',
    ],
  },
  {
    date: 'June 30, 2026',
    version: 'Public manual deepening packet',
    category: 'Website, onboarding, and operator documentation',
    notes: [
      'Broadened the public and offline manual so the website now explains concrete desktop workflows, controls, higher-dimensional families, and release details instead of only broad topology prose.',
      'Made the browser-versus-desktop split explicit on the highest-traffic public routes so teams no longer have to infer why the downloadable remains the primary simulator.',
      'Kept the current XR/controller boundary visible while strengthening what the public site can honestly claim today.',
    ],
  },
  {
    date: 'June 29, 2026',
    version: 'Validation and package-proof refresh',
    category: 'Release integrity and package evidence',
    notes: [
      'Revalidated the exact-source browser surface and refreshed the packaged higher-dimensional proof so public release pages stay attached to current native evidence.',
      'Reran owned source and browser validation without widening product scope and kept the live early-access lane green.',
      'Preserved the rule that native package proof, browser release status, and legal-distribution follow-through move together.',
    ],
  },
  {
    date: 'June 28, 2026',
    version: 'Native diagnostics truth packet',
    category: 'Controls, settings, and higher-dimensional ownership',
    notes: [
      'Tightened native control, settings, continuity, and active-scene diagnostics so operators can see the exact higher-dimensional ownership seams that are live today.',
      'Improved public and protected manual language to reflect those stronger native proofs instead of leaving them buried inside internal diagnostics only.',
      'Strengthened the public route atlas so operators can navigate documentation, help, release, and legal surfaces as one coherent product shell.',
    ],
  },
  {
    date: 'June 27, 2026',
    version: 'Launch-authority and onboarding packet',
    category: 'Public routes, protected routes, and browser shell startup',
    notes: [
      'Added dedicated public launch-status and getting-started routes plus stronger protected launch authority so rollout truth stopped depending on scattered callouts.',
      'Improved browser auth behavior, startup loading state, and public/protected route continuity without implying browser simulator parity.',
      'Turned the first real desktop-session path into a clearer public manual route instead of burying it across unrelated pages.',
    ],
  },
  {
    date: 'June 24 to June 25, 2026',
    version: 'Native XR-boundary and control-roster packet',
    category: 'Desktop control truth and public honesty',
    notes: [
      'Promoted the literal shipped control roster, settings ownership, and higher-dimensional state seams into stable native/operator surfaces.',
      'Kept the desktop-hosted OpenXR/controller widening decision explicit, including the reopen requirements for dedicated runtime owners, rebinding ownership, and Windows packaged controller validation.',
      'Mirrored that truth into the public manual, pricing, download, and support surfaces so the website cannot overclaim what the downloadable has not yet finished.',
    ],
  },
  {
    date: 'June 18 to June 23, 2026',
    version: 'Packaging, browser shell, and MagicTile hardening packet',
    category: 'Phase 10 package integrity plus bounded browser/runtime expansion',
    notes: [
      'Closed package and integration hardening while keeping the embedded browser shell, release notes, and packaged-proof story aligned.',
      'Hardened MagicTile behavior proof without reopening native renderer widening and preserved the browser-host decision as the current honest shipping model.',
      'Expanded the public site into a bounded operator/distribution surface around the downloadable rather than a replacement for it.',
    ],
  },
] as const

export const changelogEntries = [
  {
    date: 'July 2, 2026',
    title: 'Login and sign-up now stay clean and readable during load',
    details: 'The website login and registration experience now keeps its decorative backdrop safely behind the form, so people no longer hit an opaque overlay while trying to sign in or create an account. The deploy path was also tightened so validated website fixes can reach hypertwist.app through the supported production chain instead of stalling at source only.',
  },
  {
    date: 'June 30, 2026',
    title: 'The offline desktop guide now feels like the real manual',
    details: 'The downloadable guide is no longer the thinner sibling of the website. It now mirrors the richer public manual with sign-in guidance, desktop handoff steps, concrete training workflows, the shipped control roster, higher-dimensional family guidance, recovery guidance, and a page-by-page route atlas so teams can carry one substantial reference with the app.',
  },
  {
    date: 'June 30, 2026',
    title: 'Homepage and About now explain the website-versus-desktop split up front',
    details: 'The highest-traffic public pages no longer bury the web-versus-desktop question in support copy. Home and About now say plainly why the website stays lighter, why that makes the product easier to trust, and why the downloadable remains the main place for real training.',
  },
  {
    date: 'June 30, 2026',
    title: 'Higher-dimensional settings readouts are now much clearer',
    details: 'The desktop diagnostics no longer flatten degraded 120-cell, 5D, or selector states into one vague partial label. Higher-dimensional settings now show a clearer absent-versus-partial-versus-ready picture while still preserving the real profile, selector, and continuity facts that already exist.',
  },
  {
    date: 'June 30, 2026',
    title: 'Login and sign-up now preview the real desktop experience',
    details: 'The account-entry pages now place a compact desktop-workflow overview beside the existing access guidance, so people can see the classic-cube and recognition experiences they are signing in for before they even reach the dashboard.',
  },
  {
    date: 'June 30, 2026',
    title: 'The signed-in dashboard now teaches the software, not just the account state',
    details: 'The signed-in dashboard, browser-access, download, and account routes now share a first-party workflow guide for classic-cube practice, recognition and correction, replay or coaching review, and higher-dimensional sessions. Signed-in access now explains not only release and account status, but also what the installed software is actually used for once the handoff is complete.',
  },
  {
    date: 'June 30, 2026',
    title: 'The public manual now teaches real day-to-day workflows',
    details: 'Home, About, Getting Started, Docs, and Resources now include practical workflow cards for classic-cube training, recognition and correction, replay or coaching review, higher-dimensional sessions, and the moments when it makes sense to come back to the website. The public site no longer explains release posture only; it now also teaches how the current software is actually used.',
  },
  {
    date: 'June 29, 2026',
    title: 'The site now shows more of HyperTwist than cubes alone',
    details: 'The homepage, feature atlas, docs, and resources now stop flattening HyperTwist down to recognition plus hypercubing only. Public-facing product truth now also includes speech capture and narration, provider routing and usage controls, and the continuity features that support longer-term study around the desktop simulator.',
  },
  {
    date: 'June 29, 2026',
    title: 'The website and release toolchain were revalidated on current source',
    details: 'A fresh exact-state audit reconfirmed the current HyperTwist hardening packet without widening scope. The source-health tools stayed green, the GitNexus mirror refreshed cleanly, and the full website, deployment-readiness, and website-server test umbrellas passed again together with successful website and browser-runtime builds.',
  },
  {
    date: 'June 29, 2026',
    title: 'Signed-in launch status now calls out the real blockers directly',
    details: 'The signed-in dashboard and signed-in `/app/launch-status` page now mirror the same concrete live blockers shown on the public launch surface. Instead of generic setup prose, people can now see whether Windows publication, checkout readiness, webhook setup, billing mapping, shared-auth readiness, or live runtime warnings are the actual remaining blockers.',
  },
  {
    date: 'June 29, 2026',
    title: 'Responsive route coverage and live early-access readiness were rechecked',
    details: 'The responsive Playwright coverage was rerun, keeping all major public and signed-in routes clean on mobile and tablet while same-origin readiness passed again against `https://hypertwist.app`. The launch story stays disciplined: the site is live in account-gated early access, while the remaining Windows download, checkout, webhook, and shared-auth warnings remain explicit instead of being blurred into a false full-public-launch claim.',
  },
  {
    date: 'June 29, 2026',
    title: 'Owned validation and refactor-tool refresh stayed green on the refreshed package proof',
    details: 'After the exact-source browser and higher-dimensional package refresh, the owned source-health and browser-release gates were rerun cleanly: `sentrux` stayed green at `Quality: 6235`, the bounded GitNexus mirror refreshed cleanly to `16,400` nodes / `38,759` edges / `675` clusters / `300` flows while truthfully falling back to `npx gitnexus@latest` on this Linux host, and the full web-surface umbrella passed again with `14` website files / `81` tests, `3` deployment-readiness files / `30` tests, `10` website-server files / `36` tests, successful website plus browser-runtime builds, and clean production audits except for the already-documented upstream `supertokens-node -> nodemailer` residual.',
  },
  {
    date: 'June 29, 2026',
    title: 'Exact-source browser proof and higher-dimensional package proof were refreshed again',
    details: 'The maintained Windows validation lane reran the full `HyperTwist.Browser` suite with all 26 tests green on the current exact-source state, then revalidated the higher-dimensional package helper in `-SkipBuild` mode, smoke-launched both dedicated-family maps again, and refreshed the public packaged-validation summary so the website reflects current native proof instead of the older June 24 package timestamp.',
  },
  {
    date: 'June 28, 2026',
    title: 'Native control roster now exposes active scene and bounded continuity truth',
    details: 'The desktop training-panel and coach-dashboard roster surfaces now keep the active higher-dimensional scene id visible alongside the active activation, view-context, and session ids, while also rendering the shipped camera-export artifact and immersive session-recall boundary with bounded continuity counts instead of leaving those facts implied behind sibling settings surfaces.',
  },
  {
    date: 'June 28, 2026',
    title: 'Public pages now explain what each route is actually for',
    details: 'The homepage, docs, and resources routes now share a first-party public route atlas explaining what each major public page owns: product truth, onboarding, launch readiness, pricing, download, support, release notes, and the legal/distribution surfaces are now easier to navigate as one professional operator manual instead of a flatter marketing shell.',
  },
  {
    date: 'June 28, 2026',
    title: 'Native settings proof now exposes bounded camera and immersive continuity',
    details: 'The desktop operator and training diagnostics now keep the shipped camera-export artifact and the immersive session-recall boundary visible in structured non-XR settings truth, so bounded local continuity is explicit without pretending a full global preferences or controller-rebinding suite already exists.',
  },
  {
    date: 'June 28, 2026',
    title: 'Native higher-dimensional settings proof now exposes family session and persistence seams',
    details: 'The desktop operator and training diagnostics now render exact Magic120Cell and MagicCube5D session-surface, interactive-scene, persistence-boundary, and state-semantics ownership instead of only broad view-profile wording, and the maintained Windows validation lane re-exported focused browser proof green for the training-panel, coach-dashboard, and structured dashboard settings seams.',
  },
  {
    date: 'June 27, 2026',
    title: 'Protected launch status now has its own signed-in authority route',
    details: 'The browser operator shell now exposes a dedicated `/app/launch-status` route for signed-in launch-readiness truth, release action, packaged desktop proof, notices references, and protected rollout next steps instead of collapsing that lane down to one dashboard panel.',
  },
  {
    date: 'June 27, 2026',
    title: 'Launch status now has its own canonical public authority route',
    details: 'HyperTwist now exposes a dedicated public `/launch-status` surface for the live launch-readiness checklist, rollout tracks, packaged desktop proof, release references, and exact early-access blockers, so launch truth no longer has to be reconstructed from pricing plus scattered callouts.',
  },
  {
    date: 'June 27, 2026',
    title: 'A dedicated getting-started route now anchors the public onboarding story',
    details: 'HyperTwist now has a crawlable public getting-started page that turns the current first-session path into one canonical manual surface: release-target choice, protected dashboard pairing, first native classic-cube verification, higher-dimensional verification, and the current headset/controller validation boundary all live together instead of staying spread across separate pages only.',
  },
  {
    date: 'June 27, 2026',
    title: 'Public and protected manuals now show the first real desktop-session path more directly',
    details: 'Homepage, docs, download, and the protected dashboard now share a tighter operator quickstart explaining the real end-to-end journey: choose the release target, pair the installed runtime through the desktop-link token, verify the first classic-cube session, open the higher-dimensional families, and read the current headset/controller validation boundary honestly.',
  },
  {
    date: 'June 27, 2026',
    title: 'Protected dashboard and account routes now surface signed-in auth authority more explicitly',
    details: 'The protected dashboard and account lanes now carry a fuller auth/session-authority surface instead of reducing signed-in browser identity to a thin auth-stack label. Operators can now see the signed-in method, current provider lineup, shared auth readiness, runtime origins, recovery state, and deployment diagnostics directly inside the protected shell.',
  },
  {
    date: 'June 27, 2026',
    title: 'Shared browser auth now exposes real provider parity and public-manual account guidance',
    details: 'HyperTwist now gives ORCID a real shared-auth path: the auth server owns a bounded custom ORCID provider, same-origin bundle rendering emits matching ORCID env flags, auth-health reports ORCID readiness, login and register both recover cleanly around provider redirects, and the public docs route now shows the real browser-account method lineup instead of hiding it inside the form pages alone.',
  },
  {
    date: 'June 27, 2026',
    title: 'Shared browser auth now stays off the public first-paint path until it is actually needed',
    details: 'Config-only auth runtime facts now live separately from the heavy SuperTokens client modules, the route wrapper is lazy-loaded only on auth-sensitive paths, and sign-in or sign-up or provider actions now import their recipe code on demand. The website production build no longer emits the oversized auth-core warning: the remaining auth core chunk is now 391.18 kB instead of staying above the Vite warning threshold.',
  },
  {
    date: 'June 27, 2026',
    title: 'Website startup now boots with centered first-paint shell and early shared-auth init',
    details: 'The website entrypoint now initializes the shared SuperTokens runtime before React root creation, and the public root document now ships a centered HyperTwist first-paint shell inside #root so public and protected routes no longer begin from a blank page while the first bundle loads.',
  },
  {
    date: 'June 27, 2026',
    title: 'The remaining legal public routes now carry the same release-decision guide too',
    details: 'Open-source notices, privacy, terms, and shipping/payment no longer stop at the lighter surface-choice handoff. They now also expose the same explicit next release move guidance as the rest of the public site: protected desktop access, pricing/provisioning, protected browser/account continuity, or notices and source details.',
  },
  {
    date: 'June 25, 2026',
    title: 'Public pages now carry one shared release-reference bundle end to end',
    details: 'Home, About, Features, Resources, Docs, Support, Changelog, Privacy, Terms, Pricing, Download, Notices, and Shipping/Payment now all keep the same direct docs, release-notes, corresponding-source, public-repository/notices, and support references visible instead of fragmenting release details by route.',
  },
  {
    date: 'June 25, 2026',
    title: 'Public commerce pages now use the shared release-manifest view',
    details: 'Pricing and Download now consume the same public release-manifest helper used across the rest of the site, removing duplicated manifest-resolution logic while keeping platform proof, recovery behavior, and operator handoff behavior unchanged.',
  },
  {
    date: 'June 24, 2026',
    title: 'Feature atlas and support now carry the full browser-versus-desktop reality section too',
    details: 'The public Features and Support routes now also share the same direct browser-versus-desktop comparison used on the other major operator-facing website pages, so capability review and recovery/help surfaces no longer rely only on the lighter surface-choice guide to explain what stays native and how the current XR/controller boundary should be read.',
  },
  {
    date: 'June 24, 2026',
    title: 'Login and register now keep the browser-versus-desktop truth explicit too',
    details: 'The public auth entry pages now render a compact browser-versus-desktop reality panel before operators even finish sign-in, so account access, protected release routing, and desktop pairing no longer depend only on the later signed-in dashboard to explain what stays native and what remains outside the current XR/controller boundary.',
  },
  {
    date: 'June 24, 2026',
    title: 'Account and notices now keep the same protected browser-versus-desktop truth',
    details: 'The protected Account and Notices routes now carry the same compact reality panel already used on the dashboard, protected downloads, and browser-access lane, so entitlement and distribution work no longer soften the browser-support versus native-simulator split after sign-in.',
  },
  {
    date: 'June 24, 2026',
    title: 'Pricing and resources now carry the full browser-versus-desktop reality section too',
    details: 'The public Pricing and Resources routes now share the same direct browser-versus-desktop comparison already used on Home, About, Docs, and Download, so lower-friction commercial and reference surfaces no longer rely only on indirect surface-choice wording to explain what stays native and how the current XR/controller boundary should be read.',
  },
  {
    date: 'June 24, 2026',
    title: 'Protected operator routes now mirror the same browser-versus-desktop reality explanation',
    details: 'The signed-in dashboard, protected downloads, and browser-access routes now carry a compact parity panel explaining what the browser shell is for, why it stays narrower than the simulator, what remains native, and how the current XR/controller boundary should be read after sign-in.',
  },
  {
    date: 'June 24, 2026',
    title: 'The public manual now answers why HyperTwist keeps both a website and a desktop runtime',
    details: 'Homepage, About, Docs, and Download now share a direct browser-versus-desktop reality section explaining what the website is for, what stays native, why the browser is intentionally narrower, and how the current keyboard/mouse versus unfinished XR/controller truth should be read.',
  },
  {
    date: 'June 24, 2026',
    title: 'The remaining feature, docs, resource, changelog, and legal pages now carry the same surface handoff guidance',
    details: 'The reusable public surface-choice guide is no longer limited to the headline marketing routes. Feature, docs, resources, changelog, notices, privacy, terms, and shipping/payment pages now also explain when to stay on the public website, move into the protected dashboard, or move into the native desktop runtime.',
  },
  {
    date: 'June 24, 2026',
    title: 'Key public pages now answer which HyperTwist surface to use next',
    details: 'The homepage, About, Pricing, Download, and Support pages now share a direct surface-choice guide for the public website, protected dashboard, and native desktop runtime, so operators no longer have to infer the browser-versus-desktop handoff only from deeper matrix or FAQ sections.',
  },
  {
    date: 'June 24, 2026',
    title: 'Protected dashboard and downloads now keep the same help-lane split after sign-in',
    details: 'The signed-in dashboard and protected download center now mirror the same launch-readiness, operator-access, and studio-rollout guidance lanes used on the public support/manual surface, but they translate those actions into direct protected downloads, account, browser-access, notices, pricing, and release-note targets instead of sending operators back through anonymous auth hops.',
  },
  {
    date: 'June 24, 2026',
    title: 'Public and auth copy now reads as fully HyperTwist-owned',
    details: 'Remaining public pricing, resources, capability, and auth-shell copy no longer references sibling-product shells or a generic broader product family. The live web surface now describes its structure and commerce model in fully HyperTwist-native terms.',
  },
  {
    date: 'June 24, 2026',
    title: 'About and Support now surface live launch status plus packaged desktop proof',
    details: 'The public About and Support pages no longer talk about maturity only in abstract terms. They now expose the same current launch-readiness callout and Windows packaged-proof section already used by the other public manual surfaces, so narrative, rollout, and help pages stay anchored to current native release evidence.',
  },
  {
    date: 'June 24, 2026',
    title: 'Public support topics now preserve exact protected destinations through auth',
    details: 'Support-topic quick routes no longer stop at generic public guidance. Launch-readiness, operator-access, and studio-rollout actions now deep-link into the correct protected dashboard, download, browser-access, or notices destination through auth-preserving next-target links.',
  },
  {
    date: 'June 24, 2026',
    title: 'Support-topic routing now spans support, docs, and resources with the same authority split',
    details: 'Launch-readiness, operator-access, and studio-rollout topics are now first-class public guidance lanes with explicit next steps, route focus, and quick actions across the support page, docs portal, and resources portal, so operators no longer have to reconstruct the browser/package/runtime/compliance split manually.',
  },
  {
    date: 'June 24, 2026',
    title: 'Auth and release recovery now reads as an operator workflow, not scattered warnings',
    details: 'Login, protected-route loading, dashboard auth health, public/protected release-authority recovery surfaces, and the public docs/support manual now share a bounded recovery-guidance shape that preserves what still works, what stays intentionally withheld, and the next best move while live authority is degraded.',
  },
  {
    date: 'June 24, 2026',
    title: 'Higher-dimensional packaged proof refreshed again from the maintained Windows lane',
    details: 'The maintained `phase10validate` Windows validation root repackaged the higher-dimensional desktop lane into a fresh `phase6c_higherdim_refresh_20260624` archive, smoke-launched both dedicated-family maps from the packaged executable, and refreshed the public packaged-validation summary so browser release surfaces stay anchored to current native proof rather than stale yesterday-only evidence.',
  },
  {
    date: 'June 24, 2026',
    title: 'Protected operator routes now mirror packaged release proof',
    details: 'The signed-in browser-access, account, and notices routes now surface the same current Windows higher-dimensional packaged-validation proof as the main dashboard, keeping browser-to-desktop pairing, entitlement review, and distribution/legal follow-through anchored to real native release evidence.',
  },
  {
    date: 'June 24, 2026',
    title: 'Headset/controller host truth now renders end to end across native and public surfaces',
    details: 'The native training and coach-dashboard control diagnostics now render the fixed desktop-hosted validation boundary for OpenXR/controller widening directly in their operator-facing detail lines, the public/manual copy mirrors that same boundary language, and a later same-day hardening follow-up moved the same decision id plus reopen requirements into stable inspect-surface fields, with Browser-XrBoundaryStructured-PostBuild-Verify re-exporting all 20 HyperTwist.Browser tests green from the maintained Windows validation lane.',
  },
  {
    date: 'June 24, 2026',
    title: 'Signed-in operator shell now mirrors the native control roster',
    details: 'The protected dashboard, browser-access, and account routes now carry the same shipped desktop control/settings roster exposed by the public manual, including the classic-wca-keyboard/v1 profile, scenic immersive presets, dedicated-family selector/view ownership, selector-recall continuity, later dedicated-family session/scene/persistence proof, and the explicit unfinished XR/controller boundary.',
  },
  {
    date: 'June 24, 2026',
    title: 'Native selector-recall diagnostics hardened and revalidated',
    details: 'The Windows Unreal validation lane rebuilt the maintained phase10validate worktree on the refined selector-recall packet, then Browser-SelectorRecall-Verify re-exported all 20 HyperTwist.Browser tests green while the public docs and support surfaces were updated to describe bounded generated-mode selector persistence truthfully.',
  },
  {
    date: 'June 23, 2026',
    title: 'Higher-dimensional package lane refreshed and public launch manual widened',
    details: 'The maintained Windows higher-dimensional package helper was revalidated after the recovered editor rebuild, and the public download/support surfaces gained first-launch desktop setup plus clearer operator escalation guidance.',
  },
  {
    date: 'June 22, 2026',
    title: 'Public HyperTwist website, auth shell, and distribution surfaces landed',
    details: 'A dedicated hypertwist.app app now exists for public pages, browser account access, download guidance, public notices, and Paddle-ready pricing.',
  },
  {
    date: 'June 19, 2026',
    title: 'Embedded browser runtime hardened for operator diagnostics',
    details: 'Runtime-ready, runtime-status, and native training/dashboard diagnostics were typed and surfaced as first-party operator status.',
  },
  {
    date: 'June 19, 2026',
    title: 'MagicTile native behavior proof and renderer decision held',
    details: 'The native behavior proof seam landed and the renderer-port decision remained closed without new browser-host failure evidence.',
  },
  {
    date: 'June 18, 2026',
    title: 'Classic-cube package/integration validation refreshed',
    details: 'Phase 10B and 10C were revalidated with packaged smoke coverage, stricter package helper enforcement, and maintained archive proof.',
  },
] as const

export const releaseRolloutChecklist = [
  {
    title: 'Read the actual lane that changed',
    bullets: [
      'Differentiate native simulator/runtime work from browser or release-surface work before changing rollout expectations.',
      'Treat selector-recall, control-profile, and diagnostics entries as native-surface truth, not as a claim that the browser lane now owns simulator behavior.',
    ],
  },
  {
    title: 'Confirm package proof before broad rollout',
    bullets: [
      'Pair the release note with the current packaged-validation summary so teams know whether a native change is merely implemented or also freshly package-proven.',
      'Use the protected download center when actual access or package delivery status matters.',
    ],
  },
  {
    title: 'Keep distribution and legal follow-through attached',
    bullets: [
      'Review notices and corresponding-source status before redistributing any build that contains covered code or newly widened package surfaces.',
      'Keep public docs, release notes, and download guidance aligned so browser, package, and legal truths do not drift apart.',
    ],
  },
] as const

export const openSourceNotices = [
  {
    component: 'cubing/cubing.js',
    license: 'MPL-2.0',
    whyItMatters: 'HyperTwist relies on an accepted MPL-covered route for current live cubing functionality.',
  },
  {
    component: 'coqui-ai/TTS package code',
    license: 'MPL-2.0',
    whyItMatters: 'If shipped desktop builds contain this code, public pricing/download pages and the installed app must expose notices and source availability.',
  },
  {
    component: 'Retained permissive browser/runtime sidecars',
    license: 'MIT / permissive family',
    whyItMatters: 'These support the public site and embedded browser surfaces, but the public legal surface still needs to stay easy to find and stable.',
  },
] as const

export const sourceAvailability = {
  mplSourceUrl,
  openSourceRepoUrl,
  docsUrl: publicDocsUrl,
  releaseNotesUrl,
}

export const browserDesktopDecisionFaqs = [
  {
    question: 'Can I use HyperTwist entirely in my browser?',
    answer: 'Not today. The current shipping product is desktop-first and Unreal-backed. The website gives you account access, downloads, billing, support, and release guidance, but the real simulator still lives in the downloadable app.',
  },
  {
    question: 'What is the website actually for?',
    answer: 'The website is where you create an account, manage billing, read release notes, get help, review notices, and unlock private downloads. It is intentionally lighter than the desktop app for the core simulator job, and that is a strength: it keeps the front door fast, clear, and easy to trust.',
  },
  {
    question: 'Is VR support already complete?',
    answer: 'Not yet. HyperTwist already has real keyboard and mouse support, camera and immersive settings, higher-dimensional view controls, a bounded OpenXR foundation, and first-party controller settings and rebinding ownership. What still remains is packaged Windows controller validation before HyperTwist should market a finished headset branch.',
  },
]

export const supportFaqs = [
  {
    question: 'Which browser sign-in methods are actually supported?',
    answer: 'Email and password are the baseline. GitHub, Google, and ORCID may also appear when the current deployment has those providers configured. No matter which sign-in method you use, the website opens your account, release access, and desktop pairing tools; it does not replace the native desktop simulator.',
  },
  ...browserDesktopDecisionFaqs,
  {
    question: 'Can I already customize controls and higher-dimensional view settings?',
    answer: 'Yes, in a meaningful but still bounded way. The current desktop app already owns the classic keyboard profile, camera settings, immersive settings, session-local recall, and higher-dimensional projection, focus, stereo, symmetry, and visibility defaults. It can also show which Magic120Cell or MagicCube5D session, scene, and persistence details own those settings, and it can recall selector state from the latest persisted generated-mode launch request. What still remains outside the current shipping scope is packaged Windows controller proof and broader XR completion.',
  },
  {
    question: 'Do higher-dimensional selector choices persist between sessions?',
    answer: 'They can now persist in a bounded way. When the desktop app has a structurally valid generated-mode launch request on hand, the native training surfaces can recall that selector state. That is useful real continuity, but it is still narrower than a full global preferences or controller-rebinding system.',
  },
  {
    question: 'Can I download a build immediately after sign-in?',
    answer: 'Yes, once a release URL is configured for your plan. The dashboard also exposes a desktop-link token so the browser account can pair with the desktop app safely.',
  },
  {
    question: 'Does HyperTwist already include voice or speech support?',
    answer: 'Yes, in a bounded companion form. The live product already owns microphone capture, permission and readiness flows, native capture controls, transcript session envelopes, downloadable speech-model custody, transcription orchestration, local narration, and advanced voice-model review state. Those are real support systems around the simulator, not a claim that the website itself becomes the training runtime.',
  },
  {
    question: 'Are provider routing and continuity features already real?',
    answer: 'Yes, again in a bounded companion form. HyperTwist already has provider-neutral speech or vision contracts, BYOK and profile custody, custom-endpoint routing, workflow controls, usage and cost views, plus continuity, notes, memory, and provenance-aware replay or publication state families. These are support systems around the simulator, not a claim that every external service is mandatory for core local training.',
  },
  {
    question: 'Why is there an open-source notices page on pricing and download surfaces?',
    answer: 'Because HyperTwist keeps legal notices and source links visible anywhere the product is sold or delivered. If a shipped desktop build contains MPL-covered material, those links belong right beside pricing and download access.',
  },
] as const

export const desktopDownloadSteps = [
  'Sign in or create a HyperTwist account so release access and notices stay attached to the right operator identity.',
  'Choose the desktop target that matches your OS; the public page preserves that selection into the protected dashboard.',
  'Download the entitled build from the protected release surface, then review release notes and notices before rollout.',
  'Generate a desktop-link token in the browser dashboard so the installed app can pair to your account without exposing credentials.',
] as const

export const desktopFirstLaunchCards = [
  {
    title: 'Install and verify the delivered build',
    description: 'Treat the first launch as part of release validation, not as a detached post-download afterthought.',
    bullets: [
      'Confirm you installed the platform build that matches the dashboard-selected release target.',
      'Review the release notes and package-validation summary before broad internal rollout.',
      'Keep the open-source notices and corresponding-source links reachable anywhere the build is redistributed.',
    ],
  },
  {
    title: 'Pair desktop access to the browser account',
    description: 'Identity should pass through the bounded desktop-link handoff instead of through password reuse inside the runtime.',
    bullets: [
      'Open the protected dashboard and generate a desktop-link token.',
      'Use that token during first launch so the installed runtime inherits the correct account and entitlement status.',
      'Return to the dashboard if the account, plan, or release lane changes later.',
    ],
  },
  {
    title: 'Verify the current training lanes',
    description: 'First launch should confirm the real simulator state HyperTwist already claims publicly.',
    bullets: [
      'Open the classic-cube training lane to confirm timing, replay, and coaching state.',
      'Open the dedicated Magic120Cell or MagicCube5D training maps to confirm the higher-dimensional packaged lane.',
      'Treat any unfinished XR/controller/preferences behavior as a later native packet, not as a first-launch surprise.',
    ],
  },
  {
    title: 'Know when to return to browser surfaces',
    description: 'The browser shell stays relevant after install because rollout and entitlement work remain there on purpose.',
    bullets: [
      'Use the dashboard for account, billing, and release-manifest review.',
      'Use support and notices pages for rollout, legal, or access questions.',
      'Use public docs and resources pages when you need the product-safe operator manual again.',
    ],
  },
] as const

export const firstSessionVerificationCards = [
  {
    title: 'Verify the delivered build and release context',
    description: 'Treat the first session as a release-verified operator flow, not as a detached post-download guess.',
    bullets: [
      'Confirm the platform, channel, version/build id, and current packaged-validation summary on the public or protected download surface before deeper troubleshooting begins.',
      'Review release notes, notices, and corresponding-source status before wider rollout or redistribution so the exact build story stays attached to the runtime you installed.',
      'Keep the protected release lane as the delivery authority instead of relying on stale browser tabs, screenshots, or remembered package assumptions.',
    ],
  },
  {
    title: 'Verify the shipped control roster and current boundary',
    description: 'The installed runtime should match the current public control truth before broader device expectations enter the session.',
    bullets: [
      'Confirm the shipped classic profile `classic-wca-keyboard/v1` together with pointer, orbit, zoom, hint, and hold-to-talk behavior so the first native session starts from the intended control baseline.',
      'Read camera-export continuity, immersive recall, and higher-dimensional selector state as current bounded settings truth rather than as a finished global rebinding suite.',
      'Keep the packaged controller-validation boundary explicit instead of treating project groundwork as proof of finished VR or controller support.',
    ],
  },
  {
    title: 'Verify the classic training lane',
    description: 'Classic-cube execution is the fastest way to confirm that the delivered desktop runtime matches current product truth.',
    bullets: [
      'Launch the classic-cube lane and confirm timer, scramble, HUD, replay, coaching, and diagnostics state before escalating a runtime issue outward.',
      'Treat recognition, reconstruction, and solve-guidance behavior as native runtime authority instead of expecting the public browser shell to reproduce those flows directly.',
      'Return to the browser shell only when account, release, entitlement, or support status becomes the next actual job.',
    ],
  },
  {
    title: 'Verify the higher-dimensional lane you plan to use',
    description: 'The serious 120‑cell and 5D families should be confirmed intentionally, not inferred from broad capability claims.',
    bullets: [
      'Launch the dedicated `Magic120Cell` or `MagicCube5D` packaged training map from the desktop runtime instead of assuming browser parity.',
      'Confirm the current selector, projection, focus, symmetry or stereo, and visibility settings you intend to use before treating the session as higher-dimensional-ready.',
      'Use native diagnostics when session, interactive-scene, persistence-boundary, or state-semantics ownership needs confirmation for a higher-dimensional issue report.',
    ],
  },
] as const

export const issueReportingChecklistCards = [
  {
    title: 'Account, pairing, or entitlement issue report',
    description: 'Support can move faster when account-facing failures stay attached to the exact browser surface and auth state that produced them.',
    bullets: [
      'Include whether the failure happened on a public route or a protected route, and name the exact path such as `/login`, `/app`, or `/app/downloads`.',
      'State the current sign-in method and whether the UI showed normal, mixed, or recovery-mode auth state when the failure occurred.',
      'Call out whether the problem is sign-in, plan/entitlement visibility, desktop-link pairing, or protected release access rather than flattening them together.',
    ],
  },
  {
    title: 'Download, install, or release issue report',
    description: 'Package-facing problems need the concrete delivery facts that tie the issue back to one release surface and one runtime artifact.',
    bullets: [
      'Include platform, channel, version/build id, and the current packaged-validation summary line so support can tell whether the problem is delivery, install, or launch.',
      'State whether the issue is archive delivery, install, first launch, release-note mismatch, or notices/corresponding-source follow-through.',
      'Note whether the absence of a raw download URL was expected public gating or an actual failure inside the protected release lane.',
    ],
  },
  {
    title: 'Runtime or training issue report',
    description: 'Simulator bugs are easier to classify when the report keeps the actual runtime family and current control state visible.',
    bullets: [
      'State whether the issue affects classic-cube training, recognition, replay/coaching, `Magic120Cell`, `MagicCube5D`, or the `MagicTile` browser-host lane.',
      'Include the current control profile or settings lane when relevant, especially if the issue involves camera continuity, selector recall, or higher-dimensional view settings.',
      'Separate a real shipped regression from the current explicit unfinished XR/controller/preferences widening so expected non-claims do not get filed as product breakage.',
    ],
  },
  {
    title: 'Rollout, pricing, or compliance issue report',
    description: 'Commercial and legal follow-through stay easier to resolve when they are reported as rollout status issues rather than simulator defects.',
    bullets: [
      'Include the route, checkout/source target, and whether the problem is public launch status, billing/provisioning configuration, or legal-distribution follow-through.',
      'Keep pricing, notices, corresponding-source, and release-reference issues distinct from simulator bugs even when they were discovered during the same operator session.',
      'Attach the current launch-status or release-note context when it materially explains why the public or protected shell could not complete the expected next move.',
    ],
  },
] as const

export const desktopReleaseSignals = [
  {
    title: 'Package validation truth stays visible',
    description: 'The public lane reflects the existing Phase 10B and 10C package-validation proof instead of pretending distribution is detached from real packaged evidence.',
  },
  {
    title: 'Release access remains entitlement-aware',
    description: 'Public pages describe supported targets, but actual download URLs remain behind account and plan resolution inside the protected dashboard.',
  },
  {
    title: 'Legal and source linkage remain part of distribution',
    description: 'Download, pricing, and notices surfaces stay linked so MPL-covered shipped builds do not lose corresponding-source or notice visibility.',
  },
] as const

export const supportEscalationCards = [
  {
    title: 'Account and entitlement issues',
    description: 'Use the browser/operator lane first when the problem is access rather than simulator execution.',
    bullets: [
      'Absent plan access, unavailable download buttons, or failed desktop-link pairing belong to the protected dashboard lane.',
      'Support should confirm auth, billing, and entitlement status before troubleshooting simulator behavior.',
      'Do not treat account-state issues as proof that the packaged runtime itself is broken.',
    ],
  },
  {
    title: 'Download and install issues',
    description: 'Use the release lane and package evidence before widening into runtime diagnosis.',
    bullets: [
      'Confirm the selected platform, release version, and package validation summary first.',
      'Recheck notices, release notes, and rollout instructions before redistributing the build internally.',
      'Escalate with the exact target platform and release channel when the package itself is the issue.',
    ],
  },
  {
    title: 'Runtime and training issues',
    description: 'Desktop runtime issues should be described in simulator terms, not only in website terms.',
    bullets: [
      'Call out whether the issue affects classic-cube training, replay/coaching, or higher-dimensional family maps.',
      'Separate unfinished XR/controller/preferences expectations from actual regressions in the shipped keyboard/mouse lanes.',
      'Keep MagicTile browser-host behavior and dedicated-family packaged-map behavior distinguished when reporting issues.',
    ],
  },
  {
    title: 'Rollout and compliance issues',
    description: 'When the question is about public launch safety, support should keep package, pricing, and legal status tied together.',
    bullets: [
      'Route pricing, notices, and corresponding-source questions through the public/support lane instead of improvising local answers.',
      'Treat public distribution pages as part of the shipped release status.',
      'Keep release, payment, and legal guidance synchronized before broader operator rollout.',
    ],
  },
] as const

export const companyNarrative = {
  mission: 'HyperTwist closes the gap between physical cubing practice, deep replay analysis, guided coaching, and serious higher-dimensional puzzle study.',
  posture:
    'The product is intentionally honest about what already ships, what is still being validated, and what remains a future branch. That honesty is part of the quality bar.',
  distribution:
    'The website exists to support discovery, account access, pricing, notices, and desktop delivery without pretending the browser already replaces the real simulator.',
  contactEmail: brandConfig.contact.email,
}
