@steve31415/baselib 3.21.0 → 3.23.0

package/dist/app-update-browser/build-update.d.ts

@@ -26,8 +26,17 @@ export interface BuildUpdateDeps {
     reload?: () => void;
     pollMs?: number;
     onTrafficBuildChange?: (buildId: string) => void;
+    /** Whether this document's HTML came from the browser cache without a
+     * request (default: `shellServedFromCache`). */
+    shellFromCache?: () => boolean;
 }
 export declare function pageBuildId(): string;
+/** True when this page's HTML was served from the browser cache without
+ * reaching the server. Android Chrome does this when it restores a tab whose
+ * renderer it killed in the background, even for a `no-cache` shell, so the
+ * restored page can run a build older than current traffic (reader,
+ * 2026-09-26/27: 9 of 15 phone page loads). */
+export declare function shellServedFromCache(): boolean;
 export declare class BuildUpdateMonitor {
     private deps;
     private state;
@@ -40,8 +49,10 @@ export declare class BuildUpdateMonitor {
     private appliedRequestNumber;
     private trafficBuild;
     private checkFailure;
-    /** When the page last went from hidden to visible (not page load). */
+    /** When the page last went from hidden to visible, or was loaded visible
+     * from a cached shell (a restored tab is a return in all but name). */
     private returnedAt;
+    private restoredFromCache;
     private deferUntilHidden;
     constructor(deps: BuildUpdateDeps);
     getState: () => BuildUpdateState;

package/dist/app-update-browser/build-update.js

@@ -12,6 +12,19 @@ const LEGACY_BUILD = 'legacy-pre-build-id';
 export function pageBuildId() {
     return document.querySelector('meta[name="pw-build-id"]')?.content || 'development';
 }
+/** True when this page's HTML was served from the browser cache without
+ * reaching the server. Android Chrome does this when it restores a tab whose
+ * renderer it killed in the background, even for a `no-cache` shell, so the
+ * restored page can run a build older than current traffic (reader,
+ * 2026-09-26/27: 9 of 15 phone page loads). */
+export function shellServedFromCache() {
+    const entry = globalThis.performance?.getEntriesByType?.('navigation')[0];
+    if (!entry)
+        return false;
+    if (entry.deliveryType === 'cache')
+        return true;
+    return entry.transferSize === 0 && entry.decodedBodySize > 0;
+}
 export class BuildUpdateMonitor {
     deps;
     state = { kind: 'current' };
@@ -24,8 +37,10 @@ export class BuildUpdateMonitor {
     appliedRequestNumber = 0;
     trafficBuild = null;
     checkFailure = false;
-    /** When the page last went from hidden to visible (not page load). */
+    /** When the page last went from hidden to visible, or was loaded visible
+     * from a cached shell (a restored tab is a return in all but name). */
     returnedAt = null;
+    restoredFromCache = false;
     deferUntilHidden = false;
     constructor(deps) {
         this.deps = deps;
@@ -41,6 +56,13 @@ export class BuildUpdateMonitor {
         this.started = true;
         this.lifecycle += 1;
         this.stopSafety = this.deps.safety.subscribe(() => this.maybeReload());
+        // A tab restored from the cache shows whatever build it last loaded; a
+        // reload now would replace it just as it appears. Treat it as a return.
+        // (A hidden restore needs nothing: its reload is out of sight anyway.)
+        if (document.visibilityState === 'visible' && (this.deps.shellFromCache ?? shellServedFromCache)()) {
+            this.returnedAt = Date.now();
+            this.restoredFromCache = true;
+        }
         if (document.visibilityState === 'visible')
             this.startPolling();
         document.addEventListener('visibilitychange', this.onVisibility);
@@ -145,6 +167,7 @@ export class BuildUpdateMonitor {
                     pageBuildId: this.deps.currentBuildId,
                     observedBuildId: buildId,
                     sinceReturnMs: Date.now() - (this.returnedAt ?? Date.now()),
+                    restoredFromCache: this.restoredFromCache,
                 });
             }
         }
@@ -191,6 +214,7 @@ export class BuildUpdateMonitor {
     onVisibility = () => {
         if (document.visibilityState === 'visible') {
             this.returnedAt = Date.now();
+            this.restoredFromCache = false;
             this.startPolling();
             void this.checkNow();
         }

package/dist/log-browser.js

@@ -31,6 +31,12 @@ export function createBrowserLogger(opts = {}) {
             // remains best-effort, so a browser give-up is only console-noted.
             batchSize: 20,
             fetchInit: { keepalive: true },
+            // Browser logs have no stdout backstop, and the ERRORs most worth
+            // keeping are often the ones an offline stretch causes: while the
+            // browser reports itself offline, failed attempts don't count, so a
+            // batch waits out the outage (until the page dies or the buffer cap
+            // evicts it) instead of being dropped after ~60 s.
+            isOffline: () => navigator.onLine === false,
             onGiveUp: (batch, error, reason) => console.warn(`log ship dropped a batch (${reason}): ${String(error)}`, {
                 batch_id: batch.id,
                 events: batch.events.length,
@@ -66,6 +72,7 @@ export function createBrowserLogger(opts = {}) {
     // Ship what's pending whenever the page may be going away.
     const flushNow = () => void logger.flush();
     addEventListener('pagehide', flushNow);
+    addEventListener('online', () => shipper?.resume());
     document.addEventListener('visibilitychange', () => {
         if (document.visibilityState === 'hidden')
             flushNow();

package/dist/log-core.d.ts

@@ -67,6 +67,13 @@ export interface ShipperOptions {
     fetchFn?: typeof fetch;
     /** Extra fetch options (browser sets keepalive). */
     fetchInit?: RequestInit;
+    /** True while the platform knows it has no network (the browser passes
+     *  `navigator.onLine === false`). A failed attempt made while offline says
+     *  nothing about the batch or the ingest service, so it is not counted
+     *  toward maxAttempts and not reported: the batch waits and retries at the
+     *  longest backoff delay, or at once on resume(). The signal only decides
+     *  what a failure means — attempts still run while "offline". */
+    isOffline?: () => boolean;
     /** A delivery attempt failed; the batch will be retried. */
     onAttemptFailure?: (batch: ShippedBatch, error: unknown) => void;
     /** The batch is abandoned — its events will never reach Axiom. */
@@ -101,6 +108,9 @@ export declare class LogShipper {
      *  — raced with one attempt timeout, so it is bounded even when the pump
      *  is busy with older batches. */
     flush(): Promise<void>;
+    /** Retry every waiting batch now, ahead of its backoff — the browser
+     *  calls this when it comes back online. */
+    resume(): void;
     /** Shutdown path: one parallel last-chance attempt for everything
      *  undelivered, then a sweep that marks the rest dropped. Single-flight
      *  while in flight (racing SIGTERM callers join one promise), but re-arms

package/dist/log-core.js

@@ -111,6 +111,13 @@ export class LogShipper {
             return raceTimeout(Promise.allSettled([...this.inflight]), cap);
         return Promise.resolve();
     }
+    /** Retry every waiting batch now, ahead of its backoff — the browser
+     *  calls this when it comes back online. */
+    resume() {
+        for (const b of this.pending)
+            b.nextAttemptAt = 0;
+        void this.pump();
+    }
     /** Shutdown path: one parallel last-chance attempt for everything
      *  undelivered, then a sweep that marks the rest dropped. Single-flight
      *  while in flight (racing SIGTERM callers join one promise), but re-arms
@@ -229,8 +236,15 @@ export class LogShipper {
             batch.attempting = false;
             if (batch.terminal)
                 return;
-            batch.attempt++;
             batch.settleFirst();
+            if (!outcome.ok && !outcome.terminal && this.opts.isOffline?.()) {
+                // Uncounted: the budget is for failures that could be the batch's
+                // or the service's, and an offline failure is neither.
+                batch.nextAttemptAt = Date.now() + this.retryDelaysMs[this.retryDelaysMs.length - 1];
+                this.schedulePump();
+                return;
+            }
+            batch.attempt++;
             if (outcome.ok) {
                 this.remove(batch);
                 if (outcome.failed > 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.21.0",
+  "version": "3.23.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",