From 901afdbcd1b8f0cacb9b4d54459f421cd1b4b85a Mon Sep 17 00:00:00 2001
From: Patrick Stel <patrick@madebypatrick.nl>
Date: Wed, 9 Sep 2026 19:17:41 +0200
Subject: [PATCH] Move the keyboard selector by position and remember the
 hidden arrow

Issue #92: moving between the letter rows and the action row shifted the
selector two keys, because both keyboards kept the column index across
rows of different widths on a centred grid. KeyboardLayouts.ColumnAcross
now picks the key underneath. The same report asked for arrow keys: a
shared KeyboardEntry gives the entry a caret, and left/right on the action
row move it, so a typo in the middle of an address no longer means
retyping everything after it. The action row is 16 keys, so a key is
100px wide (1736px, the width the 14-key row had at 116).

Issue #91: two pointers, one on top of the other, at launch. The page
script re-installs its arrow on every visibilitychange and install() set
it visible unconditionally, so on a set where the app draws the pointer
itself the arrow came back under the dot. hide() is remembered now,
install() honours it, and show() is the one way back; both cursor classes
ask for the arrow by name when switching to the page-drawn pointer, and
the NUI reinstall sends install and hide in one evaluation.

tools/keyboard and tools/pointer hold both fixes off-device; the pointer
harness fails on the previous PageScript.cs at its third check.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 CLAUDE.md                     |  37 ++++++++
 docs/INTERNALS.md             |  85 ++++++++++++++++-
 src/common/KeyboardEntry.cs   | 102 ++++++++++++++++++++
 src/common/KeyboardLayouts.cs |  59 +++++++++++-
 src/common/PageScript.cs      |  32 ++++++-
 src/elm/ElmKeyboard.cs        |  71 ++++++++------
 src/elm/VirtualCursor.cs      |   8 +-
 src/nui/NuiCursor.cs          |  44 ++++++---
 src/nui/NuiKeyboard.cs        |  69 ++++++++------
 tools/keyboard/Program.cs     | 174 ++++++++++++++++++++++++++++++++++
 tools/keyboard/run.sh         |  58 ++++++++++++
 tools/pointer/build-page.py   | 101 ++++++++++++++++++++
 tools/pointer/run.sh          |  53 +++++++++++
 13 files changed, 815 insertions(+), 78 deletions(-)
 create mode 100644 src/common/KeyboardEntry.cs
 create mode 100644 tools/keyboard/Program.cs
 create mode 100755 tools/keyboard/run.sh
 create mode 100644 tools/pointer/build-page.py
 create mode 100755 tools/pointer/run.sh

diff --git a/CLAUDE.md b/CLAUDE.md
index 4af1904..2ab2924 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -129,6 +129,43 @@ left off" landing on the last real visit and never on the start screen, and to a
 install made before the mode existed still opening where it always did. Needs only
 the .NET 6 SDK under `~/.dotnet-local`.
 
+### The keyboard harness
+
+Any change to `KeyboardLayouts` or `KeyboardEntry` — the grids the on-screen
+keyboard shows, the move between rows, and the text with its caret — is exercised
+off-device first:
+
+```sh
+tools/keyboard/run.sh
+```
+
+It compiles the shipping files against a stub store and log and holds them to the
+shape both keyboards build their cells for, to a move between rows landing on the
+key underneath rather than the key with the same index (issue #92: the rows are
+centred and the action row is wider, so the same index is two keys away), and to
+the caret typing, deleting and stopping where it should. Both files are in
+`src/common`, so a mistake is in all six packages, and the ewk ones cannot be
+tried before somebody installs them. Needs only the .NET 6 SDK under
+`~/.dotnet-local`.
+
+### The pointer harness
+
+Any change to the pointer half of `PageScript` — `install`, `hide`, `show`, `move`
+and the `visibilitychange` hook — is exercised against desktop chromium first:
+
+```sh
+tools/pointer/run.sh
+```
+
+It lifts the shipping script out of the `.cs` and holds it to one contract: install
+puts the arrow in the DOM, hide and show decide whether it is seen, and nothing the
+page does on its own (a visibilitychange, a re-install, a move, a single-page
+navigation wiping the overlay, the whole script run again) changes that decision.
+Issue #91 was that contract not existing: the app hid the arrow to draw its own
+pointer, the page brought it back on the first visibilitychange, and the reporter
+saw two pointers one on top of the other. From a TV that is indistinguishable
+from the app having drawn two.
+
 ### The site-rules harness
 
 Any change to `SiteRules` — the per-site images/identity rules, and the "which
diff --git a/docs/INTERNALS.md b/docs/INTERNALS.md
index 6c76158..db065fd 100644
--- a/docs/INTERNALS.md
+++ b/docs/INTERNALS.md
@@ -1307,6 +1307,35 @@ to break them is the whole reason the source is split this way. They get the
 coalescing, which is the half that is safe everywhere, and key `2` was already
 there for the rest.
 
+### The page's arrow has to remember it was told to go away
+
+Issue #91, from the same set once NUI was drawing the pointer itself: "sometimes
+when load app where it shows two cursor one on top of other". Two pointers, one
+exactly under the other, is the app's dot and the page's arrow both showing at
+the same viewport fraction — and the app had asked the page to hide the arrow,
+so the question was who put it back.
+
+The page script did, on its own. Its `visibilitychange` listener re-runs
+`install()`, which is there because a single-page navigation wipes the overlay
+out of the DOM; `install()` set the arrow `display:block` unconditionally, and
+nothing in the script remembered that `hide()` had been called. `visibilitychange`
+fires on a great deal more than a navigation — the app coming to the front at
+launch, the set's own menus going over it, the screen blanking — which is the
+"sometimes" and the "when load app". The ElmSharp builds had the same fault
+behind key `2` and nobody had used it long enough to see it.
+
+So `hide()` is remembered (`st.hidden`), `install()` honours it, and `show()` is
+the only call that clears it. Both cursor classes ask for the arrow by name when
+they switch to the page-drawn pointer, rather than relying on a re-install to
+bring it back — which on the ElmSharp build it never reliably did: toggling to
+the page's arrow after the native one had hidden it left it hidden until the next
+page load. On NUI, `Reinstall` also sends the install and the hide in **one**
+evaluation, so there is no ordering between them to be wrong. The shape of the
+page script's contract is now: install puts the arrow in the DOM, hide and show
+decide whether it is seen, and the two are independent. `tools/pointer/run.sh`
+runs the shipping script in desktop chromium and fails on the old file at the
+third check.
+
 ### The one thing a script cannot click: another origin's frame
 
 `elementFromPoint` stops at an `<iframe>`, and a click dispatched on the frame
@@ -1559,7 +1588,7 @@ Shift releases itself after one letter, as on a phone: one capital is what a nam
 or a password rule usually wants, and leaving it latched turns the rest of the word
 into shouting.
 
-Every grid is deliberately the same shape (rows of 10, 10, 10, 10, 14): the
+Every grid is deliberately the same shape (rows of 10, 10, 10, 10, 16): the
 keyboards build their cells once in the constructor and only swap the labels when
 the grid changes, so a grid with different row lengths would leave cells pointing
 at keys that are no longer there. That is also why the shifted variants and the
@@ -1567,15 +1596,44 @@ symbol page are built to the same rows-of-ten shape rather than being packed
 tighter. Whatever letters a layout leaves over, the row is padded out with `-`,
 `_`, `?`, `=` so every key exists in every layout.
 
-The action row grew from 11 keys to 14 (`@`, `shift`, `sym`, `start`), which is why
-a key is 104px wide rather than 116 — fourteen of the old ones overflow a 1080p
-panel. Rows are centred rather than left-aligned, or a 10-key letter row leaves a
-ragged hole beside a 14-key action row.
+The action row grew from 11 keys to 14 (`@`, `shift`, `sym`, `start`) and then to
+16 (the two caret arrows, below), which is why a key is 100px wide rather than
+116 — fourteen of the old ones already overflowed a 1080p panel, and sixteen of
+the new ones plus their gaps are the 1736px fourteen old ones were. Rows are
+centred rather than left-aligned, or a 10-key letter row leaves a ragged hole
+beside a 16-key action row.
 
 `@` sits on the action row and not on the symbol page: signing in to anything needs
 it constantly, and having to find a second page for it was the substance of
 issue #15.
 
+### The selector follows the screen, not the index
+
+Issue #92, from the 2025 set: "when we move selector from last 2nd row to last
+row in keyboard it moves 2 character back and moves 2 character forward when
+move from last to 1st row". Both keyboards moved between rows by keeping the
+column index and clamping it to the new row's length. With the rows centred and
+the action row four keys wider than the letter rows, the same index is two keys
+to the left on the way down and two to the right on the way up — exactly his
+numbers, and it had been so since the action row first outgrew the letters.
+
+`KeyboardLayouts.ColumnAcross` does the move by position: the keys sit on one
+pitch whatever the row, so a key's centre in key units is its column plus half
+the difference between the widest row and its own, and the key in the other row
+whose centre that falls in is the one the selector lands on. It is in key units
+and not pixels so the two keyboards, which draw at different sizes, agree, and it
+is in `src/common` so the ewk builds get the same fix untested — the maths has
+no toolkit in it, which is what makes that acceptable.
+
+The same report asked for arrow keys, and it meant the entry, which was
+append-only: a typo three characters back in an address meant deleting
+everything after it and typing it again on a D-pad. `KeyboardEntry` holds the
+text and a caret for both keyboards, and `←`/`→` on the action row move it;
+typing, `.com`, `space` and `back` act at the caret. The keys are *named*
+`left`/`right` in the grid and wear the arrows as labels, because `<` and `>` are
+characters on the symbol page and a key's name is what `Press` switches on.
+`tools/keyboard/run.sh` holds all of this off-device.
+
 ### Where the browser opens
 
 Three states, and `StartPage` owns which: the generated start screen, one fixed
@@ -2734,6 +2792,23 @@ the one its report has to come from. The state is:
   cannot land on* above; both are fixed in `build-42ed14f` and his files are healed
   on load.
 
+- **The keyboard's selector jumping between rows, arrow keys in the entry, and
+  two pointers at launch — #92 and #91, built together.** Both are things a
+  browser gets asked for once it stops breaking, and both had a fault behind
+  them. #92's jump was the column index kept across rows of different widths on a
+  centred grid; the selector now moves by position, and the entry has a caret
+  with `←`/`→` on the action row. #91's second pointer was the page's arrow
+  coming back on a `visibilitychange` after the app had hidden it to draw its
+  own; the hide is remembered now. See *The selector follows the screen, not the
+  index* and *The page's arrow has to remember it was told to go away* above.
+  Both fixes are in `src/common`, so the ewk builds get them too. **Waiting on:**
+  his report from the build. Neither needs a question answered — the keyboard
+  either lands under the key or it does not, and either one pointer shows at
+  launch or two do. If two still do, the `pointer` line on the report says who is
+  drawing the one we mean, and the next thing to look for is a second
+  `__ovs_cursor` element in the DOM rather than a shown one: that would be a
+  frame or a second document, not this.
+
 Five things about that set are settled and should not be re-derived: **key `5` is
 his, not ours** — the engine's overlay path is the only one that gives him a
 picture, so a report of black or silent video is the in-page path failing and not a
diff --git a/src/common/KeyboardEntry.cs b/src/common/KeyboardEntry.cs
new file mode 100644
index 0000000..29fc29e
--- /dev/null
+++ b/src/common/KeyboardEntry.cs
@@ -0,0 +1,102 @@
+namespace Overscan
+{
+    /// <summary>
+    /// The line of text the on-screen keyboard is building, and where in it the
+    /// next character lands.
+    ///
+    /// Shared by the ElmSharp and NUI keyboards so both edit the same way. Until
+    /// issue #92 the entry was append-only: a typo three characters back in an
+    /// address meant deleting everything after it and typing it again, on a
+    /// D-pad, which is what the reporter was asking to be spared when he asked for
+    /// arrow keys. The caret is an index into <see cref="Text"/>; everything the
+    /// keyboards do to the text goes through here so the two cannot drift apart.
+    /// </summary>
+    internal sealed class KeyboardEntry
+    {
+        private string _text = string.Empty;
+        private int _caret;
+
+        /// <summary>What has been typed so far.</summary>
+        public string Text
+        {
+            get { return _text; }
+        }
+
+        /// <summary>Where the next character goes: 0 is before the first one.</summary>
+        public int Caret
+        {
+            get { return _caret; }
+        }
+
+        /// <summary>
+        /// The text with the caret drawn into it as a bar, for the entry line. An
+        /// empty entry is a bar on its own, as it always was.
+        /// </summary>
+        public string Display
+        {
+            get { return _text.Substring(0, _caret) + "|" + _text.Substring(_caret); }
+        }
+
+        /// <summary>
+        /// Starts over with <paramref name="text"/> and the caret at its end: the
+        /// keyboard opens on an address to add to it, or on nothing at all.
+        /// </summary>
+        public void Reset(string text)
+        {
+            _text = text ?? string.Empty;
+            _caret = _text.Length;
+        }
+
+        /// <summary>Puts <paramref name="value"/> in at the caret and moves past it.</summary>
+        public void Insert(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return;
+            }
+
+            _text = _text.Substring(0, _caret) + value + _text.Substring(_caret);
+            _caret += value.Length;
+        }
+
+        /// <summary>
+        /// Removes the character before the caret. False when there was none —
+        /// the keyboards close on a remote Back key that has nothing left to delete.
+        /// </summary>
+        public bool Backspace()
+        {
+            if (_caret == 0)
+            {
+                return false;
+            }
+
+            _text = _text.Substring(0, _caret - 1) + _text.Substring(_caret);
+            _caret--;
+            return true;
+        }
+
+        public void Clear()
+        {
+            _text = string.Empty;
+            _caret = 0;
+        }
+
+        /// <summary>One character towards the start; stays put at the start.</summary>
+        public void Left()
+        {
+            if (_caret > 0)
+            {
+                _caret--;
+            }
+        }
+
+        /// <summary>One character towards the end; stays put at the end.</summary>
+        public void Right()
+        {
+            if (_caret < _text.Length)
+            {
+                _caret++;
+            }
+        }
+    }
+}
diff --git a/src/common/KeyboardLayouts.cs b/src/common/KeyboardLayouts.cs
index e303adb..302db82 100644
--- a/src/common/KeyboardLayouts.cs
+++ b/src/common/KeyboardLayouts.cs
@@ -17,6 +17,10 @@ namespace Overscan
     /// because the keyboards build their cells once and only swap the labels when
     /// the grid changes. A grid of a different shape would leave those cells
     /// pointing at keys that are no longer there.
+    ///
+    /// The rows are not the same width, and they are centred, so a column index
+    /// is not a position on the screen: <see cref="ColumnAcross"/> is how the
+    /// selector moves between rows without appearing to jump (issue #92).
     /// </summary>
     internal static class KeyboardLayouts
     {
@@ -32,6 +36,17 @@ internal static class KeyboardLayouts
         /// <summary>Saves what was typed as the page to open at start-up.</summary>
         public const string StartPageKey = "start";
 
+        /// <summary>
+        /// Moves the caret in the entry one character back or forward, so a typo
+        /// in the middle of an address can be reached without deleting everything
+        /// after it (issue #92). Named rather than drawn: the arrows the keys wear
+        /// are labels, and `&lt;` and `&gt;` are characters on the symbol page.
+        /// </summary>
+        public const string CaretLeftKey = "left";
+
+        /// <summary>See <see cref="CaretLeftKey"/>.</summary>
+        public const string CaretRightKey = "right";
+
         private const string SettingKey = "keyboardLayout";
 
         private static readonly string[] LayoutNames = { "QWERTY", "AZERTY", "QWERTZ", "ABCDEF" };
@@ -156,6 +171,45 @@ public static string[][] ReleaseShift()
             return Rows;
         }
 
+        /// <summary>
+        /// The column in row <paramref name="toRow"/> that sits nearest, on the
+        /// screen, to column <paramref name="fromColumn"/> of row
+        /// <paramref name="fromRow"/>.
+        ///
+        /// Rows are centred and not all the same length: the letter rows are 10
+        /// keys and the action row is 16, so the action row starts three keys to
+        /// the left of the letters above it. Carrying the column index across
+        /// unchanged, which is what both keyboards did, moved the selector three
+        /// keys back on the way down and three forward on the way up — issue #92,
+        /// reported as "2 characters" when the row was 14 wide. The keys are laid
+        /// out on one pitch (a key plus a gap) whatever the row, so a key's centre
+        /// in units of that pitch is its column plus half, plus half the difference
+        /// between the widest row and its own; the nearest key in the other row is
+        /// the one whose centre that lands in. The maths is in key units and not
+        /// pixels so the two keyboards, which draw at different sizes, agree.
+        /// </summary>
+        public static int ColumnAcross(string[][] rows, int fromRow, int fromColumn, int toRow)
+        {
+            int widest = 0;
+            foreach (string[] row in rows)
+            {
+                widest = System.Math.Max(widest, row.Length);
+            }
+
+            int fromLength = rows[fromRow].Length;
+            int toLength = rows[toRow].Length;
+
+            // Twice the centre, to stay in integers: 2 * (offset + column + 0.5).
+            int centre2 = (widest - fromLength) + (2 * fromColumn) + 1;
+            int target = (centre2 - (widest - toLength) - 1) / 2;
+            if (target < 0)
+            {
+                return 0;
+            }
+
+            return target >= toLength ? toLength - 1 : target;
+        }
+
         /// <summary>
         /// Builds a grid from its three letter rows. The digits and the action row
         /// are the same whatever the letters do, so they are not repeated per layout.
@@ -209,13 +263,14 @@ private static string[][][] BuildShifted()
         /// The bottom row, identical on every grid. `@` sits here rather than on the
         /// symbol page because signing in to anything needs it; `shift` and `sym`
         /// are next to each other so the two ways of reaching a different character
-        /// are in one place.
+        /// are in one place; the caret arrows sit beside `back`, which is the key
+        /// they are most often used with.
         /// </summary>
         private static string[] ActionRow()
         {
             return new[]
             {
-                ".", "/", ":", "@", "space", ".com", "back", "clear",
+                ".", "/", ":", "@", "space", ".com", CaretLeftKey, CaretRightKey, "back", "clear",
                 ShiftKey, SymbolsKey, StartPageKey, "GO", "close", CycleKey,
             };
         }
diff --git a/src/common/PageScript.cs b/src/common/PageScript.cs
index 1134581..39b07da 100644
--- a/src/common/PageScript.cs
+++ b/src/common/PageScript.cs
@@ -55,7 +55,11 @@ public static string Probe(string bridgeName)
 (function(){
   if (window.__ovs) { window.__ovs.install(); return; }
 
-  var st = { x: 0, y: 0, over: null, trusted: null, frameFocus: null };
+  /* hidden is whether the app has asked for the arrow to stay off the screen
+     because it is drawing the pointer itself. install() has to honour it, or
+     every re-install puts the arrow back — see the visibilitychange hook at the
+     bottom and issue #91. */
+  var st = { x: 0, y: 0, over: null, trusted: null, frameFocus: null, hidden: false };
 
   function clamp(v, hi) { return v < 0 ? 0 : (v > hi ? hi : v); }
 
@@ -193,16 +197,33 @@ function scrollableAncestor(node) {
   }
 
   window.__ovs = {
+    /* Puts the arrow in the DOM, or back in it. It does NOT decide whether the
+       arrow is showing: that is hide()/show()'s, and it is remembered, because
+       install() is re-run by whatever wipes the overlay out of the document
+       (single-page navigations, and the visibilitychange hook below) and none of
+       those callers know who is drawing the pointer. Issue #91 was the arrow
+       coming back on a visibilitychange while the app was drawing its own dot on
+       the same spot: two pointers, one on top of the other, on a set where
+       nothing had gone wrong. */
     install: function () {
       if (!st.el) { st.el = makeCursor(); }
       if (!st.el.parentNode && root()) { root().appendChild(st.el); }
       if (!st.x && !st.y) { st.x = window.innerWidth / 2; st.y = window.innerHeight / 2; }
-      st.el.style.display = 'block';
+      st.el.style.display = st.hidden ? 'none' : 'block';
       place();
       return 1;
     },
 
-    hide: function () { if (st.el) { st.el.style.display = 'none'; } },
+    hide: function () {
+      st.hidden = true;
+      if (st.el) { st.el.style.display = 'none'; }
+    },
+
+    /* The only way the arrow comes back once hidden: the app asking for it. */
+    show: function () {
+      st.hidden = false;
+      return window.__ovs.install();
+    },
 
     /* The address of the link under the pointer, or ''. The start screen's tiles
        are plain links (see HomePage), and this is how the app acts on the tile
@@ -523,7 +544,10 @@ the thing it is watching would be worthless. */
 
   window.__ovs.install();
   if (document.addEventListener) {
-    /* Single-page navigations wipe the overlay out of the DOM. */
+    /* Single-page navigations wipe the overlay out of the DOM. This fires on a
+       great deal more than that — the app coming to the front at launch, the
+       set's own menus going over it, the screen blanking — which is why install()
+       must not be the thing that decides whether the arrow shows. */
     document.addEventListener('visibilitychange', function () { window.__ovs.install(); }, false);
   }
 })();
diff --git a/src/elm/ElmKeyboard.cs b/src/elm/ElmKeyboard.cs
index 63853dc..b191b7a 100644
--- a/src/elm/ElmKeyboard.cs
+++ b/src/elm/ElmKeyboard.cs
@@ -17,10 +17,12 @@ namespace Overscan
     /// </summary>
     internal sealed class ElmKeyboard
     {
-        // The action row is 14 keys wide now (shift, sym and start joined it), so
-        // a key can no longer be 116px: 14 of those plus the gaps overflow a 1080p
-        // panel. Everything else is laid out from these two numbers.
-        private const int KeyWidth = 104;
+        // The action row is 16 keys wide now (shift, sym, start and the two caret
+        // arrows joined it), so a key can no longer be 116px: 14 of those plus the
+        // gaps already overflowed a 1080p panel. At 100px sixteen keys and their
+        // gaps are 1736px, the width the row had at 14 keys of 116. Everything
+        // else is laid out from these two numbers.
+        private const int KeyWidth = 100;
         private const int KeyHeight = 74;
         private const int Gap = 8;
         private const int EntryHeight = 96;
@@ -40,7 +42,7 @@ internal sealed class ElmKeyboard
 
         private int _row;
         private int _column;
-        private string _text = string.Empty;
+        private readonly KeyboardEntry _text = new KeyboardEntry();
 
         public ElmKeyboard(Window window)
         {
@@ -84,7 +86,7 @@ public ElmKeyboard(Window window)
                 _labels[r] = new Label[_rows[r].Length];
 
                 // Rows are centred rather than left-aligned: the letter rows are
-                // 10 keys and the action row is 14, so aligning them all left
+                // 10 keys and the action row is 16, so aligning them all left
                 // would leave a ragged hole on the right of every letter row.
                 int rowWidth = (KeyWidth * _rows[r].Length) + (Gap * (_rows[r].Length - 1));
                 int rowLeft = left + ((width - rowWidth) / 2);
@@ -131,7 +133,7 @@ public ElmKeyboard(Window window)
         public void Open(KeyboardTarget target, string initialText)
         {
             Target = target;
-            _text = initialText ?? string.Empty;
+            _text.Reset(initialText);
             IsVisible = true;
             _rows = KeyboardLayouts.Reset();
 
@@ -219,12 +221,23 @@ public bool HandleKey(string key)
                     _column = (_column + 1) % _rows[_row].Length;
                     break;
                 case RemoteKeys.Up:
-                    _row = _row > 0 ? _row - 1 : _rows.Length - 1;
-                    _column = Math.Min(_column, _rows[_row].Length - 1);
+                    // By position, not by index: the rows are centred and the
+                    // action row is wider, so the same index is a different place
+                    // on the screen (issue #92).
+                    {
+                        int above = _row > 0 ? _row - 1 : _rows.Length - 1;
+                        _column = KeyboardLayouts.ColumnAcross(_rows, _row, _column, above);
+                        _row = above;
+                    }
+
                     break;
                 case RemoteKeys.Down:
-                    _row = (_row + 1) % _rows.Length;
-                    _column = Math.Min(_column, _rows[_row].Length - 1);
+                    {
+                        int below = (_row + 1) % _rows.Length;
+                        _column = KeyboardLayouts.ColumnAcross(_rows, _row, _column, below);
+                        _row = below;
+                    }
+
                     break;
 
                 case RemoteKeys.Ok:
@@ -233,11 +246,7 @@ public bool HandleKey(string key)
                     return true;
 
                 case RemoteKeys.Back:
-                    if (_text.Length > 0)
-                    {
-                        _text = _text.Substring(0, _text.Length - 1);
-                    }
-                    else
+                    if (!_text.Backspace())
                     {
                         Close();
                         return true;
@@ -258,20 +267,22 @@ private void Press(string label)
             switch (label)
             {
                 case "space":
-                    _text += " ";
+                    _text.Insert(" ");
                     break;
                 case ".com":
-                    _text += ".com";
+                    _text.Insert(".com");
                     break;
                 case "back":
-                    if (_text.Length > 0)
-                    {
-                        _text = _text.Substring(0, _text.Length - 1);
-                    }
-
+                    _text.Backspace();
                     break;
                 case "clear":
-                    _text = string.Empty;
+                    _text.Clear();
+                    break;
+                case KeyboardLayouts.CaretLeftKey:
+                    _text.Left();
+                    break;
+                case KeyboardLayouts.CaretRightKey:
+                    _text.Right();
                     break;
                 case KeyboardLayouts.CycleKey:
                     _rows = KeyboardLayouts.Next();
@@ -290,7 +301,7 @@ private void Press(string label)
                         break;
                     }
 
-                    string wanted = _text;
+                    string wanted = _text.Text;
                     Close();
                     Action<string> startHandler = StartPageSet;
                     if (startHandler != null)
@@ -303,7 +314,7 @@ private void Press(string label)
                     Close();
                     return;
                 case "GO":
-                    string committed = _text;
+                    string committed = _text.Text;
                     Close();
                     Action<string, KeyboardTarget> handler = Committed;
                     if (handler != null)
@@ -313,7 +324,7 @@ private void Press(string label)
 
                     return;
                 default:
-                    _text += label;
+                    _text.Insert(label);
 
                     // Shift applies to the next character only, as on a phone: one
                     // capital is what a name or a password rule usually needs, and
@@ -335,7 +346,7 @@ private void Paint()
             string prompt = Prompt(Target);
             _entry.Text =
                 Theme.Text(prompt + "   ", 24, Theme.Accent, true) +
-                Theme.Text(_text.Length == 0 ? "|" : _text + "|", 34, Theme.Ink, true);
+                Theme.Text(_text.Display, 34, Theme.Ink, true);
 
             for (int r = 0; r < _cells.Length; r++)
             {
@@ -369,6 +380,8 @@ private static Color FillFor(string key)
                 case "space":
                 case KeyboardLayouts.CycleKey:
                 case KeyboardLayouts.StartPageKey:
+                case KeyboardLayouts.CaretLeftKey:
+                case KeyboardLayouts.CaretRightKey:
                 case ".com": return Theme.KeyFillAlt;
                 default: return Theme.KeyFill;
             }
@@ -410,6 +423,8 @@ private static string KeyText(string key)
                 case KeyboardLayouts.CycleKey: return KeyboardLayouts.Name;
                 case KeyboardLayouts.SymbolsKey: return KeyboardLayouts.Symbols ? "abc" : "sym";
                 case KeyboardLayouts.ShiftKey: return KeyboardLayouts.Shift ? "SHIFT" : "shift";
+                case KeyboardLayouts.CaretLeftKey: return "\u2190";
+                case KeyboardLayouts.CaretRightKey: return "\u2192";
                 default: return key;
             }
         }
diff --git a/src/elm/VirtualCursor.cs b/src/elm/VirtualCursor.cs
index 99defa4..f34bf4e 100644
--- a/src/elm/VirtualCursor.cs
+++ b/src/elm/VirtualCursor.cs
@@ -181,7 +181,13 @@ private void Apply()
                 _dot.Hide();
                 _core.Hide();
                 _movePending = false;
-                MoveInPage();
+
+                // show() and not just move(): the page script remembers hide(), so
+                // an arrow put away while the pointer was drawn natively stays
+                // away until it is asked for by name (issue #91). Same evaluation
+                // as the move so the arrow never appears somewhere it is not.
+                Eval("try{window." + PageScript.Namespace + ".show();window." +
+                     PageScript.Namespace + ".move(" + F(_x) + "," + F(_y) + ");}catch(e){}");
             }
         }
 
diff --git a/src/nui/NuiCursor.cs b/src/nui/NuiCursor.cs
index a9a3a48..195db49 100644
--- a/src/nui/NuiCursor.cs
+++ b/src/nui/NuiCursor.cs
@@ -142,19 +142,39 @@ public void SetVisual(CursorVisual visual)
         /// two pointers is ever showing, and the position is re-sent either way.
         /// </summary>
         private void Apply()
+        {
+            Apply(false);
+        }
+
+        /// <summary>
+        /// <see cref="Apply()"/>, installing the page script first when
+        /// <paramref name="reinstall"/> is set — in the same evaluation as the
+        /// show-or-hide, so that putting the arrow in the page and taking it off
+        /// again is one call and not two that could land apart.
+        /// </summary>
+        private void Apply(bool reinstall)
         {
             if (Visual == CursorVisual.Native)
             {
-                Eval("try{window." + PageScript.Namespace + ".hide();}catch(e){}");
+                // hide() is remembered by the page script: install(), which the
+                // page re-runs on its own on every visibilitychange, keeps the
+                // arrow off until show() is asked for. Before it was remembered,
+                // the arrow came back on the first visibilitychange after a load
+                // — the app coming to the front at launch is one — and sat under
+                // our dot at the same spot (issue #91).
+                Eval((reinstall ? PageScript.Install("sbnative") : string.Empty) +
+                     "try{window." + PageScript.Namespace + ".hide();}catch(e){}");
                 Place();
             }
             else
             {
                 ShowViews(false);
 
-                // The page's arrow is put back by install(), which is idempotent
-                // and is the only call that sets it visible again.
-                Eval(PageScript.Install("sbnative"));
+                // show() is the only call that brings the arrow back; install()
+                // alone would leave it hidden if the app had hidden it earlier.
+                // The install is idempotent, so it is simply always sent here.
+                Eval(PageScript.Install("sbnative") +
+                     "try{window." + PageScript.Namespace + ".show();}catch(e){}");
             }
 
             MoveInPage();
@@ -184,17 +204,19 @@ public double FractionY
 
         public void Reinstall()
         {
-            // The ElmSharp build needs a bridge name for click feedback; NUI gets
-            // results back through EvaluateJavaScript callbacks, so the name is
-            // only used for the (unused) postMessage path.
-            Eval(PageScript.Install("sbnative"));
-
             // A load put the page's own arrow back. Two pointers on one screen is
-            // worse than either, and the page's is the one that lags.
+            // worse than either, and the page's is the one that lags — so the
+            // script is installed and the arrow hidden (or shown) in ONE evaluation.
+            // As two, a hide that somehow ran ahead of its install would be undone
+            // by it, and the result is exactly issue #91's screen.
             // Not deferred: the page has just been replaced and knows nothing about
             // where the pointer is, so the first telling is worth a call of its own.
+            //
+            // The ElmSharp build needs a bridge name for click feedback; NUI gets
+            // results back through EvaluateJavaScript callbacks, so the name is
+            // only used for the (unused) postMessage path.
             _movePending = false;
-            Apply();
+            Apply(true);
         }
 
         public void Move(int dx, int dy)
diff --git a/src/nui/NuiKeyboard.cs b/src/nui/NuiKeyboard.cs
index 2f7766a..e927979 100644
--- a/src/nui/NuiKeyboard.cs
+++ b/src/nui/NuiKeyboard.cs
@@ -15,9 +15,11 @@ namespace Overscan
     /// </summary>
     internal sealed class NuiKeyboard
     {
-        // 14 keys on the action row (shift, sym and start joined it) at 116px each
-        // overflow a 1080p panel, so the key is narrower than it was.
-        private const int KeyWidth = 104;
+        // 16 keys on the action row (shift, sym, start and the two caret arrows
+        // joined it) at the original 116px overflow a 1080p panel, so the key has
+        // narrowed twice: to 104 at 14 keys, to 100 at 16. Sixteen of these plus
+        // the gaps is 1736px, the width the 14-key row had at 116.
+        private const int KeyWidth = 100;
         private const int KeyHeight = 74;
         private const int Gap = 8;
 
@@ -34,7 +36,7 @@ internal sealed class NuiKeyboard
 
         private int _row;
         private int _column;
-        private string _text = string.Empty;
+        private readonly KeyboardEntry _text = new KeyboardEntry();
 
         public NuiKeyboard(Window window)
         {
@@ -74,7 +76,7 @@ public NuiKeyboard(Window window)
             {
                 _keys[r] = new TextLabel[_rows[r].Length];
                 // Centred, not left-aligned: the letter rows are 10 keys and the
-                // action row is 14, so left alignment leaves a hole on the right.
+                // action row is 16, so left alignment leaves a hole on the right.
                 int rowWidth = (KeyWidth * _rows[r].Length) + (Gap * (_rows[r].Length - 1));
                 int rowLeft = (width - rowWidth) / 2;
 
@@ -115,7 +117,7 @@ public NuiKeyboard(Window window)
         public void Open(KeyboardTarget target, string initialText)
         {
             Target = target;
-            _text = initialText ?? string.Empty;
+            _text.Reset(initialText);
             IsVisible = true;
             _rows = KeyboardLayouts.Reset();
             _root.Show();
@@ -143,12 +145,23 @@ public bool HandleKey(string key)
                     _column = (_column + 1) % _rows[_row].Length;
                     break;
                 case RemoteKeys.Up:
-                    _row = _row > 0 ? _row - 1 : _rows.Length - 1;
-                    _column = Math.Min(_column, _rows[_row].Length - 1);
+                    // By position, not by index: the rows are centred and the
+                    // action row is wider, so the same index is a different place
+                    // on the screen (issue #92).
+                    {
+                        int above = _row > 0 ? _row - 1 : _rows.Length - 1;
+                        _column = KeyboardLayouts.ColumnAcross(_rows, _row, _column, above);
+                        _row = above;
+                    }
+
                     break;
                 case RemoteKeys.Down:
-                    _row = (_row + 1) % _rows.Length;
-                    _column = Math.Min(_column, _rows[_row].Length - 1);
+                    {
+                        int below = (_row + 1) % _rows.Length;
+                        _column = KeyboardLayouts.ColumnAcross(_rows, _row, _column, below);
+                        _row = below;
+                    }
+
                     break;
 
                 case RemoteKeys.Ok:
@@ -157,11 +170,7 @@ public bool HandleKey(string key)
                     return true;
 
                 case RemoteKeys.Back:
-                    if (_text.Length > 0)
-                    {
-                        _text = _text.Substring(0, _text.Length - 1);
-                    }
-                    else
+                    if (!_text.Backspace())
                     {
                         Close();
                     }
@@ -181,20 +190,22 @@ private void Press(string label)
             switch (label)
             {
                 case "space":
-                    _text += " ";
+                    _text.Insert(" ");
                     break;
                 case ".com":
-                    _text += ".com";
+                    _text.Insert(".com");
                     break;
                 case "back":
-                    if (_text.Length > 0)
-                    {
-                        _text = _text.Substring(0, _text.Length - 1);
-                    }
-
+                    _text.Backspace();
                     break;
                 case "clear":
-                    _text = string.Empty;
+                    _text.Clear();
+                    break;
+                case KeyboardLayouts.CaretLeftKey:
+                    _text.Left();
+                    break;
+                case KeyboardLayouts.CaretRightKey:
+                    _text.Right();
                     break;
                 case KeyboardLayouts.CycleKey:
                     _rows = KeyboardLayouts.Next();
@@ -213,7 +224,7 @@ private void Press(string label)
                         break;
                     }
 
-                    string wanted = _text;
+                    string wanted = _text.Text;
                     Close();
                     Action<string> startHandler = StartPageSet;
                     if (startHandler != null)
@@ -226,7 +237,7 @@ private void Press(string label)
                     Close();
                     return;
                 case "GO":
-                    string committed = _text;
+                    string committed = _text.Text;
                     Close();
                     Action<string, KeyboardTarget> handler = Committed;
                     if (handler != null)
@@ -236,7 +247,7 @@ private void Press(string label)
 
                     return;
                 default:
-                    _text += label;
+                    _text.Insert(label);
 
                     // Shift applies to the next character only, as on a phone.
                     string[][] released = KeyboardLayouts.ReleaseShift();
@@ -271,6 +282,8 @@ private static Color FillFor(string key)
                 case "space":
                 case KeyboardLayouts.CycleKey:
                 case KeyboardLayouts.StartPageKey:
+                case KeyboardLayouts.CaretLeftKey:
+                case KeyboardLayouts.CaretRightKey:
                 case ".com": return NuiTheme.KeyFillAlt;
                 default: return NuiTheme.KeyFill;
             }
@@ -303,13 +316,15 @@ private static string LabelFor(string key)
                 case KeyboardLayouts.CycleKey: return KeyboardLayouts.Name;
                 case KeyboardLayouts.SymbolsKey: return KeyboardLayouts.Symbols ? "abc" : "sym";
                 case KeyboardLayouts.ShiftKey: return KeyboardLayouts.Shift ? "SHIFT" : "shift";
+                case KeyboardLayouts.CaretLeftKey: return "\u2190";
+                case KeyboardLayouts.CaretRightKey: return "\u2192";
                 default: return key;
             }
         }
 
         private void Paint()
         {
-            _entry.Text = Prompt(Target) + "   " + (_text.Length == 0 ? "|" : _text + "|");
+            _entry.Text = Prompt(Target) + "   " + _text.Display;
 
             for (int r = 0; r < _keys.Length; r++)
             {
diff --git a/tools/keyboard/Program.cs b/tools/keyboard/Program.cs
new file mode 100644
index 0000000..9ad5904
--- /dev/null
+++ b/tools/keyboard/Program.cs
@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+
+namespace Overscan
+{
+    /// <summary>Stands in for the app's diagnostics log.</summary>
+    internal static class DiagLog
+    {
+        public static readonly List<string> Lines = new List<string>();
+
+        public static void Add(string line)
+        {
+            Lines.Add(line);
+        }
+    }
+
+    /// <summary>Stands in for the settings store: the layout index, nothing else.</summary>
+    internal static class Store
+    {
+        private static readonly Dictionary<string, int> Ints = new Dictionary<string, int>();
+
+        public static int GetInt(string key, int fallback)
+        {
+            int value;
+            return Ints.TryGetValue(key, out value) ? value : fallback;
+        }
+
+        public static void Set(string key, int value)
+        {
+            Ints[key] = value;
+        }
+    }
+
+    internal static class Program
+    {
+        private static int _failures;
+
+        private static void Check(bool ok, string what)
+        {
+            Console.WriteLine((ok ? "ok   " : "FAIL ") + what);
+            if (!ok)
+            {
+                _failures++;
+            }
+        }
+
+        /// <summary>
+        /// The key's centre on the screen in half-key units, the way the keyboards
+        /// lay them out: rows centred, one pitch for every key.
+        /// </summary>
+        private static int Centre(string[][] rows, int row, int column)
+        {
+            int widest = 0;
+            foreach (string[] r in rows)
+            {
+                widest = Math.Max(widest, r.Length);
+            }
+
+            return (widest - rows[row].Length) + (2 * column) + 1;
+        }
+
+        private static int Main()
+        {
+            // 1. Every grid keeps the shape the cells were built for.
+            var grids = new List<KeyValuePair<string, string[][]>>();
+            string[][] plain = KeyboardLayouts.Reset();
+            for (int i = 0; i < 4; i++)
+            {
+                grids.Add(new KeyValuePair<string, string[][]>(KeyboardLayouts.Name, KeyboardLayouts.Rows));
+                grids.Add(new KeyValuePair<string, string[][]>(KeyboardLayouts.Name + " shifted", KeyboardLayouts.ToggleShift()));
+                KeyboardLayouts.ToggleShift();
+                KeyboardLayouts.Next();
+            }
+
+            grids.Add(new KeyValuePair<string, string[][]>("symbols", KeyboardLayouts.ToggleSymbols()));
+            KeyboardLayouts.ToggleSymbols();
+
+            int letterWidth = plain[0].Length;
+            int actionWidth = plain[plain.Length - 1].Length;
+            foreach (KeyValuePair<string, string[][]> grid in grids)
+            {
+                bool shape = grid.Value.Length == plain.Length;
+                for (int r = 0; shape && r < grid.Value.Length; r++)
+                {
+                    shape = grid.Value[r].Length == plain[r].Length;
+                }
+
+                Check(shape, grid.Key + " has the shape the cells were built for");
+            }
+
+            Check(letterWidth == 10, "letter rows are 10 wide (" + letterWidth + ")");
+            Check(actionWidth == 16, "the action row is 16 wide (" + actionWidth + ")");
+            Check(Array.IndexOf(plain[plain.Length - 1], KeyboardLayouts.CaretLeftKey) >= 0 &&
+                  Array.IndexOf(plain[plain.Length - 1], KeyboardLayouts.CaretRightKey) >= 0,
+                  "both caret arrows are on the action row");
+
+            // 2. Moving between rows follows the screen, not the index.
+            string[][] rows = KeyboardLayouts.Reset();
+            int letters = 0;
+            int action = rows.Length - 1;
+            int shift = (actionWidth - letterWidth) / 2;
+
+            for (int c = 0; c < letterWidth; c++)
+            {
+                int down = KeyboardLayouts.ColumnAcross(rows, letters, c, action);
+                int back = KeyboardLayouts.ColumnAcross(rows, action, down, letters);
+                Check(down == c + shift, "letter column " + c + " lands under itself on the action row (" + down + ")");
+                Check(back == c, "and comes back to " + c + " (" + back + ")");
+                Check(Centre(rows, action, down) == Centre(rows, letters, c),
+                      "the key it landed on is directly below");
+            }
+
+            for (int c = 0; c < actionWidth; c++)
+            {
+                int up = KeyboardLayouts.ColumnAcross(rows, action, c, letters);
+                Check(up >= 0 && up < letterWidth, "action column " + c + " lands inside the letter row (" + up + ")");
+                int expected = Math.Min(letterWidth - 1, Math.Max(0, c - shift));
+                Check(up == expected, "action column " + c + " goes to letter column " + expected + " (" + up + ")");
+            }
+
+            // The reporter's two moves, as he made them: from the digits down to
+            // the action row, and from the action row up over the wrap to the top.
+            int digits = rows.Length - 2;
+            Check(KeyboardLayouts.ColumnAcross(rows, digits, 5, action) == 5 + shift,
+                  "digit 5 goes down to the key beneath it, not " + shift + " keys back");
+            Check(KeyboardLayouts.ColumnAcross(rows, action, 5 + shift, letters) == 5,
+                  "and the key beneath it goes up over the wrap to the letter above, not " + shift + " forward");
+            Check(KeyboardLayouts.ColumnAcross(rows, letters, 3, digits) == 3,
+                  "rows of one width keep the column");
+
+            // 3. The caret.
+            var entry = new KeyboardEntry();
+            entry.Reset("abc");
+            Check(entry.Text == "abc" && entry.Caret == 3 && entry.Display == "abc|", "opens with the caret at the end");
+            entry.Right();
+            Check(entry.Caret == 3, "right at the end stays put");
+            entry.Left();
+            entry.Left();
+            Check(entry.Caret == 1 && entry.Display == "a|bc", "left moves back through the text");
+            entry.Insert("X");
+            Check(entry.Text == "aXbc" && entry.Caret == 2, "types at the caret, not the end");
+            entry.Insert(".com");
+            Check(entry.Text == "aX.combc" && entry.Caret == 6, "a multi-character key moves the caret past all of it");
+            Check(entry.Backspace() && entry.Text == "aX.cobc" && entry.Caret == 5, "backspace deletes before the caret");
+            entry.Left();
+            entry.Left();
+            entry.Left();
+            entry.Left();
+            entry.Left();
+            entry.Left();
+            Check(entry.Caret == 0, "left stops at the start");
+            Check(!entry.Backspace() && entry.Text == "aX.cobc", "nothing to delete at the start, and the text is kept");
+            entry.Right();
+            Check(entry.Backspace() && entry.Text == "X.cobc" && entry.Caret == 0, "one step in, backspace removes the first character");
+            entry.Clear();
+            Check(entry.Text.Length == 0 && entry.Caret == 0 && entry.Display == "|", "clear empties it and the bar stands alone");
+            entry.Reset(null);
+            Check(entry.Text.Length == 0 && entry.Display == "|", "opening on nothing is an empty entry");
+            entry.Insert(null);
+            entry.Insert(string.Empty);
+            Check(entry.Text.Length == 0, "an empty insert is nothing");
+
+            Console.WriteLine();
+            if (_failures > 0)
+            {
+                Console.WriteLine("keyboard: " + _failures + " FAILED");
+                return 1;
+            }
+
+            Console.WriteLine("keyboard: all checks passed");
+            return 0;
+        }
+    }
+}
diff --git a/tools/keyboard/run.sh b/tools/keyboard/run.sh
new file mode 100755
index 0000000..6df585e
--- /dev/null
+++ b/tools/keyboard/run.sh
@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# Exercises the on-screen keyboard's bookkeeping — KeyboardLayouts and
+# KeyboardEntry — off-device.
+#
+#   ./run.sh
+#
+# Issue #92: "when we move selector from last 2nd row to last row in keyboard it
+# moves 2 character back and moves 2 character forward when move from last to 1st
+# row". The rows are centred and the action row is wider than the letter rows, so
+# a column index carried across unchanged is a different place on the screen; both
+# keyboards did exactly that. The same report asked for arrow keys, which is the
+# caret the entry never had — a typo in the middle of an address meant deleting
+# everything after it.
+#
+# This compiles the shipping src/common/KeyboardLayouts.cs and KeyboardEntry.cs
+# (with stubs for the store and the diagnostics log) and holds them to:
+#   1. every grid the keyboard can show still has the shape the keyboards build
+#      their cells for — five rows, the four letter/digit rows all one width;
+#   2. a move between rows lands on the key underneath, not the key with the same
+#      index: from a letter row to the action row and back returns to the same
+#      key, the edge columns land inside the narrower row, and the offset the
+#      reporter saw is gone in both directions;
+#   3. the caret: opens at the end, types at the caret, backspaces before it,
+#      stops at both ends, and reports "nothing to delete" only when the caret is
+#      at the start so the remote's Back key closes the keyboard exactly then.
+# Needs only the .NET 6 SDK under ~/.dotnet-local.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+DOTNET="${DOTNET:-$HOME/.dotnet-local/dotnet}"
+if [ ! -x "$DOTNET" ]; then
+  echo "keyboard: no dotnet at $DOTNET (set DOTNET=...)" >&2
+  exit 1
+fi
+
+work="$(mktemp -d)"
+trap 'rm -rf "$work"' EXIT
+
+cp Program.cs "$work/"
+cat > "$work/keyboard.csproj" <<CSPROJ
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>disable</Nullable>
+    <RootNamespace>Overscan</RootNamespace>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <Compile Include="$PWD/../../src/common/KeyboardLayouts.cs" />
+    <Compile Include="$PWD/../../src/common/KeyboardEntry.cs" />
+  </ItemGroup>
+</Project>
+CSPROJ
+
+export DOTNET_CLI_TELEMETRY_OPTOUT=1 DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 DOTNET_NOLOGO=1
+DOTNET_ROOT="$(dirname "$DOTNET")" "$DOTNET" run --project "$work/keyboard.csproj" -c Release
diff --git a/tools/pointer/build-page.py b/tools/pointer/build-page.py
new file mode 100644
index 0000000..f104224
--- /dev/null
+++ b/tools/pointer/build-page.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Builds the test page around the page script as it is actually shipped.
+
+The script is lifted out of src/common/PageScript.cs, with the bridge name
+substituted the way PageScript.Install does and the verbatim-string quotes
+undoubled the way the compiler does. Keeping a copy here instead would test the
+copy. OVS_SOURCE points it at another revision of the file, which is how the
+harness is shown to catch the fault it was written for.
+"""
+import os
+import re
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SOURCE = os.environ.get(
+    "OVS_SOURCE", os.path.join(HERE, "..", "..", "src", "common", "PageScript.cs"))
+
+
+def script():
+    text = open(SOURCE, encoding="utf-8").read()
+    body = re.search(r'private const string Raw = @"\n(.*?)\n";\n', text, re.S)
+    if not body:
+        sys.exit("could not find the verbatim page script in PageScript.cs")
+    return body.group(1).replace('""', '"').replace("__BRIDGE__", "sbnative")
+
+
+# The checks run in the order the app makes the calls, and every one of them is a
+# thing the app has relied on the arrow doing. `visibilitychange` cannot be made
+# to fire for real from inside a headless page, so it is dispatched: the listener
+# does not look at the event, only at the fact of it.
+PAGE = """<!doctype html><html><head><meta charset=utf-8>
+<style>body{margin:0;height:2000px}</style>
+</head><body>
+<div id=out>running</div>
+<p><a href="#a" id=link>a link</a></p>
+<script>
+var results = [];
+function check(ok, what) { results.push((ok ? 'ok   ' : 'FAIL ') + what); }
+function arrow() { return document.getElementById('__ovs_cursor'); }
+function shown() { var a = arrow(); return !!a && a.parentNode && a.style.display === 'block'; }
+function hidden() { var a = arrow(); return !!a && a.style.display === 'none'; }
+function visibility() { document.dispatchEvent(new Event('visibilitychange')); }
+</script>
+<script>
+__SCRIPT__
+</script>
+<script type="text/plain" id="shipped">__SCRIPT__</script>
+<script>
+try {
+  // A fresh page: the script puts the arrow up. This is what a page-drawn
+  // pointer relies on, and what every load looked like before the app drew one.
+  check(shown(), 'a fresh install shows the arrow');
+
+  // The app is drawing the pointer: it hides the arrow, and then everything the
+  // page does on its own must leave it hidden. Issue #91 is the third line.
+  window.__ovs.hide();
+  check(hidden(), 'hide() takes the arrow off');
+  visibility();
+  check(hidden(), 'a visibilitychange does not bring it back');
+  window.__ovs.install();
+  check(hidden(), 'nor does a re-install');
+  window.__ovs.move(0.25, 0.25);
+  check(hidden(), 'nor does a move');
+  check(String(window.__ovs.linkAt()).length >= 0, 'the rest of the script still answers while hidden');
+
+  // The arrow is wiped by a single-page navigation and re-installed: still off.
+  arrow().parentNode.removeChild(arrow());
+  visibility();
+  check(hidden() && arrow().parentNode, 'put back into the DOM after a wipe, and still off');
+
+  // The app switches to the page's arrow: show() is the way back, and it holds.
+  window.__ovs.show();
+  check(shown(), 'show() brings it back');
+  visibility();
+  check(shown(), 'and it stays through a visibilitychange');
+  window.__ovs.install();
+  check(shown(), 'and through a re-install');
+
+  // Once more round, so hidden state is not one-shot.
+  window.__ovs.hide();
+  visibility();
+  check(hidden(), 'hidden again, and a second visibilitychange still leaves it off');
+
+  // The whole script re-evaluated on an installed page (what a re-install from
+  // the app is) does not undo a hide either.
+  eval(document.getElementById('shipped').textContent);
+  check(hidden(), 're-running the shipped script over an installed page keeps it off');
+} catch (e) {
+  check(false, 'threw: ' + e);
+}
+var out = document.getElementById('out');
+out.textContent = 'RESULTS\\n' + results.join('\\n') + '\\n';
+</script>
+</body></html>
+"""
+
+if __name__ == "__main__":
+    js = script()
+    page = PAGE.replace("__SCRIPT__", js)
+    with open(sys.argv[1], "w", encoding="utf-8") as f:
+        f.write(page)
diff --git a/tools/pointer/run.sh b/tools/pointer/run.sh
new file mode 100755
index 0000000..b142dea
--- /dev/null
+++ b/tools/pointer/run.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# Exercises the page script's half of the D-pad pointer against desktop chromium.
+#
+#   ./run.sh
+#   CHROME=/path/to/chrome ./run.sh
+#
+# Issue #91: "sometimes when load app where it shows two cursor one on top of
+# other". The NUI build draws the pointer itself and asks the page script to hide
+# its arrow, and the page script re-installs that arrow on every visibilitychange
+# — which the app coming to the front at launch is — with no memory of having
+# been told to hide it. Both are positioned from the same viewport fraction, so
+# the arrow came up exactly under the dot.
+#
+# This lifts the script out of src/common/PageScript.cs, which is in all six
+# packages, and holds it to: a fresh install shows the arrow (what the ewk builds
+# rely on), hide() is remembered through a visibilitychange, a re-install, a move
+# and a re-evaluation of the whole script, show() is the only way back, and the
+# arrow is still put back into the DOM after a single-page navigation wiped it —
+# hidden. Against the PageScript.cs before this fix the third check fails.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+# CWD is this script's own directory by now — see the cd above.
+. ../find-chrome.sh
+
+work="$(mktemp -d)"
+trap 'rm -rf "$work"' EXIT
+
+python3 build-page.py "$work/test.html"
+
+# A chrome.exe reached over /mnt/c cannot open a WSL path, so the page goes
+# somewhere both sides can name.
+page="$work/test.html"
+url="file://$page"
+case "$CHROME" in
+  /mnt/c/*)
+    cp "$page" /mnt/c/Windows/Temp/ovs-pointer-test.html
+    url="file:///C:/Windows/Temp/ovs-pointer-test.html"
+    ;;
+esac
+
+out="$("$CHROME" --headless=new --disable-gpu --no-sandbox \
+        --virtual-time-budget=3000 --dump-dom "$url" 2>/dev/null \
+      | sed -n '/RESULTS/,/<\/div>/{p;/<\/div>/q}' | sed 's/<[^>]*>//g')"
+
+echo "$out"
+if [ -z "$out" ] || echo "$out" | grep -q FAIL; then
+  echo
+  echo "pointer: FAILED" >&2
+  exit 1
+fi
+echo
+echo "pointer: all checks passed"