@steve31415/baselib 3.38.1 → 3.39.1

package/dist/bin/pw-deploy.js

@@ -3,12 +3,14 @@
 // ~/migration/research/deploy-procedure-design.md). All logic lives in
 // ../deploy/deploy.ts; configuration is the app's deploy.config.json.
 //
-// process.exit (not exitCode) so an in-flight Cloud Build child cannot keep
-// a failed deploy's process alive; the server-side build finishes on its own
-// and is reused by the next attempt.
+// An explicit exit (not exitCode) so an in-flight Cloud Build child cannot
+// keep a failed deploy's process alive; the server-side build finishes on its
+// own and is reused by the next attempt. exitWhenFlushed lets the output
+// already written reach a piped reader (Coder captures it) first.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { realRunner } from '../deploy/exec.js';
 import { runDeploy } from '../deploy/deploy.js';
-process.exit(await runDeploy({
+await exitWhenFlushed(await runDeploy({
     repoRoot: process.cwd(),
     runner: realRunner,
     argv: process.argv.slice(2),

package/dist/bin/pw-logs.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // `pw-logs` — Axiom log query (OPERATIONS.md "Investigating production
 // state"). All logic lives in ../ops/logs.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { runLogs } from '../ops/logs.js';
-process.exit(await runLogs({ argv: process.argv.slice(2), cwd: process.cwd() }));
+await exitWhenFlushed(await runLogs({ argv: process.argv.slice(2), cwd: process.cwd() }));

package/dist/bin/pw-rollback.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 // `pw-rollback` — one-command traffic move to a previously released build.
 // All logic lives in ../deploy/rollback.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { realRunner } from '../deploy/exec.js';
 import { runRollback } from '../deploy/rollback.js';
-process.exit(await runRollback({
+await exitWhenFlushed(await runRollback({
     repoRoot: process.cwd(),
     runner: realRunner,
     argv: process.argv.slice(2),

package/dist/bin/pw-sql.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // `pw-sql` — read-only production SQL (OPERATIONS.md "Investigating
 // production state"). All logic lives in ../ops/sql.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { runSql } from '../ops/sql.js';
-process.exit(await runSql({ argv: process.argv.slice(2), cwd: process.cwd() }));
+await exitWhenFlushed(await runSql({ argv: process.argv.slice(2), cwd: process.cwd() }));

package/dist/bin/release.js

@@ -2,6 +2,7 @@
 // baselib's `npm run deploy` — release the checked-out version (tag push +
 // wait for the registry; the tag-triggered workflow does the actual
 // publish). All logic lives in ../release.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { realRunner } from '../deploy/exec.js';
 import { release } from '../release.js';
 try {
@@ -12,5 +13,5 @@ try {
 }
 catch (e) {
     console.error(e instanceof Error ? e.message : String(e));
-    process.exit(1);
+    await exitWhenFlushed(1);
 }

package/dist/ops/cli.d.ts

@@ -13,4 +13,16 @@ type Parsed<T extends Options> = ReturnType<typeof parseArgs<{
 export declare function parseCli<T extends Options>(argv: string[], options: T, usage: string, io: CliIo): Parsed<T> | {
     code: number;
 };
+/**
+ * `process.exit(code)` once stdout and stderr have handed everything written
+ * to them to the OS. A plain process.exit discards what a pipe has not yet
+ * taken: Node writes to a pipe asynchronously once its buffer (64 KiB on
+ * Linux) is full, so `pw-logs … | jq` lost all but the first 64 KiB, with
+ * exit status 0 (2026-10-26). Files and terminals are written synchronously,
+ * which is why redirecting to a file never showed it. Still an explicit exit,
+ * not `exitCode`: nothing else the bin started (a connection pool, a Cloud
+ * Build child) may keep it alive. A reader that goes away (`| head`) ends the
+ * wait instead of crashing the bin on EPIPE.
+ */
+export declare function exitWhenFlushed(code: number, streams?: NodeJS.WritableStream[], exit?: (code: number) => void): Promise<void>;
 export {};

package/dist/ops/cli.js

@@ -25,3 +25,29 @@ export function parseCli(argv, options, usage, io) {
     }
     return parsed;
 }
+/**
+ * `process.exit(code)` once stdout and stderr have handed everything written
+ * to them to the OS. A plain process.exit discards what a pipe has not yet
+ * taken: Node writes to a pipe asynchronously once its buffer (64 KiB on
+ * Linux) is full, so `pw-logs … | jq` lost all but the first 64 KiB, with
+ * exit status 0 (2026-10-26). Files and terminals are written synchronously,
+ * which is why redirecting to a file never showed it. Still an explicit exit,
+ * not `exitCode`: nothing else the bin started (a connection pool, a Cloud
+ * Build child) may keep it alive. A reader that goes away (`| head`) ends the
+ * wait instead of crashing the bin on EPIPE.
+ */
+export async function exitWhenFlushed(code, streams = [process.stdout, process.stderr], exit = (c) => process.exit(c)) {
+    await Promise.all(streams.map(flushed));
+    exit(code);
+}
+function flushed(stream) {
+    return new Promise((resolve) => {
+        // A broken pipe is reported to the write callback and then, a tick
+        // later, as an 'error' event, which would crash the process if nothing
+        // listened — so the listener stays until the exit.
+        stream.on('error', () => resolve());
+        // Writes complete in order, so an empty write's callback runs only after
+        // everything written before it has gone out.
+        stream.write('', () => resolve());
+    });
+}

package/dist/sync/engine.js

@@ -1,5 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { SyncError, } from './types.js';
+// Past this many events a client is told to reload (a full bootstrap)
+// rather than catch up. Deliberate (2026-10-20, task 1e2cd274): a todo page
+// 138 events behind resynced as designed; the fault was its cached, stale
+// bootstrap, fixed in the app (no-store), not this limit.
 const DEFAULT_CATCHUP_LIMIT = 100;
 const DEFAULT_RETENTION_DAYS = 7;
 const IDENTIFIER = /^[a-z_][a-z0-9_]*$/;

package/dist/sync-browser/client.d.ts

@@ -154,6 +154,9 @@ export declare class SyncClient<B, C extends EventBody, S extends EventBody, Sum
      * after the bootstrap installs. Non-null exactly while reconciling. */
     private gapBuffer;
     private resyncBackoffTimer;
+    /** The backstop retry after a failed resync. Unlike the loop backoff it
+     * absorbs nothing: a fresh reload request runs at once and cancels it. */
+    private resyncFailureTimer;
     private loopEscalated;
     private reconciliationTail;
     private initialization;
@@ -302,6 +305,8 @@ export declare class SyncClient<B, C extends EventBody, S extends EventBody, Sum
      * cycle every reconcile succeeds. */
     private endResyncEpisode;
     private scheduleResyncRetry;
+    private scheduleResyncFailureRetry;
+    private cancelResyncFailureRetry;
     private sendConnect;
     private sendRaw;
     private trySend;

package/dist/sync-browser/client.js

@@ -1,6 +1,9 @@
 import { FirstLoadRetry } from './first-load-retry.js';
 const RECONNECT_DELAYS_SECONDS = [1, 2, 4, 8, 16, 30];
 const PING_INTERVAL_MS = 30_000;
+// Deliberate (2026-10-20 review, task 1e2cd274): todo's phone hit it 27
+// times in 25 minutes on 10-19, but none of those handshakes ever reached
+// the load balancer, so a longer limit would only have delayed the retry.
 const CONNECT_WATCHDOG_MS = 10_000;
 const DEFAULT_RECONNECT_BEFORE_MS = 55 * 60 * 1000;
 const FAILURE_TIMEOUT_MS = 60_000;
@@ -89,6 +92,9 @@ export class SyncClient {
      * after the bootstrap installs. Non-null exactly while reconciling. */
     gapBuffer = null;
     resyncBackoffTimer = null;
+    /** The backstop retry after a failed resync. Unlike the loop backoff it
+     * absorbs nothing: a fresh reload request runs at once and cancels it. */
+    resyncFailureTimer = null;
     loopEscalated = false;
     reconciliationTail = Promise.resolve();
     initialization = null;
@@ -647,7 +653,8 @@ export class SyncClient {
             }
             const planned = this.plannedClose === socket;
             this.plannedClose = null;
-            this.startOutage(event.code, event.wasClean === true);
+            const openForMs = this.socketOpenedAt === null ? null : Math.max(0, this.now() - this.socketOpenedAt);
+            this.startOutage(event.code, event.wasClean === true, openForMs);
             if (!this.isHidden()) {
                 this.noteReturnFailure(event.code);
                 this.scheduleReconnect();
@@ -972,7 +979,7 @@ export class SyncClient {
             void this.probeSession();
         }
     }
-    startOutage(closeCode, wasClean = false) {
+    startOutage(closeCode, wasClean = false, openForMs = null) {
         if (this.outageStartedAt !== null)
             return;
         // A sleep or freeze that ended in this close happened before the outage
@@ -982,7 +989,7 @@ export class SyncClient {
         this.outageStartedAt = this.options.runtime.now();
         this.outageEscalated = false;
         this.outageCloseCode = closeCode;
-        this.outageInfo = { closeCode, wasClean, visibleAtDrop: !this.isHidden(), counters: this.snapshot() };
+        this.outageInfo = { closeCode, wasClean, openForMs, visibleAtDrop: !this.isHidden(), counters: this.snapshot() };
         this.armEscalation();
     }
     /** ERROR only after OUTAGE_ESCALATE_MS of visible, on-time outage; re-armed
@@ -1002,6 +1009,7 @@ export class SyncClient {
                     durationMs: this.options.runtime.now() - this.outageStartedAt,
                     closeCode: this.outageCloseCode,
                     attempts: this.reconnectAttempts,
+                    openForMs: this.outageInfo?.openForMs ?? null,
                 });
             }
         }, OUTAGE_ESCALATE_MS);
@@ -1327,6 +1335,7 @@ export class SyncClient {
                 totalAttempts: this.totalAttempts,
                 closeCode: info?.closeCode,
                 wasClean: info?.wasClean,
+                openForMs: info ? info.openForMs : undefined,
                 visibleAtDrop: info?.visibleAtDrop,
                 hiddenMs: delta?.hiddenMs,
                 stalledMs: delta?.stalledMs,
@@ -1387,6 +1396,7 @@ export class SyncClient {
     async resyncFromServer(reason) {
         if (this.refetchInFlight || this.halted || this.disposed)
             return;
+        this.cancelResyncFailureRetry();
         const now = this.options.runtime.now();
         // `time <= now` drops entries stranded in the future by a backward
         // clock jump, which would otherwise pin the detector tripped.
@@ -1420,7 +1430,17 @@ export class SyncClient {
         }
         catch (error) {
             if (!isLifecycleAbort(error) && !this.disposed && !this.halted) {
-                this.options.logger.error('resync failed', { reason, error });
+                // As for the first bootstrap: fetch's TypeError means no HTTP answer
+                // reached the page (the device's network), a WARN; an answer that was
+                // an error is the server's, an ERROR. Either way the store may be
+                // stale, so a retry is scheduled rather than left to the next reload
+                // message or sequence gap, which a quiet page may never get.
+                const reachedServer = !(error instanceof TypeError);
+                if (reachedServer)
+                    this.options.logger.error('resync failed', { reason, reachedServer, error });
+                else
+                    this.options.logger.warn('resync failed', { reason, reachedServer, error });
+                this.scheduleResyncFailureRetry();
             }
         }
         finally {
@@ -1472,6 +1492,23 @@ export class SyncClient {
             void this.resyncFromServer('retry after resync backoff');
         }, RESYNC_RETRY_MS);
     }
+    scheduleResyncFailureRetry() {
+        if (this.resyncFailureTimer !== null || this.halted || this.disposed)
+            return;
+        this.resyncFailureTimer = this.setTimer(() => {
+            this.resyncFailureTimer = null;
+            // Hidden: no minutely retry (a phone without network would log one a
+            // minute); the return's HTTP catch-up re-triggers the resync.
+            if (this.isHidden())
+                return;
+            void this.resyncFromServer('retry after failed resync');
+        }, RESYNC_RETRY_MS);
+    }
+    cancelResyncFailureRetry() {
+        if (this.resyncFailureTimer !== null)
+            this.options.runtime.clearTimeout(this.resyncFailureTimer);
+        this.resyncFailureTimer = null;
+    }
     sendConnect() {
         this.sendRaw({
             type: 'connect',
@@ -1600,6 +1637,7 @@ export class SyncClient {
             this.options.runtime.clearTimeout(this.escalateTimer);
         if (this.resyncBackoffTimer !== null)
             this.options.runtime.clearTimeout(this.resyncBackoffTimer);
+        this.cancelResyncFailureRetry();
         for (const timer of this.failureTimers.values())
             this.options.runtime.clearTimeout(timer);
         this.cancelBackgroundTick();

package/package.json

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