@leftoff/cli 0.9.18-beta.9 → 0.9.18

package/ui/viewport-fit.js

@@ -28,6 +28,13 @@ export const KEYBOARD_MIN_PX = 120 // less than this is the browser's own bars,
 // (a keyboard swap reports a passing full-height or tiny keyboard on the way; following each report
 // means the next one puts it right). Nothing is remembered from when the box took focus. `kb` (the
 // keyboard's own look: no home-indicator gap) still needs a keyboard's worth of height.
+// 2026-11-07 (the maintainer's screen recording, iPhone, stock and four third-party keyboards): the
+// 64px kept clear for iOS 26's ^ v ✓ bar on 11-06 was pure gap. In the recording the reply box's
+// focus ring ends ~129 video px (≈76pt) above the bar's top edge on every keyboard: 64 kept + the
+// box's 8px bottom padding + the bar's drawn edge. So the bar sits outside the visual viewport iOS
+// reports, as before iOS 26, and full screen is the reported viewport exactly, with nothing kept.
+// The 11-06 clipping was the fit measuring before iOS's last resize (switching keyboards fixed it:
+// a fresh report); the board now looks again on every report and at timed beats after focus.
 export function fullViewportFit({ innerHeight, vv, typing = false } = {}) {
   if (!vv || !(Number(innerHeight) > 0)) return null
   const ih = Number(innerHeight)
@@ -54,6 +61,25 @@ export function outOfView(rect, vv, slack = 1) {
 // When to look again after a text box lets go (the keyboard takes ~0.3–0.5 s to
 // close, and iOS's reports during it can be stale or missing), in ms.
 export const SETTLE_AFTER_BLUR_MS = [0, 120, 350, 700, 1100]
-// The same beats after every report while a text box has focus: a keyboard swap's last change can
-// come with no event of its own, so the board looks again a few times after each one.
-export const SETTLE_WHILE_TYPING_MS = SETTLE_AFTER_BLUR_MS
+// The beats after a text box takes focus and after every report while it has focus: a keyboard's
+// last resize (a third-party one coming up late, a swap, the ^ v ✓ bar) can come with no event of
+// its own, so the board looks again at each of these, sizing full screen to that moment's numbers.
+export const SETTLE_WHILE_TYPING_MS = [0, 100, 300, 600, 1000]
+// And every frame for this long after the box takes focus and after each report: iOS animates the
+// keyboard (and pans) for ~0.3–0.5 s, part of it with no event, and its numbers settle a frame or
+// two after the event that announced them (WebKit bug 237851: offsetTop read 0 mid-animation).
+export const FOLLOW_FRAMES_MS = 1000
+
+// 2026-11-06 (the phone's session sheet covered the reply box while typing; "sometimes I have to
+// scroll that down, and then the message box appears"): the sheet went away only when the board
+// measured a keyboard's worth of lost height (lf-kb), and some keyboards (a third-party one coming up
+// late or in steps, or iOS shrinking the window along with the keyboard) never report that. Now the
+// sheet steps aside whenever a text box outside the sheet has focus, measured or not, and comes back
+// a beat after it lets go (so the tap that closed the keyboard lands where it was aimed, not on a
+// sheet sliding in under the finger). A text box inside the sheet keeps it.
+export const SHEET_BACK_AFTER_BLUR_MS = 400
+// typing: a text box has focus; inSheet: that box is in the sheet; blurredMs: ms since a text box outside the sheet let go (null: none lately)
+export function sheetAside({ typing = false, inSheet = false, blurredMs = null } = {}) {
+  if (typing) return !inSheet
+  return blurredMs != null && blurredMs >= 0 && blurredMs < SHEET_BACK_AFTER_BLUR_MS
+}

package/ui/walk-spots.js

@@ -58,7 +58,7 @@ export function spotsFor(data, order) {
     snips.forEach((sn, i) => {
       const here = []
       const lineIn = (side, line) => parsePatch(sn.patch).rows.some((r) => isLine(r) && (side === 'old' ? r.o : r.n) === line)
-      for (const c of st.callouts || []) if (c.hunk === sn.hunk && lineIn(c.side, c.line)) here.push({ side: c.side, line: c.line, why: SPOT_WORDS[c.kind] || SPOT_WORDS.look, kind: 'callout' })
+      for (const c of st.callouts || []) if (c.hunk === sn.hunk && lineIn(c.side, c.line)) here.push({ side: c.side, line: c.line, why: SPOT_WORDS[c.kind] || SPOT_WORDS.look, kind: 'callout', note: c.text || '' })
       for (const m of model) if (m.step === st.id && m.hunk === sn.hunk && lineIn(m.side, m.line) && !here.some((x) => x.side === m.side && x.line === m.line)) here.push({ side: m.side, line: m.line, why: m.why || 'Worth a look', kind: 'model' })
       if (!here.length && !model.length) {
         const r = snippetRisk(sn.patch, sn.file)
@@ -76,6 +76,40 @@ export function spotsFor(data, order) {
   return main.length ? main : sup
 }
 
+// 2026-11-06 (Joel: "if used midway through will just start from the first, not the next
+// from where you are"): where Next spot goes from where you're reading. rank: a step id ->
+// its place in reading order; at: the place you're on (-1 the overview, Infinity past the
+// last step). Carrying on from the spot you were last at when it's on this step; else the
+// first spot on this step or after it (dir 1), or the last one before it (dir -1), wrapping.
+export function spotFrom(spots, rank, at, cur, dir = 1) {
+  const n = spots.length
+  if (!n) return -1
+  const r = (sp) => { const v = rank(sp.step); return v == null || v < 0 ? Infinity : v }
+  if (cur != null && cur >= 0 && cur < n && r(spots[cur]) === at) return nextSpotIndex(n, cur, dir)
+  if (dir > 0) { const i = spots.findIndex((sp) => r(sp) >= at); return i < 0 ? 0 : i }
+  for (let i = n - 1; i >= 0; i--) if (r(spots[i]) < at) return i
+  return n - 1
+}
+
+// 2026-11-06 (Joel: "it needs a tooltip / popover explaining why it's a spot"): a spot's chip
+// explains itself: who picked it and what to check. Plain text.
+const RISK_WHY = {
+  'Removed logic': 'Several lines of code go away with little added in their place. Check nothing still relies on them.',
+  'Auth / permissions': 'A changed line touches auth or permissions (a token, a role, a session, a check). Check who can do what now.',
+  'Error handling': 'A changed line handles errors. Check what happens now when this fails.',
+  Config: 'A config file. A change here affects every run, not one code path.',
+  Migration: 'A migration. Check it runs once, on real data, and what undoing it takes.',
+}
+export function spotTip(sp) {
+  if (!sp) return ''
+  const why = String(sp.why || '')
+  if (sp.kind === 'callout') return 'The walkthrough flags this line (' + why + ')' + (sp.note ? ': ' + sp.note : '.')
+  if (sp.kind === 'model') return 'The model that wrote this walkthrough picked this line as worth a real look: ' + (why || 'no reason given') + '.'
+  if (sp.kind === 'risk') return why + ', found by Leftoff\'s own check (no model). ' + (RISK_WHY[why] || '')
+  if (sp.kind === 'core') return 'The first change in a Core step: the heart of what this change does.'
+  return 'Nothing riskier was found, so this is the next Supporting change to read.'
+}
+
 // The spot after (dir 1) or before (-1) index cur, wrapping; -1 when there are none.
 export function nextSpotIndex(n, cur, dir = 1) {
   if (!n) return -1