querysub 0.529.0 → 0.531.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.529.0",
+  "version": "0.531.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -25,6 +25,7 @@
     "mcp2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts",
     "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/",
     "autofix": "yarn typenode ./src/diagnostics/logs/errorTickets/autoFixerEntry.ts",
+    "parameters-timeline": "yarn typenode ./src/deployManager/parametersTimelineMain.ts",
     "ssh-a-claude": "ssh root@a.querysubtest.com"
   },
   "bin": {
@@ -70,7 +71,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.13",
+    "sliftutils": "^1.7.14",
     "socket-function": "^1.2.21",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",

package/src/-a-archives/archivesBackBlaze.ts

@@ -59,7 +59,7 @@ export class ArchivesBackblaze {
     public async get2(fileName: string, config?: { range?: { start: number; end: number; } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {
         return this.archives.get2(fileName, config);
     }
-    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {
+    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<string> {
         return this.archives.set(fileName, data, config);
     }
     public async append(fileName: string, data: Buffer): Promise<void> {

package/src/deployManager/components/MachineDetailPage.tsx

@@ -11,6 +11,7 @@ import { managementPageURL } from "../../diagnostics/managementPages";
 import { t } from "../../2-proxy/schema2";
 import { Querysub } from "../../4-querysub/Querysub";
 import { getLogViewerParams } from "../../diagnostics/logs/IndexedLogs/LogViewerParams";
+import { UsageBar, getUsageThresholds } from "../../library-components/UsageBar";
 
 export class MachineDetailPage extends qreact.Component {
     render() {
@@ -119,16 +120,7 @@ export class MachineDetailPage extends qreact.Component {
                                 <ShowMore className={css.whiteSpace("pre-wrap")} maxHeight={80}>
                                     {(() => {
                                         if (typeof value === "object") {
-                                            return <div className={css.pad2(6, 2).hsla(0, 0, 0, 0.1).relative}>
-                                                <div className={
-                                                    css.absolute.pos(0, 0)
-                                                        .size(`${value.value / value.max * 100}%`, "100%")
-                                                        .hsl(0, 0, 70)
-                                                } />
-                                                <div className={css.relative}>
-                                                    {value.type} ({formatNumber(value.value)} / {formatNumber(value.max)})
-                                                </div>
-                                            </div>;
+                                            return <UsageBar label={value.type} value={value.value} max={value.max} {...getUsageThresholds(value.type)} />;
                                         }
                                         return value;
                                     })()}

package/src/deployManager/components/MachinesListPage.tsx

@@ -11,6 +11,7 @@ import { formatDateJSX } from "../../misc/formatJSX";
 import { DeployMachineButtons, RenderGitRefInfo } from "./deployButtons";
 import { isDefined } from "../../misc";
 import { Anchor, createLink } from "../../library-components/ATag";
+import { UsageBar, getUsageThresholds } from "../../library-components/UsageBar";
 
 export class MachinesListPage extends qreact.Component {
     state = t.state({
@@ -182,17 +183,7 @@ export class MachinesListPage extends qreact.Component {
                                     <RenderGitRefInfo gitRef={machineInfo.gitRef} />
                                     {Object.values(machineInfo.info).map(value => {
                                         if (typeof value === "string") return undefined;
-                                        return <div className={css.pad2(6, 2).hsla(0, 0, 0, 0.1).relative}>
-                                            <div className={
-                                                css.absolute.pos(0, 0)
-                                                    .size(`${value.value / value.max * 100}%`, "100%")
-                                                    .hsl(0, 0, 70)
-                                            } />
-                                            <div className={css.relative}>
-                                                {value.type} ({formatNumber(value.value)} / {formatNumber(value.max)})
-                                            </div>
-                                        </div>;
-
+                                        return <UsageBar label={value.type} value={value.value} max={value.max} {...getUsageThresholds(value.type)} />;
                                     })}
                                 </div>
                                 <div className={css.vbox(4).flexGrow(1)}>

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -5,7 +5,7 @@ import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
 import { Querysub } from "../../4-querysub/Querysub";
 import { currentViewParam, selectedServiceIdParam, selectedMachineIdParam } from "../urlParams";
-import { formatDateTimeDetailed, formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
+import { formatDateTime, formatDateTimeDetailed, formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { InputPicker } from "../../library-components/InputPicker";
 import { MachinePicker } from "./MachinePicker";
 import { deepCloneJSON, nextId, sort, timeInSecond } from "socket-function/src/misc";
@@ -46,7 +46,9 @@ export class ServiceDetailPage extends qreact.Component {
         }),
         // Milliseconds; 0 means no scheduled time picked yet (use Deploy Now instead)
         switchTime: t.number(0),
-        // Seconds; 0 means use the service's configured overlapTime
+        // Seconds until the release goes live; 0 means use the default (DEFAULT_OVERLAP_TIME)
+        releaseDelayOverride: t.number(0),
+        // Seconds the old instances outlive the release; 0 means use the default (DEFAULT_OVERLAP_TIME). The no-overlap deploy buttons are how you deploy with an actual 0.
         overlapOverride: t.number(0),
     });
 
@@ -123,6 +125,7 @@ export class ServiceDetailPage extends qreact.Component {
                 Querysub.commit(() => {
                     this.state.editorState = stripReleaseState(deployConfig);
                     this.state.switchTime = 0;
+                    this.state.releaseDelayOverride = 0;
                     this.state.overlapOverride = 0;
                 });
             } finally {
@@ -151,11 +154,13 @@ export class ServiceDetailPage extends qreact.Component {
             content: <div className={css.fixed.pos(0, 0).size("100vw", "100vh").hsla(0, 0, 0, 0.5).display("flex").alignItems("center").justifyContent("center")}>
                 <div className={css.vbox(12).pad2(20).hsl(0, 0, 12).colorhsl(0, 0, 90).bord2(0, 0, 40) + " keepModalsOpen"}>
                     <div className={css.boldStyle.fontSize(16)}>⚡ Force deploy now?</div>
-                    <div>This config becomes live immediately. The old instances are shut down right away, with no overlap.</div>
+                    <div>{deployConfig.parameters.overlapTime
+                        ? `This config becomes live immediately. The old instances keep running for ${formatTime(deployConfig.parameters.overlapTime)} before shutting down.`
+                        : "This config becomes live immediately. The old instances are shut down right away, with no overlap."}</div>
                     <div className={css.hbox(10)}>
                         <Button hue={0} onClick={() => {
                             modal && modal.close();
-                            deployConfig.parameters.releaseTime = undefined;
+                            deployConfig.parameters.releaseTime = Date.now();
                             this.deployConfig(deployConfig);
                         }}>⚡ Force Deploy Now</Button>
                         <Button onClick={() => modal && modal.close()}>Cancel</Button>
@@ -251,7 +256,18 @@ export class ServiceDetailPage extends qreact.Component {
             if (!releaseTime || Date.now() >= releaseTime || !originalConfig.oldParameters) return undefined;
             return {
                 switchTime: releaseTime,
-                overlapTime: originalConfig.parameters.overlapTime || DEFAULT_OVERLAP_TIME,
+                overlapTime: originalConfig.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME,
+            };
+        })();
+        // By our calculation both the old and new parameters' instances are running (the release passed, but the old instances haven't been shut down yet). Purely time-based — we don't verify the instances are actually running.
+        const overlappingDeploy = (() => {
+            let releaseTime = originalConfig.parameters.releaseTime || 0;
+            let overlapTime = originalConfig.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME;
+            if (!releaseTime || !originalConfig.oldParameters) return undefined;
+            if (Date.now() < releaseTime || Date.now() >= releaseTime + overlapTime) return undefined;
+            return {
+                oldParameters: originalConfig.oldParameters,
+                shutdownTime: releaseTime + overlapTime,
             };
         })();
 
@@ -378,16 +394,15 @@ export class ServiceDetailPage extends qreact.Component {
                     this.updateEditorState(updated);
                 }}
             />
-            <InputLabel
-                label="Deploy overlap (seconds)"
-                integer
-                value={Math.round((config.parameters.overlapTime || DEFAULT_OVERLAP_TIME) / timeInSecond)}
-                onChangeValue={value => {
-                    let updated = deepCloneJSON(config);
-                    updated.parameters.overlapTime = (Number(value) || 0) * timeInSecond;
-                    this.updateEditorState(updated);
-                }}
-            />
+            <div className={css.hbox(12)}>
+                {(() => {
+                    let lastDeployTime = getLiveServiceParameters(originalConfig).releaseTime;
+                    if (!lastDeployTime || lastDeployTime > now) return undefined;
+                    return <span>
+                        Last deploy at {formatDateTime(lastDeployTime)} ({formatTime(now - lastDeployTime)} ago)
+                    </span>;
+                })()}
+            </div>
             {/* Machine Status */}
             {config.parameters.deploy && <div className={css.vbox(8).fillWidth}>
                 <h3>Deployed Machines ({machineIds.length})</h3>
@@ -668,7 +683,7 @@ export class ServiceDetailPage extends qreact.Component {
                 <ParametersDiff base={getLiveServiceParameters(originalConfig)} next={originalConfig.parameters} />
                 <div className={css.vbox(4)}>
                     <div>
-                        Live instance deployed at {scheduledDeploy.switchTime - scheduledDeploy.overlapTime <= now && `${formatTime(now - (scheduledDeploy.switchTime - scheduledDeploy.overlapTime))} ago` || `in ${formatTime(scheduledDeploy.switchTime - scheduledDeploy.overlapTime - now)}`} ({formatDateTimeDetailed(scheduledDeploy.switchTime - scheduledDeploy.overlapTime)})
+                        Old instances shut down in {formatTime(scheduledDeploy.switchTime + scheduledDeploy.overlapTime - now)} ({formatDateTimeDetailed(scheduledDeploy.switchTime + scheduledDeploy.overlapTime)})
                     </div>
                     <div className={css.hbox(8)}>
                         <button
@@ -684,10 +699,27 @@ export class ServiceDetailPage extends qreact.Component {
                             }}>
                             Cancel Scheduled Deploy
                         </button>
+                        <button
+                            className={css.pad2(12, 8).button.bord2(0, 70, 40).hsl(0, 70, 90)}
+                            disabled={this.state.isDeploying}
+                            title="Changes the scheduled deploy to go live immediately"
+                            onClick={() => {
+                                this.confirmForceDeployNow(deepCloneJSON(stripReleaseState(originalConfig)));
+                            }}>
+                            ⚡ Force Schedule Now
+                        </button>
                     </div>
                 </div>
             </div>}
 
+            {/* The release went live, but the old instances are still running out their overlap */}
+            {overlappingDeploy && <div className={css.vbox(10).pad2(12).fillWidth.bord2(280, 60, 50).hsl(280, 40, 95)}>
+                <div className={css.boldStyle.fontSize(15)}>
+                    🔀 Overlapping configs — the new config is live, and the old instances shut down in {formatTime(overlappingDeploy.shutdownTime - now)} ({formatDateTimeDetailed(overlappingDeploy.shutdownTime)})
+                </div>
+                <ParametersDiff base={overlappingDeploy.oldParameters} next={originalConfig.parameters} />
+            </div>}
+
             {/* The EDITOR's changes (browser-only) — deploying them schedules a (new) deploy */}
             {(() => {
                 if (!hasUnsavedChanges) return undefined;
@@ -707,18 +739,19 @@ export class ServiceDetailPage extends qreact.Component {
                         <span title={`${configCompareKey(config)} !== ${configCompareKey(deployedConfig)}`}>Only the title / notes changed, so this saves immediately</span>
                     </div>;
                 }
-                let overlapSeconds = this.state.overlapOverride || Math.round((config.parameters.overlapTime || DEFAULT_OVERLAP_TIME) / timeInSecond);
+                let releaseDelaySeconds = this.state.releaseDelayOverride || Math.round(DEFAULT_OVERLAP_TIME / timeInSecond);
+                let releaseDelay = releaseDelaySeconds * timeInSecond;
+                let overlapSeconds = this.state.overlapOverride || Math.round(DEFAULT_OVERLAP_TIME / timeInSecond);
                 let overlap = overlapSeconds * timeInSecond;
                 let scheduledTime = this.state.switchTime;
-                let notEnoughTime = !!scheduledTime && scheduledTime > now && scheduledTime - now < overlap;
-                const makeDeployConfig = (releaseTime: number) => {
+                const makeDeployConfig = (releaseTime: number, overlapTime = overlap) => {
                     let deployConfig = deepCloneJSON(config);
                     deployConfig.parameters.releaseTime = releaseTime;
-                    deployConfig.parameters.overlapTime = overlap;
+                    deployConfig.parameters.overlapTime = overlapTime;
                     return deployConfig;
                 };
-                // The switch time is inferred from the overlap, unless one is explicitly set (in which case the overlap only controls when the new instances start)
-                let effectiveSwitchTime = scheduledTime || now + overlap;
+                // The switch time is inferred from the release delay, unless one is explicitly set
+                let effectiveSwitchTime = scheduledTime || now + releaseDelay;
                 return <div className={css.vbox(10).pad2(12).fillWidth.bord2(45, 70, 45).hsl(45, 60, 95)}>
                     <div className={css.boldStyle.fontSize(15)}>
                         ✏️ Edited (only in this browser, until deployed)
@@ -729,10 +762,19 @@ export class ServiceDetailPage extends qreact.Component {
                             className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(120, 70, 85).fontWeight("bold")}
                             disabled={this.state.isDeploying}
                             onClick={() => {
-                                this.deployConfig(makeDeployConfig(scheduledTime || Date.now() + overlap));
+                                this.deployConfig(makeDeployConfig(scheduledTime || Date.now() + releaseDelay));
                             }}>
                             {this.state.isDeploying && "⏳ Scheduling..." || scheduledDeploy && "🔁 Replace Scheduled Deploy" || "🚀 Schedule Deploy"}
                         </button>
+                        <button
+                            className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(35, 70, 85)}
+                            disabled={this.state.isDeploying}
+                            title="Deploys with the configured release delay, but the old instances shut down immediately at release time (overlap of 0)"
+                            onClick={() => {
+                                this.deployConfig(makeDeployConfig(scheduledTime || Date.now() + releaseDelay, 0));
+                            }}>
+                            Deploy, No Overlap
+                        </button>
                         <div className={css.opacity(scheduledTime && 1 || 0.5)}>
                             <InputLabel
                                 label="Switch at"
@@ -749,34 +791,48 @@ export class ServiceDetailPage extends qreact.Component {
                             onClick={() => {
                                 this.state.switchTime = 0;
                             }}>
-                            ↺ Reset to overlap-based time
+                            ↺ Reset to delay-based time
                         </button>}
                         <div className={css.opacity(scheduledTime && 0.5 || 1)}>
                             <InputLabel
-                                label="Overlap (seconds)"
+                                label="Release in (seconds)"
                                 integer
-                                value={overlapSeconds}
+                                value={releaseDelaySeconds}
                                 onChangeValue={value => {
-                                    this.state.overlapOverride = Number(value) || 0;
+                                    this.state.releaseDelayOverride = Number(value) || 0;
                                 }}
                             />
                         </div>
+                        <InputLabel
+                            label="Overlap (seconds)"
+                            integer
+                            value={overlapSeconds}
+                            onChangeValue={value => {
+                                this.state.overlapOverride = Number(value) || 0;
+                            }}
+                        />
                     </div>
                     {!!scheduledTime && scheduledTime <= now && <span className={css.colorhsl(0, 85, 45).fontWeight("bold")}>
                         ⚠️ The switch time is in the past — deploying switches immediately
                     </span>}
-                    {notEnoughTime && <span className={css.colorhsl(35, 85, 40).fontWeight("bold")}>
-                        ⚠️ The switch time is sooner than the overlap ({formatTime(overlap)}) — the new instances won't be fully started before the old ones shut down
-                    </span>}
                     <div className={css.hbox(8)}>
                         <button
                             className={css.pad2(12, 8).button.bord2(0, 70, 40).hsl(0, 70, 90)}
                             disabled={this.state.isDeploying}
                             onClick={() => {
-                                this.confirmForceDeployNow(makeDeployConfig(0));
+                                this.confirmForceDeployNow(makeDeployConfig(Date.now()));
                             }}>
                             ⚡ Force Deploy Now
                         </button>
+                        <button
+                            className={css.pad2(12, 8).button.bord2(0, 90, 30).hsl(0, 85, 65).colorhsl(0, 0, 100).fontWeight("bold")}
+                            disabled={this.state.isDeploying}
+                            title="Deploys immediately AND shuts down the old instances immediately (overlap of 0)"
+                            onClick={() => {
+                                this.confirmForceDeployNow(makeDeployConfig(Date.now(), 0));
+                            }}>
+                            ⚡ Force Deploy Now, No Overlap
+                        </button>
                     </div>
                 </div>;
             })()}
@@ -790,21 +846,27 @@ export class ServiceDetailPage extends qreact.Component {
             )}
 
             {/* Config Editor */}
-            <TypedConfigEditor
-                value={config}
-                onValueChange={(newValue) => {
-                    this.updateEditorState(newValue as ServiceConfig);
-                }}
-                typeDefinition={serviceConfigType}
-                sizeClassName={css.size(1000, 600)}
-            />
-            {hasUnsavedChanges && <button
-                className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(50, 80, 50)}
-                onClick={() => {
-                    this.state.editorState = undefined;
-                }}>
-                Discard Changes
-            </button>}
+            {(() => {
+                const discardButton = hasUnsavedChanges && <button
+                    className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(50, 80, 50)}
+                    onClick={() => {
+                        this.state.editorState = undefined;
+                    }}>
+                    Discard Changes
+                </button>;
+                return <>
+                    {discardButton}
+                    <TypedConfigEditor
+                        value={config}
+                        onValueChange={(newValue) => {
+                            this.updateEditorState(newValue as ServiceConfig);
+                        }}
+                        typeDefinition={serviceConfigType}
+                        sizeClassName={css.size(1000, 600)}
+                    />
+                    {discardButton}
+                </>;
+            })()}
         </div>;
     }
 }

package/src/deployManager/components/ServicesListPage.tsx

@@ -141,7 +141,19 @@ export class ServicesListPage extends qreact.Component {
                                 </div>
                                 <div className={css.vbox(4)}>
                                     <div>Updated {formatDateJSX(config.info.lastUpdatedTime)} AGO</div>
-                                    {config.parameters.overlapTime && <div className={css.colorhsl(210, 50, 50).fontSize(14).fontWeight("bold")}>Deploy overlap: {formatTime(config.parameters.overlapTime)}</div> || undefined}
+                                    {(() => {
+                                        // The old instances probably still run out their overlap (purely time-based, we don't verify they're actually running)
+                                        let releaseTime = config.parameters.releaseTime || 0;
+                                        let overlapTime = config.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME;
+                                        if (!releaseTime || !config.oldParameters) return undefined;
+                                        if (now < releaseTime || now >= releaseTime + overlapTime) return undefined;
+                                        return <div
+                                            className={css.colorhsl(280, 60, 45).fontSize(14).fontWeight("bold")}
+                                            title={`Old instances shut down at ${formatDateTimeDetailed(releaseTime + overlapTime)}`}
+                                        >
+                                            🔀 Old version still running for {formatTime(releaseTime + overlapTime - now)}
+                                        </div>;
+                                    })()}
                                     {(() => {
                                         let releaseTime = config.parameters.releaseTime || 0;
                                         if (!releaseTime || releaseTime <= now || !config.oldParameters) return undefined;

package/src/deployManager/components/deployButtons.tsx

@@ -46,18 +46,21 @@ export class UpdateButtons extends qreact.Component<{
     state = t.state({
         isDeploying: t.type(false),
     });
-    // Deploys all outdated services to latestRef. Scheduled releases use the configured overlap so the new instances are running before the old ones shut down; immediate skips the release entirely (old instances restart right away, no overlap).
-    private deployAll(outdatedServices: ServiceConfig[], latestRef: string, immediate: boolean) {
+    // Deploys all outdated services to latestRef. "scheduled" delays the release by the configured overlap (an unrelated value, but a reasonable delay); "now" releases immediately but the old instances still run out their configured overlap; "nowNoOverlap" releases immediately AND shuts the old instances down immediately.
+    private deployAll(outdatedServices: ServiceConfig[], latestRef: string, mode: "scheduled" | "now" | "nowNoOverlap") {
         this.state.isDeploying = true;
         // Props are synchronized state, so everything the async work needs is cloned into plain locals HERE, in the synced part
         let toDeploy = outdatedServices.map(service => {
             let updated = deepCloneJSON(service);
             updated.parameters.gitRef = latestRef;
-            if (immediate) {
-                updated.parameters.releaseTime = undefined;
-            } else {
-                let overlap = updated.parameters.overlapTime || DEFAULT_OVERLAP_TIME;
+            if (mode === "scheduled") {
+                let overlap = updated.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME;
                 updated.parameters.releaseTime = Date.now() + overlap;
+            } else {
+                updated.parameters.releaseTime = Date.now();
+                if (mode === "nowNoOverlap") {
+                    updated.parameters.overlapTime = 0;
+                }
             }
             return updated;
         });
@@ -72,6 +75,32 @@ export class UpdateButtons extends qreact.Component<{
             }
         });
     }
+    private confirmDeployAllNow(outdatedServices: ServiceConfig[], latestRef: string, noOverlap: boolean) {
+        let modal: { close: () => void } | undefined;
+        modal = showFullscreenModal({
+            content: <div className={css.vbox(12).pad2(20)}>
+                <div className={css.boldStyle.fontSize(16)}>⚡ Deploy all {outdatedServices.length} services now?</div>
+                <div>{noOverlap
+                    ? "All services release immediately AND their old instances shut down immediately (overlap of 0)."
+                    : "All services release immediately. Their old instances keep running for their configured overlap before shutting down."}</div>
+                <div className={css.hbox(10)}>
+                    <button
+                        className={css.pad2(12, 8).button.bord2(0, 70, 40).hsl(0, 70, 90)}
+                        onClick={() => {
+                            modal && modal.close();
+                            this.deployAll(outdatedServices, latestRef, noOverlap ? "nowNoOverlap" : "now");
+                        }}>
+                        ⚡ Deploy Now
+                    </button>
+                    <button
+                        className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(0, 0, 100)}
+                        onClick={() => modal && modal.close()}>
+                        Cancel
+                    </button>
+                </div>
+            </div>
+        });
+    }
     render() {
         let controller = MachineServiceController(SocketFunction.browserNodeId());
         const gitInfo = controller.getGitInfo();
@@ -129,7 +158,7 @@ export class UpdateButtons extends qreact.Component<{
                     className={buttonStyle.hsl(120, 70, 90)}
                     disabled={this.state.isDeploying}
                     onClick={() => {
-                        this.deployAll(outdatedServices, gitInfo.latestRef, false);
+                        this.deployAll(outdatedServices, gitInfo.latestRef, "scheduled");
                     }}
                 >
                     <div>
@@ -147,15 +176,27 @@ export class UpdateButtons extends qreact.Component<{
                 <button
                     className={buttonStyle.hsl(0, 70, 90)}
                     disabled={this.state.isDeploying}
-                    title="Deploys immediately, with no overlap: the old instances are shut down right away"
+                    title="Deploys immediately; the old instances keep running for their configured overlap before shutting down"
                     onClick={() => {
-                        this.deployAll(outdatedServices, gitInfo.latestRef, true);
+                        this.confirmDeployAllNow(outdatedServices, gitInfo.latestRef, false);
                     }}
                 >
                     <div>
                         {bigEmoji("⚡")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy All (${outdatedServices.length}) Now (no delay)`}</span>
                     </div>
                 </button>
+                <button
+                    className={buttonStyle.hsl(0, 85, 70)}
+                    disabled={this.state.isDeploying}
+                    title="Deploys immediately AND shuts down the old instances immediately (overlap of 0)"
+                    onClick={() => {
+                        this.confirmDeployAllNow(outdatedServices, gitInfo.latestRef, true);
+                    }}
+                >
+                    <div>
+                        {bigEmoji("⚡")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy All (${outdatedServices.length}) Now (no delay, no overlap)`}</span>
+                    </div>
+                </button>
             </>}
         </>;
     }
@@ -183,8 +224,8 @@ export class UpdateServiceButtons extends qreact.Component<{
                     // Props are synchronized state, so everything the async work needs is cloned into plain locals HERE, in the synced part
                     let service = deepCloneJSON(this.props.service);
                     service.parameters.gitRef = gitInfo.latestRef;
-                    // Release with the configured overlap, so the new instances are running before the old ones shut down
-                    let overlap = service.parameters.overlapTime || DEFAULT_OVERLAP_TIME;
+                    // Delay the release by the configured overlap (an unrelated value, but a reasonable delay)
+                    let overlap = service.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME;
                     service.parameters.releaseTime = Date.now() + overlap;
                     Querysub.onCommitFinished(async () => {
                         try {

package/src/deployManager/machineApplyMainCode.ts

@@ -25,6 +25,7 @@ import { onServiceConfigChange, scheduleNodeShutdown } from "./machineController
 import { PromiseObj } from "../promise";
 import path from "path";
 import { fsExistsAsync } from "../fs";
+import { ALIVE_WINDOW_FOREVER, ParametersTimelineEntry, syncParametersTimelineFiles } from "./parametersTimeline";
 
 // The deployed-service stdout log (pipe.txt) is a rolling buffer: once it grows
 // to PIPE_FILE_LINE_LIMIT lines it is truncated down to PIPE_FILE_LINE_KEEP. The
@@ -132,9 +133,9 @@ const SCREEN_SUFFIX = "-dply";
 export function getScreenName(config: { serviceKey: string; index: number }): string {
     return `${config.serviceKey}-${config.index}${SCREEN_SUFFIX}`.replace(/[^a-zA-Z0-9\-_]/g, "_");
 }
-// The new instances started during a release overlap. They cover the service while the canonical screens are restarted with the new config at release time, and are killed shortly after.
-export function getNextScreenName(config: { serviceKey: string; index: number }): string {
-    return getScreenName({ serviceKey: config.serviceKey + "-next", index: config.index });
+// The old instances kept alive during a release overlap. The canonical screens restart with the new config at release time; these keep the OLD version serving until releaseTime + overlapTime, and are killed shortly after.
+export function getOldScreenName(config: { serviceKey: string; index: number }): string {
+    return getScreenName({ serviceKey: config.serviceKey + "-old", index: config.index });
 }
 
 export async function streamScreenOutput(config: {
@@ -585,35 +586,41 @@ const ensureGitSynced = measureWrap(async function ensureGitSynced(config: {
 let launchesPerService = new Map<string, number>();
 let lastLaunchedTimePerService = new Map<string, number>();
 
-// Starts (or verifies) the "-next" instance of a service during a release overlap, running the new (not yet live) parameters. It covers the service while the canonical screens restart with the new parameters at release time, and is killed by the unused-screen cleanup afterwards (once the release passes we stop ensuring it).
-async function ensureNextInstance(config: {
-    next: ServiceParameters;
+// Starts (or verifies) the "-old" instance of a service during a release overlap, running the old (no longer live) parameters. It keeps the old version serving while the new canonical instances start up, and is killed by the unused-screen cleanup afterwards (once releaseTime + overlapTime passes we stop ensuring it).
+async function ensureOldInstance(config: {
+    old: ServiceParameters;
+    aliveWindow: [number, number];
     index: number;
     screenNamesUsed: Set<string>;
     screenStateMap: Map<string, { screenName: string; isProcessRunning: boolean; pid: string }>;
 }) {
-    let { next, index } = config;
-    let nextScreenName = getNextScreenName({ serviceKey: next.key, index });
-    config.screenNamesUsed.add(nextScreenName);
+    let { old, index } = config;
+    let oldScreenName = getOldScreenName({ serviceKey: old.key, index });
+    config.screenNamesUsed.add(oldScreenName);
+    let shutdownTime = config.aliveWindow[1];
+    const syncTimeline = async () => {
+        let pid = parseInt(config.screenStateMap.get(oldScreenName)?.pid || "") || undefined;
+        await syncParametersTimelineFiles(os.homedir() + "/" + SERVICE_FOLDER + oldScreenName + "/", [{ pid, aliveWindow: config.aliveWindow, parameters: old }]);
+    };
 
     let root = os.homedir() + "/" + SERVICE_FOLDER;
-    let folder = root + nextScreenName + "/";
+    let folder = root + oldScreenName + "/";
     let gitFolder = folder + "git/";
     await fs.promises.mkdir(gitFolder, { recursive: true });
-    if (next.gitRef) {
+    if (old.gitRef) {
         let prevGitRef = "";
         try {
             prevGitRef = await getGitRefLive(gitFolder);
         } catch { }
         await ensureGitSynced({
             gitFolder,
-            repoUrl: next.repoUrl,
-            gitRef: next.gitRef,
+            repoUrl: old.repoUrl,
+            gitRef: old.gitRef,
         });
         let afterGitRef = await getGitRefLive(gitFolder);
         let nodeModulesMissing = !await fsExistsAsync(gitFolder + "node_modules");
         if (afterGitRef !== prevGitRef || nodeModulesMissing) {
-            console.log(green(`Yarn installing for ${magenta(nextScreenName)} (ref ${prevGitRef} -> ${afterGitRef}, nodeModulesMissing=${nodeModulesMissing})`));
+            console.log(green(`Yarn installing for ${magenta(oldScreenName)} (ref ${prevGitRef} -> ${afterGitRef}, nodeModulesMissing=${nodeModulesMissing})`));
             await runPromise(`yarn install --mutex network`, { cwd: gitFolder });
         }
     }
@@ -623,23 +630,27 @@ async function ensureNextInstance(config: {
     if (await fsExistsAsync(parameterPath)) {
         prevParameters = await fs.promises.readFile(parameterPath, "utf8");
     }
-    let newParametersString = JSON.stringify(next);
-    let sameParameters = sameRestartParameters(prevParameters, next);
-    let screenIsRunning = config.screenStateMap.get(nextScreenName)?.isProcessRunning;
+    let newParametersString = JSON.stringify(old);
+    let sameParameters = sameRestartParameters(prevParameters, old);
+    let screenIsRunning = config.screenStateMap.get(oldScreenName)?.isProcessRunning;
     if (sameParameters && screenIsRunning) {
         if (prevParameters !== newParametersString) {
             await fs.promises.writeFile(parameterPath, newParametersString);
         }
-        console.log(green(`Verified release-overlap instance ${magenta(nextScreenName)} is running`));
+        await notifyServiceShutdown(oldScreenName, shutdownTime);
+        await syncTimeline();
+        console.log(green(`Verified release-overlap old instance ${magenta(oldScreenName)} is running`));
         return;
     }
 
-    console.log(`Starting release-overlap instance ${magenta(nextScreenName)}, with ${newParametersString}, isRunning = ${screenIsRunning}, sameParameters = ${sameParameters}`);
+    console.log(`Starting release-overlap old instance ${magenta(oldScreenName)}, with ${newParametersString}, isRunning = ${screenIsRunning}, sameParameters = ${sameParameters}`);
     await fs.promises.writeFile(parameterPath, newParametersString);
     await runScreenCommand({
-        screenName: nextScreenName,
-        command: next.command,
+        screenName: oldScreenName,
+        command: old.command,
     });
+    await notifyServiceShutdown(oldScreenName, shutdownTime);
+    await syncTimeline();
 }
 
 function sameRestartParameters(prevParametersJSON: string, next: ServiceParameters): boolean {
@@ -656,8 +667,8 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
     let machineId = getOwnMachineId(getDomain());
     let allConfigs = await getEffectiveServiceConfigs();
     let relevantConfigs = allConfigs
-        .filter(config => getMachineIdList(getLiveServiceParameters(config)).includes(machineId) || getMachineIdList(config.parameters).includes(machineId))
-        .filter(x => getLiveServiceParameters(x).deploy || x.parameters.deploy);
+        .filter(config => getMachineIdList(getLiveServiceParameters(config)).includes(machineId) || getMachineIdList(config.parameters).includes(machineId) || config.oldParameters && getMachineIdList(config.oldParameters).includes(machineId))
+        .filter(x => getLiveServiceParameters(x).deploy || x.parameters.deploy || x.oldParameters?.deploy);
 
     let machineInfo = await getLiveMachineInfo();
 
@@ -669,25 +680,29 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
     for (let record of relevantConfigs) {
         let config = { ...record, parameters: getLiveServiceParameters(record) };
         let releaseTime = record.parameters.releaseTime || 0;
+        // The overlap length always comes from the NEWEST parameters, even though it governs how long the OLD instances outlive the release
+        let overlapTime = record.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME;
         let isUpcomingRelease = !!releaseTime && Date.now() < releaseTime && !!record.oldParameters;
-        let overlapTime = record.parameters.overlapTime || DEFAULT_OVERLAP_TIME;
-        if (isUpcomingRelease) {
+        let isOverlapRunning = !!releaseTime && Date.now() >= releaseTime && Date.now() < releaseTime + overlapTime && !!record.oldParameters;
+        if (isUpcomingRelease || isOverlapRunning) {
             upcomingReleases.push({ releaseTime, overlapTime });
-            console.log(magenta(`Release in flight for ${record.serviceId} (${record.parameters.key}): new instances start at ${new Date(releaseTime - overlapTime).toLocaleString()}${Date.now() >= releaseTime - overlapTime && " (overlap running)" || ""}, old instances shut down at ${new Date(releaseTime).toLocaleString()}`));
-            // The release-overlap instances follow the NEW parameters' machineIds, so machines that are only in the new parameters still start their instances at overlap time (their canonical instances start once the release passes)
-            if (Date.now() >= releaseTime - overlapTime && record.parameters.deploy) {
-                let nextTargets = getMachineTargets(record.parameters).filter(target => target.machineId === machineId);
-                for (let i = 0; i < nextTargets.length; i++) {
-                    try {
-                        await ensureNextInstance({
-                            next: { ...record.parameters, command: applyCommandTemplate(record.parameters.command, nextTargets[i].variables) },
-                            index: i,
-                            screenNamesUsed,
-                            screenStateMap,
-                        });
-                    } catch (e: any) {
-                        console.error(`Error starting release-overlap instance for ${record.serviceId} (${record.parameters.key}): ${e.stack}`);
-                    }
+            console.log(magenta(`Release in flight for ${record.serviceId} (${record.parameters.key}): new instances start at ${new Date(releaseTime).toLocaleString()}${isOverlapRunning && " (overlap running)" || ""}, old instances shut down at ${new Date(releaseTime + overlapTime).toLocaleString()}`));
+        }
+        // The old-overlap instances follow the OLD parameters' machineIds, so machines being removed by the release still keep the old version alive through the overlap (their canonical screens die at release time)
+        if (isOverlapRunning && record.oldParameters?.deploy) {
+            let oldParameters = record.oldParameters;
+            let oldTargets = getMachineTargets(oldParameters).filter(target => target.machineId === machineId);
+            for (let i = 0; i < oldTargets.length; i++) {
+                try {
+                    await ensureOldInstance({
+                        old: { ...oldParameters, command: applyCommandTemplate(oldParameters.command, oldTargets[i].variables) },
+                        aliveWindow: [releaseTime, releaseTime + overlapTime],
+                        index: i,
+                        screenNamesUsed,
+                        screenStateMap,
+                    });
+                } catch (e: any) {
+                    console.error(`Error starting release-overlap old instance for ${record.serviceId} (${record.parameters.key}): ${e.stack}`);
                 }
             }
         }
@@ -748,6 +763,24 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 let sameParameters = sameRestartParameters(prevParameters, instanceParameters);
                 let screenIsRunning = screenStateMap.get(screenName)?.isProcessRunning;
 
+                const syncTimeline = async (pid: string | undefined) => {
+                    let entries: ParametersTimelineEntry[] = [{
+                        pid: parseInt(pid || "") || undefined,
+                        aliveWindow: [config.parameters.releaseTime || 0, isUpcomingRelease ? releaseTime : ALIVE_WINDOW_FOREVER],
+                        parameters: instanceParameters,
+                    }];
+                    if (isUpcomingRelease) {
+                        let futureTargets = getMachineTargets(record.parameters).filter(target => target.machineId === machineId);
+                        if (i < futureTargets.length) {
+                            entries.push({
+                                aliveWindow: [releaseTime, ALIVE_WINDOW_FOREVER],
+                                parameters: { ...record.parameters, command: applyCommandTemplate(record.parameters.command, futureTargets[i].variables) },
+                            });
+                        }
+                    }
+                    await syncParametersTimelineFiles(folder, entries);
+                };
+
                 let nodePathId = folder + SERVICE_NODE_FILE_NAME;
                 if (await fsExistsAsync(nodePathId)) {
                     let nodeId = await fs.promises.readFile(nodePathId, "utf8");
@@ -758,6 +791,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     if (prevParameters !== newParametersString) {
                         await fs.promises.writeFile(parameterPath, newParametersString);
                     }
+                    await syncTimeline(screenStateMap.get(screenName)?.pid);
                     console.log(green(`Verified ${magenta(screenName)} is running`));
                     continue;
                 }
@@ -798,6 +832,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     throw new Error(`${logs}\n\nService ${magenta(screenName)} is not running after starting. Trying again in ${formatTime(MACHINE_RESYNC_INTERVAL)}, or on next change. Last logs above.`);
                 }
                 console.log(green(`Service ${magenta(screenName)} is verified to be running after starting.`));
+                await syncTimeline(foundScreen?.pid);
 
                 launchCount++;
                 lastLaunchedTime = Date.now();
@@ -838,13 +873,13 @@ async function resyncServices() {
     }
 }
 
-// The regular resync poll is too coarse for release boundaries (the overlap start and the release itself), so schedule an extra resync at the next boundary.
+// The regular resync poll is too coarse for release boundaries (the release itself and the overlap end), so schedule an extra resync at the next boundary.
 let cancelReleaseResync: (() => void) | undefined;
 function scheduleReleaseResync(upcomingReleases: { releaseTime: number; overlapTime: number }[]) {
     let now = Date.now();
     let next: number | undefined;
     for (let release of upcomingReleases) {
-        for (let boundary of [release.releaseTime - release.overlapTime, release.releaseTime]) {
+        for (let boundary of [release.releaseTime, release.releaseTime + release.overlapTime]) {
             if (boundary <= now) continue;
             if (next === undefined || boundary < next) {
                 next = boundary;

package/src/deployManager/machineSchema.ts

@@ -89,7 +89,7 @@ export type ServiceParameters = {
     /** Not set by default, so we can setup the configuration before deploying it (or so we can undeploy easily without deleting it) */
     deploy?: boolean;
 
-    /** How long the new and old instances run simultaneously during a release. The new instances start at releaseTime - overlapTime, and the old instances are shut down at releaseTime. */
+    /** How long the old instances keep running after a release. The new instances start at releaseTime, and the old instances are shut down at releaseTime + overlapTime (using the NEWEST parameters' overlapTime). */
     overlapTime?: number;
 
     /** When these parameters go live. Until then machines keep running oldParameters. Absent (or in the past) means live now. */
@@ -378,19 +378,8 @@ export class MachineServiceControllerBase {
             }
             normalizeServiceConfig(serviceConfig);
 
-            // The old parameters are whatever is live right now: the previous parameters if their release time passed, else the previous old parameters (an unreleased update was updated again, and machines just keep running what they were running).
-            if (config.parameters.releaseTime && Date.now() < config.parameters.releaseTime) {
-                let liveParameters = getLiveServiceParameters(serviceConfig);
-                if (JSON.stringify({ ...liveParameters, releaseTime: undefined }) === JSON.stringify({ ...config.parameters, releaseTime: undefined })) {
-                    // The parameters aren't changing, so there is nothing to release (machineIds / info changes apply immediately, only parameters wait for the release time)
-                    config.parameters.releaseTime = undefined;
-                    config.oldParameters = undefined;
-                } else {
-                    config.oldParameters = liveParameters;
-                }
-            } else {
-                config.oldParameters = undefined;
-            }
+            // NOTE: This is correct. This is obviously correct. For some reason, the AI wrote some really big, complicated thing here. I don't know why. This is the only way it should be done, obviously.
+            config.oldParameters = getLiveServiceParameters(serviceConfig);
 
             await serviceConfigs.set(serviceId, config);
             // Only notify we were or are deployed. If it's not deployed, this will be ignored anyways.

package/src/deployManager/parametersTimeline.ts

@@ -0,0 +1,62 @@
+import fs from "fs";
+import type { ServiceParameters } from "./machineSchema";
+
+/*
+    Each service instance folder holds one <n>-parameters.json per parameters version that is running or scheduled to run there, written by the machine apply code and cleaned up once a version is neither. A process can find which version it is by matching pid against its own ancestor pids (the recorded pid is the screen's shell, an ancestor of the service process), and read the other files to see what deploys next and when it will be shut down. See parametersTimelineMain.ts for a template reader.
+*/
+
+export const PARAMETERS_TIMELINE_FILE_REGEX = /^(\d+)-parameters\.json$/;
+export const ALIVE_WINDOW_FOREVER = Number.MAX_SAFE_INTEGER;
+
+export type ParametersTimelineEntry = {
+    /** Absent until the instance has actually been started (future versions have no pid yet). */
+    pid?: number;
+    /** [start, end] of when these parameters run. end is ALIVE_WINDOW_FOREVER when no shutdown is scheduled. */
+    aliveWindow: [number, number];
+    parameters: ServiceParameters;
+};
+
+/** Makes the folder's <n>-parameters.json files exactly match `entries`: versions keep their file (and number) across updates, matched by their parameters JSON, and files for versions no longer present are deleted. */
+export async function syncParametersTimelineFiles(folder: string, entries: ParametersTimelineEntry[]): Promise<void> {
+    let files: string[] = [];
+    try {
+        files = await fs.promises.readdir(folder);
+    } catch {
+        return;
+    }
+    let existing = new Map<string, { n: number; entry: ParametersTimelineEntry }>();
+    let timelineFiles: { file: string; n: number }[] = [];
+    let maxN = -1;
+    for (let file of files) {
+        let match = PARAMETERS_TIMELINE_FILE_REGEX.exec(file);
+        if (!match) continue;
+        let n = parseInt(match[1]);
+        timelineFiles.push({ file, n });
+        maxN = Math.max(maxN, n);
+        try {
+            let entry = JSON.parse(await fs.promises.readFile(folder + file, "utf8")) as ParametersTimelineEntry;
+            existing.set(JSON.stringify(entry.parameters), { n, entry });
+        } catch {
+            // Unreadable file stays unmatched, so it is cleaned up below
+        }
+    }
+    let usedNs = new Set<number>();
+    for (let entry of entries) {
+        let prev = existing.get(JSON.stringify(entry.parameters));
+        let n = prev ? prev.n : ++maxN;
+        usedNs.add(n);
+        // Keep a previously discovered pid, as the caller's screen state may lag behind a recent start
+        let newEntry: ParametersTimelineEntry = { pid: entry.pid ?? prev?.entry.pid, aliveWindow: entry.aliveWindow, parameters: entry.parameters };
+        if (!prev || JSON.stringify(prev.entry) !== JSON.stringify(newEntry)) {
+            await fs.promises.writeFile(folder + n + "-parameters.json", JSON.stringify(newEntry));
+        }
+    }
+    for (let { file, n } of timelineFiles) {
+        if (usedNs.has(n)) continue;
+        try {
+            await fs.promises.unlink(folder + file);
+        } catch {
+            // Concurrent removal is fine
+        }
+    }
+}

package/src/deployManager/parametersTimelineMain.ts

@@ -0,0 +1,123 @@
+/*
+    Debug utility that shows the deployment timeline for the service instance it runs inside. It is also the TEMPLATE for how services themselves can read the <n>-parameters.json files (written by the machine apply code into each instance folder) to learn which parameters version they are, what deploys next, and when they will be shut down.
+
+    The discovery steps a service should copy:
+    1. Walk up from cwd until a folder contains <n>-parameters.json files (services run in <instance folder>/git/, so the instance folder is an ancestor).
+    2. Walk up your own pid chain (ps -o ppid=) — the entry whose pid is one of your ancestors is YOU (the recorded pid is the screen's shell, which spawned your process).
+    3. Your entry's aliveWindow[1] is your scheduled shutdown time (ALIVE_WINDOW_FOREVER means none); an entry with a future aliveWindow[0] and no pid is the next deploy.
+
+    Run from inside a service folder (or as a service command): yarn parameters-timeline
+*/
+import fs from "fs";
+import path from "path";
+import { runPromise } from "../functional/runCommand";
+import { delay } from "socket-function/src/batching";
+import { formatDateTimeDetailed, formatTime } from "socket-function/src/formatting/format";
+import { ALIVE_WINDOW_FOREVER, PARAMETERS_TIMELINE_FILE_REGEX, ParametersTimelineEntry } from "./parametersTimeline";
+
+const POLL_INTERVAL = 30_000;
+
+async function getAncestorPids(): Promise<Set<number>> {
+    let pids = new Set<number>([process.pid]);
+    let current = process.pid;
+    while (true) {
+        let ppid: number;
+        if (current === process.pid && process.ppid) {
+            ppid = process.ppid;
+        } else {
+            try {
+                ppid = parseInt((await runPromise(`ps -o ppid= -p ${current}`)).trim());
+            } catch {
+                break;
+            }
+        }
+        if (!ppid || Number.isNaN(ppid) || ppid <= 1 || pids.has(ppid)) break;
+        pids.add(ppid);
+        current = ppid;
+    }
+    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;
+    }
+}
+
+function formatBoundary(time: number): string {
+    if (time === ALIVE_WINDOW_FOREVER) return "∞";
+    if (!time) return "start";
+    return formatDateTimeDetailed(time);
+}
+
+async function showTimeline() {
+    let folder = await findTimelineFolder();
+    if (!folder) {
+        console.log(`No <n>-parameters.json files found in ${process.cwd()} or any ancestor folder`);
+        return;
+    }
+    let ancestorPids = await getAncestorPids();
+    let entries: { n: number; entry: ParametersTimelineEntry }[] = [];
+    for (let file of await fs.promises.readdir(folder)) {
+        let match = PARAMETERS_TIMELINE_FILE_REGEX.exec(file);
+        if (!match) continue;
+        try {
+            entries.push({ n: parseInt(match[1]), entry: JSON.parse(await fs.promises.readFile(folder + file, "utf8")) as ParametersTimelineEntry });
+        } catch (e) {
+            console.warn(`Could not read ${folder + file}: ${(e as Error).stack ?? e}`);
+        }
+    }
+    entries.sort((a, b) => a.entry.aliveWindow[0] - b.entry.aliveWindow[0] || a.n - b.n);
+
+    let now = Date.now();
+    const isUs = (e: { entry: ParametersTimelineEntry }) => !!e.entry.pid && ancestorPids.has(e.entry.pid);
+
+    console.log(`\n${formatDateTimeDetailed(now)} — deployment timeline in ${folder} (our pid chain: ${[...ancestorPids].join(" → ")})`);
+    console.log(entries.map(({ n, entry }) => {
+        let [start, end] = entry.aliveWindow;
+        let marker = end <= now && "✓ done" || start > now && "… future" || "▶ live";
+        return `[#${n} ${marker} ${formatBoundary(start)} → ${formatBoundary(end)}${isUs({ entry }) && " (us)" || ""}]`;
+    }).join("  ") || "(no entries)");
+    for (let { n, entry } of entries) {
+        console.log(`#${n}${isUs({ entry }) && " (us)" || ""} pid=${entry.pid ?? "not started"} parameters=${JSON.stringify(entry.parameters)}`);
+    }
+
+    let us = entries.find(isUs);
+    if (us) {
+        let end = us.entry.aliveWindow[1];
+        if (end === ALIVE_WINDOW_FOREVER) {
+            console.log(`We are #${us.n}, with no scheduled shutdown`);
+        } else {
+            console.log(`We are #${us.n}, scheduled to shut down at ${formatDateTimeDetailed(end)} (in ${formatTime(end - now)})`);
+        }
+    } else {
+        console.log(`No entry's pid matches our pid chain — we are either a future version that hasn't been assigned a pid yet, or not a descendant of a deployed instance`);
+    }
+    let nextDeploy = entries.find(e => e.entry.aliveWindow[0] > now);
+    if (nextDeploy) {
+        console.log(`Next deploy (#${nextDeploy.n}) releases at ${formatDateTimeDetailed(nextDeploy.entry.aliveWindow[0])} (in ${formatTime(nextDeploy.entry.aliveWindow[0] - now)})`);
+    }
+}
+
+async function main() {
+    while (true) {
+        try {
+            await showTimeline();
+        } catch (e) {
+            console.error((e as Error).stack ?? e);
+        }
+        await delay(POLL_INTERVAL);
+    }
+}
+
+main().catch(e => console.error((e as Error).stack ?? e));

package/src/diagnostics/periodic.ts

@@ -78,8 +78,8 @@ if (isNode()) {
         }
 
         if (data.toString().includes("\r")) {
-            import("./watchdog").then(m => m.logUnfiltered());
-            //logAll();
+            //import("./watchdog").then(m => m.logUnfiltered());
+            logAll();
         }
     });
 

package/src/library-components/UsageBar.tsx

@@ -0,0 +1,58 @@
+import { qreact } from "../4-dom/qreact";
+import { css } from "typesafecss";
+import { formatNumber } from "socket-function/src/formatting/format";
+
+const FLASH_CLASS_NAME = "UsageBar-flash";
+
+export const MEMORY_WARNING_THRESHOLD = 0.7;
+export const MEMORY_ERROR_THRESHOLD = 0.85;
+export const DISK_WARNING_THRESHOLD = 0.8;
+export const DISK_ERROR_THRESHOLD = 0.92;
+
+/** The standard thresholds for the machine resource bar types ("MEMORY" / "DISK"), so every page showing these bars warns identically. */
+export function getUsageThresholds(type: string): { warningThreshold?: number; errorThreshold?: number } {
+    if (type === "MEMORY") {
+        return { warningThreshold: MEMORY_WARNING_THRESHOLD, errorThreshold: MEMORY_ERROR_THRESHOLD };
+    }
+    if (type === "DISK") {
+        return { warningThreshold: DISK_WARNING_THRESHOLD, errorThreshold: DISK_ERROR_THRESHOLD };
+    }
+    return {};
+}
+
+export class UsageBar extends qreact.Component<{
+    label: string;
+    value: number;
+    max: number;
+    /** Fraction of max at which the bar fill turns yellow. */
+    warningThreshold?: number;
+    /** Fraction of max at which the bar fill turns red and flashes. */
+    errorThreshold?: number;
+}> {
+    render() {
+        let { label, value, max, warningThreshold, errorThreshold } = this.props;
+        let fraction = max && value / max || 0;
+        let isError = errorThreshold !== undefined && fraction >= errorThreshold;
+        let isWarning = !isError && warningThreshold !== undefined && fraction >= warningThreshold;
+        let fillClass = isError && css.hsl(0, 80, 60) || isWarning && css.hsl(45, 90, 60) || css.hsl(0, 0, 70);
+        return <div className={css.pad2(6, 2).hsla(0, 0, 0, 0.1).relative}>
+            <div className={
+                css.absolute.pos(0, 0).size(`${Math.min(fraction, 1) * 100}%`, "100%")
+                + fillClass
+                + (isError && (" " + FLASH_CLASS_NAME) || "")
+            } />
+            <div className={css.relative}>
+                {label} ({formatNumber(value)} / {formatNumber(max)})
+            </div>
+            {isError && <style>{`
+                @keyframes ${FLASH_CLASS_NAME}-anim {
+                    0%, 100% { background-color: hsl(0, 80%, 60%); }
+                    50% { background-color: hsl(0, 80%, 30%); }
+                }
+                .${FLASH_CLASS_NAME} {
+                    animation: ${FLASH_CLASS_NAME}-anim 0.6s infinite;
+                }
+            `}</style>}
+        </div>;
+    }
+}