@cplieger/web-terminal-ui 5.4.3 → 5.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/web-terminal-ui",
-  "version": "5.4.3",
+  "version": "5.4.5",
   "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

@@ -233,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
@@ -246,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);
       });
@@ -738,26 +744,58 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
       // name, `list()` reports the real name, and clearing the progress needs no
       // cleanup — the next paint simply stops adding it.
       function relabelAll(): void {
-        // Count only real (non-fallback) labels, so multiple untitled tabs all
-        // read "New tab" without a numeric suffix.
-        const counts = new Map<string, number>();
+        // De-duplicate identical labels with a "(k)" suffix, numbered by the session's
+        // AGE — never by its position in the strip.
+        //
+        // The suffix used to be assigned by encounter order while walking tabList, which
+        // made it a property of the SLOT: two tabs both called "workspace" always read
+        // "workspace" then "workspace (2)" whichever way round they sat, so the label
+        // text stayed put while the sessions moved underneath it. Dragging one of them
+        // changed nothing on screen, and the reorder — which had worked correctly all
+        // along, server included — was invisible. It also meant dragging tab A could
+        // renumber tab B, which is the clearest sign the number belonged to the wrong
+        // thing.
+        //
+        // A label answers "which session is this", so it has to be a property of the
+        // session: stable while other tabs move, and travelling with its own tab. Age is
+        // that key. createdAt (the server's, tie-broken by id) rather than the local
+        // `born` counter, so every device and every reload agrees on which "workspace"
+        // is (2) — `born` is adoption order, which races.
+        //
+        // Numbering is recomputed over the LIVE group each time, so it stays contiguous:
+        // closing "(2)" of three renumbers the survivor rather than leaving a hole. That
+        // is a renumber with a visible cause the user just performed, which is the one
+        // kind that reads as sensible.
+        const groups = new Map<string, Tab[]>();
         for (const t of tabList) {
           const { text, fallback } = baseLabel(t);
-          if (!fallback) {
-            counts.set(text, (counts.get(text) ?? 0) + 1);
+          // Fallback labels are not real names: several untitled tabs all read
+          // "New tab" with no numbering, which is the pre-existing behaviour.
+          if (fallback) {
+            continue;
+          }
+          const group = groups.get(text);
+          if (group) {
+            group.push(t);
+          } else {
+            groups.set(text, [t]);
           }
         }
-        const seen = new Map<string, number>();
-        for (const t of tabList) {
-          const { text, fallback } = baseLabel(t);
-          let display = text;
-          if (!fallback && (counts.get(text) ?? 0) > 1) {
-            const k = (seen.get(text) ?? 0) + 1;
-            seen.set(text, k);
-            if (k > 1) {
-              display = `${text} (${String(k)})`;
-            }
+        const ordinals = new Map<Tab, number>();
+        for (const group of groups.values()) {
+          if (group.length < 2) {
+            continue; // nothing to disambiguate from, so no suffix at all
           }
+          [...group]
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id))
+            .forEach((t, i) => {
+              ordinals.set(t, i + 1);
+            });
+        }
+        for (const t of tabList) {
+          const { text } = baseLabel(t);
+          const k = ordinals.get(t);
+          const display = k !== undefined && k > 1 ? `${text} (${String(k)})` : text;
           t.display = display;
           t.label.textContent = display;
           // The accessible name carries the state and the percentage as well as

package/src/features/tabs/strip.ts

@@ -31,7 +31,7 @@ import { statusPhrase, statusRevealsDot } from "./model.js";
  *  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;
+export const REORDER_STILL_MS = 50;
 
 /** 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