querysub 0.564.0 → 0.566.0

package/appSecrets.ts

@@ -24,7 +24,7 @@ export const getCloudflareCreds = lazy(async (): Promise<{ key: string; email: s
 /** Serves the secret keys sliftutils' getSecret expects, reading them the way querysub already does: backblaze creds off disk (getBackblazePath), cloudflare creds from the keys archives bucket (with its local file fallback). */
 export async function getAppSecret(key: string): Promise<string | undefined> {
     // Import query sub so our logs go to our actual log server. Otherwise we won't know if we get any errors. 
-    Querysub;
+    //Querysub;
     if (key.startsWith("backblaze.json.")) {
         let creds = JSON.parse(fs.readFileSync(getBackblazePath(), "utf8")) as { applicationKeyId?: string; applicationKey?: string };
         if (key === "backblaze.json.applicationKeyId") return creds.applicationKeyId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.564.0",
+  "version": "0.566.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -71,7 +71,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.42",
+    "sliftutils": "^1.7.43",
     "socket-function": "^1.2.26",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",

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

@@ -19,6 +19,9 @@ function createSourceWindows(
     let timeRanges: [number, number][] = [];
     for (let windowIndex = 0; windowIndex < sourceWindows.length; windowIndex++) {
         let startTime = sourceWindows[windowIndex].startTime;
+        if (windowIndex === 0) {
+            startTime = 0;
+        }
         let endTime = sourceWindows[windowIndex + 1]?.startTime ?? Number.MAX_SAFE_INTEGER;
         if (startTime > endTime) throw new Error(`Source window ${formatDateTime(startTime)} starts after end of ${formatDateTime(endTime)}`);
         timeRanges.push([startTime, endTime]);
@@ -40,29 +43,29 @@ function archiveBuilder(bucket: string, overrides: Partial<RemoteConfigBase>) {
     const BACKBLAZE = `https://f002.backblazeb2.com/file/${bucket}/storage/storagerouting.json`;
     let sources = createSourceWindows(overrides, [
         {
-            startTime: 0,
+            startTime: +new Date("2026-07-20 18:00:00-04:00"),
             sources: [
-                { type: "remote", url: ONTARIO, route: [0, 0.5], },
-                { type: "remote", url: HETZNER, route: [0.5, 1], },
+                { type: "remote", url: ONTARIO, route: [0.5, 1], },
+                { type: "remote", url: HETZNER, route: [0, 0.5], },
                 { type: "remote", url: ONTARIO, },
                 { type: "remote", url: HETZNER, },
                 { type: "backblaze", url: BACKBLAZE, },
             ]
         },
         {
-            startTime: +new Date("2026-07-20 18:00:00-04:00"),
+            startTime: +new Date("2026-07-21 02:59:00-04:00"),
             sources: [
-                { type: "remote", url: ONTARIO, route: [0.5, 1], },
-                { type: "remote", url: HETZNER, route: [0, 0.5], },
+                { type: "remote", url: ONTARIO, route: [0, 0.5], },
+                { type: "remote", url: HETZNER, route: [0.5, 1], },
                 { type: "remote", url: ONTARIO, },
                 { type: "remote", url: HETZNER, },
                 { type: "backblaze", url: BACKBLAZE, },
             ]
-        }
+        },
     ]);
 
     return createArchives({
-        version: 14,
+        version: 15,
         sources,
     });
 }

package/src/deployManager/components/ProcessesView.tsx

@@ -167,6 +167,12 @@ export class ProcessesView extends qreact.Component<{
     serviceId?: string;
 }> {
     render() {
+        // Callers hand us one entry per service instance, so a machine running several instances arrives several times. Each machine's processes are listed once, whatever it is running.
+        let machines = new Map<string, { machineId: string; applyNodeId: string }>();
+        for (let machine of this.props.machines) {
+            if (machines.has(machine.machineId)) continue;
+            machines.set(machine.machineId, machine);
+        }
         return <div className={css.vbox(14).fillWidth}>
             <div className={css.hbox(10).alignItems("center")}>
                 <h3 className={css.flexGrow(1)}>Processes</h3>
@@ -176,7 +182,7 @@ export class ProcessesView extends qreact.Component<{
                     Invalidate
                 </Button>
             </div>
-            {this.props.machines.map(machine => <MachineProcesses
+            {[...machines.values()].map(machine => <MachineProcesses
                 key={machine.machineId}
                 machineId={machine.machineId}
                 applyNodeId={machine.applyNodeId}

package/src/deployManager/components/RouteConfigView.tsx

@@ -12,7 +12,7 @@ import type { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig } fr
 import { showModal } from "../../5-diagnostics/Modal";
 import { FullscreenModal } from "../../5-diagnostics/FullscreenModal";
 import { Button } from "../../library-components/Button";
-import { Tag, TAG_FONT_SIZE, TAG_WARNING_COLOR, NO_FULL_SYNC_TAG } from "./Tag";
+import { Tag, TAG_FONT_SIZE, TAG_WARNING_COLOR, getSourceTags } from "./Tag";
 import { StorageSynced, type StorageServerBuckets } from "./StoragePage";
 
 module.hotreload = true;
@@ -343,21 +343,6 @@ function showConfigModal(bucketName: string, rawConfig: RemoteConfig): void {
     });
 }
 
-function getSourceTags(source: Source): { icon: string; text: string }[] {
-    let tags: { icon: string; text: string }[] = [];
-    if (source.public) tags.push({ icon: "🌐", text: "public" });
-    if (source.immutable) tags.push({ icon: "🔒", text: "immutable" });
-    if (source.noFullSync) tags.push(NO_FULL_SYNC_TAG);
-    if (source.intermediate) tags.push({ icon: "⏳", text: "intermediate" });
-    if (source.type === "remote") {
-        if (source.fast) tags.push({ icon: "⚡", text: "fast" });
-        if (source.rawDisk) tags.push({ icon: "💽", text: "rawDisk" });
-        if (source.writeDelay !== undefined) tags.push({ icon: "⏱", text: `writeDelay ${formatTime(source.writeDelay)}` });
-    }
-    if (source.readerDiskLimit !== undefined) tags.push({ icon: "📦", text: `readCache ${formatNumber(source.readerDiskLimit)}B` });
-    return tags;
-}
-
 /** Watching a source pins that server's own live view of the bucket to the top of the page, so disagreements between servers are visible directly. */
 class WatchButton extends qreact.Component<{ source: Source; bucketName: string }> {
     render() {

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -35,10 +35,6 @@ export class ServiceDetailPage extends qreact.Component {
         expandedErrors: t.lookup({
             expanded: t.type(false)
         }),
-        // Milliseconds; 0 means no scheduled time picked yet (use Deploy Now instead)
-        switchTime: t.number(0),
-        // 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),
     });
@@ -64,8 +60,6 @@ export class ServiceDetailPage extends qreact.Component {
                 await MachineServiceController(SocketFunction.browserNodeId()).setServiceConfigs.promise([deployConfig]);
                 Querysub.commit(() => {
                     this.state.editorState = stripReleaseState(deployConfig);
-                    this.state.switchTime = 0;
-                    this.state.releaseDelayOverride = 0;
                     this.state.overlapOverride = 0;
                 });
             } finally {
@@ -93,16 +87,16 @@ export class ServiceDetailPage extends qreact.Component {
         modal = showModal({
             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 className={css.boldStyle.fontSize(16)}>🚀 Deploy?</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>
+                        ? `This config goes live now. The old instances keep running for ${formatTime(deployConfig.parameters.overlapTime)} before shutting down.`
+                        : "This config goes live now. The old instances are shut down as soon as the new ones are up, so anything still connected to them is dropped."}</div>
                     <div className={css.hbox(10)}>
                         <Button hue={0} onClick={() => {
                             modal && modal.close();
                             deployConfig.parameters.releaseTime = Date.now();
                             this.deployConfig(deployConfig);
-                        }}>⚡ Force Deploy Now</Button>
+                        }}>🚀 Deploy</Button>
                         <Button onClick={() => modal && modal.close()}>Cancel</Button>
                     </div>
                 </div>
@@ -642,70 +636,39 @@ export class ServiceDetailPage extends qreact.Component {
                         <span title={`${configCompareKey(config)} !== ${configCompareKey(deployedConfig)}`}>Only the title / notes changed, so this saves immediately</span>
                     </div>;
                 }
-                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;
-                const makeDeployConfig = (releaseTime: number, overlapTime = overlap) => {
+                // A deploy always goes live now. The overlap is what keeps the service up: the old instances keep running for it, so connections have somewhere to go while clients move across.
+                const makeDeployConfig = (overlapTime = overlap) => {
                     let deployConfig = deepCloneJSON(config);
-                    deployConfig.parameters.releaseTime = releaseTime;
+                    deployConfig.parameters.releaseTime = Date.now();
                     deployConfig.parameters.overlapTime = overlapTime;
                     return deployConfig;
                 };
-                // 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)
                     </div>
                     <ParametersDiff base={liveParameters} next={config.parameters} />
-                    <div className={css.hbox(12).wrap}>
+                    <div className={css.hbox(12).wrap.alignItems("center")}>
                         <button
                             className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(120, 70, 85).fontWeight("bold")}
                             disabled={this.state.isDeploying}
+                            title="Deploys now; the old instances keep running for the overlap before shutting down"
                             onClick={() => {
-                                this.deployConfig(makeDeployConfig(scheduledTime || Date.now() + releaseDelay));
+                                this.confirmForceDeployNow(makeDeployConfig());
                             }}>
-                            {this.state.isDeploying && "⏳ Scheduling..." || scheduledDeploy && "🔁 Replace Scheduled Deploy" || "🚀 Schedule Deploy"}
+                            {this.state.isDeploying && "⏳ Deploying..." || "🚀 Deploy"}
                         </button>
                         <button
-                            className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(35, 70, 85)}
+                            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 with the configured release delay, but the old instances shut down immediately at release time (overlap of 0)"
+                            title="Deploys now AND shuts the old instances down as soon as the new ones are up (overlap of 0)"
                             onClick={() => {
-                                this.deployConfig(makeDeployConfig(scheduledTime || Date.now() + releaseDelay, 0));
+                                this.confirmForceDeployNow(makeDeployConfig(0));
                             }}>
                             Deploy, No Overlap
                         </button>
-                        <div className={css.opacity(scheduledTime && 1 || 0.5)}>
-                            <InputLabel
-                                label="Switch at"
-                                isDatetime
-                                value={effectiveSwitchTime}
-                                onChangeValue={value => {
-                                    this.state.switchTime = Number(value) || 0;
-                                }}
-                            />
-                        </div>
-                        <span>(in {formatTime(effectiveSwitchTime - now)})</span>
-                        {!!scheduledTime && <button
-                            className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(0, 0, 90)}
-                            onClick={() => {
-                                this.state.switchTime = 0;
-                            }}>
-                            ↺ Reset to delay-based time
-                        </button>}
-                        <div className={css.opacity(scheduledTime && 0.5 || 1)}>
-                            <InputLabel
-                                label="Release in (seconds)"
-                                integer
-                                value={releaseDelaySeconds}
-                                onChangeValue={value => {
-                                    this.state.releaseDelayOverride = Number(value) || 0;
-                                }}
-                            />
-                        </div>
                         <InputLabel
                             label="Overlap (seconds)"
                             integer
@@ -715,29 +678,6 @@ export class ServiceDetailPage extends qreact.Component {
                             }}
                         />
                     </div>
-                    {!!scheduledTime && scheduledTime <= now && <span className={css.colorhsl(0, 85, 45).fontWeight("bold")}>
-                        ⚠️ The switch time is in the past — deploying switches immediately
-                    </span>}
-                    <div className={css.hbox(8)}>
-                        <button
-                            className={css.pad2(12, 8).button.bord2(45, 80, 35).hsl(45, 85, 82)}
-                            disabled={this.state.isDeploying}
-                            title="Deploys immediately; the old instances keep running for their configured overlap before shutting down"
-                            onClick={() => {
-                                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>;
             })()}
 

package/src/deployManager/components/StoragePage.tsx

@@ -17,7 +17,7 @@ import { isDefined } from "../../misc";
 import { STORAGE_ACCOUNT } from "../../-a-archives/archives2";
 import { Table } from "../../5-diagnostics/Table";
 import { RouteConfigView } from "./RouteConfigView";
-import { Tag, NO_FULL_SYNC_TAG } from "./Tag";
+import { Tag, SourceTag, getSourceTags } from "./Tag";
 
 module.hotreload = true;
 
@@ -134,7 +134,7 @@ type BucketRow = {
     state: string;
     files: string;
     bytes: string;
-    noFullSync: boolean;
+    flags: SourceTag[];
     indexSources: ArchivesConfig["indexSources"];
     readerDiskLimit: string;
     writes: string;
@@ -152,13 +152,13 @@ const DISK_BAR_TYPE = "DISK";
 const ACTIVE_STATE = "active";
 const INACTIVE_STATE = "inactive";
 
-/** Whether this server only caches what is read of the bucket instead of keeping a full copy, read off its own entry in the bucket's routing config. */
-function getNoFullSync(serverUrl: string, bucketName: string, remoteConfig: RemoteConfig | undefined): boolean {
+/** The flags this server's own entries in the bucket's routing config set - how it holds the bucket, which is not something the bucket's own state reports. */
+function getBucketFlags(serverUrl: string, bucketName: string, remoteConfig: RemoteConfig | undefined): SourceTag[] {
     let host: URL;
     try {
         host = new URL(serverUrl);
     } catch {
-        return false;
+        return [];
     }
     let selfEntries: HostedConfig[] = [];
     for (let source of remoteConfig?.sources || []) {
@@ -173,7 +173,15 @@ function getNoFullSync(serverUrl: string, bucketName: string, remoteConfig: Remo
             // A malformed url in the config is not this column's problem
         }
     }
-    return selfEntries.some(x => x.noFullSync);
+    // A server can hold several entries for one bucket (different windows or route shards), so the flags are the union of theirs, deduped by what they say
+    let flags = new Map<string, SourceTag>();
+    for (let entry of selfEntries) {
+        for (let tag of getSourceTags(entry)) {
+            if (flags.has(tag.text)) continue;
+            flags.set(tag.text, tag);
+        }
+    }
+    return [...flags.values()];
 }
 
 /** How much fast-mode coalescing saved: every accepted write over the ones that actually reached a source. */
@@ -195,7 +203,7 @@ function getBucketRows(servers: StorageServerBuckets[]): BucketRow[] {
             state: "",
             files: "",
             bytes: "",
-            noFullSync: false,
+            flags: [],
             indexSources: undefined,
             readerDiskLimit: "",
             writes: "",
@@ -225,7 +233,7 @@ function getBucketRows(servers: StorageServerBuckets[]): BucketRow[] {
                 state: bucket.active && ACTIVE_STATE || INACTIVE_STATE,
                 files: config?.index && formatNumber(config.index.fileCount) || "",
                 bytes: config?.index && formatNumber(config.index.byteCount) + "B" || "",
-                noFullSync: getNoFullSync(server.url, bucket.bucketName, config?.remoteConfig),
+                flags: getBucketFlags(server.url, bucket.bucketName, config?.remoteConfig),
                 indexSources: config?.indexSources,
                 readerDiskLimit: config?.readerDiskLimit && formatNumber(config.readerDiskLimit) + "B" || "",
                 writes: bucket.writeStats && formatNumber(bucket.writeStats.originalWrites) || "",
@@ -581,10 +589,12 @@ export class StoragePage extends qreact.Component {
                     },
                     files: { title: "Files" },
                     bytes: { title: "Bytes" },
-                    noFullSync: {
-                        title: "Sync",
-                        // Nothing to show when a full copy is kept - that is the default, and the tag is the flag
-                        formatter: noFullSync => noFullSync && <Tag icon={NO_FULL_SYNC_TAG.icon} text={NO_FULL_SYNC_TAG.text} /> || ""
+                    flags: {
+                        title: "Flags",
+                        // Only flags that are set produce a tag, so an empty cell means every default
+                        formatter: flags => <div className={css.hbox(4).wrap}>
+                            {(flags || []).map(tag => <Tag key={tag.text} icon={tag.icon} text={tag.text} />)}
+                        </div>
                     },
                     indexSources: {
                         title: "Index sources",

package/src/deployManager/components/Tag.tsx

@@ -1,5 +1,7 @@
 import { qreact } from "../../4-dom/qreact";
 import { css } from "typesafecss";
+import { formatNumber, formatTime } from "socket-function/src/formatting/format";
+import type { HostedConfig, BackblazeConfig } from "sliftutils/storage/IArchives";
 
 module.hotreload = true;
 
@@ -9,8 +11,23 @@ export const TAG_COLOR: TagColor = { h: 210, s: 45, l: 88 };
 export const TAG_WARNING_COLOR: TagColor = { h: 35, s: 90, l: 85 };
 export const TAG_FONT_SIZE = 11;
 
-/** A source flag, shown wherever that flag matters. The tag is only ever rendered when the flag is on - an absent tag is the default, so there is nothing to show for it. */
-export const NO_FULL_SYNC_TAG = { icon: "⇣", text: "noFullSync" };
+export type SourceTag = { icon: string; text: string };
+
+/** Every flag a source has set. Only flags that are on produce a tag - an absent tag is the default, so there is nothing to show for it. */
+export function getSourceTags(source: HostedConfig | BackblazeConfig): SourceTag[] {
+    let tags: SourceTag[] = [];
+    if (source.public) tags.push({ icon: "🌐", text: "public" });
+    if (source.immutable) tags.push({ icon: "🔒", text: "immutable" });
+    if (source.noFullSync) tags.push({ icon: "⇣", text: "noFullSync" });
+    if (source.intermediate) tags.push({ icon: "⏳", text: "intermediate" });
+    if (source.type === "remote") {
+        if (source.fast) tags.push({ icon: "⚡", text: "fast" });
+        if (source.rawDisk) tags.push({ icon: "💽", text: "rawDisk" });
+        if (source.writeDelay !== undefined) tags.push({ icon: "⏱", text: `writeDelay ${formatTime(source.writeDelay)}` });
+    }
+    if (source.readerDiskLimit !== undefined) tags.push({ icon: "📦", text: `readCache ${formatNumber(source.readerDiskLimit)}B` });
+    return tags;
+}
 
 export class Tag extends qreact.Component<{ icon: string; text: string; warning?: boolean; color?: TagColor; title?: string; }> {
     render() {

package/src/deployManager/components/deployButtons.tsx

@@ -77,21 +77,16 @@ export class UpdateButtons extends qreact.Component<{
     state = t.state({
         isDeploying: t.type(false),
     });
-    // 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") {
+    // Deploys all outdated services to latestRef, always immediately. The overlap is what keeps the service up - the old instances keep running for it, so connections have somewhere to go while clients move across. noOverlap kills them at once instead.
+    private deployAll(outdatedServices: ServiceConfig[], latestRef: string, noOverlap: boolean) {
         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 (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;
-                }
+            updated.parameters.releaseTime = Date.now();
+            if (noOverlap) {
+                updated.parameters.overlapTime = 0;
             }
             return updated;
         });
@@ -112,14 +107,14 @@ export class UpdateButtons extends qreact.Component<{
             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>
+                    ? "The old instances are shut down as soon as the new ones are up (overlap of 0), so anything still connected to them is dropped."
+                    : "The old instances keep running for their configured overlap before shutting down, so connections have somewhere to go while clients move across."}</div>
                 <div className={css.hbox(10)}>
                     <button
                         className={css.pad2(12, 8).button + (noOverlap && css.bord2(0, 90, 30).hsl(0, 85, 65).colorhsl(0, 0, 100).fontWeight("bold") || css.bord2(45, 80, 35).hsl(45, 85, 82))}
                         onClick={() => {
                             modal && modal.close();
-                            this.deployAll(outdatedServices, latestRef, noOverlap ? "nowNoOverlap" : "now");
+                            this.deployAll(outdatedServices, latestRef, noOverlap);
                         }}>
                         ⚡ Deploy Now
                     </button>
@@ -188,8 +183,9 @@ export class UpdateButtons extends qreact.Component<{
                 <button
                     className={buttonStyle.hsl(120, 70, 90)}
                     disabled={this.state.isDeploying}
+                    title="Deploys now; the old instances keep running for their configured overlap before shutting down"
                     onClick={() => {
-                        this.deployAll(outdatedServices, gitInfo.latestRef, "scheduled");
+                        this.confirmDeployAllNow(outdatedServices, gitInfo.latestRef, false);
                     }}
                 >
                     <div>
@@ -204,28 +200,16 @@ export class UpdateButtons extends qreact.Component<{
                         <RenderGitRefInfo gitRef={ref} />
                     </div>)}
                 </button>
-                <button
-                    className={buttonStyle.hsl(45, 85, 82)}
-                    disabled={this.state.isDeploying}
-                    title="Deploys immediately; the old instances keep running for their configured overlap before shutting down"
-                    onClick={() => {
-                        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)"
+                    title="Deploys now AND shuts the old instances down as soon as the new ones are up (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>
+                        {bigEmoji("⚡")} <span>{this.state.isDeploying && "⏳ Deploying..." || `Deploy All (${outdatedServices.length}), No Overlap`}</span>
                     </div>
                 </button>
             </>}