perf: trim application startup and deferred runtime work

apps/desktop/src/app/DesktopApp.ts

@@ -244,6 +244,20 @@ const bootstrap = Effect.gen(function* () {
     }
     yield* primaryBackend.start;
     yield* logBootstrapInfo("bootstrap backend start requested");
+    // The renderer loads bundled assets and can connect while the backend
+    // boots. Starting first makes its endpoint and bootstrap credential
+    // available before the preload reads them. WSL-only retains its splash
+    // until the primary has a usable endpoint. A failed open is not fatal:
+    // backend readiness tries again.
+    if (!(settings.wslOnly === true && settings.wslBackendEnabled === true)) {
+      yield* desktopWindow.ensureMain.pipe(
+        Effect.catch((error) =>
+          logBootstrapWarning("failed to open main window while the backend starts", {
+            error: error.message,
+          }),
+        ),
+      );
+    }
     yield* appActivation.start.pipe(
       Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
       Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),

apps/desktop/src/backend/DesktopBackendManager.test.ts

@@ -4,6 +4,8 @@ import {
   type DesktopBackendBootstrap as DesktopBackendBootstrapValue,
   DesktopTelemetryControlMessage,
 } from "@t3tools/contracts";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, describe, it } from "@effect/vitest";
 import * as Deferred from "effect/Deferred";
 import * as Duration from "effect/Duration";
@@ -568,6 +570,36 @@ describe("DesktopBackendManager", () => {
     ),
   );
 
+  // POSIX socketpairs reset when the reader exits with unread data; Windows uses named pipes.
+  it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
+    "survives a backend that exits with unread bootstrap input",
+    () =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const uncaught: Array<unknown> = [];
+          const onUncaught = (error: unknown) => {
+            uncaught.push(error);
+          };
+          yield* Effect.acquireRelease(
+            Effect.sync(() => process.on("uncaughtException", onUncaught)),
+            () => Effect.sync(() => process.off("uncaughtException", onUncaught)),
+          );
+
+          // Reads one byte of the bootstrap line and exits, so its pipe resets.
+          const exit = yield* DesktopBackendManager.runBackendProcess({
+            ...baseConfig,
+            executablePath: process.execPath,
+            args: ["-e", 'require("node:fs").readSync(3, Buffer.alloc(1)); process.exit(0)'],
+            cwd: process.cwd(),
+            desktopTelemetryStream: Stream.empty,
+          }).pipe(Effect.provide(Layer.merge(NodeServices.layer, layerHealthyHttpClient)));
+
+          assert.equal(exit.code.pipe(Option.getOrUndefined), 0);
+          assert.deepEqual(uncaught, []);
+        }),
+      ),
+  );
+
   it.effect("continues routing desktop telemetry control messages after an invalid line", () =>
     Effect.scoped(
       Effect.gen(function* () {

apps/desktop/src/backend/DesktopLocalEnvironmentAuth.test.ts

@@ -67,6 +67,7 @@ describe("DesktopLocalEnvironmentAuth", () => {
           {
             id: PRIMARY_LOCAL_ENVIRONMENT_ID,
             label: Effect.succeed("Windows"),
+            waitForReady: () => Effect.succeed(true),
             currentConfig: Effect.succeedSome(config),
           },
         ]),
@@ -120,6 +121,7 @@ describe("DesktopLocalEnvironmentAuth", () => {
             {
               id: PRIMARY_LOCAL_ENVIRONMENT_ID,
               label: Effect.succeed("Windows"),
+              waitForReady: () => Effect.succeed(true),
               currentConfig: Effect.succeedSome({
                 ...config,
                 bootstrap: { ...config.bootstrap, desktopBootstrapSecret: "desktop-secret" },
@@ -166,6 +168,7 @@ describe("DesktopLocalEnvironmentAuth", () => {
       {
         id: PRIMARY_LOCAL_ENVIRONMENT_ID,
         label: Effect.succeed("Windows"),
+        waitForReady: () => Effect.succeed(true),
         currentConfig: Effect.succeedSome(config),
       },
     ]),
@@ -232,4 +235,49 @@ describe("DesktopLocalEnvironmentAuth", () => {
       assert.strictEqual(yield* Ref.get(requestCount), 1);
     }).pipe(Effect.provide(TestClock.layer())),
   );
+
+  it.effect.each([true, false])("waits for backend readiness before exchange: %s", (ready) =>
+    Effect.gen(function* () {
+      let requests = 0;
+      const pool = Layer.succeed(DesktopBackendPool.DesktopBackendPool, {
+        list: Effect.succeed([
+          {
+            id: PRIMARY_LOCAL_ENVIRONMENT_ID,
+            label: Effect.succeed("Local"),
+            waitForReady: () =>
+              Effect.sleep(ready ? "40 seconds" : "2 minutes").pipe(Effect.as(ready)),
+            currentConfig: Effect.succeedSome(config),
+          },
+        ]),
+      } as unknown as DesktopBackendPool.DesktopBackendPool["Service"]);
+      const client = Layer.succeed(
+        HttpClient.HttpClient,
+        HttpClient.make((request) =>
+          Effect.sync(() => {
+            requests++;
+            return ready
+              ? tokenResponse(request)
+              : HttpClientResponse.fromWeb(request, new Response("", { status: 503 }));
+          }),
+        ),
+      );
+      const result = yield* DesktopLocalEnvironmentAuth.DesktopLocalEnvironmentAuth.pipe(
+        Effect.flatMap((auth) => auth.getBearerToken),
+        Effect.match({ onSuccess: (token) => token, onFailure: (error) => error._tag }),
+        Effect.forkChild,
+        Effect.provide(
+          DesktopLocalEnvironmentAuth.layer.pipe(Layer.provide(Layer.merge(pool, client))),
+        ),
+      );
+      assert.equal(requests, 0);
+      yield* TestClock.adjust("3 minutes");
+      const token = yield* Fiber.join(result);
+      assert.equal(
+        token,
+        ready ? "desktop-bearer-token" : "DesktopLocalEnvironmentAuthSessionBootstrapError",
+      );
+      if (ready) assert.equal(requests, 1);
+      else assert.isAbove(requests, 0);
+    }).pipe(Effect.provide(TestClock.layer())),
+  );
 });

apps/desktop/src/backend/DesktopLocalEnvironmentAuth.ts

@@ -19,6 +19,10 @@ import * as DesktopBackendPool from "./DesktopBackendPool.ts";
 const BOOTSTRAP_TRANSIENT_RETRY_TIMEOUT = Duration.seconds(15);
 const BOOTSTRAP_TRANSIENT_RETRY_INTERVAL = Duration.millis(500);
 const TRANSIENT_BOOTSTRAP_STATUS_CODES = new Set([502, 503, 504]);
+// The window opens while the backend starts, and a cold start can outlast the
+// retry window above. The exchange waits for readiness first, up to this
+// bound, so a backend that never becomes ready still fails it.
+const BACKEND_START_TIMEOUT = Duration.minutes(2);
 
 const isTransientBearerBootstrapError = (error: RemoteEnvironmentRequestError): boolean => {
   switch (error._tag) {
@@ -80,6 +84,10 @@ export const make = Effect.gen(function* () {
 
         const instances = yield* pool.list;
         const primary = instances.find((instance) => instance.id === PRIMARY_LOCAL_ENVIRONMENT_ID);
+        // Returns at once for a ready backend or one that is not running.
+        if (primary !== undefined) {
+          yield* primary.waitForReady(BACKEND_START_TIMEOUT);
+        }
         const configOption = primary === undefined ? Option.none() : yield* primary.currentConfig;
         if (Option.isNone(configOption)) {
           return yield* new DesktopLocalEnvironmentAuthBackendNotConfiguredError();

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

@@ -631,7 +631,7 @@ describe("DesktopWindow", () => {
     );
   });
 
-  it.effect("does not open a development window until the backend is ready", () =>
+  it.effect("creates one window when bootstrap and backend readiness overlap", () =>
     Effect.gen(function* () {
       const fakeWindow = makeFakeBrowserWindow();
       const createCount = yield* Ref.make(0);
@@ -649,7 +649,13 @@ describe("DesktopWindow", () => {
         yield* desktopWindow.activate;
         assert.equal(yield* Ref.get(createCount), 0);
 
-        yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
+        yield* Effect.all(
+          [
+            desktopWindow.ensureMain,
+            desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773")),
+          ],
+          { concurrency: "unbounded" },
+        );
         assert.equal(yield* Ref.get(createCount), 1);
         assert.equal(createdWindowOptions[0]?.width, 1100);
         assert.equal(createdWindowOptions[0]?.height, 780);
@@ -664,6 +670,53 @@ describe("DesktopWindow", () => {
     }),
   );
 
+  it.effect("keeps a window closed during a cold start closed until activation", () =>
+    Effect.gen(function* () {
+      const fakeWindow = makeFakeBrowserWindow();
+      const createCount = yield* Ref.make(0);
+      const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
+      const layer = layerTest({ window: fakeWindow.window, createCount, mainWindow });
+      const readyUrl = new URL("http://127.0.0.1:3773");
+
+      yield* Effect.gen(function* () {
+        const desktopWindow = yield* DesktopWindow.DesktopWindow;
+        const closeMain = Effect.sync(() => fakeWindow.windowListeners.get("closed")!());
+
+        yield* desktopWindow.ensureMain;
+        yield* closeMain;
+        yield* desktopWindow.handleBackendReady(readyUrl);
+        assert.equal(yield* Ref.get(createCount), 1);
+        yield* desktopWindow.activate;
+        assert.equal(yield* Ref.get(createCount), 2);
+
+        // A dock click while the backend restarts reopens the window at readiness.
+        yield* desktopWindow.handleBackendNotReady;
+        yield* closeMain;
+        yield* desktopWindow.activate;
+        assert.equal(yield* Ref.get(createCount), 2);
+        yield* desktopWindow.handleBackendReady(readyUrl);
+        assert.equal(yield* Ref.get(createCount), 3);
+      }).pipe(Effect.provide(layer));
+    }),
+  );
+
+  it.effect("opens the main window at readiness when the early open failed", () =>
+    Effect.gen(function* () {
+      const main = makeFakeBrowserWindow();
+      const scenario = yield* makeSplashScenario([null, main.window]);
+
+      yield* Effect.gen(function* () {
+        const desktopWindow = yield* DesktopWindow.DesktopWindow;
+        const earlyExit = yield* Effect.exit(desktopWindow.ensureMain);
+        assert.equal(earlyExit._tag, "Failure");
+
+        yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
+        assert.equal(yield* Ref.get(scenario.createCalls), 2);
+        assert.equal(Option.getOrThrow(yield* Ref.get(scenario.mainWindow)), main.window);
+      }).pipe(Effect.provide(scenario.layer));
+    }),
+  );
+
   it.effect(
     "opens and reopens the window without backend readiness when local execution is disabled",
     () =>

apps/desktop/src/window/DesktopWindow.ts

@@ -5,6 +5,7 @@ import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
+import * as Semaphore from "effect/Semaphore";
 
 import * as Electron from "electron";
 
@@ -299,6 +300,10 @@ export const make = Effect.gen(function* () {
   const electronApp = yield* ElectronApp.ElectronApp;
   const rendererHistory = yield* DesktopRendererHistory.DesktopRendererHistory;
   const backendReadyRef = yield* Ref.make(false);
+  const mainWindowCreation = yield* Semaphore.make(1);
+  // Set when the main window closes while the backend starts, so readiness
+  // leaves it closed. macOS keeps the app running; activation reopens it.
+  const mainClosedBeforeReadyRef = yield* Ref.make(false);
   const splashWindowRef = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
   const context = yield* Effect.context<DesktopWindowRuntimeServices>();
   const runFork = Effect.runForkWith(context);
@@ -832,7 +837,14 @@ export const make = Effect.gen(function* () {
     window.on("closed", () => {
       clearDevelopmentLoadRetry();
       clearBoundsPersist();
-      void runPromise(electronWindow.clearMain(Option.some(window)));
+      void runPromise(
+        electronWindow.clearMain(Option.some(window)).pipe(
+          Effect.andThen(waitingForBackend),
+          Effect.flatMap((waiting) =>
+            waiting ? Ref.set(mainClosedBeforeReadyRef, true) : Effect.void,
+          ),
+        ),
+      );
     });
 
     return window;
@@ -851,7 +863,7 @@ export const make = Effect.gen(function* () {
       return existingWindow.value;
     }
     return yield* createMain;
-  }).pipe(Effect.withSpan("desktop.window.ensureMain"));
+  }).pipe(mainWindowCreation.withPermit, Effect.withSpan("desktop.window.ensureMain"));
 
   const revealOrCreateMain = Effect.gen(function* () {
     const window = yield* ensureMain;
@@ -866,9 +878,7 @@ export const make = Effect.gen(function* () {
 
   const createMainIfBackendReady = Effect.gen(function* () {
     if (yield* waitingForBackend) return;
-    const existingWindow = yield* currentMainWindow;
-    if (Option.isSome(existingWindow)) return;
-    yield* createMain;
+    yield* ensureMain;
   }).pipe(Effect.withSpan("desktop.window.createMainIfBackendReady"));
 
   const showConnectingSplash = Effect.gen(function* () {
@@ -956,6 +966,8 @@ export const make = Effect.gen(function* () {
         yield* electronWindow.reveal(existingWindow.value);
         return;
       }
+      // Asking for the window also undoes an earlier close, so readiness opens it.
+      yield* Ref.set(mainClosedBeforeReadyRef, false);
       const backendReady = yield* Ref.get(backendReadyRef);
       if (!backendReady) {
         const splash = yield* Ref.get(splashWindowRef);
@@ -971,6 +983,7 @@ export const make = Effect.gen(function* () {
     handleBackendReady: Effect.fn("desktop.window.handleBackendReady")(function* (httpBaseUrl) {
       yield* Ref.set(backendReadyRef, true);
       yield* logWindowInfo("backend ready", { source: "http", url: httpBaseUrl.href });
+      if (yield* Ref.getAndSet(mainClosedBeforeReadyRef, false)) return;
       yield* createMainIfBackendReady;
     }),
     handleBackendNotReady: Ref.set(backendReadyRef, false).pipe(

apps/server/src/http.test.ts

@@ -1,5 +1,6 @@
 import { expect, it } from "@effect/vitest";
 import { describe, vi } from "vite-plus/test";
+import * as NodeZlib from "node:zlib";
 import * as NodeHttpPlatform from "@effect/platform-node/NodeHttpPlatform";
 import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
 import * as NodeServices from "@effect/platform-node/NodeServices";
@@ -214,6 +215,74 @@ it.layer(
     Layer.provideMerge(NodeServices.layer),
   ),
 )("static HTTP responses", (it) => {
+  it.effect("serves precompressed manifest assets and revalidates other files", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const staticDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-static-compressed-" });
+      yield* fs.makeDirectory(path.join(staticDir, "assets"));
+      const body = 'export const build = "precompressed";\n'.repeat(100);
+      const asset = "assets/app-1234abcd.js";
+      const br = NodeZlib.brotliCompressSync(body);
+      const gz = NodeZlib.gzipSync(body);
+      yield* fs.writeFileString(path.join(staticDir, asset), body);
+      yield* fs.writeFile(path.join(staticDir, `${asset}.br`), br);
+      yield* fs.writeFile(path.join(staticDir, `${asset}.gz`), gz);
+      yield* fs.writeFileString(
+        path.join(staticDir, "vite-manifest.json"),
+        JSON.stringify({ "src/app.ts": { file: asset, isEntry: true } }),
+      );
+      // A hash-like filename and a compressed copy alone cannot make a custom file immutable.
+      const custom = "assets/custom-1234abcd.js";
+      yield* fs.writeFileString(path.join(staticDir, custom), body);
+      yield* fs.writeFile(path.join(staticDir, `${custom}.br`), br);
+      const request = yield* makeStaticRequest(staticDir);
+
+      for (const [acceptEncoding, encoding, length] of [
+        ["br, gzip", "br", br.byteLength],
+        ["br;q=0, gzip", "gzip", gz.byteLength],
+        ["identity", undefined, Buffer.byteLength(body)],
+      ] as const) {
+        const response = yield* request(`/${asset}`, {
+          headers: { "accept-encoding": acceptEncoding },
+        });
+        expect(response.status).toBe(200);
+        expect(response.headers["content-encoding"]).toBe(encoding);
+        expect(response.headers["content-length"]).toBe(String(length));
+        expect(response.headers["content-type"]).toContain("javascript");
+        expect(response.headers["cache-control"]).toBe("public, max-age=31536000, immutable");
+        expect(response.headers["vary"]).toBe("Accept-Encoding");
+        expect(yield* response.text).toBe(body);
+        const head = yield* request(`/${asset}`, {
+          method: "HEAD",
+          headers: { "accept-encoding": acceptEncoding },
+        });
+        expect(head.headers["content-encoding"]).toBe(encoding);
+        expect(head.headers["content-length"]).toBe(String(length));
+        expect(yield* head.text).toBe("");
+        const unchanged = yield* request(`/${asset}`, {
+          headers: {
+            "accept-encoding": acceptEncoding,
+            "if-none-match": response.headers["etag"]!,
+          },
+        });
+        expect(unchanged.status).toBe(304);
+        expect(unchanged.headers["vary"]).toBe("Accept-Encoding");
+        expect(yield* unchanged.text).toBe("");
+      }
+      const unlisted = yield* request(`/${custom}`, { headers: { "accept-encoding": "br" } });
+      expect(unlisted.headers["cache-control"]).toBe("no-cache");
+      expect(unlisted.headers["content-length"]).toBeUndefined();
+      expect(yield* unlisted.text).toBe(body);
+
+      yield* fs.remove(path.join(staticDir, `${asset}.br`));
+      const fallback = yield* request(`/${asset}`, { headers: { "accept-encoding": "br, gzip" } });
+      expect(fallback.headers["content-encoding"]).toBe("gzip");
+      expect(fallback.headers["content-length"]).toBe(String(gz.byteLength));
+      expect(yield* fallback.text).toBe(body);
+    }),
+  );
+
   it.effect("revalidates non-HTML files and returns changed contents", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;