perf: large threads open from a viewport snapshot, and typing and streaming render less

apps/desktop/scripts/main-process-bundle.test.mjs

@@ -2,6 +2,7 @@ import * as NodeChildProcess from "node:child_process";
 import * as NodeFSP from "node:fs/promises";
 import * as NodeOS from "node:os";
 import * as NodePath from "node:path";
+import * as NodeURL from "node:url";
 import * as NodeVM from "node:vm";
 import { build } from "vite-plus/pack";
 import { assert, it } from "vite-plus/test";
@@ -110,6 +111,34 @@ void import("./linux.ts").then(({ result }) => process.emit("ready", result));`,
   }
 });
 
+it("keeps the real desktop chunks from requiring the application entry", async () => {
+  // conf can evict the entry from the require cache. Lazy chunks must not require it.
+  const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-desktop-chunks-"));
+  try {
+    assert.ok(Array.isArray(desktopConfig.pack));
+    const packConfig = desktopConfig.pack.find((config) =>
+      Object.values(config.entry ?? {}).includes("src/main.ts"),
+    );
+    assert.ok(packConfig);
+    await build({
+      ...packConfig,
+      config: false,
+      cwd: NodeURL.fileURLToPath(new URL("..", import.meta.url)),
+      outDir: directory,
+      sourcemap: false,
+      onSuccess: undefined,
+      logLevel: "silent",
+    });
+    for (const filename of await NodeFSP.readdir(directory)) {
+      if (!filename.endsWith(".cjs") || filename === "main.cjs") continue;
+      const source = await NodeFSP.readFile(NodePath.join(directory, filename), "utf8");
+      assert.notMatch(source, /require\(["'`]\.\/(?:application|main)\.cjs["'`]\)/, filename);
+    }
+  } finally {
+    await NodeFSP.rm(directory, { recursive: true, force: true });
+  }
+}, 120_000);
+
 it("loads the emitted packaged boot entry and backend cache preload", async () => {
   const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-desktop-boot-"));
   try {

apps/desktop/src/app/DesktopObservability.test.ts

@@ -6,6 +6,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
+import * as TestClock from "effect/testing/TestClock";
 import * as HttpClient from "effect/http/HttpClient";
 import * as HttpClientResponse from "effect/http/HttpClientResponse";
 
@@ -76,18 +77,29 @@ interface ExportedRequest {
   readonly body: string;
 }
 
-const layerCollector = (requests: Array<ExportedRequest>) =>
+/**
+ * Answers every export with a 200 and keeps what was posted for assertions.
+ * `stallFirst` never answers the first export.
+ */
+const layerCollector = (
+  requests: Array<ExportedRequest>,
+  options?: { readonly stallFirst?: boolean },
+) =>
   Layer.succeed(
     HttpClient.HttpClient,
     HttpClient.make((request) =>
-      Effect.sync(() => {
+      Effect.suspend(() => {
         requests.push({
           url: request.url,
           headers: request.headers,
           body:
             request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "",
         });
-        return HttpClientResponse.fromWeb(request, new Response(null, { status: 200 }));
+        return options?.stallFirst === true && requests.length === 1
+          ? Effect.never
+          : Effect.succeed(
+              HttpClientResponse.fromWeb(request, new Response(null, { status: 200 })),
+            );
       }),
     ),
   );
@@ -384,7 +396,7 @@ describe("DesktopObservability", () => {
     ),
   );
 
-  it.effect("exports main process log records to the configured logs endpoint", () => {
+  it.effect("exports log records after a stalled collector times out", () => {
     const requests: Array<ExportedRequest> = [];
     return Effect.gen(function* () {
       const fileSystem = yield* FileSystem.FileSystem;
@@ -394,21 +406,29 @@ describe("DesktopObservability", () => {
       const layerEnvironment = layerEnvironmentFor(baseDir, true, {
         T3CODE_OTLP_LOGS_URL: "https://collector.example.com/v1/logs",
         T3CODE_OTLP_HEADERS: "x-scope=desktop",
+        T3CODE_OTLP_EXPORT_INTERVAL_MS: "1000",
       });
       const tracePath = yield* Effect.gen(function* () {
         const environment = yield* DesktopEnvironment.DesktopEnvironment;
         return environment.path.join(environment.logDir, "desktop.trace.ndjson");
       }).pipe(Effect.provide(layerEnvironment));
 
       yield* Effect.scoped(
-        Effect.logInfo("desktop log export").pipe(
-          Effect.withSpan("desktop-log-export-test"),
+        Effect.gen(function* () {
+          yield* Effect.logInfo("before the stall");
+          for (let second = 0; second < 15; second += 1) yield* TestClock.adjust("1 second");
+          yield* Effect.logInfo("desktop log export").pipe(
+            Effect.withSpan("desktop-log-export-test"),
+          );
+          for (let second = 0; second < 5; second += 1) yield* TestClock.adjust("1 second");
+          // Before shutdown, whose flush could hide a stuck exporter.
+          assert.isTrue(requests.some((request) => request.body.includes("desktop log export")));
+        }).pipe(
           Effect.provide(DesktopObservability.layer.pipe(Layer.provideMerge(layerEnvironment))),
         ),
       );
 
-      assert.lengthOf(requests, 1);
-      const [request] = requests;
+      const request = requests.find((value) => value.body.includes("desktop log export"));
       assert.strictEqual(request?.url, "https://collector.example.com/v1/logs");
       assert.include(request?.body ?? "", "desktop log export");
       assert.include(request?.body ?? "", "service.runtime");
@@ -424,7 +444,13 @@ describe("DesktopObservability", () => {
       assert.lengthOf(record?.events ?? [], 0);
     }).pipe(
       Effect.scoped,
-      Effect.provide(Layer.mergeAll(NodeServices.layer, layerCollector(requests), layerEmptyEnv)),
+      Effect.provide(
+        Layer.mergeAll(
+          NodeServices.layer,
+          layerCollector(requests, { stallFirst: true }),
+          layerEmptyEnv,
+        ),
+      ),
     );
   });
 

apps/desktop/src/app/DesktopObservability.ts

@@ -27,6 +27,8 @@ import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
 import * as SynchronizedRef from "effect/SynchronizedRef";
 import * as Tracer from "effect/Tracer";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientError from "effect/http/HttpClientError";
 import { OtlpExporter, OtlpLogger, OtlpTracer } from "effect/observability";
 
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
@@ -591,6 +593,33 @@ const layerBackendOutputLogFactory = Layer.effect(
   }),
 );
 
+// Bound both headers and body so a stalled collector cannot stop later exports.
+const withOtlpTimeout = (client: HttpClient.HttpClient) =>
+  client.pipe(
+    HttpClient.transform((response, request) =>
+      response.pipe(
+        Effect.tap((received) => received.arrayBuffer),
+        Effect.timeoutOrElse({
+          duration: "10 seconds",
+          orElse: () =>
+            Effect.fail(
+              new HttpClientError.HttpClientError({
+                reason: new HttpClientError.TransportError({
+                  request,
+                  description: "OTLP export timed out",
+                }),
+              }),
+            ),
+        }),
+      ),
+    ),
+  );
+
+/**
+ * Logs and traces for the main process, assembled together because they share
+ * one read of the environment and Settings, and because a process gets exactly
+ * one logger set.
+ */
 const layerTelemetry = Layer.unwrap(
   Effect.gen(function* () {
     const environment = yield* DesktopEnvironment.DesktopEnvironment;
@@ -678,7 +707,11 @@ const layerTelemetry = Layer.unwrap(
     );
 
     return layerOtelWarnings.pipe(
-      Layer.provideMerge(Layer.mergeAll(layerLogger, layerTracer)),
+      Layer.provideMerge(
+        Layer.mergeAll(layerLogger, layerTracer).pipe(
+          Layer.updateService(HttpClient.HttpClient, withOtlpTimeout),
+        ),
+      ),
       Layer.provide(OtelEnvironment.layerResourceAttributes(endpoints.resourceAttributes)),
     );
   }),

apps/desktop/src/main.ts

@@ -227,9 +227,10 @@ const layerDesktopClerk = DesktopClerk.layer.pipe(
   Layer.provideMerge(ElectronApp.layer),
 );
 
+// node:http bypasses environment proxies and keeps undici out of the main bundle.
 const layerDesktopApplicationRuntime = layerDesktopApplication.pipe(
   Layer.provideMerge(NodeServices.layer),
-  Layer.provideMerge(NodeHttpClient.layerUndici),
+  Layer.provideMerge(NodeHttpClient.layerNodeHttp),
   Layer.provideMerge(NetService.layer),
   Layer.provideMerge(layerElectron),
 );

apps/desktop/src/preview/Manager.ts

@@ -587,6 +587,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
     { readonly semaphore: Semaphore.Semaphore; users: number }
   >();
   const tabLifecycleGenerations = new Map<string, number>();
+  let nextTabLifecycleGeneration = 0;
 
   const attempt = <A>(errorContext: PreviewOperationContext, evaluate: () => A) =>
     Effect.try({
@@ -1685,7 +1686,8 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
       },
     );
     if (result.created) {
-      tabLifecycleGenerations.set(tabId, (tabLifecycleGenerations.get(tabId) ?? 0) + 1);
+      // Generations remain unique when a closed tab id is reused.
+      tabLifecycleGenerations.set(tabId, ++nextTabLifecycleGeneration);
     }
     yield* emit(tabId, result.state);
     return result.state;
@@ -1724,6 +1726,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
       ] as const;
     });
     if (Option.isNone(tab)) return;
+    tabLifecycleGenerations.delete(tabId);
     const closedTab = tab.value;
     if (closedTab.webContentsId != null) {
       yield* Effect.all(

apps/desktop/src/snapShot/LinuxSnapShot.ts

@@ -19,6 +19,9 @@ import { isKdeCaptureSession, type KdeCapturePaths } from "./KdeSnapShot.ts";
 import { isGnomeCaptureSession, readPortalPng, resizeLinuxCapture } from "./linuxCaptureSession.ts";
 export { readPortalPng, resizeLinuxCapture } from "./linuxCaptureSession.ts";
 import { isHyprlandCaptureSession, type HyprlandCapturePaths } from "./HyprlandSnapShot.ts";
+// The entry chunk also imports NiriSnapShot, so a lazy import of it would
+// require application.cjs again, and conf evicts that from the require cache.
+import { captureNiriWindow, checkNiriCaptureSupport, niriSocketPath } from "./NiriSnapShot.ts";
 
 const PORTAL = "org.freedesktop.portal.Desktop";
 const PORTAL_PATH = "/org/freedesktop/portal/desktop";
@@ -365,7 +368,6 @@ export class LinuxCaptureConnection {
 export async function getLinuxCaptureSupport(appId: string) {
   if (isHyprlandCaptureSession())
     return { linuxBackend: "hyprland" as const, linuxFeedbackAvailable: false };
-  const { niriSocketPath, checkNiriCaptureSupport } = await import("./NiriSnapShot.ts");
   const niri = niriSocketPath();
   if (niri) {
     await checkNiriCaptureSupport(niri);
@@ -392,7 +394,6 @@ export async function captureLinuxWindow(
     const { captureHyprlandWindow } = await import("./HyprlandSnapShot.ts");
     return captureHyprlandWindow(hyprlandPaths, options);
   }
-  const { niriSocketPath, captureNiriWindow } = await import("./NiriSnapShot.ts");
   const niri = niriSocketPath();
   if (niri) return captureNiriWindow(niri);
   const connection = new LinuxCaptureConnection();

apps/mobile/src/connection/environment-cache-store.test.ts

@@ -1,6 +1,9 @@
+import * as Schema from "effect/Schema";
 import {
   ORCHESTRATION_CACHE_SCHEMA_VERSION,
   ORCHESTRATION_THREAD_CACHE_SCHEMA_VERSION,
+  StoredOrchestrationShellSnapshot,
+  StoredOrchestrationThreadSnapshot,
 } from "@t3tools/client-runtime/platform";
 import {
   CommandId,
@@ -27,6 +30,10 @@ const PROJECT_ID = ProjectId.make("project-1");
 const THREAD_ID = ThreadId.make("thread-1");
 const PROVIDER_INSTANCE_ID = ProviderInstanceId.make("codex");
 const NOW = DateTime.makeUnsafe("2026-07-29T12:00:00.000Z");
+// How a bundle without the deferred-thread envelope decodes a cached thread.
+const decodePlainStoredThread = Schema.decodeUnknownExit(
+  Schema.fromJsonString(StoredOrchestrationThreadSnapshot),
+);
 const SHELL_SNAPSHOT: OrchestrationV2ShellSnapshot = {
   schemaVersion: 1,
   snapshotSequence: 3,
@@ -246,6 +253,36 @@ describe("mobile SQLite environment cache store", () => {
       expect(memory.schemaVersions.get(cacheId(ENVIRONMENT_ID, "thread", THREAD_ID))).toBe(
         ORCHESTRATION_THREAD_CACHE_SCHEMA_VERSION,
       );
+
+      // An older bundle reads deferred checkpoints' empty file lists as "no
+      // changes", so it must not be able to decode their entry.
+      yield* store.saveThread(ENVIRONMENT_ID, {
+        ...THREAD_SNAPSHOT,
+        projection: {
+          ...THREAD_SNAPSHOT.projection,
+          checkpoints: [
+            {
+              id: "checkpoint-deferred" as never,
+              threadId: THREAD_ID,
+              scopeId: "scope" as never,
+              runId: null,
+              nodeId: "node" as never,
+              parentCheckpointId: null,
+              ordinalWithinScope: 1,
+              appRunOrdinal: 1,
+              ref: "refs/t3/deferred" as never,
+              status: "ready",
+              files: [],
+              deferredFileCount: 2,
+              capturedAt: NOW,
+            },
+          ],
+        },
+      });
+      const deferredPayload = memory.values.get(cacheId(ENVIRONMENT_ID, "thread", THREAD_ID))!;
+      expect(decodePlainStoredThread(deferredPayload)._tag).toBe("Failure");
+      const deferred = Option.getOrThrow(yield* store.loadThread(ENVIRONMENT_ID, THREAD_ID));
+      expect(deferred.projection.checkpoints[0]?.deferredFileCount).toBe(2);
     }),
   );
 

apps/mobile/src/connection/environment-cache-store.ts

@@ -33,12 +33,24 @@ const StoredVcsRefs = Schema.Struct({
   refs: VcsListRefsResult,
 });
 
-const decodeStoredThreadSnapshot = Schema.decodeUnknownEffect(
-  Schema.fromJsonString(StoredOrchestrationThreadSnapshot),
-);
-const encodeStoredThreadSnapshot = Schema.encodeEffect(
-  Schema.fromJsonString(StoredOrchestrationThreadSnapshot),
+// Deferred checkpoints have empty file lists that an older bundle, after an
+// OTA rollback, would show as turns with no changes. Their entries are
+// wrapped, so an older bundle fails to decode them, drops them and loads live.
+const StoredThreadCache = Schema.Union([
+  StoredOrchestrationThreadSnapshot,
+  Schema.Struct({
+    format: Schema.Literal("deferred-thread-1"),
+    stored: StoredOrchestrationThreadSnapshot,
+  }),
+]);
+const decodeStoredThreadCache = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(StoredThreadCache),
 );
+const decodeStoredThreadSnapshot = (raw: string) =>
+  decodeStoredThreadCache(raw).pipe(
+    Effect.map((cached) => ("format" in cached ? cached.stored : cached)),
+  );
+const encodeStoredThreadSnapshot = Schema.encodeEffect(Schema.fromJsonString(StoredThreadCache));
 const decodeStoredServerConfig = Schema.decodeUnknownEffect(
   Schema.fromJsonString(StoredServerConfig),
 );
@@ -146,12 +158,18 @@ export const make = Effect.fn("MobileEnvironmentCacheStore.make")(function* () {
     ),
     saveThread: Effect.fn("MobileEnvironmentCache.saveThread")(function* (environmentId, snapshot) {
       const threadId = snapshot.projection.thread.id;
-      const payload = yield* encodeStoredThreadSnapshot({
+      const stored = {
         schemaVersion: ORCHESTRATION_THREAD_CACHE_SCHEMA_VERSION,
         environmentId,
         threadId,
         snapshot,
-      }).pipe(Effect.mapError((cause) => persistenceError("save-thread", cause)));
+      };
+      const deferred = snapshot.projection.checkpoints.some(
+        (checkpoint) => checkpoint.deferredFileCount !== undefined,
+      );
+      const payload = yield* encodeStoredThreadSnapshot(
+        deferred ? { format: "deferred-thread-1", stored } : stored,
+      ).pipe(Effect.mapError((cause) => persistenceError("save-thread", cause)));
       yield* database
         .saveCache(
           environmentId,

apps/mobile/src/features/review/reviewModel.ts

@@ -99,7 +99,7 @@ function checkpointTitle(checkpoint: ThreadCheckpointSummary): string {
 }
 
 function checkpointSubtitle(checkpoint: ThreadCheckpointSummary): string {
-  const fileCount = checkpoint.files.length;
+  const fileCount = checkpoint.deferredFileCount ?? checkpoint.files.length;
   if (checkpoint.status !== "ready") {
     return `Diff ${checkpoint.status}`;
   }

apps/server/src/bin.ts

@@ -35,6 +35,9 @@ if (
   }
   if (process.argv.length === 3 && command === "--version") {
     process.stdout.write(`t3 v${packageJson.version}\n`);
+  } else if (command === "--bootstrap-fd" || command?.startsWith("--bootstrap-fd=")) {
+    const { runLightCli } = await import("./binLightCli.ts");
+    await runLightCli("desktop");
   } else if (
     command === "pair" ||
     command === "auth" ||