@@ -322,6 +322,7 @@ describe("ElectronProtocol", () => {
     ]);
     assert.deepEqual(directives["media-src"], ["'self'", "t3code:", "blob:", "http:", "https:"]);
     assert.deepEqual(directives["frame-src"], ["'self'", "blob:", "http:", "https:"]);
+    assert.deepEqual(directives["object-src"], ["'self'", "blob:", "http:", "https:"]);
     assert.deepEqual(directives["font-src"], ["'self'", "t3code:", "data:"]);
   });
 });
@@ -95,6 +95,7 @@ export function makeDesktopContentSecurityPolicy(input: DesktopProtocolRegistrat
     `font-src 'self' ${input.scheme}: data:`,
     "worker-src 'self' blob:",
     "frame-src 'self' blob: http: https:",
+    "object-src 'self' blob: http: https:",
     "form-action 'self'",
   ].join("; ");
 }
 
@@ -180,7 +180,6 @@ describe("BrowserSession", () => {
       for (const permission of [
         "clipboard-read",
         "clipboard-sanitized-write",
-        "notifications",
         "geolocation",
         "fullscreen",
       ]) {
@@ -194,7 +193,7 @@ describe("BrowserSession", () => {
       // `clipboard-write` is not a real Electron permission — the async write API
       // uses `clipboard-sanitized-write` — so the stale name must not be granted,
       // and unrelated permissions stay denied.
-      for (const permission of ["clipboard-write", "midi"]) {
+      for (const permission of ["clipboard-write", "notifications", "midi"]) {
         assert.isFalse(requestAllows(permission), `request handler should deny ${permission}`);
         assert.isFalse(
           checkHandler(null, permission) as boolean,
 
@@ -33,7 +33,6 @@ export type BrowserSessionPartitionNamespace = "profile";
 const ALLOWED_PREVIEW_PERMISSIONS: ReadonlySet<string> = new Set([
   "clipboard-read",
   "clipboard-sanitized-write",
-  "notifications",
   "geolocation",
   // `DesktopWindow` disables HTML fullscreen window resizing for the app window
   // and every preview guest, so a page that goes fullscreen fills its own
@@ -42,6 +41,8 @@ const ALLOWED_PREVIEW_PERMISSIONS: ReadonlySet<string> = new Set([
   // Deliberately NOT local-fonts: preview sessions run untrusted web content,
   // and silently granting it would hand every page the user's installed-font
   // fingerprint (and font file bytes via FontData.blob()).
+  // Deliberately NOT notifications: a page could post OS notifications branded
+  // as T3 Code. T3's own come from the app window on the default session.
 ]);
 
 const NEVER_EXTERNAL_PROTOCOLS: ReadonlySet<string> = new Set([
 
@@ -1886,6 +1886,8 @@ describe("PreviewManager", () => {
     const sendCommand = vi.fn<(method: string, params?: unknown) => Promise<unknown>>(
       async () => undefined,
     );
+    const detachListeners = new Set<() => void>();
+    let chromiumDetaches = 0;
     let destroyed = false;
     const wc = {
       id,
@@ -1914,19 +1916,30 @@ describe("PreviewManager", () => {
       setIgnoreMenuShortcuts: vi.fn(),
       setWindowOpenHandler: vi.fn(),
       debugger: {
-        isAttached: () => attach.mock.calls.length > detach.mock.calls.length,
+        isAttached: () => attach.mock.calls.length > detach.mock.calls.length + chromiumDetaches,
         attach,
         detach,
         sendCommand,
-        on: vi.fn(),
-        off: vi.fn(),
+        on: (event: string, listener: () => void) => {
+          if (event === "detach") detachListeners.add(listener);
+        },
+        off: (event: string, listener: () => void) => {
+          if (event === "detach") detachListeners.delete(listener);
+        },
       },
     };
+    /** Chromium dropping the debugger without a detach() call. */
+    const chromiumDetach = () => {
+      chromiumDetaches += 1;
+      // Snapshot like an EventEmitter, so a listener added during emit waits for the next one.
+      for (const listener of Array.from(detachListeners)) listener();
+    };
     return {
       wc: wc as unknown as Electron.WebContents,
       attach,
       detach,
       sendCommand,
+      chromiumDetach,
       destroy: () => {
         destroyed = true;
         listeners.get("destroyed")?.();
@@ -1965,6 +1978,24 @@ describe("PreviewManager", () => {
     ),
   );
 
+  effectIt.effect("reattaches a debugger that Chromium dropped on its own", () =>
+    withManager((manager) =>
+      Effect.gen(function* () {
+        const guest = makeAttachingGuest(48);
+        fromId.mockReturnValue(guest.wc);
+        yield* manager.createTab("tab_detached");
+        yield* manager.registerWebview("tab_detached", 48);
+        yield* Effect.yieldNow;
+        expect(guest.attach).toHaveBeenCalledTimes(1);
+
+        guest.chromiumDetach();
+        yield* Effect.yieldNow;
+        yield* Effect.yieldNow;
+        expect(guest.attach).toHaveBeenCalledTimes(2);
+      }),
+    ),
+  );
+
   effectIt.effect("skips a guest destroyed while another guest's session opens", () =>
     withManager((manager) =>
       Effect.gen(function* () {
 
@@ -1023,13 +1023,22 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
         copy.delete(webContentsId);
       }),
     ]);
-    if (control) {
-      if (closedServerTab) browserHost.detach(closedServerTab);
-      for (const tab of (yield* SynchronizedRef.get(tabsRef)).values()) {
-        if (tab.webContentsId === webContentsId && tab.serverTab) browserHost.detach(tab.serverTab);
+    if (control) yield* releaseControlSession(control, closedServerTab);
+  });
+
+  // Closes a session already removed from `controlSessionsRef`. The server can
+  // only drive a tab while the desktop holds its debugger.
+  const releaseControlSession = Effect.fnUntraced(function* (
+    control: BrowserControlSession,
+    closedServerTab?: PreviewTabState["serverTab"],
+  ) {
+    if (closedServerTab) browserHost.detach(closedServerTab);
+    for (const tab of (yield* SynchronizedRef.get(tabsRef)).values()) {
+      if (tab.webContentsId === control.webContentsId && tab.serverTab) {
+        browserHost.detach(tab.serverTab);
       }
-      yield* Scope.close(control.scope, Exit.void).pipe(Effect.ignore);
     }
+    yield* Scope.close(control.scope, Exit.void).pipe(Effect.ignore);
   });
 
   const ensureControlSession = Effect.fn("PreviewManager.ensureControlSession")(function* (
@@ -1141,23 +1150,36 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
           const onMessage: BrowserControlSession["onMessage"] = (_event, method, params) => {
             runFork(handleDebuggerMessage(method, params));
           };
-          yield* Scope.addFinalizer(
-            scope,
-            attempt({ operation: "detachControlSession", webContentsId: wc.id }, () => {
-              wcDebugger.off("message", onMessage);
-              if (wcDebugger.isAttached()) wcDebugger.detach();
-            }).pipe(Effect.ignore),
-          );
           const control: BrowserControlSession = {
             webContentsId: wc.id,
             debugger: wcDebugger,
             semaphore,
             scope,
             onMessage,
           };
+          // Electron emits `detach` when Chromium closes the debugger session on its
+          // own. The cached session would then fail every command until the webview
+          // is replaced.
+          let dropped = false;
+          const onDetach = () => {
+            dropped = true;
+            runFork(recoverDetachedControlSession(wc, control));
+          };
+          // The listener comes off before detach() so a detach this manager requested
+          // never looks like a dropped one. A dropped session has nothing left to
+          // detach: `wc.debugger` is shared, so detaching here would hit a successor.
+          yield* Scope.addFinalizer(
+            scope,
+            attempt({ operation: "detachControlSession", webContentsId: wc.id }, () => {
+              wcDebugger.off("message", onMessage);
+              wcDebugger.off("detach", onDetach);
+              if (!dropped && wcDebugger.isAttached()) wcDebugger.detach();
+            }).pipe(Effect.ignore),
+          );
           const initialize = Effect.fn("PreviewManager.initializeControlSession")(function* () {
             yield* attempt({ operation: "attachDebuggerListeners", webContentsId: wc.id }, () => {
               wcDebugger.on("message", onMessage);
+              wcDebugger.on("detach", onDetach);
               wcDebugger.attach("1.3");
             });
             // Without this, dark-scheme pages with no background of their own (text/plain, e.g.
@@ -2356,6 +2378,30 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
       }
     }).pipe(Effect.ignore);
 
+  // Only the session that saw the detach is replaced: by the time the event is
+  // handled the guest may already hold a newer one, which must stay.
+  const recoverDetachedControlSession = Effect.fn("PreviewManager.recoverDetachedControlSession")(
+    function* (wc: Electron.WebContents, detached: BrowserControlSession) {
+      const removed = yield* SynchronizedRef.modify(controlSessionsRef, (sessions) =>
+        sessions.get(wc.id) === detached
+          ? ([
+              true,
+              replaceMap(sessions, (copy) => {
+                copy.delete(wc.id);
+              }),
+            ] as const)
+          : ([false, sessions] as const),
+      );
+      if (!removed) return;
+      yield* releaseControlSession(detached);
+      if (wc.isDestroyed()) return;
+      const tabId = yield* tabIdForWebContents(wc.id);
+      if (tabId === null) return;
+      yield* restoreControlSession(tabId, wc);
+    },
+    (recover) => Effect.ignore(recover),
+  );
+
   const setColorScheme = Effect.fn("PreviewManager.setColorScheme")(function* (
     tabId: string,
     colorScheme: DesktopPreviewColorScheme,
 
@@ -175,7 +175,7 @@ window.prepareCaptureTransition=async destination=>{
   const inner={width:Math.max(1,target.width-borderWidth*2),height:Math.max(1,target.height-borderWidth*2)};
   const sourceCenter={x:source.x+source.width/2,y:source.y+source.height/2},targetCenter={x:target.x+target.width/2,y:target.y+target.height/2};
   const initial="translate3d("+(sourceCenter.x-targetCenter.x)+"px,"+(sourceCenter.y-targetCenter.y)+"px,0) scale("+(source.width/target.width)+","+(source.height/target.height)+")";
-  const imageWidth=Math.max(1,snapshot.naturalWidth||source.width),imageHeight=Math.max(1,snapshot.naturalHeight||source.height),cover=Math.max(inner.width/imageWidth,inner.height/imageHeight);
+  const imageWidth=Math.max(1,snapshot.naturalWidth||source.width),imageHeight=Math.max(1,snapshot.naturalHeight||source.height),fit=Math.min(inner.width/imageWidth,inner.height/imageHeight);
   Object.assign(card.style,{left:target.x+"px",top:target.y+"px",width:target.width+"px",height:target.height+"px",borderRadius:destination.cornerRadius+"px",backgroundColor:destination.backgroundColor,boxShadow:"none"});
   Object.assign(content.style,{inset:borderWidth+"px",borderRadius:Math.max(0,destination.cornerRadius-borderWidth)+"px"});
   Object.assign(border.style,{borderWidth:borderWidth+"px",borderColor:destination.borderColor});
@@ -185,7 +185,7 @@ window.prepareCaptureTransition=async destination=>{
   const animations=[
     card.animate([{transform:initial},{transform:"translate3d(0,0,0) scale(1)"}],options),
     content.animate([{transform:"scale("+(target.width/inner.width)+","+(target.height/inner.height)+")"},{transform:"scale(1)"}],options),
-    snapshot.animate([{transform:"scale(1)"},{transform:"scale("+((imageWidth*cover)/inner.width)+","+((imageHeight*cover)/inner.height)+")"}],options),
+    snapshot.animate([{transform:"scale(1)"},{transform:"scale("+((imageWidth*fit)/inner.width)+","+((imageHeight*fit)/inner.height)+")"}],options),
     border.animate([{opacity:0},{opacity:1}],options),
     details.animate([{opacity:0},{opacity:1}],{delay:Math.max(0,destination.durationMs-125),duration:125,fill:"both",easing:"ease-in"})
   ];
 
@@ -2,22 +2,30 @@
 import { describe, it } from "@effect/vitest";
 import { afterAll, expect } from "vite-plus/test";
 import * as NodeChildProcess from "node:child_process";
+import * as Deferred from "effect/Deferred";
 import * as Duration from "effect/Duration";
 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";
+import * as Path from "effect/Path";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as TestClock from "effect/testing/TestClock";
 import { ChildProcessSpawner } from "effect/process";
 
+import * as DesktopConfig from "../app/DesktopConfig.ts";
+import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
 import {
   buildWslRuntimeInstallScript,
   buildWslRuntimeInvalidateScript,
   buildWslRuntimePruneScript,
   buildWslRuntimeProbeScript,
   DesktopWslDistroListError,
+  DesktopWslEnvironment,
   formatMissingToolsReason,
+  layer as wslEnvironmentLayer,
   parseNodePath,
   parseNodeVersion,
   parseResolvedPath,
@@ -158,6 +166,102 @@ describe("probeWslDistros", () => {
   });
 });
 
+describe("WSL command deadlines", () => {
+  const makeControlledEnvironment = Effect.gen(function* () {
+    const started = yield* Deferred.make<void>();
+    const exited = yield* Deferred.make<ChildProcessSpawner.ExitCode>();
+    const released = yield* Deferred.make<void>();
+    const spawner = ChildProcessSpawner.make(() =>
+      Effect.acquireRelease(
+        Deferred.succeed(started, undefined).pipe(
+          Effect.as(
+            ChildProcessSpawner.makeHandle({
+              pid: ChildProcessSpawner.ProcessId(1),
+              exitCode: Deferred.await(exited),
+              isRunning: Deferred.isDone(exited).pipe(Effect.map((done) => !done)),
+              kill: () => Effect.void,
+              unref: Effect.succeed(Effect.void),
+              stdin: Sink.drain,
+              stdout: Stream.empty,
+              stderr: Stream.empty,
+              all: Stream.empty,
+              getInputFd: () => Sink.drain,
+              getOutputFd: () => Stream.empty,
+            }),
+          ),
+        ),
+        () => Deferred.succeed(released, undefined),
+      ),
+    );
+    const environment = yield* DesktopWslEnvironment.pipe(
+      Effect.provide(
+        wslEnvironmentLayer.pipe(
+          Layer.provide([
+            DesktopEnvironment.layer({
+              dirname: "/repo/apps/desktop",
+              homeDirectory: "/home/test",
+              platform: "win32",
+              processArch: "x64",
+              appVersion: "1.2.3",
+              appPath: "/repo",
+              isPackaged: true,
+              resourcesPath: "/repo/resources",
+              runningUnderArm64Translation: false,
+            }).pipe(Layer.provide([Path.layer, DesktopConfig.layerTest({})])),
+            FileSystem.layerNoop({ exists: () => Effect.succeed(true) }),
+            Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, spawner),
+          ]),
+        ),
+      ),
+    );
+    return { environment, started, exited, released };
+  });
+
+  it.effect("waits for a cold distro to finish starting after 15 seconds", () =>
+    Effect.gen(function* () {
+      const { environment, started, exited, released } = yield* makeControlledEnvironment;
+      const fiber = yield* environment.preWarm("Ubuntu").pipe(Effect.forkScoped);
+      yield* Deferred.await(started);
+      yield* TestClock.adjust(Duration.seconds(15));
+      expect(yield* Deferred.isDone(released)).toBe(false);
+
+      yield* Deferred.succeed(exited, ChildProcessSpawner.ExitCode(0));
+      yield* Fiber.join(fiber);
+      expect(yield* Deferred.isDone(released)).toBe(true);
+    }),
+  );
+
+  it.effect("releases a stalled warmup process at the 30-second deadline", () =>
+    Effect.gen(function* () {
+      const { environment, started, released } = yield* makeControlledEnvironment;
+      const fiber = yield* environment.preWarm("Ubuntu").pipe(Effect.forkScoped);
+      yield* Deferred.await(started);
+      yield* TestClock.adjust(Duration.seconds(29));
+      expect(yield* Deferred.isDone(released)).toBe(false);
+
+      yield* TestClock.adjust(Duration.seconds(1));
+      yield* Fiber.join(fiber);
+      expect(yield* Deferred.isDone(released)).toBe(true);
+    }),
+  );
+
+  it.effect("still gives path conversion only 10 seconds and releases its process", () =>
+    Effect.gen(function* () {
+      const { environment, started, released } = yield* makeControlledEnvironment;
+      const fiber = yield* environment
+        .windowsToWslPath("Ubuntu", "C:\\project")
+        .pipe(Effect.forkScoped);
+      yield* Deferred.await(started);
+      yield* TestClock.adjust(Duration.seconds(9));
+      expect(yield* Deferred.isDone(released)).toBe(false);
+
+      yield* TestClock.adjust(Duration.seconds(1));
+      expect(yield* Fiber.join(fiber)).toEqual(Option.none());
+      expect(yield* Deferred.isDone(released)).toBe(true);
+    }),
+  );
+});
+
 describe("WSL runtime cache", () => {
   it.each([
     [
 
@@ -17,7 +17,8 @@ import { parseWslDistroList, type WslDistro } from "./wslPathParsing.ts";
 
 const PROCESS_TERMINATE_GRACE = Duration.seconds(1);
 const LIST_TIMEOUT = Duration.seconds(8);
-const PRE_WARM_TIMEOUT = Duration.seconds(10);
+// Booting a stopped distro needs more time than converting paths in a running one.
+const PRE_WARM_TIMEOUT = Duration.seconds(30);
 const WSLPATH_TIMEOUT = Duration.seconds(10);
 const PROBE_TIMEOUT = Duration.seconds(10);
 const TOOLCHAIN_TIMEOUT = Duration.seconds(10);
 
@@ -317,6 +317,7 @@ const config: ExpoConfig = {
   },
   plugins: [
     "expo-asset",
+    "react-native-pdf-jsi",
     [
       "expo-font",
       {
Original file line number	Diff line number	Diff line change
`@@ -95,6 +95,7 @@ export function makeDesktopContentSecurityPolicy(input: DesktopProtocolRegistrat`
`95`	`95`	`font-src 'self' ${input.scheme}: data:`,
`96`	`96`	`"worker-src 'self' blob:",`
`97`	`97`	`"frame-src 'self' blob: http: https:",`
	`98`	`+ "object-src 'self' blob: http: https:",`
`98`	`99`	`"form-action 'self'",`
`99`	`100`	`].join("; ");`
`100`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -317,6 +317,7 @@ const config: ExpoConfig = {`
`317`	`317`	`},`
`318`	`318`	`plugins: [`
`319`	`319`	`"expo-asset",`
	`320`	`+ "react-native-pdf-jsi",`
`320`	`321`	`[`
`321`	`322`	`"expo-font",`
`322`	`323`	`{`