@leftoff/cli 0.9.18-beta.8 → 0.9.18

package/ui/viewport-fit.js

@@ -23,18 +23,63 @@ export const KEYBOARD_MIN_PX = 120 // less than this is the browser's own bars,
 
 // innerHeight: the layout viewport's height; vv: { height, offsetTop, scale }; typing: a text box has focus.
 // -> { h, top, kb } in CSS px (null without a visualViewport: the CSS falls back to 100dvh).
+// 2026-11-04 (switching keyboards mid-typing hid the composer): while a text box has focus, full
+// screen is exactly the visual viewport as iOS reports it right now, whatever the keyboard's height
+// (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)
   const vh = Number(vv.height) > 0 ? Number(vv.height) : ih
   const zoomed = Number(vv.scale) > 1.01 // pinch-zoomed: follow the visual viewport as before
   const kb = !!typing && ih - vh > KEYBOARD_MIN_PX
-  if (!kb && !zoomed) return { h: Math.round(ih), top: 0, kb: false } // no keyboard: the whole window, from its top
-  const room = Math.max(0, ih - vh)
+  if (!typing && !zoomed) return { h: Math.round(ih), top: 0, kb: false } // no keyboard: the whole window, from its top
+  const room = Math.max(0, ih - vh) // a visual viewport as tall as the window can't be panned (a stale pan)
   const top = Math.min(Math.max(0, Number(vv.offsetTop) || 0), room)
-  return { h: Math.round(vh), top: Math.round(top), kb }
+  return { h: Math.round(Math.min(vh, ih)), top: Math.round(top), kb }
+}
+
+// How far full screen's composer sits outside what you can see (the visual viewport, in the same
+// page coordinates as getBoundingClientRect): > 0 means move it up by that much, < 0 down, 0 it's in view.
+// rect: the composer's { top, bottom }; vv: { height, offsetTop }.
+export function outOfView(rect, vv, slack = 1) {
+  if (!rect || !vv || !(Number(vv.height) > 0)) return 0
+  const top = Number(vv.offsetTop) || 0, bottom = top + Number(vv.height)
+  if (rect.bottom > bottom + slack) return Math.round(Math.min(rect.bottom - bottom, rect.top - top)) // below the keyboard's edge (never past its own top)
+  if (rect.top < top - slack) return -Math.round(top - rect.top) // above the top of what you can see
+  return 0
 }
 
 // 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 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