sliftutils 1.7.14 → 1.7.15

package/index.d.ts

@@ -223,7 +223,7 @@ declare module "sliftutils/misc/https/hostServer" {
         setDNSRecord?: boolean;
         publicIp?: string;
         allowHostnames?: string[];
-        /** Deploy takeover: when the port is busy (the previous version still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). Only pass this when a deploy timeline actually exists; without it a busy port is a real misconfiguration and must throw. */
+        /** When the port is busy (e.g. the previous deploy still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). */
         portFallback?: {
             /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
             getAcquireDelay: () => number;
@@ -3273,14 +3273,14 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
 declare module "sliftutils/storage/remoteStorage/deployTakeover" {
     import { RemoteConfig } from "../IArchives";
     export type TakeoverEvent = "remapChanged" | "diskScan";
-    /** Starts the takeover machinery. Returns whether a deploy timeline exists - when it doesn't,
-     *  everything here stays inert (and the caller must NOT fall back to alternate ports, since a busy
-     *  port then means a real misconfiguration, not a deploy). */
+    /** 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 declare function initDeployTakeover(config: {
         domain: string;
         mainPort: number;
         storageFolder: string;
-    }): Promise<boolean>;
+    }): Promise<void>;
     /** Called when we had to listen on an alternate port (the main port was still held by our
      *  predecessor): registers it so the predecessor can route the middle overlap window to us. */
     export declare function registerAltPort(port: number): Promise<void>;

package/misc/https/hostServer.d.ts

@@ -6,7 +6,7 @@ export type HostServerConfig = {
     setDNSRecord?: boolean;
     publicIp?: string;
     allowHostnames?: string[];
-    /** Deploy takeover: when the port is busy (the previous version still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). Only pass this when a deploy timeline actually exists; without it a busy port is a real misconfiguration and must throw. */
+    /** When the port is busy (e.g. the previous deploy still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). */
     portFallback?: {
         /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
         getAcquireDelay: () => number;

package/misc/https/hostServer.ts

@@ -32,7 +32,7 @@ export type HostServerConfig = {
     setDNSRecord?: boolean;
     publicIp?: string;
     allowHostnames?: string[];
-    /** Deploy takeover: when the port is busy (the previous version still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). Only pass this when a deploy timeline actually exists; without it a busy port is a real misconfiguration and must throw. */
+    /** When the port is busy (e.g. the previous deploy still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). */
     portFallback?: {
         /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
         getAcquireDelay: () => number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.14",
+    "version": "1.7.15",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/remoteStorage/deployTakeover.d.ts

@@ -1,13 +1,13 @@
 import { RemoteConfig } from "../IArchives";
 export type TakeoverEvent = "remapChanged" | "diskScan";
-/** Starts the takeover machinery. Returns whether a deploy timeline exists - when it doesn't,
- *  everything here stays inert (and the caller must NOT fall back to alternate ports, since a busy
- *  port then means a real misconfiguration, not a deploy). */
+/** 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 declare function initDeployTakeover(config: {
     domain: string;
     mainPort: number;
     storageFolder: string;
-}): Promise<boolean>;
+}): Promise<void>;
 /** Called when we had to listen on an alternate port (the main port was still held by our
  *  predecessor): registers it so the predecessor can route the middle overlap window to us. */
 export declare function registerAltPort(port: number): Promise<void>;

package/storage/remoteStorage/deployTakeover.ts

@@ -273,20 +273,19 @@ async function recompute(): Promise<void> {
     emit("remapChanged");
 }
 
-/** Starts the takeover machinery. Returns whether a deploy timeline exists - when it doesn't,
- *  everything here stays inert (and the caller must NOT fall back to alternate ports, since a busy
- *  port then means a real misconfiguration, not a deploy). */
-export async function initDeployTakeover(config: { domain: string; mainPort: number; storageFolder: string }): Promise<boolean> {
+/** 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 false;
+    if (!timelineFolder) return;
     await recompute();
     let poll = setInterval(() => {
         void recompute().catch((e: Error) => console.error(`Deploy takeover recompute failed: ${e.stack ?? e}`));
     }, TIMELINE_POLL_INTERVAL);
     (poll as { unref?: () => void }).unref?.();
-    return true;
 }
 
 /** Called when we had to listen on an alternate port (the main port was still held by our

package/storage/remoteStorage/storageServer.ts

@@ -119,21 +119,22 @@ export async function hostStorageServer(config: HostStorageServerConfig): Promis
     }, DISK_SPACE_CHECK_INTERVAL_MS);
     (interval as { unref?: () => void }).unref?.();
 
-    // Zero-downtime deploys: only enabled when a deploy timeline exists - otherwise a busy port is
-    // a real misconfiguration and must throw, not silently listen elsewhere
-    let hasDeployTimeline = await initDeployTakeover({ domain, mainPort: port, storageFolder: path.resolve(folder) });
+    // Port fallback is always on: a busy port means listening on an alternate, registering it, and
+    // polling to take the real port. The deploy takeover machinery merely rides on top (tighter
+    // polling around a scheduled switchover, and the valid-window remap once a successor is known).
+    await initDeployTakeover({ domain, mainPort: port, storageFolder: path.resolve(folder) });
 
     await hostServer({
         domain,
         port,
         setDNSRecord: true,
-        portFallback: hasDeployTimeline && {
+        portFallback: {
             getAcquireDelay: getMainPortAcquireDelay,
             onListening: (listeningPort, isMainPort) => {
                 if (isMainPort) return;
                 addExtraListenPort(listeningPort);
                 void registerAltPort(listeningPort).catch((e: Error) => console.error(`Registering alternate port ${listeningPort} failed: ${e.stack ?? e}`));
             },
-        } || undefined,
+        },
     });
 }