@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.1

package/docs-md/index.json

@@ -0,0 +1,4205 @@
+[
+  {
+    "id": "start/introduction",
+    "title": "Introduction",
+    "description": "What @apexnative/navigation is, how it differs from a router in the React tree, and which apps it fits.",
+    "anchors": [
+      {
+        "heading": "Three ways to build navigation",
+        "anchor": "models"
+      },
+      {
+        "heading": "Describe, don't command",
+        "anchor": "describe"
+      },
+      {
+        "heading": "The platform already knows how to navigate",
+        "anchor": "platform"
+      },
+      {
+        "heading": "Principles",
+        "anchor": "principles"
+      },
+      {
+        "heading": "How it works",
+        "anchor": "how"
+      },
+      {
+        "heading": "What it means for your code",
+        "anchor": "code"
+      },
+      {
+        "heading": "When it fits",
+        "anchor": "fit"
+      },
+      {
+        "heading": "How these docs are built",
+        "anchor": "docs"
+      },
+      {
+        "heading": "Where to go next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "start/installation",
+    "title": "Installation",
+    "description": "Start a new app with the navigation or add it to the app you have, run it, and check the setup with doctor.",
+    "anchors": [
+      {
+        "heading": "Requirements",
+        "anchor": "requirements"
+      },
+      {
+        "heading": "Two ways to start",
+        "anchor": "paths"
+      },
+      {
+        "heading": "A new app",
+        "anchor": "new-app"
+      },
+      {
+        "heading": "The starters",
+        "anchor": "templates"
+      },
+      {
+        "heading": "The options of init",
+        "anchor": "init-options"
+      },
+      {
+        "heading": "The app you have",
+        "anchor": "existing-app"
+      },
+      {
+        "heading": "What setup changes, and why",
+        "anchor": "why-native"
+      },
+      {
+        "heading": "Android files",
+        "anchor": "android-files"
+      },
+      {
+        "heading": "iOS files",
+        "anchor": "ios-files"
+      },
+      {
+        "heading": "JavaScript files",
+        "anchor": "js-files"
+      },
+      {
+        "heading": "Typed commands",
+        "anchor": "typed-commands"
+      },
+      {
+        "heading": "Check everything with doctor",
+        "anchor": "doctor"
+      },
+      {
+        "heading": "Next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "start/quick-start",
+    "title": "Quick start",
+    "description": "Build two screens in a native stack: Home, and Details that Home pushes with a title.",
+    "anchors": [
+      {
+        "heading": "1. Write the first screen",
+        "anchor": "screens"
+      },
+      {
+        "heading": "2. Write the screen it opens",
+        "anchor": "details"
+      },
+      {
+        "heading": "3. Create the navigation",
+        "anchor": "navigation"
+      },
+      {
+        "heading": "4. Check the entry point",
+        "anchor": "register"
+      },
+      {
+        "heading": "5. Run the app",
+        "anchor": "run"
+      },
+      {
+        "heading": "What a root can be",
+        "anchor": "roots"
+      },
+      {
+        "heading": "Where to go next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "fundamentals/starting-the-app",
+    "title": "Starting the app",
+    "description": "What createNavigation takes, what runs before and after the first screen, and what happens when the app launches again or fails to start.",
+    "anchors": [
+      {
+        "heading": "What createNavigation takes",
+        "anchor": "config"
+      },
+      {
+        "heading": "The screens and the first root",
+        "anchor": "basics"
+      },
+      {
+        "heading": "Screens",
+        "anchor": "screens"
+      },
+      {
+        "heading": "The first root",
+        "anchor": "root"
+      },
+      {
+        "heading": "Data and launch",
+        "anchor": "data"
+      },
+      {
+        "heading": "The app's data",
+        "anchor": "context"
+      },
+      {
+        "heading": "At launch",
+        "anchor": "launch"
+      },
+      {
+        "heading": "How the screens look and show",
+        "anchor": "appearance"
+      },
+      {
+        "heading": "How the screens look",
+        "anchor": "look"
+      },
+      {
+        "heading": "How the screens show",
+        "anchor": "presentation"
+      },
+      {
+        "heading": "Across the app",
+        "anchor": "app-wide"
+      },
+      {
+        "heading": "Events",
+        "anchor": "listeners"
+      },
+      {
+        "heading": "Links",
+        "anchor": "linking"
+      },
+      {
+        "heading": "Providers",
+        "anchor": "providers"
+      },
+      {
+        "heading": "Errors and loading",
+        "anchor": "errors"
+      },
+      {
+        "heading": "Rarely needed",
+        "anchor": "system"
+      },
+      {
+        "heading": "Before the first screen",
+        "anchor": "before"
+      },
+      {
+        "heading": "The splash screen",
+        "anchor": "splash"
+      },
+      {
+        "heading": "After the first screen",
+        "anchor": "after"
+      },
+      {
+        "heading": "The order",
+        "anchor": "order"
+      },
+      {
+        "heading": "When the app launches again",
+        "anchor": "launches"
+      },
+      {
+        "heading": "When the start fails",
+        "anchor": "failure"
+      },
+      {
+        "heading": "Opened by a link",
+        "anchor": "links"
+      },
+      {
+        "heading": "Next: screens and props",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "fundamentals/screens-and-props",
+    "title": "Screens and props",
+    "description": "What a screen is, how it gets its props and options, how it lives, and the details you meet later: the same screen many times, groups, loading later.",
+    "anchors": [
+      {
+        "heading": "What a screen is",
+        "anchor": "what"
+      },
+      {
+        "heading": "How the app knows its screens",
+        "anchor": "register"
+      },
+      {
+        "heading": "How a screen is shown",
+        "anchor": "show"
+      },
+      {
+        "heading": "Props",
+        "anchor": "props"
+      },
+      {
+        "heading": "TypeScript checks them",
+        "anchor": "typed"
+      },
+      {
+        "heading": "Props stay in JavaScript",
+        "anchor": "props-in-js"
+      },
+      {
+        "heading": "Options",
+        "anchor": "options"
+      },
+      {
+        "heading": "The life of a screen",
+        "anchor": "lifecycle"
+      },
+      {
+        "heading": "Hooks of the life",
+        "anchor": "hooks"
+      },
+      {
+        "heading": "The same screen, many times",
+        "anchor": "instances"
+      },
+      {
+        "heading": "One screen per item",
+        "anchor": "key"
+      },
+      {
+        "heading": "Screens that share options",
+        "anchor": "groups"
+      },
+      {
+        "heading": "Loading a screen later",
+        "anchor": "lazy"
+      },
+      {
+        "heading": "Which screen a component is in",
+        "anchor": "use-screen"
+      },
+      {
+        "heading": "Next: moving between screens",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "fundamentals/moving-between-screens",
+    "title": "Moving between screens",
+    "description": "The moves between screens, where the commands come from, how a move finishes, how a screen gives a result back, and the defaults of every move.",
+    "anchors": [
+      {
+        "heading": "The moves",
+        "anchor": "moves"
+      },
+      {
+        "heading": "Push a screen",
+        "anchor": "push"
+      },
+      {
+        "heading": "Show a modal",
+        "anchor": "modal"
+      },
+      {
+        "heading": "Show an overlay",
+        "anchor": "overlay"
+      },
+      {
+        "heading": "Select a tab",
+        "anchor": "tab"
+      },
+      {
+        "heading": "Show beside a list",
+        "anchor": "column"
+      },
+      {
+        "heading": "Replace everything",
+        "anchor": "root"
+      },
+      {
+        "heading": "Where the commands come from",
+        "anchor": "where"
+      },
+      {
+        "heading": "In a screen: useNavigation",
+        "anchor": "use-navigation"
+      },
+      {
+        "heading": "Anywhere else: navigation",
+        "anchor": "navigation"
+      },
+      {
+        "heading": "Which one",
+        "anchor": "which"
+      },
+      {
+        "heading": "Going back",
+        "anchor": "back"
+      },
+      {
+        "heading": "Can it go back?",
+        "anchor": "can"
+      },
+      {
+        "heading": "Replacing a screen",
+        "anchor": "replace"
+      },
+      {
+        "heading": "When a move is done",
+        "anchor": "done"
+      },
+      {
+        "heading": "A result back",
+        "anchor": "results"
+      },
+      {
+        "heading": "Setting a move up",
+        "anchor": "settings"
+      },
+      {
+        "heading": "Defaults for the whole app",
+        "anchor": "presentation"
+      },
+      {
+        "heading": "Next: screen options",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "fundamentals/screen-options",
+    "title": "Screen options",
+    "description": "What options are, where a screen gets them and which win, the chain, how options merge, and how a shown screen changes them.",
+    "anchors": [
+      {
+        "heading": "What options are",
+        "anchor": "what"
+      },
+      {
+        "heading": "Where a screen gets them",
+        "anchor": "layers"
+      },
+      {
+        "heading": "The chain and plain objects",
+        "anchor": "chain"
+      },
+      {
+        "heading": "One platform only",
+        "anchor": "platforms"
+      },
+      {
+        "heading": "How options merge",
+        "anchor": "merge"
+      },
+      {
+        "heading": "Changing the options of a shown screen",
+        "anchor": "change"
+      },
+      {
+        "heading": "From a handler: setOptions",
+        "anchor": "set-options"
+      },
+      {
+        "heading": "From the state: useScreenOptions",
+        "anchor": "use-screen-options"
+      },
+      {
+        "heading": "Where each option is described",
+        "anchor": "map"
+      },
+      {
+        "heading": "Next: switching roots",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "fundamentals/switching-roots",
+    "title": "Switching roots",
+    "description": "What a root is, one root or named roots, what a switch does to the app, a root made on the go, a root with a modal, and how a new root comes in.",
+    "anchors": [
+      {
+        "heading": "What a root is",
+        "anchor": "what"
+      },
+      {
+        "heading": "One root, or named roots",
+        "anchor": "roots"
+      },
+      {
+        "heading": "A root with a param",
+        "anchor": "param"
+      },
+      {
+        "heading": "What a switch does",
+        "anchor": "switch"
+      },
+      {
+        "heading": "A root made on the go",
+        "anchor": "on-the-go"
+      },
+      {
+        "heading": "A root with a modal",
+        "anchor": "with-modal"
+      },
+      {
+        "heading": "How a new root comes in",
+        "anchor": "transitions"
+      },
+      {
+        "heading": "When Android brings the app back",
+        "anchor": "android"
+      },
+      {
+        "heading": "Next: lifecycle and events",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "fundamentals/lifecycle-and-events",
+    "title": "Lifecycle and events",
+    "description": "The events of a screen and of the whole app, their order in one move, where to listen to them, what the user sees now, and every event the navigation sends.",
+    "anchors": [
+      {
+        "heading": "What a screen goes through",
+        "anchor": "screen"
+      },
+      {
+        "heading": "The order in one move",
+        "anchor": "order"
+      },
+      {
+        "heading": "The hooks of a screen",
+        "anchor": "hooks"
+      },
+      {
+        "heading": "Where to listen",
+        "anchor": "where"
+      },
+      {
+        "heading": "Why the events are outside React",
+        "anchor": "outside-react"
+      },
+      {
+        "heading": "What the user sees now",
+        "anchor": "state"
+      },
+      {
+        "heading": "Every event",
+        "anchor": "events"
+      },
+      {
+        "heading": "Next: the containers",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "containers/stack",
+    "title": "Stack",
+    "description": "What a stack is and where stacks live, how to build one, every command of a stack, the way back, and a whole stack at once for a deep link.",
+    "anchors": [
+      {
+        "heading": "What a stack is",
+        "anchor": "what"
+      },
+      {
+        "heading": "Where stacks live",
+        "anchor": "where"
+      },
+      {
+        "heading": "Building a stack",
+        "anchor": "build"
+      },
+      {
+        "heading": "The commands of a stack",
+        "anchor": "commands"
+      },
+      {
+        "heading": "The way back",
+        "anchor": "back"
+      },
+      {
+        "heading": "A whole stack at once",
+        "anchor": "deep-link"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "containers/tabs",
+    "title": "Tabs",
+    "description": "Tabs with a stack each, how to build them, how the app selects a tab, presses and badges, lazy tabs, and the tab bars of iOS 26, iPad and Android.",
+    "anchors": [
+      {
+        "heading": "What tabs are",
+        "anchor": "what"
+      },
+      {
+        "heading": "Building tabs",
+        "anchor": "build"
+      },
+      {
+        "heading": "Screens without the tab bar",
+        "anchor": "hide"
+      },
+      {
+        "heading": "Selecting a tab",
+        "anchor": "select"
+      },
+      {
+        "heading": "A press on a tab",
+        "anchor": "press"
+      },
+      {
+        "heading": "Back on Android",
+        "anchor": "back"
+      },
+      {
+        "heading": "Badges and dots",
+        "anchor": "badges"
+      },
+      {
+        "heading": "When tabs are created",
+        "anchor": "lazy"
+      },
+      {
+        "heading": "The tab bar on each platform",
+        "anchor": "platforms"
+      },
+      {
+        "heading": "Events",
+        "anchor": "events"
+      },
+      {
+        "heading": "Options",
+        "anchor": "options"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "containers/modals",
+    "title": "Modals",
+    "description": "What a modal is, how to show one, the presentation styles, sheets with detents, popovers, how a modal closes and how to ask before it does.",
+    "anchors": [
+      {
+        "heading": "What a modal is",
+        "anchor": "what"
+      },
+      {
+        "heading": "Showing a modal",
+        "anchor": "show"
+      },
+      {
+        "heading": "How a modal looks",
+        "anchor": "styles"
+      },
+      {
+        "heading": "A form on iPad",
+        "anchor": "form"
+      },
+      {
+        "heading": "A popover",
+        "anchor": "popover"
+      },
+      {
+        "heading": "Sheets",
+        "anchor": "sheets"
+      },
+      {
+        "heading": "How a modal closes",
+        "anchor": "close"
+      },
+      {
+        "heading": "Asking before closing",
+        "anchor": "ask"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "containers/overlays",
+    "title": "Overlays",
+    "description": "What an overlay is and what it is for, how to show and close one, where the touches go, the keyboard, and how overlays live with modals and roots.",
+    "anchors": [
+      {
+        "heading": "What an overlay is",
+        "anchor": "what"
+      },
+      {
+        "heading": "Showing and closing",
+        "anchor": "show"
+      },
+      {
+        "heading": "Where the touches go",
+        "anchor": "touches"
+      },
+      {
+        "heading": "The keyboard",
+        "anchor": "keyboard"
+      },
+      {
+        "heading": "Overlays, modals and roots",
+        "anchor": "layers"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "containers/side-menu",
+    "title": "Side menu",
+    "description": "What a side menu is, how to build one, how it opens and closes, how a pick in the menu changes the content, and how it looks on each platform.",
+    "anchors": [
+      {
+        "heading": "What a side menu is",
+        "anchor": "what"
+      },
+      {
+        "heading": "Building a side menu",
+        "anchor": "build"
+      },
+      {
+        "heading": "Opening and closing",
+        "anchor": "open"
+      },
+      {
+        "heading": "A pick in the menu",
+        "anchor": "pick"
+      },
+      {
+        "heading": "How it looks",
+        "anchor": "look"
+      },
+      {
+        "heading": "Where the swipe is off",
+        "anchor": "swipe"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "containers/split-view",
+    "title": "Split view",
+    "description": "Columns side by side on iPad, how to build them, how a pick shows beside the list, how the sidebar shows and hides, and what iPhone and Android show.",
+    "anchors": [
+      {
+        "heading": "What a split view is",
+        "anchor": "what"
+      },
+      {
+        "heading": "Building a split view",
+        "anchor": "build"
+      },
+      {
+        "heading": "Showing beside the list",
+        "anchor": "show"
+      },
+      {
+        "heading": "How the sidebar shows",
+        "anchor": "sidebar"
+      },
+      {
+        "heading": "A phone and a narrow window",
+        "anchor": "compact"
+      },
+      {
+        "heading": "Android",
+        "anchor": "android"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "containers/arrangement",
+    "title": "Arrangement",
+    "description": "Two screens as one screen of a stack: side by side on iPad, iPhone Duo open, Android tablets and open foldables, each on its side of the fold, and the main one alone on a phone.",
+    "anchors": [
+      {
+        "heading": "What a pair is",
+        "anchor": "what"
+      },
+      {
+        "heading": "Two ways to make a pair",
+        "anchor": "two-ways"
+      },
+      {
+        "heading": "On the screen",
+        "anchor": "on-the-screen"
+      },
+      {
+        "heading": "A pair of its own",
+        "anchor": "define-arrangement"
+      },
+      {
+        "heading": "What each device shows",
+        "anchor": "devices"
+      },
+      {
+        "heading": "Split and overlay",
+        "anchor": "style"
+      },
+      {
+        "heading": "The props of the second screen",
+        "anchor": "secondary-props"
+      },
+      {
+        "heading": "How the pair lies now",
+        "anchor": "use-arrangement"
+      },
+      {
+        "heading": "When the window changes",
+        "anchor": "time"
+      },
+      {
+        "heading": "The bar of the pair",
+        "anchor": "bar"
+      },
+      {
+        "heading": "Native screens in a pair",
+        "anchor": "native"
+      },
+      {
+        "heading": "A pair or a split view",
+        "anchor": "split-view"
+      },
+      {
+        "heading": "A pair that names a screen not in screens",
+        "anchor": "missing"
+      },
+      {
+        "heading": "A screen with a key in a pair",
+        "anchor": "key"
+      },
+      {
+        "heading": "Read next",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "screen-ui/top-bar",
+    "title": "Top bar",
+    "description": "The bar at the top of a stack: the title and the subtitle, the large title, the background and the border, hiding the bar, a component in place of the title, and the title menu.",
+    "anchors": [
+      {
+        "heading": "What the top bar is",
+        "anchor": "what"
+      },
+      {
+        "heading": "The title",
+        "anchor": "title"
+      },
+      {
+        "heading": "The large title",
+        "anchor": "large-title"
+      },
+      {
+        "heading": "The background and the border",
+        "anchor": "background"
+      },
+      {
+        "heading": "Hiding the bar",
+        "anchor": "hide"
+      },
+      {
+        "heading": "A component in place of the title",
+        "anchor": "title-component"
+      },
+      {
+        "heading": "The title menu",
+        "anchor": "title-menu"
+      },
+      {
+        "heading": "The layout of the bar",
+        "anchor": "layout"
+      },
+      {
+        "heading": "The bar on iPhone Duo",
+        "anchor": "iphone-duo"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "screen-ui/bar-buttons",
+    "title": "Bar buttons",
+    "description": "The buttons of the top bar: adding one, what a button can be, where the press is handled, menus and the overflow menu, which buttons stay when the bar is short of room, a component as a button, buttons that change with the state, and the vertical bar of iPhone Duo.",
+    "anchors": [
+      {
+        "heading": "Where buttons go",
+        "anchor": "where"
+      },
+      {
+        "heading": "What a button can be",
+        "anchor": "kinds"
+      },
+      {
+        "heading": "Where the press is handled",
+        "anchor": "press"
+      },
+      {
+        "heading": "Menus",
+        "anchor": "menus"
+      },
+      {
+        "heading": "The overflow menu",
+        "anchor": "overflow"
+      },
+      {
+        "heading": "Which buttons stay",
+        "anchor": "priority"
+      },
+      {
+        "heading": "A component as a button",
+        "anchor": "component"
+      },
+      {
+        "heading": "Buttons that change",
+        "anchor": "change"
+      },
+      {
+        "heading": "Buttons on iPhone Duo",
+        "anchor": "iphone-duo"
+      },
+      {
+        "heading": "Center buttons",
+        "anchor": "center"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "screen-ui/back-and-gestures",
+    "title": "Back and gestures",
+    "description": "Every way the user goes back on each platform, the back button and its look, the swipe back, the system back of Android, and how to keep the user on a screen with unsaved changes.",
+    "anchors": [
+      {
+        "heading": "The ways back",
+        "anchor": "ways"
+      },
+      {
+        "heading": "The back button",
+        "anchor": "back-button"
+      },
+      {
+        "heading": "Its title",
+        "anchor": "title"
+      },
+      {
+        "heading": "Its look",
+        "anchor": "look"
+      },
+      {
+        "heading": "The swipe back",
+        "anchor": "swipe"
+      },
+      {
+        "heading": "The system back of Android",
+        "anchor": "system-back"
+      },
+      {
+        "heading": "Back to the home screen",
+        "anchor": "system-animation"
+      },
+      {
+        "heading": "Handling back yourself: BackHandler",
+        "anchor": "back-handler"
+      },
+      {
+        "heading": "Keeping the user on a screen",
+        "anchor": "prevent"
+      },
+      {
+        "heading": "Knowing the user went back",
+        "anchor": "popped"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "screen-ui/search",
+    "title": "Search",
+    "description": "The search field of the platform in the top bar: adding it and filtering with it, where it sits, what shows while searching, scopes, tokens, suggestions and a results screen.",
+    "anchors": [
+      {
+        "heading": "Adding search",
+        "anchor": "add"
+      },
+      {
+        "heading": "Where the field sits",
+        "anchor": "placement"
+      },
+      {
+        "heading": "While searching",
+        "anchor": "while"
+      },
+      {
+        "heading": "Narrowing the search",
+        "anchor": "narrow"
+      },
+      {
+        "heading": "Scopes",
+        "anchor": "scopes"
+      },
+      {
+        "heading": "Tokens",
+        "anchor": "tokens"
+      },
+      {
+        "heading": "Suggestions",
+        "anchor": "suggestions"
+      },
+      {
+        "heading": "A results screen",
+        "anchor": "results"
+      },
+      {
+        "heading": "In the toolbar",
+        "anchor": "toolbar"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "screen-ui/toolbar-and-fab",
+    "title": "Toolbar and FAB",
+    "description": "Actions at the bottom of a screen, each platform its own way: the toolbar of iOS, the floating action button of Android, and one screen with both.",
+    "anchors": [
+      {
+        "heading": "Which one is for what",
+        "anchor": "which"
+      },
+      {
+        "heading": "The toolbar",
+        "anchor": "toolbar"
+      },
+      {
+        "heading": "The floating action button",
+        "anchor": "fab"
+      },
+      {
+        "heading": "Actions",
+        "anchor": "fab-actions"
+      },
+      {
+        "heading": "One screen, both platforms",
+        "anchor": "both"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "screen-ui/system-ui",
+    "title": "System UI",
+    "description": "The parts of the system around a screen: the safe area, the fold and the camera, the hinge, the status bar, the bottom of the system, orientation, backgrounds, keyboard shortcuts and the direction of the app.",
+    "anchors": [
+      {
+        "heading": "The parts of the system",
+        "anchor": "parts"
+      },
+      {
+        "heading": "The safe area",
+        "anchor": "safe-area"
+      },
+      {
+        "heading": "The vertical bar of iPhone Duo",
+        "anchor": "vertical-bar"
+      },
+      {
+        "heading": "The fold and the camera",
+        "anchor": "reserved-regions"
+      },
+      {
+        "heading": "The hinge",
+        "anchor": "hinge"
+      },
+      {
+        "heading": "The status bar",
+        "anchor": "status-bar"
+      },
+      {
+        "heading": "The bottom of the system",
+        "anchor": "bottom"
+      },
+      {
+        "heading": "Orientation",
+        "anchor": "orientation"
+      },
+      {
+        "heading": "Backgrounds",
+        "anchor": "backgrounds"
+      },
+      {
+        "heading": "The window",
+        "anchor": "window"
+      },
+      {
+        "heading": "The edge of the scroll",
+        "anchor": "scroll-edge"
+      },
+      {
+        "heading": "Keyboard shortcuts",
+        "anchor": "shortcuts"
+      },
+      {
+        "heading": "The direction of the app",
+        "anchor": "direction"
+      },
+      {
+        "heading": "Rarely needed",
+        "anchor": "rare"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "architecture/theme-and-context",
+    "title": "Theme and context",
+    "description": "Two things every screen shares: the theme, the colors of the bars and backgrounds, and the context, what every screen can rely on. Why the navigation keeps them, how to use them, and what belongs in them.",
+    "anchors": [
+      {
+        "heading": "Why the navigation keeps them",
+        "anchor": "why"
+      },
+      {
+        "heading": "The theme",
+        "anchor": "theme"
+      },
+      {
+        "heading": "Dark mode",
+        "anchor": "dark"
+      },
+      {
+        "heading": "Changing the theme",
+        "anchor": "set-theme"
+      },
+      {
+        "heading": "The theme in React content",
+        "anchor": "use-theme"
+      },
+      {
+        "heading": "The theme in options",
+        "anchor": "theme-options"
+      },
+      {
+        "heading": "Android's colors",
+        "anchor": "android"
+      },
+      {
+        "heading": "The context",
+        "anchor": "context"
+      },
+      {
+        "heading": "Why it exists",
+        "anchor": "context-why"
+      },
+      {
+        "heading": "Filling it",
+        "anchor": "context-fill"
+      },
+      {
+        "heading": "Reading it",
+        "anchor": "read"
+      },
+      {
+        "heading": "Typing it",
+        "anchor": "types"
+      },
+      {
+        "heading": "What goes in the context",
+        "anchor": "context-roles"
+      },
+      {
+        "heading": "What to keep in it",
+        "anchor": "context-keep"
+      },
+      {
+        "heading": "In code",
+        "anchor": "context-examples"
+      },
+      {
+        "heading": "Why not everything",
+        "anchor": "context-why-not"
+      },
+      {
+        "heading": "Compared with the other places",
+        "anchor": "context-compared"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "architecture/one-tree",
+    "title": "One tree",
+    "description": "How screens render: a React root per screen by default, a provider around every screen, or one tree with every screen inside the app's provider. How it differs from navigation in the React tree, and when to pick which.",
+    "anchors": [
+      {
+        "heading": "How it differs",
+        "anchor": "compare"
+      },
+      {
+        "heading": "How screens render",
+        "anchor": "modes"
+      },
+      {
+        "heading": "A root per screen",
+        "anchor": "root-per-screen"
+      },
+      {
+        "heading": "A provider around every screen",
+        "anchor": "screen-provider"
+      },
+      {
+        "heading": "One tree",
+        "anchor": "one-tree"
+      },
+      {
+        "heading": "Which to pick",
+        "anchor": "which"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "architecture/errors-and-loading",
+    "title": "Errors and loading",
+    "description": "What a screen shows when it fails to render and while it waits for its data, where each kind of error goes, and what happens when the start of the app fails.",
+    "anchors": [
+      {
+        "heading": "What a screen shows",
+        "anchor": "fallbacks"
+      },
+      {
+        "heading": "A screen that fails",
+        "anchor": "error"
+      },
+      {
+        "heading": "Errors outside the render",
+        "anchor": "outside-render"
+      },
+      {
+        "heading": "A screen that loads",
+        "anchor": "loading"
+      },
+      {
+        "heading": "Where the errors go",
+        "anchor": "on-error"
+      },
+      {
+        "heading": "When the start fails",
+        "anchor": "start"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "architecture/transitions",
+    "title": "Transitions",
+    "description": "How screens come and go: the platform's transitions, presets for a command, transitions out of a view (shared elements, zoom, preview), animations of your own, and waiting for the content. Which to pick, and what each costs.",
+    "anchors": [
+      {
+        "heading": "The platform's transitions",
+        "anchor": "platform"
+      },
+      {
+        "heading": "Presets",
+        "anchor": "presets"
+      },
+      {
+        "heading": "Transitions out of a view",
+        "anchor": "views"
+      },
+      {
+        "heading": "Shared elements",
+        "anchor": "shared"
+      },
+      {
+        "heading": "Zoom",
+        "anchor": "zoom"
+      },
+      {
+        "heading": "Preview",
+        "anchor": "preview"
+      },
+      {
+        "heading": "Animations of your own",
+        "anchor": "custom"
+      },
+      {
+        "heading": "Which to pick",
+        "anchor": "which"
+      },
+      {
+        "heading": "Waiting for the content",
+        "anchor": "wait"
+      },
+      {
+        "heading": "A push on Android, in one tree",
+        "anchor": "wait-one-tree"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "architecture/native-screens",
+    "title": "Native screens",
+    "description": "Screens written in SwiftUI, UIKit, Jetpack Compose or Android views, as full screens of the navigation next to React ones: how they talk to the app, when to make one, one screen from the command to the device, types, functions and commands.",
+    "anchors": [
+      {
+        "heading": "What a native screen is",
+        "anchor": "what"
+      },
+      {
+        "heading": "When to make one",
+        "anchor": "when"
+      },
+      {
+        "heading": "One screen, step by step",
+        "anchor": "example"
+      },
+      {
+        "heading": "1. The command",
+        "anchor": "step-command"
+      },
+      {
+        "heading": "2. The definition in TypeScript",
+        "anchor": "step-definition"
+      },
+      {
+        "heading": "3. The generated code",
+        "anchor": "step-codegen"
+      },
+      {
+        "heading": "4. The screen in SwiftUI",
+        "anchor": "step-swiftui"
+      },
+      {
+        "heading": "5. The screen in Compose",
+        "anchor": "step-compose"
+      },
+      {
+        "heading": "6. Opening it",
+        "anchor": "step-open"
+      },
+      {
+        "heading": "What happens when it shows",
+        "anchor": "flow"
+      },
+      {
+        "heading": "Types",
+        "anchor": "types"
+      },
+      {
+        "heading": "Functions with results",
+        "anchor": "results"
+      },
+      {
+        "heading": "Commands from a native screen",
+        "anchor": "commands"
+      },
+      {
+        "heading": "Typed commands",
+        "anchor": "typed-commands"
+      },
+      {
+        "heading": "UIKit and Android views",
+        "anchor": "imperative"
+      },
+      {
+        "heading": "In layouts",
+        "anchor": "layouts"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "flows/sign-in-and-sign-out",
+    "title": "Sign in and sign out",
+    "description": "An app with a signed-out part and a signed-in part: the saved session read at launch, the switch after a sign-in and a sign-out, a session that expires, and links that wait for the user to sign in.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Keep the user where every screen reads it",
+        "anchor": "context"
+      },
+      {
+        "heading": "2. Name the two roots",
+        "anchor": "roots"
+      },
+      {
+        "heading": "3. Read the saved session at launch",
+        "anchor": "launch"
+      },
+      {
+        "heading": "4. Sign in",
+        "anchor": "sign-in"
+      },
+      {
+        "heading": "5. Sign out",
+        "anchor": "sign-out"
+      },
+      {
+        "heading": "6. Make links wait for the sign-in",
+        "anchor": "links"
+      },
+      {
+        "heading": "Tell the user a link waits",
+        "anchor": "pending"
+      },
+      {
+        "heading": "The session expires while the app runs",
+        "anchor": "expired"
+      },
+      {
+        "heading": "Signing out from a modal",
+        "anchor": "from-modal"
+      },
+      {
+        "heading": "The back button on Login",
+        "anchor": "android-back"
+      },
+      {
+        "heading": "An app that guests can browse",
+        "anchor": "guests"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "flows/onboarding",
+    "title": "Onboarding",
+    "description": "A few screens shown on the first launch only, with Skip and Get started, then the main app; the next launches open on the app at once.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Make onboarding a root",
+        "anchor": "roots"
+      },
+      {
+        "heading": "2. Remember that it was shown",
+        "anchor": "launch"
+      },
+      {
+        "heading": "3. Go through the steps",
+        "anchor": "steps"
+      },
+      {
+        "heading": "4. Finish it",
+        "anchor": "finish"
+      },
+      {
+        "heading": "5. Let the user skip",
+        "anchor": "skip"
+      },
+      {
+        "heading": "With a sign-in",
+        "anchor": "sign-in"
+      },
+      {
+        "heading": "A step that asks for a permission",
+        "anchor": "permission"
+      },
+      {
+        "heading": "The user leaves halfway",
+        "anchor": "halfway"
+      },
+      {
+        "heading": "The back button on the steps",
+        "anchor": "android-back"
+      },
+      {
+        "heading": "Showing it again from Settings",
+        "anchor": "again"
+      },
+      {
+        "heading": "A link on the first launch",
+        "anchor": "links"
+      },
+      {
+        "heading": "A tour over the app",
+        "anchor": "tour"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "flows/an-app-with-tabs",
+    "title": "An app with tabs",
+    "description": "Tabs with a stack each, icons and badges, a tap on the current tab, a screen without the tab bar, a tab that opens a modal, and switching tabs from code.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Build the tabs",
+        "anchor": "tabs"
+      },
+      {
+        "heading": "2. Give them icons",
+        "anchor": "icons"
+      },
+      {
+        "heading": "3. Push inside a tab",
+        "anchor": "push"
+      },
+      {
+        "heading": "4. Hide the tab bar on a screen",
+        "anchor": "hide"
+      },
+      {
+        "heading": "5. Show a badge",
+        "anchor": "badge"
+      },
+      {
+        "heading": "6. Handle a tap on the current tab",
+        "anchor": "tap"
+      },
+      {
+        "heading": "7. Open a tab from code",
+        "anchor": "select"
+      },
+      {
+        "heading": "8. A tab that opens a modal",
+        "anchor": "button-tab"
+      },
+      {
+        "heading": "9. Back on Android",
+        "anchor": "android-back"
+      },
+      {
+        "heading": "The chat that is open already",
+        "anchor": "same-chat"
+      },
+      {
+        "heading": "What every tab reads",
+        "anchor": "shared"
+      },
+      {
+        "heading": "Heavy tabs and a fast start",
+        "anchor": "lazy"
+      },
+      {
+        "heading": "On iPad and iOS 26",
+        "anchor": "platforms"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "flows/list-and-details",
+    "title": "List and details",
+    "description": "A list that opens its items: a push on the phone, the list and the item side by side on iPad and wide Android screens, one call for both, a list that stays fresh after a change, and no second screen on a double tap.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Push the item on the phone",
+        "anchor": "push"
+      },
+      {
+        "heading": "2. Load the item from its id",
+        "anchor": "load"
+      },
+      {
+        "heading": "3. Put them side by side on iPad",
+        "anchor": "split"
+      },
+      {
+        "heading": "4. Open the item in the column beside",
+        "anchor": "show-in-column"
+      },
+      {
+        "heading": "5. Mark the open item",
+        "anchor": "selected"
+      },
+      {
+        "heading": "6. The sidebar",
+        "anchor": "sidebar"
+      },
+      {
+        "heading": "Pass the id, not the object",
+        "anchor": "ids"
+      },
+      {
+        "heading": "The list after a change on the details",
+        "anchor": "refresh"
+      },
+      {
+        "heading": "Two taps open two screens",
+        "anchor": "double-tap"
+      },
+      {
+        "heading": "The item is gone",
+        "anchor": "missing"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "flows/forms-in-a-modal",
+    "title": "Forms in a modal",
+    "description": "A form in a modal with Cancel and Save, a question before unsaved changes are lost, the keyboard, and the saved value back on the screen that opened it.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Open the form",
+        "anchor": "open"
+      },
+      {
+        "heading": "2. Add Cancel and Save",
+        "anchor": "buttons"
+      },
+      {
+        "heading": "3. Save and close",
+        "anchor": "save"
+      },
+      {
+        "heading": "4. Give the value back",
+        "anchor": "result"
+      },
+      {
+        "heading": "5. Ask before changes are lost",
+        "anchor": "prevent"
+      },
+      {
+        "heading": "The keyboard",
+        "anchor": "keyboard"
+      },
+      {
+        "heading": "A result as a promise",
+        "anchor": "promise"
+      },
+      {
+        "heading": "Closed by something else",
+        "anchor": "closed-elsewhere"
+      },
+      {
+        "heading": "A form in steps",
+        "anchor": "steps"
+      },
+      {
+        "heading": "On iPad",
+        "anchor": "ipad"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "flows/bottom-sheets",
+    "title": "Bottom sheets",
+    "description": "A sheet that stops at half and full height: its detents, a grabber, the screen under it kept usable, a list inside it, the detent the user picked, a pick back on the screen under it, and when a JavaScript sheet fits better.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Show a sheet",
+        "anchor": "show"
+      },
+      {
+        "heading": "2. Show the grabber",
+        "anchor": "grabber"
+      },
+      {
+        "heading": "3. Keep the screen under it usable",
+        "anchor": "undimmed"
+      },
+      {
+        "heading": "4. Put a list in it",
+        "anchor": "list"
+      },
+      {
+        "heading": "5. Know where the sheet is",
+        "anchor": "event"
+      },
+      {
+        "heading": "6. Move it from code",
+        "anchor": "move"
+      },
+      {
+        "heading": "7. A sheet as tall as its content",
+        "anchor": "content"
+      },
+      {
+        "heading": "8. Close it with a pick",
+        "anchor": "close"
+      },
+      {
+        "heading": "Two sheets on a double tap",
+        "anchor": "double-tap"
+      },
+      {
+        "heading": "A sheet with a draft",
+        "anchor": "draft"
+      },
+      {
+        "heading": "A native sheet or a JavaScript sheet",
+        "anchor": "js-sheet"
+      },
+      {
+        "heading": "On each platform",
+        "anchor": "platforms"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "flows/a-search-screen",
+    "title": "A search screen",
+    "description": "A screen that searches with the search field of the platform: filtering as the user types, recent searches, results that open a screen, a search on the server that keeps up with the typing, suggestions, and a search tab.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Add the field",
+        "anchor": "field"
+      },
+      {
+        "heading": "2. Filter as the user types",
+        "anchor": "filter"
+      },
+      {
+        "heading": "3. Show something for an empty field",
+        "anchor": "empty"
+      },
+      {
+        "heading": "4. Open a result",
+        "anchor": "open"
+      },
+      {
+        "heading": "5. Search on the server",
+        "anchor": "server"
+      },
+      {
+        "heading": "Answers that come out of order",
+        "anchor": "out-of-order"
+      },
+      {
+        "heading": "6. Offer suggestions",
+        "anchor": "suggestions"
+      },
+      {
+        "heading": "7. Make it a search tab",
+        "anchor": "tab"
+      },
+      {
+        "heading": "Recent searches across launches",
+        "anchor": "recent"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/overview",
+    "title": "All guides",
+    "description": "Every guide and app flow by the task it answers: wiring a store or a fetch library, gestures, launch, links, notifications, errors, testing, and whole flows such as sign-in and tabs.",
+    "anchors": [
+      {
+        "heading": "Start here",
+        "anchor": "start"
+      },
+      {
+        "heading": "Wire your libraries",
+        "anchor": "libraries"
+      },
+      {
+        "heading": "Launch and entry points",
+        "anchor": "entry"
+      },
+      {
+        "heading": "Whole app flows",
+        "anchor": "flows"
+      },
+      {
+        "heading": "Coming from another library",
+        "anchor": "migration"
+      }
+    ]
+  },
+  {
+    "id": "guides/building-a-screen",
+    "title": "Building a screen",
+    "description": "One screen from start to end: its component and props, its title and a Save button, fresh data each time it shows, and leaving it without losing changes.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. The component and its props",
+        "anchor": "component"
+      },
+      {
+        "heading": "2. The data, each time the screen shows",
+        "anchor": "data"
+      },
+      {
+        "heading": "3. The title from the data",
+        "anchor": "title"
+      },
+      {
+        "heading": "4. A Save button",
+        "anchor": "button"
+      },
+      {
+        "heading": "5. Keep the edits when the user comes back",
+        "anchor": "keep-edits"
+      },
+      {
+        "heading": "6. Leave after a save",
+        "anchor": "leave"
+      },
+      {
+        "heading": "7. Ask before the changes are lost",
+        "anchor": "prevent"
+      },
+      {
+        "heading": "The complete file",
+        "anchor": "file"
+      },
+      {
+        "heading": "Coming from React Navigation",
+        "anchor": "react-navigation"
+      },
+      {
+        "heading": "A save that fails",
+        "anchor": "save-fails"
+      },
+      {
+        "heading": "The same note opened twice",
+        "anchor": "same-note"
+      },
+      {
+        "heading": "The note in a modal",
+        "anchor": "modal"
+      },
+      {
+        "heading": "The note from a store or a query client",
+        "anchor": "stores"
+      },
+      {
+        "heading": "When Android brings the app back",
+        "anchor": "relaunch"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/app-context",
+    "title": "The app context, and working without it",
+    "description": "What the app context is for, every way to read and change it, signing in and out with it, and the same app built with a store, with screen props, or with React context instead.",
+    "anchors": [
+      {
+        "heading": "What the context is",
+        "anchor": "what"
+      },
+      {
+        "heading": "Why it exists",
+        "anchor": "why"
+      },
+      {
+        "heading": "What to keep in it",
+        "anchor": "keep"
+      },
+      {
+        "heading": "Set it up",
+        "anchor": "set-up"
+      },
+      {
+        "heading": "Its type and first value",
+        "anchor": "type"
+      },
+      {
+        "heading": "Register the type",
+        "anchor": "register"
+      },
+      {
+        "heading": "Read it",
+        "anchor": "read"
+      },
+      {
+        "heading": "In a component: useAppContext",
+        "anchor": "use-app-context"
+      },
+      {
+        "heading": "When the app starts",
+        "anchor": "at-start"
+      },
+      {
+        "heading": "In options",
+        "anchor": "options"
+      },
+      {
+        "heading": "In links",
+        "anchor": "links"
+      },
+      {
+        "heading": "Outside React",
+        "anchor": "outside-react"
+      },
+      {
+        "heading": "Change it",
+        "anchor": "write"
+      },
+      {
+        "heading": "What renders again",
+        "anchor": "renders"
+      },
+      {
+        "heading": "Sign-in and sign-out with the context",
+        "anchor": "sign-in"
+      },
+      {
+        "heading": "Without the context",
+        "anchor": "without"
+      },
+      {
+        "heading": "With a store only",
+        "anchor": "only-store"
+      },
+      {
+        "heading": "With screen props only",
+        "anchor": "only-props"
+      },
+      {
+        "heading": "With React context in appProvider",
+        "anchor": "react-context"
+      },
+      {
+        "heading": "Which to choose",
+        "anchor": "choose"
+      },
+      {
+        "heading": "Mistakes to avoid",
+        "anchor": "pitfalls"
+      },
+      {
+        "heading": "Everything in the context",
+        "anchor": "everything"
+      },
+      {
+        "heading": "Services and other values that aren't data",
+        "anchor": "services"
+      },
+      {
+        "heading": "Reading it before willMount",
+        "anchor": "before-will-mount"
+      },
+      {
+        "heading": "A selector that returns a new object",
+        "anchor": "new-object"
+      },
+      {
+        "heading": "Changing the object in place",
+        "anchor": "mutation"
+      },
+      {
+        "heading": "A title that doesn't follow the context",
+        "anchor": "title"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/state-management",
+    "title": "State management",
+    "description": "Wire Redux Toolkit, Zustand, Jotai, MobX or Valtio into an app whose screens are native: one store for every screen, the first root from it, sign-out and saved state.",
+    "anchors": [
+      {
+        "heading": "What every store shares here",
+        "anchor": "shared"
+      },
+      {
+        "heading": "Each screen is a React root",
+        "anchor": "roots"
+      },
+      {
+        "heading": "A store in a module reaches every screen",
+        "anchor": "module-store"
+      },
+      {
+        "heading": "A provider wraps the screens in createNavigation",
+        "anchor": "providers"
+      },
+      {
+        "heading": "Reading and writing outside React",
+        "anchor": "outside-react"
+      },
+      {
+        "heading": "The first root from the store",
+        "anchor": "first-root"
+      },
+      {
+        "heading": "Signing in and out",
+        "anchor": "sign-in-out"
+      },
+      {
+        "heading": "Saving the state between launches",
+        "anchor": "persist"
+      },
+      {
+        "heading": "The store and the app's context",
+        "anchor": "context"
+      },
+      {
+        "heading": "Redux Toolkit",
+        "anchor": "redux"
+      },
+      {
+        "heading": "Install",
+        "anchor": "redux-install"
+      },
+      {
+        "heading": "Create the store",
+        "anchor": "redux-create"
+      },
+      {
+        "heading": "Connect it to the screens",
+        "anchor": "redux-connect"
+      },
+      {
+        "heading": "Read and write in a screen",
+        "anchor": "redux-screen"
+      },
+      {
+        "heading": "Outside React",
+        "anchor": "redux-outside"
+      },
+      {
+        "heading": "The first root and sign-out",
+        "anchor": "redux-roots"
+      },
+      {
+        "heading": "Save the state",
+        "anchor": "redux-persist"
+      },
+      {
+        "heading": "Zustand",
+        "anchor": "zustand"
+      },
+      {
+        "heading": "Install",
+        "anchor": "zustand-install"
+      },
+      {
+        "heading": "Create the store",
+        "anchor": "zustand-create"
+      },
+      {
+        "heading": "Connect it to the screens",
+        "anchor": "zustand-connect"
+      },
+      {
+        "heading": "Read and write in a screen",
+        "anchor": "zustand-screen"
+      },
+      {
+        "heading": "Outside React",
+        "anchor": "zustand-outside"
+      },
+      {
+        "heading": "The first root and sign-out",
+        "anchor": "zustand-roots"
+      },
+      {
+        "heading": "Save the state",
+        "anchor": "zustand-persist"
+      },
+      {
+        "heading": "Jotai",
+        "anchor": "jotai"
+      },
+      {
+        "heading": "Install",
+        "anchor": "jotai-install"
+      },
+      {
+        "heading": "Create the store",
+        "anchor": "jotai-create"
+      },
+      {
+        "heading": "Connect it to the screens",
+        "anchor": "jotai-connect"
+      },
+      {
+        "heading": "Read and write in a screen",
+        "anchor": "jotai-screen"
+      },
+      {
+        "heading": "Outside React",
+        "anchor": "jotai-outside"
+      },
+      {
+        "heading": "The first root and sign-out",
+        "anchor": "jotai-roots"
+      },
+      {
+        "heading": "Save the state",
+        "anchor": "jotai-persist"
+      },
+      {
+        "heading": "MobX",
+        "anchor": "mobx"
+      },
+      {
+        "heading": "Install",
+        "anchor": "mobx-install"
+      },
+      {
+        "heading": "Create the store",
+        "anchor": "mobx-create"
+      },
+      {
+        "heading": "Connect it to the screens",
+        "anchor": "mobx-connect"
+      },
+      {
+        "heading": "Read and write in a screen",
+        "anchor": "mobx-screen"
+      },
+      {
+        "heading": "Outside React",
+        "anchor": "mobx-outside"
+      },
+      {
+        "heading": "The first root and sign-out",
+        "anchor": "mobx-roots"
+      },
+      {
+        "heading": "Save the state",
+        "anchor": "mobx-persist"
+      },
+      {
+        "heading": "Valtio",
+        "anchor": "valtio"
+      },
+      {
+        "heading": "Install",
+        "anchor": "valtio-install"
+      },
+      {
+        "heading": "Create the store",
+        "anchor": "valtio-create"
+      },
+      {
+        "heading": "Connect it to the screens",
+        "anchor": "valtio-connect"
+      },
+      {
+        "heading": "Read and write in a screen",
+        "anchor": "valtio-screen"
+      },
+      {
+        "heading": "Outside React",
+        "anchor": "valtio-outside"
+      },
+      {
+        "heading": "The first root and sign-out",
+        "anchor": "valtio-roots"
+      },
+      {
+        "heading": "Save the state",
+        "anchor": "valtio-persist"
+      },
+      {
+        "heading": "The libraries side by side",
+        "anchor": "compare"
+      },
+      {
+        "heading": "Which to pick",
+        "anchor": "which"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/data-fetching",
+    "title": "Data fetching",
+    "description": "TanStack Query, SWR, Apollo Client and RTK Query with native screens: where the client and its provider go, loading before a screen shows, refreshing when a screen shows again, Suspense and errors.",
+    "anchors": [
+      {
+        "heading": "How it works here",
+        "anchor": "how"
+      },
+      {
+        "heading": "One client, at module level",
+        "anchor": "client"
+      },
+      {
+        "heading": "Where the provider goes",
+        "anchor": "provider"
+      },
+      {
+        "heading": "A client created inside screenProvider",
+        "anchor": "per-screen-client"
+      },
+      {
+        "heading": "Ids in props, not objects",
+        "anchor": "ids"
+      },
+      {
+        "heading": "Loading before the screen shows",
+        "anchor": "prefetch"
+      },
+      {
+        "heading": "When the user comes back to a screen",
+        "anchor": "refetch"
+      },
+      {
+        "heading": "Screens the user doesn't see",
+        "anchor": "hidden"
+      },
+      {
+        "heading": "Suspense and the loading screen",
+        "anchor": "suspense"
+      },
+      {
+        "heading": "Errors",
+        "anchor": "errors"
+      },
+      {
+        "heading": "TanStack Query",
+        "anchor": "tanstack-query"
+      },
+      {
+        "heading": "Create the client",
+        "anchor": "tanstack-client"
+      },
+      {
+        "heading": "Connect it to the screens",
+        "anchor": "tanstack-provider"
+      },
+      {
+        "heading": "Read and write from a screen",
+        "anchor": "tanstack-screen"
+      },
+      {
+        "heading": "Load before the screen shows",
+        "anchor": "tanstack-prefetch"
+      },
+      {
+        "heading": "Suspense and errors",
+        "anchor": "tanstack-suspense"
+      },
+      {
+        "heading": "Sign-out",
+        "anchor": "tanstack-sign-out"
+      },
+      {
+        "heading": "Tests",
+        "anchor": "tanstack-tests"
+      },
+      {
+        "heading": "SWR",
+        "anchor": "swr"
+      },
+      {
+        "heading": "Create the cache",
+        "anchor": "swr-cache"
+      },
+      {
+        "heading": "Read and write from a screen",
+        "anchor": "swr-screen"
+      },
+      {
+        "heading": "Load before the screen shows",
+        "anchor": "swr-prefetch"
+      },
+      {
+        "heading": "Suspense and errors",
+        "anchor": "swr-suspense"
+      },
+      {
+        "heading": "Sign-out",
+        "anchor": "swr-sign-out"
+      },
+      {
+        "heading": "Apollo Client",
+        "anchor": "apollo"
+      },
+      {
+        "heading": "Create the client",
+        "anchor": "apollo-client"
+      },
+      {
+        "heading": "Connect it to the screens",
+        "anchor": "apollo-provider"
+      },
+      {
+        "heading": "Read and write from a screen",
+        "anchor": "apollo-screen"
+      },
+      {
+        "heading": "Load before the screen shows",
+        "anchor": "apollo-prefetch"
+      },
+      {
+        "heading": "Suspense and errors",
+        "anchor": "apollo-suspense"
+      },
+      {
+        "heading": "Sign-out",
+        "anchor": "apollo-sign-out"
+      },
+      {
+        "heading": "RTK Query",
+        "anchor": "rtk-query"
+      },
+      {
+        "heading": "Related",
+        "anchor": "related"
+      }
+    ]
+  },
+  {
+    "id": "guides/gestures-and-animations",
+    "title": "Gestures and animations",
+    "description": "Wire React Native Gesture Handler, Reanimated, @gorhom/bottom-sheet and Keyboard Controller into an app whose screens are native: where each provider goes, what they do next to the transitions and gestures of the platform, and what to test.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it fits",
+        "anchor": "how"
+      },
+      {
+        "heading": "1. Gesture Handler in every screen",
+        "anchor": "gesture-handler"
+      },
+      {
+        "heading": "In one tree",
+        "anchor": "gesture-handler-one-tree"
+      },
+      {
+        "heading": "A first gesture",
+        "anchor": "first-gesture"
+      },
+      {
+        "heading": "2. Gestures and the swipe back",
+        "anchor": "swipe-back"
+      },
+      {
+        "heading": "3. Gestures in a sheet",
+        "anchor": "sheet-drag"
+      },
+      {
+        "heading": "4. Reanimated",
+        "anchor": "reanimated"
+      },
+      {
+        "heading": "Animations as the screen comes in",
+        "anchor": "entering"
+      },
+      {
+        "heading": "Animations as the screen goes",
+        "anchor": "exiting"
+      },
+      {
+        "heading": "Shared elements",
+        "anchor": "shared-elements"
+      },
+      {
+        "heading": "5. @gorhom/bottom-sheet",
+        "anchor": "bottom-sheet"
+      },
+      {
+        "heading": "The platform's sheet or this one",
+        "anchor": "which-sheet"
+      },
+      {
+        "heading": "6. Keyboard Controller",
+        "anchor": "keyboard-controller"
+      },
+      {
+        "heading": "A library asks you to wrap the app root",
+        "anchor": "wrap-the-root"
+      },
+      {
+        "heading": "The whole setup",
+        "anchor": "files"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/splash-screen",
+    "title": "Splash screen",
+    "description": "The splash screen from the tap on the icon to the first screen: one command makes the native one on iOS and Android, the navigation keeps it until the first screen is drawn, and a splash of your own in React Native can continue it with an animation.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Make the native splash",
+        "anchor": "command"
+      },
+      {
+        "heading": "2. Build the app and launch it cold",
+        "anchor": "check"
+      },
+      {
+        "heading": "3. Keep the start short",
+        "anchor": "short"
+      },
+      {
+        "heading": "4. Add a splash of your own",
+        "anchor": "own-splash"
+      },
+      {
+        "heading": "5. Animate the logo",
+        "anchor": "animate"
+      },
+      {
+        "heading": "How the native splash stays",
+        "anchor": "how-long"
+      },
+      {
+        "heading": "What the command writes",
+        "anchor": "files"
+      },
+      {
+        "heading": "Light and dark",
+        "anchor": "dark"
+      },
+      {
+        "heading": "A progress while the start loads",
+        "anchor": "progress"
+      },
+      {
+        "heading": "The splash of your own is outside the providers",
+        "anchor": "providers"
+      },
+      {
+        "heading": "The splash in the navigation's state",
+        "anchor": "state"
+      },
+      {
+        "heading": "When the splash shows",
+        "anchor": "launches"
+      },
+      {
+        "heading": "When the start fails",
+        "anchor": "failure"
+      },
+      {
+        "heading": "In a development build",
+        "anchor": "development"
+      },
+      {
+        "heading": "Android shows an icon, not a picture",
+        "anchor": "android-icon"
+      },
+      {
+        "heading": "A launch screen of your own",
+        "anchor": "custom"
+      },
+      {
+        "heading": "Other splash screen libraries",
+        "anchor": "libraries"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/deep-links",
+    "title": "Deep links",
+    "description": "Links that open screens of the app: declaring them on iOS and Android, the routes, a link that launches the app and one that comes while it runs, links that wait for sign-in, and testing.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Declare the links",
+        "anchor": "declare"
+      },
+      {
+        "heading": "A scheme of the app",
+        "anchor": "scheme"
+      },
+      {
+        "heading": "Links to your web site",
+        "anchor": "web-links"
+      },
+      {
+        "heading": "The files your site serves",
+        "anchor": "web-files"
+      },
+      {
+        "heading": "2. Add the routes",
+        "anchor": "routes"
+      },
+      {
+        "heading": "Which route takes a URL",
+        "anchor": "matching"
+      },
+      {
+        "heading": "3. At a launch, and in a running app",
+        "anchor": "start-and-open"
+      },
+      {
+        "heading": "A link that launches the app, step by step",
+        "anchor": "launch"
+      },
+      {
+        "heading": "4. Links that wait for the sign-in",
+        "anchor": "when"
+      },
+      {
+        "heading": "Opened after the sign-in",
+        "anchor": "auto"
+      },
+      {
+        "heading": "Taken by the app",
+        "anchor": "manual"
+      },
+      {
+        "heading": "Typed params",
+        "anchor": "params"
+      },
+      {
+        "heading": "Errors, and links no route takes",
+        "anchor": "errors"
+      },
+      {
+        "heading": "Links no route takes",
+        "anchor": "unmatched"
+      },
+      {
+        "heading": "Links that come from elsewhere",
+        "anchor": "other-sources"
+      },
+      {
+        "heading": "When the app launches again",
+        "anchor": "relaunch"
+      },
+      {
+        "heading": "An app with its own scene delegate",
+        "anchor": "scene-delegate"
+      },
+      {
+        "heading": "Testing",
+        "anchor": "testing"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "code"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/notifications",
+    "title": "Notifications that open a screen",
+    "description": "A tap on a push notification opens its screen: with Firebase Cloud Messaging, Notifee or expo-notifications, in a running app, at a launch with the screen already in place, and after the user signs in.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. One function that opens the screen",
+        "anchor": "open"
+      },
+      {
+        "heading": "2. Read the taps from your library",
+        "anchor": "library"
+      },
+      {
+        "heading": "3. A tap while the app runs",
+        "anchor": "running"
+      },
+      {
+        "heading": "4. A tap that launches the app",
+        "anchor": "launch"
+      },
+      {
+        "heading": "5. A tap while signed out",
+        "anchor": "signed-out"
+      },
+      {
+        "heading": "The order of a launch by a tap",
+        "anchor": "order"
+      },
+      {
+        "heading": "A command too early",
+        "anchor": "too-early"
+      },
+      {
+        "heading": "A notification while the user is in the app",
+        "anchor": "foreground"
+      },
+      {
+        "heading": "When the notification has a link",
+        "anchor": "links"
+      },
+      {
+        "heading": "When Android brings the app back",
+        "anchor": "relaunch"
+      },
+      {
+        "heading": "Testing a tap",
+        "anchor": "testing"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "code"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/analytics",
+    "title": "Screen analytics",
+    "description": "Every screen the user sees, sent to Firebase Analytics, Segment, PostHog or Amplitude from one place: the names of the screens, the data of a screen, modals, tabs and sheets, and the time on a screen.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. One file for your analytics",
+        "anchor": "module"
+      },
+      {
+        "heading": "2. Report every screen",
+        "anchor": "every-screen"
+      },
+      {
+        "heading": "3. Name the screens for analytics",
+        "anchor": "names"
+      },
+      {
+        "heading": "4. What counts as a view",
+        "anchor": "what-counts"
+      },
+      {
+        "heading": "What the user looks at, sheets included",
+        "anchor": "state"
+      },
+      {
+        "heading": "5. The data of a screen",
+        "anchor": "props"
+      },
+      {
+        "heading": "6. The time on a screen",
+        "anchor": "time"
+      },
+      {
+        "heading": "7. Tabs",
+        "anchor": "tabs"
+      },
+      {
+        "heading": "Listening from your analytics module",
+        "anchor": "on"
+      },
+      {
+        "heading": "Your library's provider and hooks",
+        "anchor": "providers"
+      },
+      {
+        "heading": "The app in the background",
+        "anchor": "background"
+      },
+      {
+        "heading": "Testing the reports",
+        "anchor": "testing"
+      },
+      {
+        "heading": "The whole code",
+        "anchor": "code"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "guides/error-reporting",
+    "title": "Error reporting",
+    "description": "Every error of the app in Sentry, Bugsnag or Crashlytics, with the screen it happened on: onError, an error screen with Try again, the screens the user went through, and native crashes.",
+    "anchors": [
+      {
+        "heading": "How it will work",
+        "anchor": "how"
+      },
+      {
+        "heading": "1. Start Sentry before anything else",
+        "anchor": "sentry-init"
+      },
+      {
+        "heading": "2. Report what the navigation catches",
+        "anchor": "on-error"
+      },
+      {
+        "heading": "3. Show an error screen with a retry",
+        "anchor": "fallback"
+      },
+      {
+        "heading": "Where Sentry.wrap goes",
+        "anchor": "sentry-wrap"
+      },
+      {
+        "heading": "Not Sentry.ErrorBoundary",
+        "anchor": "sentry-error-boundary"
+      },
+      {
+        "heading": "4. Breadcrumbs of the screens",
+        "anchor": "breadcrumbs"
+      },
+      {
+        "heading": "5. Errors of commands",
+        "anchor": "commands"
+      },
+      {
+        "heading": "6. Native crashes",
+        "anchor": "native"
+      },
+      {
+        "heading": "Check it",
+        "anchor": "check"
+      },
+      {
+        "heading": "Bugsnag",
+        "anchor": "bugsnag"
+      },
+      {
+        "heading": "Firebase Crashlytics",
+        "anchor": "crashlytics"
+      },
+      {
+        "heading": "Related",
+        "anchor": "related"
+      }
+    ]
+  },
+  {
+    "id": "guides/right-to-left",
+    "title": "Right-to-left and languages",
+    "description": "An app in several languages on iOS and Android: translated texts and titles with i18next, the language of the device, a language switch inside the app, and right-to-left languages that turn the whole app around.",
+    "anchors": [
+      {
+        "heading": "1. Follow the language of the app",
+        "anchor": "locale"
+      },
+      {
+        "heading": "2. Or a fixed direction",
+        "anchor": "fixed"
+      },
+      {
+        "heading": "What follows the direction",
+        "anchor": "what-follows"
+      },
+      {
+        "heading": "3. Translate the texts",
+        "anchor": "translate"
+      },
+      {
+        "heading": "Start i18next in a module",
+        "anchor": "i18n-module"
+      },
+      {
+        "heading": "Wait for it before the first screen",
+        "anchor": "i18n-will-mount"
+      },
+      {
+        "heading": "The language of the device",
+        "anchor": "device-language"
+      },
+      {
+        "heading": "4. Titles and tab labels",
+        "anchor": "titles"
+      },
+      {
+        "heading": "5. A language switch in the app",
+        "anchor": "switch"
+      },
+      {
+        "heading": "What the screens already shown do",
+        "anchor": "shown-screens"
+      },
+      {
+        "heading": "6. Keep the choice between launches",
+        "anchor": "launch"
+      },
+      {
+        "heading": "The user changes the language of the device",
+        "anchor": "device-change"
+      },
+      {
+        "heading": "Direction in your own code",
+        "anchor": "own-code"
+      },
+      {
+        "heading": "Related",
+        "anchor": "related"
+      }
+    ]
+  },
+  {
+    "id": "guides/testing",
+    "title": "Testing",
+    "description": "Tests of an app with native navigation: Jest with the navigation mocked once for every test, ids for the bars and the back button, end-to-end tests with Maestro and Detox, links opened cold and warm, and what only a device can check.",
+    "anchors": [
+      {
+        "heading": "What you need",
+        "anchor": "need"
+      },
+      {
+        "heading": "How it will work",
+        "anchor": "plan"
+      },
+      {
+        "heading": "1. Set up Jest",
+        "anchor": "jest"
+      },
+      {
+        "heading": "2. A screen in Jest",
+        "anchor": "screens"
+      },
+      {
+        "heading": "A hook outside a screen",
+        "anchor": "hook-outside"
+      },
+      {
+        "heading": "3. Code outside the screens",
+        "anchor": "outside"
+      },
+      {
+        "heading": "4. Ids of the bars and the buttons",
+        "anchor": "ids"
+      },
+      {
+        "heading": "5. The back button",
+        "anchor": "back-button"
+      },
+      {
+        "heading": "6. An end-to-end test",
+        "anchor": "e2e"
+      },
+      {
+        "heading": "Links in end-to-end tests",
+        "anchor": "links"
+      },
+      {
+        "heading": "What only a device can check",
+        "anchor": "device"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      },
+      {
+        "heading": "API",
+        "anchor": "api"
+      }
+    ]
+  },
+  {
+    "id": "guides/cli",
+    "title": "The CLI",
+    "description": "Every command of apex-navigation: what it changes, its options and one example each, the JSON it prints for scripts and AI agents, its exit codes, and the MCP server for coding agents.",
+    "anchors": [
+      {
+        "heading": "How the commands work",
+        "anchor": "how"
+      },
+      {
+        "heading": "Exit codes",
+        "anchor": "exit-codes"
+      },
+      {
+        "heading": "The JSON",
+        "anchor": "json"
+      },
+      {
+        "heading": "init",
+        "anchor": "init"
+      },
+      {
+        "heading": "setup",
+        "anchor": "setup"
+      },
+      {
+        "heading": "screen",
+        "anchor": "screen"
+      },
+      {
+        "heading": "codegen",
+        "anchor": "codegen"
+      },
+      {
+        "heading": "doctor",
+        "anchor": "doctor"
+      },
+      {
+        "heading": "info",
+        "anchor": "info"
+      },
+      {
+        "heading": "links",
+        "anchor": "links"
+      },
+      {
+        "heading": "Declare the links",
+        "anchor": "links-declare"
+      },
+      {
+        "heading": "Open a link",
+        "anchor": "links-open"
+      },
+      {
+        "heading": "Write the files of your web site",
+        "anchor": "links-files"
+      },
+      {
+        "heading": "icons",
+        "anchor": "icons"
+      },
+      {
+        "heading": "splash",
+        "anchor": "splash"
+      },
+      {
+        "heading": "upgrade",
+        "anchor": "upgrade"
+      },
+      {
+        "heading": "migrate",
+        "anchor": "migrate"
+      },
+      {
+        "heading": "AI agents",
+        "anchor": "ai-agents"
+      },
+      {
+        "heading": "The tools",
+        "anchor": "mcp-tools"
+      },
+      {
+        "heading": "The docs in the package",
+        "anchor": "docs-in-package"
+      },
+      {
+        "heading": "What's next",
+        "anchor": "next"
+      }
+    ]
+  },
+  {
+    "id": "migration/from-react-navigation",
+    "title": "From React Navigation",
+    "description": "Move an app from React Navigation 7 to @apexnative/navigation: the two models side by side, each piece of the old API mapped to the new one, and the move step by step.",
+    "anchors": [
+      {
+        "heading": "Two models",
+        "anchor": "models"
+      },
+      {
+        "heading": "What it changes in the app",
+        "anchor": "what-changes"
+      },
+      {
+        "heading": "The map",
+        "anchor": "map"
+      },
+      {
+        "heading": "Structure",
+        "anchor": "map-structure"
+      },
+      {
+        "heading": "Moves",
+        "anchor": "map-moves"
+      },
+      {
+        "heading": "Screens",
+        "anchor": "map-screens"
+      },
+      {
+        "heading": "The move, step by step",
+        "anchor": "steps"
+      },
+      {
+        "heading": "Start with migrate",
+        "anchor": "migrate"
+      },
+      {
+        "heading": "1. Install and set up",
+        "anchor": "install"
+      },
+      {
+        "heading": "2. Screens and their params",
+        "anchor": "screens"
+      },
+      {
+        "heading": "3. The navigators become a root",
+        "anchor": "root"
+      },
+      {
+        "heading": "4. Register the app",
+        "anchor": "register"
+      },
+      {
+        "heading": "5. Moves between screens",
+        "anchor": "moves"
+      },
+      {
+        "heading": "6. Header options",
+        "anchor": "options"
+      },
+      {
+        "heading": "7. Modals",
+        "anchor": "modals"
+      },
+      {
+        "heading": "8. A drawer",
+        "anchor": "drawer"
+      },
+      {
+        "heading": "9. Hooks of a screen",
+        "anchor": "hooks"
+      },
+      {
+        "heading": "10. Providers and the theme",
+        "anchor": "providers"
+      },
+      {
+        "heading": "11. Signed in and signed out",
+        "anchor": "auth"
+      },
+      {
+        "heading": "12. Deep links",
+        "anchor": "linking"
+      },
+      {
+        "heading": "13. Typed routes",
+        "anchor": "types"
+      },
+      {
+        "heading": "14. Remove the old packages",
+        "anchor": "cleanup"
+      },
+      {
+        "heading": "What has no direct equivalent",
+        "anchor": "no-equivalent"
+      },
+      {
+        "heading": "Related",
+        "anchor": "related"
+      }
+    ]
+  },
+  {
+    "id": "migration/from-expo-router",
+    "title": "From Expo Router",
+    "description": "Move an app from Expo Router to @apexnative/navigation: files and registered screens side by side, what the native setup needs, and each piece of the old API mapped to the new one.",
+    "anchors": [
+      {
+        "heading": "Before you start",
+        "anchor": "before"
+      },
+      {
+        "heading": "Two models",
+        "anchor": "models"
+      },
+      {
+        "heading": "What it changes in the app",
+        "anchor": "what-changes"
+      },
+      {
+        "heading": "The map",
+        "anchor": "map"
+      },
+      {
+        "heading": "Structure",
+        "anchor": "map-structure"
+      },
+      {
+        "heading": "Moves and hooks",
+        "anchor": "map-moves"
+      },
+      {
+        "heading": "The move, step by step",
+        "anchor": "steps"
+      },
+      {
+        "heading": "1. Routes become screens",
+        "anchor": "screens"
+      },
+      {
+        "heading": "2. Layout files become one layout",
+        "anchor": "layouts"
+      },
+      {
+        "heading": "3. The root layout and the entry point",
+        "anchor": "entry"
+      },
+      {
+        "heading": "4. Links and the router become commands",
+        "anchor": "moves"
+      },
+      {
+        "heading": "5. Modals",
+        "anchor": "modals"
+      },
+      {
+        "heading": "6. Options and header buttons",
+        "anchor": "options"
+      },
+      {
+        "heading": "7. Signed in and signed out",
+        "anchor": "auth"
+      },
+      {
+        "heading": "8. Deep links",
+        "anchor": "linking"
+      },
+      {
+        "heading": "9. Typed routes",
+        "anchor": "types"
+      },
+      {
+        "heading": "10. Hooks of a screen",
+        "anchor": "hooks"
+      },
+      {
+        "heading": "What has no direct equivalent",
+        "anchor": "no-equivalent"
+      },
+      {
+        "heading": "Related",
+        "anchor": "related"
+      }
+    ]
+  },
+  {
+    "id": "migration/from-react-native-navigation",
+    "title": "From react-native-navigation",
+    "description": "Move an app from react-native-navigation to @apexnative/navigation: the same native model, the new JavaScript API and setup, each old call mapped to the new one, and the move step by step.",
+    "anchors": [
+      {
+        "heading": "Before you start",
+        "anchor": "before"
+      },
+      {
+        "heading": "The same model",
+        "anchor": "models"
+      },
+      {
+        "heading": "What changes in the app",
+        "anchor": "what-changes"
+      },
+      {
+        "heading": "The map",
+        "anchor": "map"
+      },
+      {
+        "heading": "Layouts",
+        "anchor": "map-layouts"
+      },
+      {
+        "heading": "Commands",
+        "anchor": "map-commands"
+      },
+      {
+        "heading": "Options and events",
+        "anchor": "map-events"
+      },
+      {
+        "heading": "Setup",
+        "anchor": "map-setup"
+      },
+      {
+        "heading": "The move, step by step",
+        "anchor": "steps"
+      },
+      {
+        "heading": "Start with migrate",
+        "anchor": "migrate"
+      },
+      {
+        "heading": "1. Swap the package",
+        "anchor": "package"
+      },
+      {
+        "heading": "2. The native files",
+        "anchor": "native"
+      },
+      {
+        "heading": "3. Register the screens",
+        "anchor": "screens"
+      },
+      {
+        "heading": "4. The first root, and the entry point",
+        "anchor": "root"
+      },
+      {
+        "heading": "5. Options next to the screen",
+        "anchor": "options"
+      },
+      {
+        "heading": "6. Commands without componentId",
+        "anchor": "commands"
+      },
+      {
+        "heading": "7. Modals and overlays",
+        "anchor": "modals"
+      },
+      {
+        "heading": "8. Buttons and the events of a screen",
+        "anchor": "events"
+      },
+      {
+        "heading": "9. Options of a shown screen",
+        "anchor": "merge-options"
+      },
+      {
+        "heading": "10. Leaving a screen",
+        "anchor": "prevent"
+      },
+      {
+        "heading": "11. Default options, the theme, providers",
+        "anchor": "defaults"
+      },
+      {
+        "heading": "12. Signed in and signed out",
+        "anchor": "auth"
+      },
+      {
+        "heading": "13. Deep links",
+        "anchor": "linking"
+      },
+      {
+        "heading": "14. Native components",
+        "anchor": "native-screens"
+      },
+      {
+        "heading": "15. Check and clean up",
+        "anchor": "cleanup"
+      },
+      {
+        "heading": "Option keys",
+        "anchor": "option-keys"
+      },
+      {
+        "heading": "Renamed or moved",
+        "anchor": "option-keys-moved"
+      },
+      {
+        "heading": "Removed",
+        "anchor": "option-keys-removed"
+      },
+      {
+        "heading": "What has no direct equivalent",
+        "anchor": "no-equivalent"
+      },
+      {
+        "heading": "Related",
+        "anchor": "related"
+      }
+    ]
+  },
+  {
+    "id": "help/glossary",
+    "title": "Glossary",
+    "description": "The words these docs use for the parts of the navigation, each in a sentence or two, with the page that explains it.",
+    "anchors": [
+      {
+        "heading": "A",
+        "anchor": "a"
+      },
+      {
+        "heading": "Accessory",
+        "anchor": "accessory"
+      },
+      {
+        "heading": "App defaults",
+        "anchor": "app-defaults"
+      },
+      {
+        "heading": "appProvider",
+        "anchor": "app-provider"
+      },
+      {
+        "heading": "AppRegistry",
+        "anchor": "app-registry"
+      },
+      {
+        "heading": "Appear, disappear",
+        "anchor": "appear"
+      },
+      {
+        "heading": "B",
+        "anchor": "b"
+      },
+      {
+        "heading": "Back button",
+        "anchor": "back-button"
+      },
+      {
+        "heading": "Badge",
+        "anchor": "badge"
+      },
+      {
+        "heading": "Bar button",
+        "anchor": "bar-button"
+      },
+      {
+        "heading": "Builder",
+        "anchor": "builder"
+      },
+      {
+        "heading": "C",
+        "anchor": "c"
+      },
+      {
+        "heading": "Center",
+        "anchor": "center"
+      },
+      {
+        "heading": "Chain",
+        "anchor": "chain"
+      },
+      {
+        "heading": "Codegen",
+        "anchor": "codegen"
+      },
+      {
+        "heading": "Column",
+        "anchor": "column"
+      },
+      {
+        "heading": "Command",
+        "anchor": "command"
+      },
+      {
+        "heading": "Compact layout",
+        "anchor": "compact"
+      },
+      {
+        "heading": "Context",
+        "anchor": "context"
+      },
+      {
+        "heading": "D",
+        "anchor": "d"
+      },
+      {
+        "heading": "Detent",
+        "anchor": "detent"
+      },
+      {
+        "heading": "didMount",
+        "anchor": "did-mount"
+      },
+      {
+        "heading": "Direction",
+        "anchor": "direction"
+      },
+      {
+        "heading": "doctor",
+        "anchor": "doctor"
+      },
+      {
+        "heading": "E",
+        "anchor": "e"
+      },
+      {
+        "heading": "Edge effect",
+        "anchor": "edge-effect"
+      },
+      {
+        "heading": "Engine",
+        "anchor": "engine"
+      },
+      {
+        "heading": "errorFallback",
+        "anchor": "error-fallback"
+      },
+      {
+        "heading": "Event",
+        "anchor": "event"
+      },
+      {
+        "heading": "F",
+        "anchor": "f"
+      },
+      {
+        "heading": "FAB",
+        "anchor": "fab"
+      },
+      {
+        "heading": "Focused",
+        "anchor": "focused"
+      },
+      {
+        "heading": "Fold",
+        "anchor": "fold"
+      },
+      {
+        "heading": "Form sheet",
+        "anchor": "form-sheet"
+      },
+      {
+        "heading": "G",
+        "anchor": "g"
+      },
+      {
+        "heading": "Grabber",
+        "anchor": "grabber"
+      },
+      {
+        "heading": "Group",
+        "anchor": "group"
+      },
+      {
+        "heading": "H",
+        "anchor": "h"
+      },
+      {
+        "heading": "Hinge",
+        "anchor": "hinge"
+      },
+      {
+        "heading": "I",
+        "anchor": "i"
+      },
+      {
+        "heading": "Id of a screen",
+        "anchor": "screen-id"
+      },
+      {
+        "heading": "init",
+        "anchor": "init"
+      },
+      {
+        "heading": "initialRoot",
+        "anchor": "initial-root"
+      },
+      {
+        "heading": "Inspector",
+        "anchor": "inspector"
+      },
+      {
+        "heading": "K",
+        "anchor": "k"
+      },
+      {
+        "heading": "Key",
+        "anchor": "key"
+      },
+      {
+        "heading": "Keyboard shortcut",
+        "anchor": "keyboard-shortcut"
+      },
+      {
+        "heading": "L",
+        "anchor": "l"
+      },
+      {
+        "heading": "Large title",
+        "anchor": "large-title"
+      },
+      {
+        "heading": "Large window",
+        "anchor": "large-window"
+      },
+      {
+        "heading": "Layout",
+        "anchor": "layout"
+      },
+      {
+        "heading": "Lazy tabs",
+        "anchor": "lazy-tabs"
+      },
+      {
+        "heading": "Liquid Glass",
+        "anchor": "liquid-glass"
+      },
+      {
+        "heading": "listeners",
+        "anchor": "listeners"
+      },
+      {
+        "heading": "Loading a screen later",
+        "anchor": "load"
+      },
+      {
+        "heading": "loadingFallback",
+        "anchor": "loading-fallback"
+      },
+      {
+        "heading": "M",
+        "anchor": "m"
+      },
+      {
+        "heading": "Modal",
+        "anchor": "modal"
+      },
+      {
+        "heading": "Mounted",
+        "anchor": "mounted"
+      },
+      {
+        "heading": "Move",
+        "anchor": "move"
+      },
+      {
+        "heading": "N",
+        "anchor": "n"
+      },
+      {
+        "heading": "Native screen",
+        "anchor": "native-screen"
+      },
+      {
+        "heading": "navigation",
+        "anchor": "navigation"
+      },
+      {
+        "heading": "navigation-env.d.ts",
+        "anchor": "navigation-env"
+      },
+      {
+        "heading": "Navigation state",
+        "anchor": "navigation-state"
+      },
+      {
+        "heading": "O",
+        "anchor": "o"
+      },
+      {
+        "heading": "One tree",
+        "anchor": "one-tree"
+      },
+      {
+        "heading": "Options",
+        "anchor": "options"
+      },
+      {
+        "heading": "Overflow menu",
+        "anchor": "overflow-menu"
+      },
+      {
+        "heading": "Overlay",
+        "anchor": "overlay"
+      },
+      {
+        "heading": "P",
+        "anchor": "p"
+      },
+      {
+        "heading": "Pair",
+        "anchor": "pair"
+      },
+      {
+        "heading": "Popover",
+        "anchor": "popover"
+      },
+      {
+        "heading": "Presentation",
+        "anchor": "presentation"
+      },
+      {
+        "heading": "Presentation style",
+        "anchor": "presentation-style"
+      },
+      {
+        "heading": "Preset",
+        "anchor": "preset"
+      },
+      {
+        "heading": "Preview",
+        "anchor": "preview"
+      },
+      {
+        "heading": "Props",
+        "anchor": "props"
+      },
+      {
+        "heading": "R",
+        "anchor": "r"
+      },
+      {
+        "heading": "React root",
+        "anchor": "react-root"
+      },
+      {
+        "heading": "Reserved region",
+        "anchor": "reserved-region"
+      },
+      {
+        "heading": "Root",
+        "anchor": "root"
+      },
+      {
+        "heading": "Roots",
+        "anchor": "roots"
+      },
+      {
+        "heading": "Route",
+        "anchor": "route"
+      },
+      {
+        "heading": "S",
+        "anchor": "s"
+      },
+      {
+        "heading": "Safe area",
+        "anchor": "safe-area"
+      },
+      {
+        "heading": "Screen",
+        "anchor": "screen"
+      },
+      {
+        "heading": "screenProvider",
+        "anchor": "screen-provider"
+      },
+      {
+        "heading": "Search field",
+        "anchor": "search-field"
+      },
+      {
+        "heading": "setup",
+        "anchor": "setup"
+      },
+      {
+        "heading": "Shared elements",
+        "anchor": "shared-elements"
+      },
+      {
+        "heading": "Sheet",
+        "anchor": "sheet"
+      },
+      {
+        "heading": "Side menu",
+        "anchor": "side-menu"
+      },
+      {
+        "heading": "Sidebar",
+        "anchor": "sidebar"
+      },
+      {
+        "heading": "Splash screen",
+        "anchor": "splash-screen"
+      },
+      {
+        "heading": "Split view",
+        "anchor": "split-view"
+      },
+      {
+        "heading": "Stack",
+        "anchor": "stack"
+      },
+      {
+        "heading": "Starter",
+        "anchor": "starter"
+      },
+      {
+        "heading": "Status bar",
+        "anchor": "status-bar"
+      },
+      {
+        "heading": "Swipe back",
+        "anchor": "swipe-back"
+      },
+      {
+        "heading": "System back",
+        "anchor": "system-back"
+      },
+      {
+        "heading": "T",
+        "anchor": "t"
+      },
+      {
+        "heading": "Tab",
+        "anchor": "tab"
+      },
+      {
+        "heading": "Tab bar",
+        "anchor": "tab-bar"
+      },
+      {
+        "heading": "Theme",
+        "anchor": "theme"
+      },
+      {
+        "heading": "Title component",
+        "anchor": "title-component"
+      },
+      {
+        "heading": "Toolbar",
+        "anchor": "toolbar"
+      },
+      {
+        "heading": "Top bar",
+        "anchor": "top-bar"
+      },
+      {
+        "heading": "Transition",
+        "anchor": "transition"
+      },
+      {
+        "heading": "V",
+        "anchor": "v"
+      },
+      {
+        "heading": "Vertical bar",
+        "anchor": "vertical-bar"
+      },
+      {
+        "heading": "W",
+        "anchor": "w"
+      },
+      {
+        "heading": "Waiting link",
+        "anchor": "waiting-link"
+      },
+      {
+        "heading": "willMount",
+        "anchor": "will-mount"
+      },
+      {
+        "heading": "Window",
+        "anchor": "window"
+      },
+      {
+        "heading": "Z",
+        "anchor": "z"
+      },
+      {
+        "heading": "Zoom",
+        "anchor": "zoom"
+      }
+    ]
+  },
+  {
+    "id": "help/troubleshooting",
+    "title": "Troubleshooting",
+    "description": "Problems you may meet with the navigation, by area: what you see, why it happens, how to fix it, and the page that explains it.",
+    "anchors": [
+      {
+        "heading": "Setup and build",
+        "anchor": "setup"
+      },
+      {
+        "heading": "setup stops: \"This is an Expo app\"",
+        "anchor": "expo"
+      },
+      {
+        "heading": "setup says a file is changed by hand",
+        "anchor": "changed-by-hand"
+      },
+      {
+        "heading": "doctor warns \"Another navigation\"",
+        "anchor": "another-navigation"
+      },
+      {
+        "heading": "Android: unresolved `com.reactnativenavigation` after setup",
+        "anchor": "old-imports"
+      },
+      {
+        "heading": "A screen ignores its static options",
+        "anchor": "static-options"
+      },
+      {
+        "heading": "The Android app crashes at start: React Native loads twice",
+        "anchor": "loads-twice"
+      },
+      {
+        "heading": "doctor warns about the JDK",
+        "anchor": "jdk"
+      },
+      {
+        "heading": "codegen stops on a prop",
+        "anchor": "codegen"
+      },
+      {
+        "heading": "Commands take any screen name",
+        "anchor": "untyped"
+      },
+      {
+        "heading": "Starting the app",
+        "anchor": "start"
+      },
+      {
+        "heading": "iOS logs \"RCTStatusBarManager module requires…\"",
+        "anchor": "status-bar"
+      },
+      {
+        "heading": "registerComponent \"expects the navigation made by createNavigation\"",
+        "anchor": "register-component"
+      },
+      {
+        "heading": "The app doesn't start: \"a name goes once\"",
+        "anchor": "duplicate-name"
+      },
+      {
+        "heading": "The splash screen never goes away",
+        "anchor": "splash-stays"
+      },
+      {
+        "heading": "The splash of your own doesn't show",
+        "anchor": "own-splash-missing"
+      },
+      {
+        "heading": "The splash of your own throws: no provider",
+        "anchor": "splash-provider"
+      },
+      {
+        "heading": "Login flashes before the tabs",
+        "anchor": "login-flash"
+      },
+      {
+        "heading": "iOS shows the old launch screen",
+        "anchor": "launch-screen-cache"
+      },
+      {
+        "heading": "An empty screen shows after the launch screen",
+        "anchor": "empty-after-launch"
+      },
+      {
+        "heading": "Android brings the app back without its pushed screens",
+        "anchor": "android-relaunch"
+      },
+      {
+        "heading": "Moving between screens",
+        "anchor": "moves"
+      },
+      {
+        "heading": "A hook throws \"is for the screens of createNavigation\"",
+        "anchor": "hook-outside-screen"
+      },
+      {
+        "heading": "pop rejects: \"the first screen of its stack\"",
+        "anchor": "pop-first"
+      },
+      {
+        "heading": "A command rejects: \"before the app started\"",
+        "anchor": "command-before-start"
+      },
+      {
+        "heading": "navigation has no dismiss or setOptions",
+        "anchor": "no-dismiss"
+      },
+      {
+        "heading": "switchTo fails: \"There is no root\"",
+        "anchor": "switch-to-name"
+      },
+      {
+        "heading": "selectTab doesn't select the tab",
+        "anchor": "select-tab-id"
+      },
+      {
+        "heading": "A push after selectTab lands in the old tab",
+        "anchor": "push-after-select-tab"
+      },
+      {
+        "heading": "The same chat opens twice",
+        "anchor": "duplicate-screen"
+      },
+      {
+        "heading": "A command fails: \"an id goes to one screen\"",
+        "anchor": "id-clash"
+      },
+      {
+        "heading": "Pushing a native screen fails",
+        "anchor": "use-props"
+      },
+      {
+        "heading": "useFocusEffect doesn't restart when a value changes",
+        "anchor": "focus-effect"
+      },
+      {
+        "heading": "A custom pop animation doesn't play on the swipe back",
+        "anchor": "custom-pop"
+      },
+      {
+        "heading": "Back on the first screen leaves without the system's animation",
+        "anchor": "back-animation"
+      },
+      {
+        "heading": "A BackHandler listener isn't called on the first screen",
+        "anchor": "back-handler-early"
+      },
+      {
+        "heading": "The zoom or the preview does nothing",
+        "anchor": "zoom"
+      },
+      {
+        "heading": "A split view on Android has no middle column",
+        "anchor": "split-android"
+      },
+      {
+        "heading": "Bars, tabs and buttons",
+        "anchor": "bars"
+      },
+      {
+        "heading": "The first rows of a list hide under the top bar",
+        "anchor": "rows-under-bar"
+      },
+      {
+        "heading": "A pick in the overflow menu does nothing",
+        "anchor": "overflow-pick"
+      },
+      {
+        "heading": "A press runs the handler of another button",
+        "anchor": "button-ids"
+      },
+      {
+        "heading": "The toolbar hides behind the tab bar",
+        "anchor": "toolbar-tabs"
+      },
+      {
+        "heading": "A list that loads later has no edge effect",
+        "anchor": "scroll-edge"
+      },
+      {
+        "heading": "The tab bar doesn't hide on scroll on Android",
+        "anchor": "tabs-hide-on-scroll"
+      },
+      {
+        "heading": "The user can't arrange the tabs on iPad",
+        "anchor": "customizable"
+      },
+      {
+        "heading": "Modals, sheets and overlays",
+        "anchor": "modals"
+      },
+      {
+        "heading": "An overlay blocks the app under it",
+        "anchor": "overlay-touches"
+      },
+      {
+        "heading": "An overFullScreen modal hides the screen under it",
+        "anchor": "over-full-screen"
+      },
+      {
+        "heading": "Cancel closes a form with unsaved changes",
+        "anchor": "cancel-not-held"
+      },
+      {
+        "heading": "A content sheet doesn't fit its content",
+        "anchor": "content-sheet"
+      },
+      {
+        "heading": "A sheet leaves out a detent on iOS 15",
+        "anchor": "detents-ios-15"
+      },
+      {
+        "heading": "Theme, context and direction",
+        "anchor": "theme"
+      },
+      {
+        "heading": "setTheme drops colors",
+        "anchor": "set-theme"
+      },
+      {
+        "heading": "A title from the context doesn't change",
+        "anchor": "context-options"
+      },
+      {
+        "heading": "A screen keeps old theme colors after setTheme",
+        "anchor": "theme-options"
+      },
+      {
+        "heading": "State in screenProvider starts over on each screen",
+        "anchor": "screen-provider-state"
+      },
+      {
+        "heading": "A shown screen keeps its direction after setDirection",
+        "anchor": "direction"
+      },
+      {
+        "heading": "Links and notifications",
+        "anchor": "links"
+      },
+      {
+        "heading": "A link doesn't open the app",
+        "anchor": "link-not-declared"
+      },
+      {
+        "heading": "The console warns \"No route of linking takes\"",
+        "anchor": "unmatched"
+      },
+      {
+        "heading": "A waiting link opens in the old root",
+        "anchor": "link-old-root"
+      },
+      {
+        "heading": "A failed link doesn't reach onError",
+        "anchor": "link-error"
+      },
+      {
+        "heading": "The launch link doesn't run after a reload",
+        "anchor": "launch-link-reload"
+      },
+      {
+        "heading": "A notification that launched the app opens its screen twice",
+        "anchor": "notification-twice"
+      },
+      {
+        "heading": "Tests",
+        "anchor": "tests"
+      },
+      {
+        "heading": "Jest can't parse the package",
+        "anchor": "jest-esm"
+      },
+      {
+        "heading": "A hook throws in Jest",
+        "anchor": "jest-hook"
+      },
+      {
+        "heading": "A command rejects in Jest",
+        "anchor": "jest-command"
+      },
+      {
+        "heading": "Related",
+        "anchor": "related"
+      }
+    ]
+  }
+]