feat(desktop): add an Off option to the quit shortcut setting

apps/desktop/src/ipc/methods/preview.test.ts

@@ -61,6 +61,7 @@ describe("preview IPC methods", () => {
         ),
         Effect.provideService(DesktopClientSettings.DesktopClientSettings, {
           get: Effect.succeedNone,
+          peek: Effect.succeedNone,
           set: () => Effect.void,
         }),
       ),

apps/desktop/src/settings/DesktopClientSettings.test.ts

@@ -5,7 +5,9 @@ import {
   DEFAULT_CLIENT_SETTINGS,
   type ClientSettings,
 } from "@t3tools/contracts";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
@@ -153,6 +155,7 @@ describe("DesktopClientSettings", () => {
           onboardingCompletedAt: "2026-09-05T12:00:00.000Z",
         };
         yield* settings.set(savedSettings);
+        assert.deepEqual(yield* settings.peek, Option.some(savedSettings));
         const savedContents = yield* fileSystem.readFileString(environment.clientSettingsPath);
         const cause = PlatformError.systemError({
           _tag: failure.reason,
@@ -179,13 +182,91 @@ describe("DesktopClientSettings", () => {
         assert.equal(error.operation, "read-file");
         assert.equal(error.path, environment.clientSettingsPath);
         assert.strictEqual(error.cause, cause);
+        assert.deepEqual(yield* retryableSettings.peek, Option.none());
         assert.equal(
           yield* fileSystem.readFileString(environment.clientSettingsPath),
           savedContents,
         );
 
         failRead = false;
         assert.deepEqual(yield* retryableSettings.get, Option.some(savedSettings));
+        assert.deepEqual(yield* retryableSettings.peek, Option.some(savedSettings));
+      }),
+    ),
+  );
+
+  it.effect("keeps a newer write when an older read finishes after it", () =>
+    withClientSettings(
+      Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const settings = yield* DesktopClientSettings.DesktopClientSettings;
+        const holdSettings = { ...clientSettings, confirmQuit: "hold" as const };
+        const offSettings = { ...clientSettings, confirmQuit: "off" as const };
+        yield* settings.set(holdSettings);
+        const readStarted = yield* Deferred.make<void>();
+        const releaseRead = yield* Deferred.make<void>();
+        let delayRead = true;
+        const raceSettings = yield* DesktopClientSettings.make.pipe(
+          Effect.provideService(
+            FileSystem.FileSystem,
+            FileSystem.FileSystem.of({
+              ...fileSystem,
+              readFileString: (path) =>
+                fileSystem
+                  .readFileString(path)
+                  .pipe(
+                    Effect.tap(() =>
+                      delayRead
+                        ? Deferred.succeed(readStarted, undefined).pipe(
+                            Effect.andThen(Deferred.await(releaseRead)),
+                          )
+                        : Effect.void,
+                    ),
+                  ),
+            }),
+          ),
+        );
+
+        const staleRead = yield* Effect.forkChild(raceSettings.get);
+        yield* Deferred.await(readStarted);
+        delayRead = false;
+        yield* raceSettings.set(offSettings);
+        yield* Deferred.succeed(releaseRead, undefined);
+
+        assert.deepEqual(yield* Fiber.join(staleRead), Option.some(holdSettings));
+        assert.deepEqual(yield* raceSettings.peek, Option.some(offSettings));
+      }),
+    ),
+  );
+
+  it.effect("keeps the cached settings when a write fails", () =>
+    withClientSettings(
+      Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const settings = yield* DesktopClientSettings.DesktopClientSettings;
+        yield* settings.set(clientSettings);
+        const failingSettings = yield* DesktopClientSettings.make.pipe(
+          Effect.provideService(
+            FileSystem.FileSystem,
+            FileSystem.FileSystem.of({
+              ...fileSystem,
+              writeFileString: (path) =>
+                Effect.fail(
+                  PlatformError.systemError({
+                    _tag: "PermissionDenied",
+                    module: "FileSystem",
+                    method: "writeFileString",
+                    pathOrDescriptor: path,
+                  }),
+                ),
+            }),
+          ),
+        );
+        yield* failingSettings.get;
+
+        yield* failingSettings.set({ ...clientSettings, confirmQuit: "off" }).pipe(Effect.flip);
+
+        assert.deepEqual(yield* failingSettings.peek, Option.some(clientSettings));
       }),
     ),
   );

apps/desktop/src/settings/DesktopClientSettings.ts

@@ -66,6 +66,8 @@ export class DesktopClientSettings extends Context.Service<
   DesktopClientSettings,
   {
     readonly get: Effect.Effect<Option.Option<ClientSettings>, DesktopClientSettingsReadError>;
+    /** Latest settings read or written, for callers that must decide synchronously. */
+    readonly peek: Effect.Effect<Option.Option<ClientSettings>>;
     readonly set: (
       settings: ClientSettings,
     ) => Effect.Effect<void, DesktopClientSettingsWriteError>;
@@ -189,30 +191,50 @@ export const make = Effect.gen(function* () {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const crypto = yield* Crypto.Crypto;
+  const latestRef = yield* Ref.make(Option.none<ClientSettings>());
+  // Each write starts a generation; a read or write publishes only if no newer write began.
+  const generationRef = yield* Ref.make(0);
+  const publish = (generation: number, settings: Option.Option<ClientSettings>) =>
+    Ref.get(generationRef).pipe(
+      Effect.flatMap((current) =>
+        current === generation ? Ref.set(latestRef, settings) : Effect.void,
+      ),
+    );
 
   return DesktopClientSettings.of({
-    get: readClientSettings(fileSystem, environment.clientSettingsPath).pipe(
+    get: Ref.get(generationRef).pipe(
+      Effect.flatMap((generation) =>
+        readClientSettings(fileSystem, environment.clientSettingsPath).pipe(
+          Effect.tap((settings) => publish(generation, settings)),
+        ),
+      ),
       Effect.withSpan("desktop.clientSettings.get"),
     ),
+    peek: Ref.get(latestRef),
     set: Effect.fn("desktop.clientSettings.set")(function (settings) {
-      return crypto.randomUUIDv4().pipe(
-        Effect.map((uuid) => uuid.replace(/-/g, "")),
-        Effect.mapError(
-          (cause) =>
-            new DesktopClientSettingsWriteError({
-              operation: "create-temporary-file-name",
-              path: environment.clientSettingsPath,
-              cause,
-            }),
-        ),
-        Effect.flatMap((suffix) =>
-          writeClientSettings({
-            fileSystem,
-            path,
-            settingsPath: environment.clientSettingsPath,
-            settings,
-            suffix,
-          }),
+      return Ref.updateAndGet(generationRef, (generation) => generation + 1).pipe(
+        Effect.flatMap((generation) =>
+          crypto.randomUUIDv4().pipe(
+            Effect.map((uuid) => uuid.replace(/-/g, "")),
+            Effect.mapError(
+              (cause) =>
+                new DesktopClientSettingsWriteError({
+                  operation: "create-temporary-file-name",
+                  path: environment.clientSettingsPath,
+                  cause,
+                }),
+            ),
+            Effect.flatMap((suffix) =>
+              writeClientSettings({
+                fileSystem,
+                path,
+                settingsPath: environment.clientSettingsPath,
+                settings,
+                suffix,
+              }),
+            ),
+            Effect.andThen(publish(generation, Option.some(settings))),
+          ),
         ),
       );
     }),
@@ -228,6 +250,7 @@ export const layerTest = (initialSettings: Option.Option<ClientSettings> = Optio
       const settingsRef = yield* Ref.make(initialSettings);
       return DesktopClientSettings.of({
         get: Ref.get(settingsRef),
+        peek: Ref.get(settingsRef),
         set: Effect.fn("DesktopClientSettings.set")(function (settings) {
           return Ref.set(settingsRef, Option.some(settings));
         }),

apps/desktop/src/snapShot/DesktopSnapShot.test.ts

@@ -503,6 +503,7 @@ const layerTest = (
           DesktopClientSettings.DesktopClientSettings,
           DesktopClientSettings.DesktopClientSettings.of({
             get: settingsGet,
+            peek: Effect.succeedNone,
             set: () => Effect.void,
           }),
         ),

apps/desktop/src/window/DesktopApplicationMenu.test.ts

@@ -234,6 +234,27 @@ describe("DesktopApplicationMenu", () => {
     }),
   );
 
+  it.effect("leaves Ctrl+Q to the quit shortcut setting on Windows and Linux", () =>
+    Effect.gen(function* () {
+      for (const platform of ["linux", "win32"] as const) {
+        const applicationMenuTemplate =
+          yield* Deferred.make<readonly Electron.MenuItemConstructorOptions[]>();
+        yield* configureMenu(yield* Deferred.make<string>(), applicationMenuTemplate, {
+          platform,
+        });
+
+        const fileMenu = (yield* Deferred.await(applicationMenuTemplate)).find(
+          (item) => item.label === "File",
+        );
+        if (!Array.isArray(fileMenu?.submenu)) {
+          throw new Error("Expected File menu submenu to be an array.");
+        }
+        const quitItem = fileMenu.submenu.find((item) => item.role === "quit");
+        assert.isFalse(quitItem?.registerAccelerator, platform);
+      }
+    }),
+  );
+
   it.effect("reloads the main window even while a browser page has focus", () =>
     Effect.gen(function* () {
       const selectedAction = yield* Deferred.make<string>();

apps/desktop/src/window/DesktopApplicationMenu.ts

@@ -203,7 +203,8 @@ export const make = Effect.gen(function* () {
           // Cmd/Ctrl+W belongs to the renderer's tab close; it must never close the window.
           environment.platform === "darwin"
             ? { label: "Close Window", click: (_item, window) => window?.close() }
-            : { role: "quit" },
+            : // Linux's role accelerator would bypass the quit shortcut setting; QuitHold owns Ctrl+Q.
+              { role: "quit", registerAccelerator: false },
         ],
       },
       {

apps/desktop/src/window/DesktopWindow.ts

@@ -302,6 +302,7 @@ export const make = Effect.gen(function* () {
   const context = yield* Effect.context<DesktopWindowRuntimeServices>();
   const runFork = Effect.runForkWith(context);
   const runPromise = Effect.runPromiseWith(context);
+  const runSync = Effect.runSyncWith(context);
   let flushMainWindowBounds: Effect.Effect<void> = Effect.void;
 
   const dismissConnectingSplash = Effect.gen(function* () {
@@ -619,6 +620,8 @@ export const make = Effect.gen(function* () {
       }
     });
 
+    // Fills clientSettings.peek before the first key press.
+    runFork(Effect.ignore(clientSettings.get));
     const quitShortcutHandler = makeQuitShortcutHandler({
       platform: environment.platform,
       getMode: () =>
@@ -631,6 +634,7 @@ export const make = Effect.gen(function* () {
             }),
           ),
         ),
+      peekMode: () => Option.getOrUndefined(runSync(clientSettings.peek))?.confirmQuit,
       notify: (hint) => {
         if (!window.isDestroyed()) {
           window.webContents.send(QUIT_SHORTCUT_CHANNEL, hint);

apps/desktop/src/window/QuitHold.test.ts

@@ -28,13 +28,15 @@ function makeHarness(options?: {
   mode?: QuitConfirmationMode;
   platform?: NodeJS.Platform;
   getMode?: () => Promise<QuitConfirmationMode>;
+  peekMode?: () => QuitConfirmationMode | undefined;
 }) {
   const notifications: Array<QuitShortcutHintEvent> = [];
   const concealWindow = vi.fn();
   const quit = vi.fn();
   const handler = makeQuitShortcutHandler({
     platform: options?.platform ?? "darwin",
     getMode: options?.getMode ?? (() => Promise.resolve(options?.mode ?? "hold")),
+    peekMode: options?.peekMode ?? (() => undefined),
     notify: (event) => notifications.push(event),
     concealWindow,
     quit,
@@ -160,4 +162,57 @@ describe("makeQuitShortcutHandler", () => {
     expect(harness.quit).not.toHaveBeenCalled();
     expect(harness.notifications).toEqual([DOUBLE_CLICK_DOWN, UP, DOUBLE_CLICK_DOWN]);
   });
+
+  it.each(["win32", "linux"] as const)(
+    "passes Ctrl+Q through without quitting when Off on %s",
+    async (platform) => {
+      const harness = makeHarness({ mode: "off", peekMode: () => "off", platform });
+      const ctrlQ = { meta: false, control: true };
+      await harness.send(makeInput(ctrlQ));
+      await harness.holdFor(QUIT_HOLD_DURATION_MS + 200, ctrlQ);
+      await harness.send(makeInput({ ...ctrlQ, type: "keyUp" }));
+      await harness.send(makeInput(ctrlQ));
+
+      expect(harness.preventDefault).not.toHaveBeenCalled();
+      expect(harness.quit).not.toHaveBeenCalled();
+      expect(harness.notifications).toEqual([]);
+    },
+  );
+
+  it("keeps Cmd+Q from reaching the app menu when Off on macOS", async () => {
+    const harness = makeHarness({ mode: "off", peekMode: () => "off", platform: "darwin" });
+    await harness.send(makeInput({}));
+    await harness.send(makeInput({}));
+
+    expect(harness.preventDefault).toHaveBeenCalled();
+    expect(harness.quit).not.toHaveBeenCalled();
+    expect(harness.notifications).toEqual([]);
+  });
+
+  it("does not quit on a quick second press once Off is known, even with a read pending", async () => {
+    let peeked: QuitConfirmationMode = "hold";
+    const ctrlQ = { meta: false, control: true };
+    const harness = makeHarness({
+      platform: "win32",
+      getMode: () => new Promise(() => undefined),
+      peekMode: () => peeked,
+    });
+    await harness.send(makeInput(ctrlQ));
+    await harness.send(makeInput({ ...ctrlQ, type: "keyUp" }));
+    peeked = "off";
+    vi.advanceTimersByTime(QUIT_DOUBLE_PRESS_MS - 100);
+    await harness.send(makeInput(ctrlQ));
+
+    expect(harness.quit).not.toHaveBeenCalled();
+    expect(harness.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not quit when the mode read settles as Off", async () => {
+    const harness = makeHarness({ mode: "off", platform: "win32" });
+    await harness.send(makeInput({ meta: false, control: true }));
+    await harness.holdFor(QUIT_HOLD_DURATION_MS + 200, { meta: false, control: true });
+
+    expect(harness.quit).not.toHaveBeenCalled();
+    expect(harness.notifications).toEqual([]);
+  });
 });

apps/desktop/src/window/QuitHold.ts

 if (previousPressAt !== 0 && now - previousPressAt <= QUIT_DOUBLE_PRESS_MS) { 
 if (previousPressAt !== 0 && now - previousPressAt <= QUIT_DOUBLE_PRESS_MS) { 
@@ -25,6 +25,8 @@ export interface QuitHoldKeyInput {
 export interface QuitShortcutOptions {
   readonly platform: NodeJS.Platform;
   readonly getMode: () => Promise<QuitConfirmationMode>;
+  /** Latest known mode; preventDefault must be decided before getMode settles. */
+  readonly peekMode: () => QuitConfirmationMode | undefined;
   readonly notify: (event: QuitShortcutHintEvent) => void;
   readonly concealWindow: () => void;
   readonly quit: () => void;
@@ -129,6 +131,16 @@ export function makeQuitShortcutHandler(
       return;
     }
 
+    if (options.peekMode() === "off") {
+      // Passing Cmd+Q through would reach the macOS app menu's Quit accelerator.
+      if (options.platform === "darwin") event.preventDefault();
+      if (!input.isAutoRepeat) {
+        lastPressAt = 0;
+        release();
+      }
+      return;
+    }
+
     event.preventDefault();
 
     if (input.isAutoRepeat) {
@@ -158,6 +170,10 @@ export function makeQuitShortcutHandler(
     void options.getMode().then(
       (resolvedMode) => {
         if (generation !== pressGeneration) return;
+        if (resolvedMode === "off") {
+          release();
+          return;
+        }
         if (resolvedMode === "direct") {
           quitNow();
           return;