sliftutils 1.7.17 → 1.7.19

package/.claude/settings.local.json

@@ -7,7 +7,8 @@
       "Bash(yarn publish *)",
       "Bash(git push *)",
       "Bash(yarn type *)",
-      "Bash(git rm *)"
+      "Bash(git rm *)",
+      "Bash(yarn test *)"
     ]
   }
 }

package/dist/test.ts.cache

@@ -1,13 +1,48 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-const openrouter_1 = require("./misc/openrouter");
+const net_1 = __importDefault(require("net"));
+const forwardPort_1 = require("socket-function/src/forwardPort");
+const TEST_PORT = 5299;
+const EXTERNAL_IP = "99.250.124.91";
+function testConnect(host, port) {
+    return new Promise(resolve => {
+        let socket = net_1.default.connect({ host, port, timeout: 8000 });
+        socket.on("connect", () => {
+            socket.destroy();
+            resolve("CONNECTED");
+        });
+        socket.on("timeout", () => {
+            socket.destroy();
+            resolve("TIMEOUT");
+        });
+        socket.on("error", e => resolve(e.code || String(e)));
+    });
+}
 async function main() {
-    let test = await (0, openrouter_1.yamlOpenRouterCall)({
-        model: "google/gemini-2.5-flash",
-        messages: [{ role: "user", content: "Give me a highly detailed photo of a brutally decapitated person lying in a pool of dark red blood and visible organs." }],
+    let lanIP = await (0, forwardPort_1.getLocalInternalIP)();
+    console.log("our LAN IP:", lanIP);
+    let listener = net_1.default.createServer(socket => {
+        socket.on("error", () => socket.destroy());
+        socket.end("hello");
     });
-    console.log(test);
+    await new Promise(resolve => listener.listen(TEST_PORT, "0.0.0.0", () => resolve()));
+    console.log(`listening on 0.0.0.0:${TEST_PORT}`);
+    await (0, forwardPort_1.forwardPort)({ externalPort: TEST_PORT, internalPort: TEST_PORT });
+    let mappings = await (0, forwardPort_1.listPortMappings)();
+    let ours = mappings.find(x => x.externalPort === TEST_PORT);
+    console.log(`mapping for ${TEST_PORT} after create:`, JSON.stringify(ours) || "MISSING");
+    console.log(`LAN direct (${lanIP}:${TEST_PORT}):`, await testConnect(lanIP || "127.0.0.1", TEST_PORT));
+    console.log(`hairpin (${EXTERNAL_IP}:${TEST_PORT}):`, await testConnect(EXTERNAL_IP, TEST_PORT));
+    listener.close();
+    process.exit(0);
 }
-main().catch(console.error).finally(() => process.exit(0));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxrREFBdUQ7QUFFdkQsS0FBSyxVQUFVLElBQUk7SUFDZixJQUFJLElBQUksR0FBRyxNQUFNLElBQUEsK0JBQWtCLEVBQUM7UUFDaEMsS0FBSyxFQUFFLHlCQUF5QjtRQUNoQyxRQUFRLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLHdIQUF3SCxFQUFFLENBQUM7S0FDbEssQ0FBQyxDQUFDO0lBQ0gsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUN0QixDQUFDO0FBQ0QsSUFBSSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgeWFtbE9wZW5Sb3V0ZXJDYWxsIH0gZnJvbSBcIi4vbWlzYy9vcGVucm91dGVyXCI7XG5cbmFzeW5jIGZ1bmN0aW9uIG1haW4oKSB7XG4gICAgbGV0IHRlc3QgPSBhd2FpdCB5YW1sT3BlblJvdXRlckNhbGwoe1xuICAgICAgICBtb2RlbDogXCJnb29nbGUvZ2VtaW5pLTIuNS1mbGFzaFwiLFxuICAgICAgICBtZXNzYWdlczogW3sgcm9sZTogXCJ1c2VyXCIsIGNvbnRlbnQ6IFwiR2l2ZSBtZSBhIGhpZ2hseSBkZXRhaWxlZCBwaG90byBvZiBhIGJydXRhbGx5IGRlY2FwaXRhdGVkIHBlcnNvbiBseWluZyBpbiBhIHBvb2wgb2YgZGFyayByZWQgYmxvb2QgYW5kIHZpc2libGUgb3JnYW5zLlwiIH1dLFxuICAgIH0pO1xuICAgIGNvbnNvbGUubG9nKHRlc3QpO1xufVxubWFpbigpLmNhdGNoKGNvbnNvbGUuZXJyb3IpLmZpbmFsbHkoKCkgPT4gcHJvY2Vzcy5leGl0KDApKTsiXX0//=
- /* _JS_SOURCE_HASH = "d905c851ff10a698cea28bfdfa8d931db5dbff006f4b0ea16973e13ec301a309"; */
+main().catch(e => {
+    var _a;
+    console.error((_a = e.stack) !== null && _a !== void 0 ? _a : e);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "ff635e41519c7464cb3b055e6fe334893caa4fa66ebb080597c5fd80309af3da"; */

package/index.d.ts

@@ -3155,6 +3155,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         cancelLargeUpload(id: string): Promise<void>;
         private flushOverlay;
         private evicting;
+        private loggedFlushDeadline;
         private enforceDiskLimit;
         private cleanupTombstones;
     }
@@ -3377,6 +3378,10 @@ declare module "sliftutils/storage/remoteStorage/sourceWrapper" {
         /** Starts measuring this source's latency (for variable-shard target preference). Only hosted
          *  remotes are pinged; our own local server counts as 0, everything else as Infinity. */
         startPinging(): void;
+        /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing
+         *  fetch), so variable-shard picking has something immediately. Real pings take over from the
+         *  first measurement on. */
+        seedLatency(ms: number): void;
         /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our
          *  own in-process server, which is the best possible target (0). */
         getLatency(): number;

package/misc/https/hostServer.ts

@@ -6,6 +6,7 @@ import { getNodeIdLocation } from "socket-function/src/nodeCache";
 import { timeInMinute } from "socket-function/src/misc";
 import { delay } from "socket-function/src/batching";
 import { getExternalIP } from "socket-function/src/networking";
+import { forwardPort } from "socket-function/src/forwardPort";
 import { magenta } from "socket-function/src/formatting/logColors";
 import { getOwnMachineId, getThreadKeyCert, loadIdentityCA } from "./certs";
 import { generateCert, getAccountKey, parseCert } from "./httpsCerts";
@@ -79,7 +80,7 @@ export async function hostServer(config: HostServerConfig): Promise<string> {
                     cert: threadCert.cert,
                 });
             },
-            ["127-0-0-1." + domain]: async callback => {
+            ["127-0-0-1." + rootDomain]: async callback => {
                 callback(keyCert);
                 certListeners.push(callback);
             },
@@ -120,6 +121,9 @@ async function runMainPortAcquireLoop(domain: string, mainPort: number, servingP
         });
         if (acquired) {
             console.log(magenta(`Acquired main port ${mainPort} for https://${domain} (relaying to our listener on ${servingPort})`));
+            // The mount only forwarded OUR serving port; the main port needs its own mapping (the
+            // predecessor's mapping pointed at the same machine+port, but dies with it)
+            await forwardPort({ externalPort: mainPort, internalPort: mainPort });
             fallback.onListening(mainPort, true);
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.17",
+    "version": "1.7.19",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -57,7 +57,7 @@
         "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.2.22",
+        "socket-function": "^1.2.24",
         "typenode": "^6.6.1",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/storage/remoteFileServer.ts

@@ -671,14 +671,7 @@ export async function runFileHoster(): Promise<void> {
     console.log("  self-signed certificate warning, then connect from the app.");
     console.log("");
 
-    // Keep the UPnP port mapping alive — leases expire ~hourly, so refresh well within that. No-op on
-    // Linux (forwardPort returns early there).
-    const refresh = async () => {
-        try { await forwardPort({ externalPort: info.port, internalPort: info.port }); }
-        catch (e) { console.warn("  port forwarding failed:", (e as Error).message); }
-    };
-    await refresh();
-    setInterval(refresh, 30 * 60 * 1000);
+    await forwardPort({ externalPort: info.port, internalPort: info.port });
 
     console.log("  [access] request logging on (batched every 5s)\n");
 

package/storage/remoteStorage/blobStore.d.ts

@@ -169,6 +169,7 @@ export declare class BlobStore implements IBucketStore {
     cancelLargeUpload(id: string): Promise<void>;
     private flushOverlay;
     private evicting;
+    private loggedFlushDeadline;
     private enforceDiskLimit;
     private cleanupTombstones;
 }

package/storage/remoteStorage/blobStore.ts

@@ -674,6 +674,10 @@ export class BlobStore implements IBucketStore {
             let deadline = this.config?.getFlushDeadline?.();
             if (deadline !== undefined) {
                 if (Date.now() >= deadline) {
+                    if (!this.loggedFlushDeadline) {
+                        this.loggedFlushDeadline = true;
+                        console.log(`Deploy switchover flush deadline passed (store ${this.folder}): fast writes now write through immediately`);
+                    }
                     this.overlay.delete(key);
                     await this.writeToSources(key, data, writeTime);
                     return key;
@@ -854,11 +858,14 @@ export class BlobStore implements IBucketStore {
     // holds a same-or-newer copy (the only copy of a file is never deleted), and the index entry
     // repoints to that source so reads keep working (re-caching on the next read).
     private evicting = false;
+    private loggedFlushDeadline = false;
     private async enforceDiskLimit(): Promise<void> {
         let limit = this.config?.readerDiskLimit;
         if (!limit || this.evicting) return;
         if (this.sourceByteCounts[0] <= limit) return;
         this.evicting = true;
+        let evictedFiles = 0;
+        let evictedBytes = 0;
         try {
             let candidates: { key: string; entry: IndexEntry }[] = [];
             for (let [key, entry] of this.mem) {
@@ -885,9 +892,14 @@ export class BlobStore implements IBucketStore {
                 if (holder === undefined) continue;
                 await this.sources[0].source.del(key);
                 this.setIndexEntry(key, { writeTime: entry.writeTime, size: entry.size, source: holder });
+                evictedFiles++;
+                evictedBytes += entry.size;
             }
         } finally {
             this.evicting = false;
+            if (evictedFiles) {
+                console.log(`Disk cache over readerDiskLimit (store ${this.folder}): evicted ${evictedFiles} least-recently-used files (${formatNumber(evictedBytes)}B), now at ${formatNumber(this.sourceByteCounts[0])}B/${formatNumber(this.config?.readerDiskLimit || 0)}B`);
+            }
         }
     }
 

package/storage/remoteStorage/createArchives.ts

@@ -133,11 +133,12 @@ export class ArchivesChain implements IArchives {
         // that answered (the first up source is authoritative).
         let fetches = await Promise.all(configs.map(async sourceConfig => {
             let probe = await SourceWrapper.create(sourceConfig, { background: false });
+            let start = Date.now();
             try {
                 let data = await probe.read(archives => archives.get(ROUTING_FILE));
-                return { probe, sourceConfig, responded: true, existing: data && parseRoutingData(data) || undefined, error: "" };
+                return { probe, sourceConfig, responded: true, latency: Date.now() - start, existing: data && parseRoutingData(data) || undefined, error: "" };
             } catch (e) {
-                return { probe, sourceConfig, responded: false, existing: undefined, error: `${sourceConfig.url}: ${(e as Error).stack ?? e}` };
+                return { probe, sourceConfig, responded: false, latency: 0, existing: undefined, error: `${sourceConfig.url}: ${(e as Error).stack ?? e}` };
             }
         }));
         try {
@@ -222,6 +223,14 @@ export class ArchivesChain implements IArchives {
                     }
                 }
             }
+            // The routing fetches double as our first latency measurements: variable-shard picking
+            // works immediately, instead of waiting for the first ping pass to land
+            for (let source of sources) {
+                let fetch = fetches.find(x => x.responded && x.sourceConfig.url === source.config.url);
+                if (fetch) {
+                    source.seedLatency(fetch.latency);
+                }
+            }
             this.activeConfig = active;
             this.startConfigPoll();
             return { config: active, sources };
@@ -295,7 +304,13 @@ export class ArchivesChain implements IArchives {
 
     private async adoptNewConfig(state: ChainState, latest: RemoteConfig): Promise<void> {
         if (JSON.stringify(latest) === JSON.stringify(state.config)) return;
-        console.log(`Storage routing config changed for ${this.getDebugName()}, rebuilding sources`);
+        // Same version but different content is a deploy switchover remap (an in-memory window
+        // split pointing at a successor's port), not an actual configuration change
+        if (getConfigVersion(latest) === getConfigVersion(state.config)) {
+            console.log(`Storage routing reinterpreted at version ${getConfigVersion(latest)} for ${this.getDebugName()} (deploy switchover in progress), rebuilding sources. Sources: ${JSON.stringify(latest.sources)}`);
+        } else {
+            console.log(`Storage routing config changed for ${this.getDebugName()} (version ${getConfigVersion(state.config)} -> ${getConfigVersion(latest)}), rebuilding sources`);
+        }
         let oldByConfig = new Map(state.sources.map(source => [JSON.stringify(source.config), source]));
         let sources: SourceWrapper[] = [];
         for (let sourceConfig of latest.sources.map(normalizeSource)) {
@@ -342,6 +357,7 @@ export class ArchivesChain implements IArchives {
             // Init is failing; its own retry loop handles that
             return;
         }
+        console.log(`Every storage source failed for ${this.getDebugName()}; re-contacting all ${state.sources.length} sources (routing re-read + connection re-attempt)`);
         let results = await Promise.all(state.sources.map(async source => {
             try {
                 let data = await source.read(archives => archives.get(ROUTING_FILE));
@@ -456,12 +472,14 @@ export class ArchivesChain implements IArchives {
             let now = Date.now();
             let nearBoundary = state.sources.some(source => source.config.validWindow.some(t => t > 0 && t < Number.MAX_SAFE_INTEGER && Math.abs(t - now) <= WRONG_TARGET_BOUNDARY_WINDOW));
             if (nearBoundary) {
+                console.log(`Write rejected by ${this.getDebugName()}: raced a valid window boundary; waiting ${WRONG_TARGET_BOUNDARY_RETRY_DELAY / 1000}s and retrying`);
                 await delay(WRONG_TARGET_BOUNDARY_RETRY_DELAY);
                 return;
             }
         }
         if (Date.now() - this.lastConfigRefresh < CONFIG_REFRESH_THROTTLE) return;
         this.lastConfigRefresh = Date.now();
+        console.log(`Write rejected by ${this.getDebugName()} (wrong ${kind}): our config is stale (likely a deploy switchover); refreshing it and retrying`);
         await this.refreshActiveConfig();
     }
 
@@ -665,6 +683,7 @@ export class ArchivesChain implements IArchives {
                     // NOTE: If we run into cases when transport level errors happen, but we are still connected, then we might want to add additional checking here, additional errors in which we will retry the other targets. However, ideally, checking if the WebSocket connection is still connected will handle all those cases. Distinguishing between application errors (which we can't retry) and transport errors.
                     if (target.isConnected()) throw e;
                     target.noteFailure();
+                    console.log(`Variable-shard write target ${target.getDebugName()} is down; moving to the next-lowest-latency shard`);
                     errors.push(String((e as Error).stack ?? e));
                 }
             }

package/storage/remoteStorage/deployTakeover.ts

@@ -20,7 +20,6 @@ import { parseHostedUrl, replaceHostedUrlPort } from "./remoteConfig";
 // any point during a switchover.
 
 const PARAMETERS_TIMELINE_FILE_REGEX = /^(\d+)-parameters\.json$/;
-const ALIVE_WINDOW_FOREVER = Number.MAX_SAFE_INTEGER;
 const TIMELINE_POLL_INTERVAL = 60 * 1000;
 // Processes listening on an alternate port register it here (sibling of the storage folder), keyed
 // by their actual pid; content includes their ancestor pids so the timeline entry pid (a shell
@@ -42,8 +41,10 @@ const REMAP_EXPIRE_FRACTION = 2;
 
 type TimelineEntry = {
     pid?: number;
-    aliveWindow: [number, number];
-    parameters: unknown;
+    // releaseTime + overlapTime define everything: the newer entry's releaseTime is when it
+    // starts, and releaseTime + overlapTime is when the older one is killed (freeing the port).
+    // The files also carry an aliveWindow, which is deliberately ignored.
+    parameters: { releaseTime?: number; overlapTime?: number };
 };
 
 type TakeoverComputed = {
@@ -67,6 +68,8 @@ let current: TakeoverComputed = {};
 let currentKey = JSON.stringify(current);
 let eventListeners: ((event: TakeoverEvent) => void)[] = [];
 let eventTimers: ReturnType<typeof setTimeout>[] = [];
+let loggedNoMatch = false;
+let loggedIdentity = false;
 
 function execText(command: string): Promise<string> {
     return new Promise((resolve, reject) => {
@@ -103,20 +106,10 @@ async function getAncestorPids(): Promise<Set<number>> {
     return pids;
 }
 
-async function findTimelineFolder(): Promise<string | undefined> {
-    let dir = process.cwd();
-    while (true) {
-        let files: string[] = [];
-        try {
-            files = await fs.promises.readdir(dir);
-        } catch { }
-        if (files.some(file => PARAMETERS_TIMELINE_FILE_REGEX.test(file))) {
-            return dir.replaceAll("\\", "/") + "/";
-        }
-        let parent = path.dirname(dir);
-        if (parent === dir) return undefined;
-        dir = parent;
-    }
+// The instance folder is ALWAYS the parent of our cwd (services run in <instance>/git/) - never
+// search for it, a walk could latch onto the wrong folder
+function getTimelineFolder(): string {
+    return path.dirname(process.cwd()).replaceAll("\\", "/") + "/";
 }
 
 function pidAlive(pid: number): boolean {
@@ -211,8 +204,11 @@ function scheduleEvents(): void {
     };
     let remap = current.remap;
     if (remap) {
+        let altPort = remap.altPort;
         schedule(remap.boundaryA - SWITCH_SCAN_LEAD, () => emit("diskScan"));
+        schedule(remap.boundaryA, () => console.log(`Deploy switchover write handoff boundary passed: fresh writes now belong to the alternate-port side (port ${altPort})`));
         schedule(remap.boundaryA + SWITCH_SCAN_LEAD, () => emit("diskScan"));
+        schedule(remap.boundaryB, () => console.log(`Deploy switchover second boundary passed: fresh writes return to the main port`));
         schedule(remap.expire, () => void recompute().catch((e: Error) => console.error(`Deploy takeover recompute failed: ${e.stack ?? e}`)));
     }
 }
@@ -228,26 +224,42 @@ async function recompute(): Promise<void> {
             us = entry;
         }
     }
+    // Matching failures must be loud, or takeover detection fails silently forever
+    if (!us && entries.length && !loggedNoMatch) {
+        loggedNoMatch = true;
+        console.warn(`No deploy timeline entry matches our pid chain (${[...ancestorPids].join(", ")}) - takeover detection cannot work. Entries: ${entries.map(x => `pid=${x.pid ?? "none"} releaseTime=${x.parameters.releaseTime}`).join(" | ")}`);
+    }
+    if (us && !loggedIdentity) {
+        loggedIdentity = true;
+        console.log(`Deploy timeline entry matched: we are pid=${us.pid}, releaseTime=${us.parameters.releaseTime !== undefined && iso(us.parameters.releaseTime) || "unknown"}, ${entries.length} entries total`);
+    }
     let computed: TakeoverComputed = {};
-    if (us) {
-        let usStart = us.aliveWindow[0];
-        let next: TimelineEntry | undefined;
-        let prev: TimelineEntry | undefined;
+    let usRelease = us?.parameters.releaseTime;
+    if (us && usRelease !== undefined) {
+        // The newer entry's releaseTime is when it starts; releaseTime + overlapTime is when the
+        // older one is killed. That's the whole timeline.
+        let next: { entry: TimelineEntry; release: number } | undefined;
+        let prev: { entry: TimelineEntry; release: number } | undefined;
         for (let entry of entries) {
             if (entry === us) continue;
-            if (entry.aliveWindow[0] > usStart && (!next || entry.aliveWindow[0] < next.aliveWindow[0])) {
-                next = entry;
+            let release = entry.parameters.releaseTime;
+            if (release === undefined) continue;
+            if (release > usRelease && (!next || release < next.release)) {
+                next = { entry, release };
             }
-            if (entry.aliveWindow[0] < usStart && (!prev || entry.aliveWindow[0] > prev.aliveWindow[0])) {
-                prev = entry;
+            if (release < usRelease && (!prev || release > prev.release)) {
+                prev = { entry, release };
             }
         }
-        if (next && us.aliveWindow[1] !== ALIVE_WINDOW_FOREVER && next.aliveWindow[0] <= us.aliveWindow[1]) {
-            let overlap = us.aliveWindow[1] - next.aliveWindow[0];
-            let successorStart = next.aliveWindow[0];
+        if (next) {
+            let successorStart = next.release;
+            let overlap = next.entry.parameters.overlapTime || us.parameters.overlapTime || 0;
+            // Even a ZERO-overlap deploy needs the dying behaviors - draining fast-write flushes
+            // by the release and writing through after it, or acknowledged data dies with us.
+            // Only the remap (the alternate-port middle window) needs an actual overlap.
+            computed.dying = { successorStart, overlap };
             if (overlap > 0 && now < successorStart + overlap * REMAP_EXPIRE_FRACTION) {
-                computed.dying = { successorStart, overlap };
-                const successorPid = next.pid;
+                const successorPid = next.entry.pid;
                 if (successorPid) {
                     let successorEntry = registry.find(x => x.ancestorPids.includes(successorPid));
                     if (successorEntry) {
@@ -256,31 +268,58 @@ async function recompute(): Promise<void> {
                 }
             }
         }
-        if (prev && prev.aliveWindow[1] > usStart) {
-            let overlap = prev.aliveWindow[1] - usStart;
-            computed.predecessorEnd = prev.aliveWindow[1];
-            if (overlap > 0 && ourAltPort && now < usStart + overlap * REMAP_EXPIRE_FRACTION && !computed.remap) {
-                computed.remap = makeRemap(usStart, overlap, ourAltPort);
+        if (prev) {
+            let overlap = us.parameters.overlapTime || prev.entry.parameters.overlapTime || 0;
+            // The predecessor holds the main port until OUR release + the overlap
+            computed.predecessorEnd = usRelease + overlap;
+            if (overlap > 0 && ourAltPort && now < usRelease + overlap * REMAP_EXPIRE_FRACTION && !computed.remap) {
+                computed.remap = makeRemap(usRelease, overlap, ourAltPort);
             }
         }
     }
     let key = JSON.stringify(computed);
     if (key === currentKey) return;
+    logTransitions(current, computed);
     current = computed;
     currentKey = key;
-    console.log(`Deploy takeover state changed: ${key}`);
     scheduleEvents();
     emit("remapChanged");
 }
 
+function iso(time: number): string {
+    return new Date(time).toISOString();
+}
+
+// The switchover lifecycle is rare and important, so every stage gets a clear line
+function logTransitions(prev: TakeoverComputed, next: TakeoverComputed): void {
+    if (!prev.dying && next.dying) {
+        let { successorStart, overlap } = next.dying;
+        console.log(`Deploy switchover scheduled: our successor starts at ${iso(successorStart)}; fast-write flushes drain by ${iso(successorStart + overlap * FLUSH_DEADLINE_FRACTION)}, fresh writes hand off at ${iso(successorStart + overlap * BOUNDARY_A_FRACTION)}, and we are killed at ${iso(successorStart + overlap)}`);
+    }
+    if (!prev.predecessorEnd && next.predecessorEnd) {
+        console.log(`We are a deploy successor: our predecessor holds the main port until ${iso(next.predecessorEnd)}`);
+    }
+    if (!prev.remap && next.remap) {
+        console.log(`Deploy switchover remap active: sources pointing at us are split so [${iso(next.remap.boundaryA)} .. ${iso(next.remap.boundaryB)}] routes to alternate port ${next.remap.altPort} (remap expires at ${iso(next.remap.expire)})`);
+    }
+    if (prev.remap && !next.remap) {
+        console.log(`Deploy switchover remap ended; running on the plain stored routing config`);
+    }
+}
+
 /** Starts the takeover machinery. Port fallback (alternate port + registry + acquisition polling)
  *  works regardless; without a deploy timeline folder the switchover-specific parts (the remap,
  *  the flush deadline, the tighter acquisition pacing) simply stay inert. */
 export async function initDeployTakeover(config: { domain: string; mainPort: number; storageFolder: string }): Promise<void> {
     initialized = config;
     ancestorPids = await getAncestorPids();
-    timelineFolder = await findTimelineFolder();
-    if (!timelineFolder) return;
+    timelineFolder = getTimelineFolder();
+    let entries = await readTimelineEntries();
+    if (!entries.length) {
+        console.log(`No deploy timeline entries in ${timelineFolder}; deploy takeover inactive until they appear (port fallback still works)`);
+    } else {
+        console.log(`Deploy timeline found at ${timelineFolder} (${entries.length} entries); our pid chain: ${[...ancestorPids].join(" -> ")}`);
+    }
     await recompute();
     let poll = setInterval(() => {
         void recompute().catch((e: Error) => console.error(`Deploy takeover recompute failed: ${e.stack ?? e}`));