@cplieger/web-terminal-ui 5.4.2 → 5.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/web-terminal-ui",
-  "version": "5.4.2",
+  "version": "5.4.4",
   "type": "module",
   "description": "Reference touch-first browser UI for @cplieger/web-terminal-engine: a composable kernel + feature modules (tabs, activity monitor, mobile toolbar, context menu, IME, predictive echo, viewport handling) and CSS. One createTerminal() call.",
   "license": "MPL-2.0",

package/src/features/tabs/index.ts

@@ -45,6 +45,7 @@ import { browserNotifierEnv, createNotifier } from "./notify.js";
 import {
   REORDER_MOVE_EPS_PX,
   REORDER_REST_MS,
+  REORDER_STILL_MS,
   REORDER_SETTLE_MS,
   REORDER_SHIFT_TRANS,
   REORDER_SLOT_FADE_MS,
@@ -232,11 +233,17 @@ async function createSessionHonouringRetry(
       // First refusal always speaks; after that only every
       // CREATE_RETRY_REANNOUNCE_MS, so a multi-minute wait is neither silent nor
       // a toast storm.
+      //
+      // The suffix says the page is WAITING, not recovering from a failure. It
+      // used to say "retrying", which read as an error loop when the server had
+      // only said "not yet" -- and the first announcement fires before any retry
+      // has happened at all, so a user two seconds into a boot was told
+      // "retrying" about a request that had been made exactly once.
       if (lastAnnouncedAt === 0 || elapsed - lastAnnouncedAt >= CREATE_RETRY_REANNOUNCE_MS) {
         lastAnnouncedAt = elapsed;
-        const waiting = err.serverMessage ?? "Server is not ready yet";
-        ctx.toast(`${waiting}; retrying`, 8000);
-        ctx.announce(`${waiting}; retrying`);
+        const reason = err.serverMessage ?? "Server is not ready yet";
+        ctx.toast(`${reason}; waiting…`, 8000);
+        ctx.announce(`${reason}; waiting…`);
       }
       // Separate from the throttled pair above, and unthrottled: this writes the
       // reason onto the loading OVERLAY, which is the only surface a user can
@@ -245,7 +252,7 @@ async function createSessionHonouringRetry(
       // stacking notifications, so there is no storm to throttle, and repeating
       // the same string is idempotent. This is what turns the black screen of a
       // twenty-minute tools install into a screen that says why it is waiting.
-      ctx.loadingReason(`${err.serverMessage ?? "Server is not ready yet"} — retrying…`);
+      ctx.loadingReason(`${err.serverMessage ?? "Server is not ready yet"}; waiting…`);
       await new Promise((resolve) => {
         window.setTimeout(resolve, err.retryAfterMs ?? CREATE_RETRY_FALLBACK_MS);
       });
@@ -679,6 +686,9 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
       let restTimer: ReturnType<typeof setTimeout> | null = null;
       let restBefore: HTMLElement | null = null;
       let restX: number | null = null;
+      // When the pointer last actually MOVED. A stationary dragover this long after it
+      // is believed as a stop (see trackRest).
+      let restMovedAt = 0;
       // Whether a `drop` fired for the drag in flight. It is the exact signal for
       // "the user released deliberately" as opposed to "the drag was abandoned":
       // Escape and a refused release fire dragend with no drop at all. dragend
@@ -1943,12 +1953,19 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
       // travelling pointer rearranges nothing at all; the moment it comes to REST the
       // slot opens.
       //
-      // Rest is detected, not waited out: the timer is re-armed by MOVEMENT, so it
-      // expires a rest window after the last movement rather than a fixed time after a
-      // decision. The window has a hard FLOOR set by the platform rather than by taste —
-      // HTML5 drag-and-drop only guarantees a `dragover` every 350ms, so a window at or
-      // below that cadence expires between two events of a fast sweep and commits every
-      // slot the pointer crosses (see REORDER_REST_MS).
+      // Rest is detected from TWO signals, and separating them is what lets the slot
+      // open promptly without a fast sweep committing every slot it crosses:
+      //
+      //  - a `dragover` at an unchanged position is POSITIVE evidence of a stop, so it
+      //    commits after a short REORDER_STILL_MS confirmation. This is the signal that
+      //    normally decides, and the reason the delay is short.
+      //  - the absence of events is only a FALLBACK (armRestNet), for a browser that
+      //    stops delivering dragover entirely. That one has to out-wait the drag loop's
+      //    350ms cadence, so it is long — and it is rarely what decides.
+      //
+      // One quiet window had to serve both jobs before this, which is why it could not be
+      // shortened: the timer deciding responsiveness was the same one that had to survive
+      // the cadence.
       function trackRest(clientX: number): void {
         const dragged = draggingEl;
         if (!dragged) {
@@ -1964,21 +1981,39 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
           return;
         }
         restBefore = before;
-        // Movement pushes the commit out; stillness lets the armed timer run down to it.
-        // A stationary pointer that has nothing armed still needs one — a browser may
-        // deliver dragover repeatedly at an unchanged position, and the first of those is
-        // the only signal that the pointer arrived and stopped.
-        if (moved || restTimer === null) {
-          if (restTimer !== null) {
-            clearTimeout(restTimer);
-          }
-          restTimer = setTimeout(() => {
-            restTimer = null;
-            const target = restBefore;
-            restBefore = null;
-            commitSlot(target);
-          }, REORDER_REST_MS);
+        const now = Date.now();
+        if (moved) {
+          // Still travelling. Push the net out and wait.
+          restMovedAt = now;
+          armRestNet();
+          return;
+        }
+        // A dragover at an UNCHANGED position is positive evidence that the pointer has
+        // stopped, which is a far stronger signal than the absence of events — and it is
+        // what lets the slot open promptly instead of out-waiting the drag loop's 350ms
+        // cadence. The elapsed check filters the coincidence where one event of a sweep
+        // lands within REORDER_MOVE_EPS_PX of the previous (a reversal, or a frame whose
+        // motion was almost all vertical); a real stop clears it on the next event.
+        if (now - restMovedAt >= REORDER_STILL_MS) {
+          flushRest();
+          return;
         }
+        armRestNet(); // too soon to believe; keep the net alive
+      }
+      // armRestNet is the no-events fallback: if dragover stops arriving altogether, no
+      // stationary event will ever confirm the stop, so this commits anyway. Sized to
+      // out-wait the cadence (see REORDER_REST_MS) because it is the one timer that a
+      // fast sweep could otherwise expire between two of its own events.
+      function armRestNet(): void {
+        if (restTimer !== null) {
+          clearTimeout(restTimer);
+        }
+        restTimer = setTimeout(() => {
+          restTimer = null;
+          const target = restBefore;
+          restBefore = null;
+          commitSlot(target);
+        }, REORDER_REST_MS);
       }
       function cancelRest(): void {
         if (restTimer === null) {

package/src/features/tabs/strip.ts

@@ -21,24 +21,35 @@ import { statusPhrase, statusRevealsDot } from "./model.js";
 // motion is spelled in — index.ts owns the mechanism, strip.ts owns the values,
 // the same split switcher.ts keeps for the mobile swipe.
 
-/** The quiet window (ms) that means the pointer has STOPPED. When it elapses with no
- *  movement, the strip opens the slot the pointer is over.
+/** How long (ms) the pointer must have been un-moved before a stationary `dragover` is
+ *  believed as "stopped".
  *
- *  This is a rest detector, not a hold: it is re-armed by MOVEMENT, so it expires a
- *  rest window after the last movement rather than a fixed time after a decision.
- *  Sweeping the strip rearranges nothing; stopping is what commits.
+ *  This is the number that decides how fast the slot opens, and it is small because a
+ *  `dragover` at an UNCHANGED position is positive evidence of rest — far better
+ *  evidence than the absence of events, which is all the fallback below has. The drag
+ *  loop keeps delivering events while the pointer is held still, so a genuinely stopped
+ *  pointer announces itself; this only filters the coincidence where one event of a
+ *  sweep happens to land within REORDER_MOVE_EPS_PX of the previous one (a direction
+ *  reversal, or a frame where the motion was almost entirely vertical). */
+export const REORDER_STILL_MS = 90;
+
+/** Fallback guard (ms): commit the pending slot this long after the last MOVEMENT, for
+ *  the case where `dragover` stops arriving altogether and no stationary event ever
+ *  confirms the stop.
  *
- *  **The floor is set by the drag loop, not by taste.** HTML5 drag-and-drop only
- *  guarantees a `dragover` every 350ms — the processing model runs on that cadence,
- *  not per mouse movement — so any window at or below it expires BETWEEN two events
- *  of a fast sweep, and the strip commits every slot the pointer crosses. That is
- *  exactly what 120ms did in production: a quick pass over five tabs moved all five.
- *  500ms clears the cadence with margin and is the reason this number is not smaller.
+ *  **Its floor is set by the platform, not by taste, and this is the timer that floor
+ *  applies to.** HTML5 drag-and-drop only guarantees a `dragover` every 350ms — the drag
+ *  loop runs on that cadence, not per mouse movement — so a guard at or below it can
+ *  expire BETWEEN two events of a fast sweep, and the strip then commits every slot the
+ *  pointer crosses. Measured in production: at 120ms a quick pass over five tabs moved
+ *  all five.
  *
- *  It costs a decisive user nothing, which is what makes the margin affordable: a
- *  release commits whatever slot is pending at once (flushRest), so the window is only
- *  ever felt by a pointer that has stopped and is waiting to see the gap open. */
-export const REORDER_REST_MS = 500;
+ *  A pure quiet-window design has to make this ONE number carry both jobs, which is why
+ *  it could not be shortened — the same timer that decides responsiveness was the one
+ *  that had to out-wait the cadence, so 500ms was safe and felt slow. Splitting rest
+ *  DETECTION (the stationary event above) from the no-events NET (here) lets each be
+ *  sized for its own job. This one is rarely the deciding signal at all. */
+export const REORDER_REST_MS = 450;
 
 /** Movement (px) between two dragover events below which the pointer counts as still.
  *  A hand resting on a mouse is never perfectly still, and treating a 1px tremor as a