diff --git a/package.json b/package.json
index ceeaec032342..1ad418b9a127 100644
--- a/package.json
+++ b/package.json
@@ -43,7 +43,8 @@
     "patchedDependencies": {
       "@vscode/monaco-lsp-client@0.1.0": "patches/@vscode__monaco-lsp-client@0.1.0.patch",
       "gatsby-remark-shiki-twoslash@3.0.38": "patches/gatsby-remark-shiki-twoslash@3.0.38.patch",
-      "monaco-editor-core@0.56.0": "patches/monaco-editor-core@0.56.0.patch"
+      "monaco-editor-core@0.56.0": "patches/monaco-editor-core@0.56.0.patch",
+      "coi-serviceworker@0.1.7": "patches/coi-serviceworker@0.1.7.patch"
     },
     "ignoredBuiltDependencies": [
       "@parcel/watcher",
diff --git a/packages/playground-v2/src/compiler-assets.ts b/packages/playground-v2/src/compiler-assets.ts
new file mode 100644
index 000000000000..b903a4bf5267
--- /dev/null
+++ b/packages/playground-v2/src/compiler-assets.ts
@@ -0,0 +1,128 @@
+export type CompilerAssetMetadata = { size: number; integrity: string }
+
+export class CompilerDownloadError extends Error {
+  constructor(url: string, readonly status: number) {
+    super(`Unable to load ${url}: HTTP ${status}`)
+  }
+}
+
+export async function fetchCompilerResource<T>(
+  url: URL,
+  read: (response: Response) => Promise<T>,
+  options: { cache?: RequestCache; timeout?: number; onRetry?(): void } = {}
+): Promise<T> {
+  for (let attempt = 0; ; attempt++) {
+    let response: Response | undefined
+    try {
+      response = await fetch(url, {
+        signal: AbortSignal.timeout(options.timeout ?? 30_000),
+        cache: attempt === 0 ? options.cache : "no-store",
+      })
+      if (!response.ok) throw new CompilerDownloadError(url.href, response.status)
+      return await read(response)
+    } catch (error) {
+      await response?.body?.cancel().catch(() => {})
+      const permanent =
+        error instanceof CompilerDownloadError && error.status !== 408 && error.status !== 429 && error.status < 500
+      if (attempt === 2 || permanent) throw error
+      console.warn(`Retrying compiler download (${attempt + 2}/3): ${url.href}`, error)
+      options.onRetry?.()
+      await new Promise(resolve => setTimeout(resolve, 300 * 2 ** attempt))
+    }
+  }
+}
+
+export async function readResponseBytes(
+  response: Response,
+  onProgress: (length: number) => void,
+  maximum = Infinity
+): Promise<Uint8Array<ArrayBuffer>> {
+  if (!response.body) {
+    const bytes = new Uint8Array(await response.arrayBuffer())
+    if (bytes.length > maximum) throw new Error("Compiler download is larger than expected")
+    onProgress(bytes.length)
+    return bytes
+  }
+  const chunks: Uint8Array[] = []
+  const reader = response.body.getReader()
+  let length = 0
+  try {
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      length += value.length
+      if (length > maximum) throw new Error("Compiler download is larger than expected")
+      chunks.push(value)
+      onProgress(length)
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {})
+    throw error
+  } finally {
+    reader.releaseLock()
+  }
+  const bytes = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset)
+    offset += chunk.length
+  }
+  return bytes
+}
+
+export async function downloadCompilerAsset(
+  url: URL,
+  metadata: CompilerAssetMetadata,
+  options: {
+    cache?: Pick<Cache, "match" | "delete" | "put">
+    onProgress(length: number): void
+    onSource(cached: boolean): void
+    onRetry(): void
+  }
+) {
+  const request = new Request(url)
+  const validate = async (response: Response) => {
+    if (!response.ok) throw new CompilerDownloadError(url.href, response.status)
+    const bytes = await readResponseBytes(response, options.onProgress, metadata.size)
+    if (bytes.length !== metadata.size) {
+      throw new Error(`Incomplete compiler download: ${url.pathname} (${bytes.length}/${metadata.size} bytes)`)
+    }
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))
+    const integrity = `sha256-${btoa(String.fromCharCode(...digest))}`
+    if (integrity !== metadata.integrity)
+      throw new Error(`Compiler download failed integrity validation: ${url.pathname}`)
+    return bytes
+  }
+  let cached: Response | undefined
+  try {
+    cached = await options.cache?.match(request)
+  } catch (error) {
+    console.warn("Could not read the TypeScript asset cache", error)
+  }
+  if (cached) {
+    options.onSource(true)
+    try {
+      return await validate(cached)
+    } catch (error) {
+      console.warn(`Discarding invalid cached compiler asset: ${url.pathname}`, error)
+      try {
+        await options.cache?.delete(request)
+      } catch (cacheError) {
+        console.warn("Could not remove the invalid TypeScript asset", cacheError)
+      }
+    }
+  }
+  options.onSource(false)
+  const bytes = await fetchCompilerResource(url, validate, {
+    // A previous browser HTTP cache entry may be as incomplete as the app cache.
+    cache: cached ? "no-store" : "default",
+    timeout: 120_000,
+    onRetry: options.onRetry,
+  })
+  try {
+    await options.cache?.put(request, new Response(bytes))
+  } catch (error) {
+    console.warn("Could not cache the validated TypeScript asset", error)
+  }
+  return bytes
+}
diff --git a/packages/playground-v2/src/compiler-distribution.ts b/packages/playground-v2/src/compiler-distribution.ts
index 58ea1d79f838..3772eb9ced54 100644
--- a/packages/playground-v2/src/compiler-distribution.ts
+++ b/packages/playground-v2/src/compiler-distribution.ts
@@ -1,4 +1,5 @@
 import { prerelease, valid } from "semver"
+import { fetchCompilerResource, type CompilerAssetMetadata } from "./compiler-assets"
 
 export type CompilerModules = {
   sync: string
@@ -14,6 +15,7 @@ export type CompilerDistribution = CompilerModules & {
   libraries: URL[]
   assetBytes: number
   estimatedDownloadBytes: number
+  assets: ReadonlyMap<string, CompilerAssetMetadata>
 }
 
 export async function loadPublishedCompilerDistribution(version: string): Promise<CompilerDistribution> {
@@ -28,11 +30,11 @@ export async function loadPublishedCompilerDistribution(version: string): Promis
   const schema = packageEntry(main, "./schemas/tsconfig.schema.json")
   const libraryDirectory = new URL("./", wasm)
   const [mainFiles, artifactFiles] = await Promise.all([
-    loadFileSizes(main.base),
-    loadFileSizes(artifact.base, libraryDirectory),
+    loadFileMetadata(main.base),
+    loadFileMetadata(artifact.base, libraryDirectory),
   ])
-  function size(files: ReadonlyMap<string, number>, url: URL) {
-    const bytes = files.get(url.href)
+  function size(files: ReadonlyMap<string, CompilerAssetMetadata>, url: URL) {
+    const bytes = files.get(url.href)?.size
     if (bytes === undefined) throw new Error(`Missing compiler file size: ${url.pathname}`)
     return bytes
   }
@@ -47,7 +49,7 @@ export async function loadPublishedCompilerDistribution(version: string): Promis
   const wasmBytes = size(artifactFiles, wasm)
   const libraryBytes = libraries.reduce((sum, url) => sum + size(artifactFiles, url), 0)
   const schemaBytes = size(mainFiles, schema)
-  const moduleBytes = [...mainFiles].reduce((sum, [url, bytes]) => sum + (url.endsWith(".js") ? bytes : 0), 0)
+  const moduleBytes = [...mainFiles].reduce((sum, [url, file]) => sum + (url.endsWith(".js") ? file.size : 0), 0)
   // CDN samples: WASM ~25%, JavaScript ~12%, JSON ~10%; declarations are uncompressed.
   const estimatedDownloadBytes = Math.ceil(wasmBytes * 0.25 + moduleBytes * 0.12 + schemaBytes * 0.1 + libraryBytes)
   return {
@@ -61,15 +63,14 @@ export async function loadPublishedCompilerDistribution(version: string): Promis
     libraries,
     assetBytes: wasmBytes + schemaBytes + libraryBytes,
     estimatedDownloadBytes,
+    assets: new Map([...mainFiles, ...artifactFiles]),
   }
 }
 
 async function loadPackage(name: string, version: string) {
   const base = new URL(`https://unpkg.com/${name}@${version}/`)
   const url = new URL("package.json", base)
-  const response = await fetch(url, { signal: AbortSignal.timeout(30_000) })
-  if (!response.ok) throw new Error(`Could not load ${name}@${version}: ${response.status}`)
-  const metadata: unknown = await response.json()
+  const metadata: unknown = await fetchCompilerResource(url, response => response.json())
   if (
     !isRecord(metadata) ||
     metadata.name !== name ||
@@ -87,23 +88,23 @@ async function loadPackage(name: string, version: string) {
   }
 }
 
-async function loadFileSizes(base: URL, directory = base): Promise<ReadonlyMap<string, number>> {
-  const response = await fetch(new URL("?meta", directory), { signal: AbortSignal.timeout(30_000) })
-  if (!response.ok) throw new Error(`Could not load compiler file sizes: ${response.status}`)
-  const metadata: unknown = await response.json()
+async function loadFileMetadata(base: URL, directory = base): Promise<ReadonlyMap<string, CompilerAssetMetadata>> {
+  const metadata: unknown = await fetchCompilerResource(new URL("?meta", directory), response => response.json())
   if (!isRecord(metadata) || !Array.isArray(metadata.files)) throw new Error("Invalid compiler file sizes")
-  const files = new Map<string, number>()
+  const files = new Map<string, CompilerAssetMetadata>()
   for (const file of metadata.files) {
     if (
       !isRecord(file) ||
       typeof file.path !== "string" ||
       typeof file.size !== "number" ||
       !Number.isSafeInteger(file.size) ||
-      file.size < 0
+      file.size < 0 ||
+      typeof file.integrity !== "string" ||
+      !/^sha256-[A-Za-z0-9+/]{43}=$/.test(file.integrity)
     ) {
       throw new Error("Invalid compiler file size")
     }
-    files.set(new URL(file.path.replace(/^\//, ""), base).href, file.size)
+    files.set(new URL(file.path.replace(/^\//, ""), base).href, { size: file.size, integrity: file.integrity })
   }
   return files
 }
diff --git a/packages/playground-v2/src/compiler-versions.ts b/packages/playground-v2/src/compiler-versions.ts
index 020e227eb972..aa3a384e60d4 100644
--- a/packages/playground-v2/src/compiler-versions.ts
+++ b/packages/playground-v2/src/compiler-versions.ts
@@ -1,4 +1,5 @@
 import { gte, prerelease, rcompare, valid } from "semver"
+import { CompilerDownloadError, fetchCompilerResource } from "./compiler-assets"
 
 export type PublishedCompilerVersions = {
   versions: string[]
@@ -43,13 +44,17 @@ export function isNativeCompilerVersion(version: string | null) {
 export async function loadPublishedCompilerVersions(): Promise<PublishedCompilerVersions> {
   const entries = await Promise.all(
     (["latest", "next", "beta", "rc"] as const).map(async tag => {
-      const response = await fetch(`https://unpkg.com/typescript@${tag}/package.json`, {
-        cache: "no-cache",
-        signal: AbortSignal.timeout(15_000),
-      })
-      if (response.status === 404) return [tag, undefined] as const
-      if (!response.ok) throw new Error(`Could not resolve TypeScript ${tag}: ${response.status}`)
-      const metadata: unknown = await response.json()
+      let metadata: unknown
+      try {
+        metadata = await fetchCompilerResource(
+          new URL(`https://unpkg.com/typescript@${tag}/package.json`),
+          response => response.json(),
+          { cache: "no-cache", timeout: 15_000 }
+        )
+      } catch (error) {
+        if (error instanceof CompilerDownloadError && error.status === 404) return [tag, undefined] as const
+        throw error
+      }
       const version: unknown = metadata && typeof metadata === "object" ? Reflect.get(metadata, "version") : undefined
       if (
         !metadata ||
@@ -70,12 +75,11 @@ export async function loadPublishedCompilerVersions(): Promise<PublishedCompiler
 }
 
 export async function loadLegacyCompilerVersions(): Promise<string[]> {
-  const response = await fetch("https://playgroundcdn.typescriptlang.org/indexes/releases.json", {
-    cache: "no-cache",
-    signal: AbortSignal.timeout(15_000),
-  })
-  if (!response.ok) throw new Error(`Could not load historical TypeScript versions: ${response.status}`)
-  const metadata: unknown = await response.json()
+  const metadata: unknown = await fetchCompilerResource(
+    new URL("https://playgroundcdn.typescriptlang.org/indexes/releases.json"),
+    response => response.json(),
+    { cache: "no-cache", timeout: 15_000 }
+  )
   const versions: unknown = metadata && typeof metadata === "object" ? Reflect.get(metadata, "versions") : undefined
   if (
     !Array.isArray(versions) ||
diff --git a/packages/playground-v2/src/index.html b/packages/playground-v2/src/index.html
index cb0ff74cd56a..3c93de346730 100644
--- a/packages/playground-v2/src/index.html
+++ b/packages/playground-v2/src/index.html
@@ -10,7 +10,6 @@
         location.replace(url)
       }
     </script>
-    <script src="./coi-serviceworker.min.js"></script>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1, interactive-widget=resizes-content" />
     <meta name="color-scheme" content="light dark" />
@@ -314,6 +313,7 @@ <h2 id="text-input-title">Enter a value</h2>
             <p id="loading-message" role="status">Loading TypeScript...</p>
             <progress id="loading-progress" max="100" value="0" aria-labelledby="loading-message"></progress>
             <small id="loading-detail"></small>
+            <button id="retry-startup-button" class="action-button" type="button" hidden>Retry</button>
           </div>
           <section id="download-consent" class="download-consent" aria-labelledby="download-consent-title" hidden>
             <h2 id="download-consent-title">Download TypeScript?</h2>
diff --git a/packages/playground-v2/src/isolation.ts b/packages/playground-v2/src/isolation.ts
new file mode 100644
index 000000000000..54931f335cc8
--- /dev/null
+++ b/packages/playground-v2/src/isolation.ts
@@ -0,0 +1,89 @@
+const reloadKey = "ts7-playground-isolation-reload"
+
+export async function ensureCrossOriginIsolation() {
+  if (globalThis.crossOriginIsolated && typeof SharedArrayBuffer !== "undefined") {
+    try {
+      sessionStorage.removeItem(reloadKey)
+    } catch (error) {
+      console.warn("Could not clear the isolation reload marker", error)
+    }
+    if (navigator.serviceWorker?.controller) {
+      navigator.serviceWorker.controller.postMessage({ type: "coepCredentialless", value: false })
+      void navigator.serviceWorker
+        .register(new URL("./coi-serviceworker.min.js", import.meta.url), {
+          updateViaCache: "none",
+        })
+        .catch(error => console.warn("Could not update the TypeScript serviceworker", error))
+    }
+    return
+  }
+  const unavailable =
+    "This browser cannot enable the TypeScript language service. Open this page in your system browser, or choose TypeScript 6."
+  if (!isSecureContext || !navigator.serviceWorker) throw new Error(unavailable)
+  const controller = new AbortController()
+  const timeout = setTimeout(
+    () => controller.abort(new Error("Timed out enabling the TypeScript language service. Retry to reconnect.")),
+    15_000
+  )
+  try {
+    const registration = await Promise.race([
+      navigator.serviceWorker.register(new URL("./coi-serviceworker.min.js", import.meta.url), {
+        updateViaCache: "none",
+      }),
+      aborted(controller.signal),
+    ])
+    const worker = registration.installing ?? registration.waiting ?? registration.active
+    if (!worker) throw new Error("The TypeScript serviceworker did not start. Retry to reconnect.")
+    if (worker.state !== "activated") {
+      await new Promise<void>((resolve, reject) => {
+        const change = () => {
+          if (worker.state === "activated") resolve()
+          else if (worker.state === "redundant")
+            reject(new Error("The TypeScript serviceworker could not activate. Retry to reconnect."))
+        }
+        worker.addEventListener("statechange", change, { signal: controller.signal })
+        controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true })
+        change()
+      })
+    }
+    if (navigator.serviceWorker.controller !== worker) {
+      await new Promise<void>((resolve, reject) => {
+        const change = () => {
+          if (navigator.serviceWorker.controller === worker) resolve()
+        }
+        navigator.serviceWorker.addEventListener("controllerchange", change, { signal: controller.signal })
+        controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true })
+        change()
+      })
+    }
+    // Safari does not reliably support credentialless; all runtime CDNs support CORS.
+    worker.postMessage({ type: "coepCredentialless", value: false })
+    if (sessionStorage.getItem(reloadKey) === location.href) throw new Error(unavailable)
+    sessionStorage.setItem(reloadKey, location.href)
+    clearTimeout(timeout)
+    location.reload()
+    // The next document, not a worker claiming this one, receives COOP/COEP.
+    await new Promise<never>(() => {})
+  } catch (error) {
+    if (error instanceof Error && error.message === unavailable) throw error
+    throw new Error(
+      `Could not enable the TypeScript language service: ${error instanceof Error ? error.message : String(error)}`
+    )
+  } finally {
+    clearTimeout(timeout)
+    controller.abort()
+  }
+}
+
+function aborted(signal: AbortSignal): Promise<never> {
+  return new Promise((_, reject) => signal.addEventListener("abort", () => reject(signal.reason), { once: true }))
+}
+
+export function retryStartup() {
+  try {
+    sessionStorage.removeItem(reloadKey)
+  } catch (error) {
+    console.warn("Could not clear the isolation reload marker", error)
+  }
+  location.reload()
+}
diff --git a/packages/playground-v2/src/main.ts b/packages/playground-v2/src/main.ts
index d9f49fca6c3c..f7b31df12421 100644
--- a/packages/playground-v2/src/main.ts
+++ b/packages/playground-v2/src/main.ts
@@ -1,4 +1,6 @@
 import type { Diagnostic as CompilerDiagnostic } from "@typescript/typescript/sync"
+import { downloadCompilerAsset, fetchCompilerResource, readResponseBytes } from "./compiler-assets"
+import { ensureCrossOriginIsolation, retryStartup } from "./isolation"
 import {
   legacyCompilerBaseUrl,
   loadPublishedCompilerDistribution,
@@ -250,6 +252,7 @@ const downloadConsent = getElement("download-consent")
 const downloadSize = getElement("download-size")
 const rememberDownloadConsent = getElement<HTMLInputElement>("remember-download-consent")
 const confirmDownloadButton = getElement<HTMLButtonElement>("confirm-download-button")
+const retryStartupButton = getElement<HTMLButtonElement>("retry-startup-button")
 
 let compilerReady = false
 let lspReady = false
@@ -873,6 +876,7 @@ toggleRunOutputButton.addEventListener("click", () => {
 })
 navigateBackButton.addEventListener("click", navigateBack)
 runButton.addEventListener("click", runProject)
+retryStartupButton.addEventListener("click", retryStartup)
 settingsButton.addEventListener("click", openSettings)
 settingsCancelButton.addEventListener("click", () => settingsDialog.close())
 settingsResetButton.addEventListener("click", () => populateSettingsForm(defaultPlaygroundSettings()))
@@ -913,6 +917,8 @@ void (useNativeCompiler ? initializeNativeCompiler() : initializeStradaCompiler(
 
 async function initializeNativeCompiler() {
   try {
+    setLoadingIndeterminate("Preparing TypeScript...", "")
+    await ensureCrossOriginIsolation()
     if (isDefaultNativeCompilerVersion(selectedCompiler)) compilerVersionLabel.textContent = "Default"
     else if (normalizeRequestedVersion(selectedCompiler!) === "next") compilerVersionLabel.textContent = "Nightly"
     const distribution = await getCompilerDistribution()
@@ -976,13 +982,11 @@ async function initializeStradaCompiler(requestedVersion: string) {
     const baseUrl = legacyCompilerBaseUrl(version, mirroredVersions)
     const compilerUrl = new URL("typescript.js", baseUrl)
     setLoadingIndeterminate("Downloading TypeScript...", "")
-    const compilerResponse = await fetch(compilerUrl)
-    if (!compilerResponse.ok) {
-      throw new Error(`Unable to load TypeScript ${version}: ${compilerResponse.status} ${compilerResponse.statusText}`)
-    }
     const compilerSource = new TextDecoder().decode(
-      await readResponseBytes(compilerResponse, length =>
-        setLoadingIndeterminate("Downloading TypeScript...", `${formatBytes(length)} received`)
+      await fetchCompilerResource(compilerUrl, response =>
+        readResponseBytes(response, length =>
+          setLoadingIndeterminate("Downloading TypeScript...", `${formatBytes(length)} received`)
+        )
       )
     )
     setLoadingIndeterminate("Starting TypeScript...", "")
@@ -1908,54 +1912,23 @@ async function downloadLibraries(distribution: CompilerDistribution) {
 }
 
 async function downloadAsset(name: string, url: URL): Promise<Uint8Array<ArrayBuffer>> {
-  const request = new Request(url)
   const cache = await getAssetCache()
-  let response = await cache?.match(url)
-  cachedAssets.set(name, response !== undefined)
-  let cacheWrite: Promise<void> | undefined
-  if (!response) {
-    response = await fetch(request)
-  }
-  if (!response.ok) {
-    throw new Error(`Unable to load ${url.pathname}: ${response.status} ${response.statusText}`)
-  }
-  if (cache && !cachedAssets.get(name)) cacheWrite = cache.put(request, response.clone())
-  const bytes = await readResponseBytes(response, length => {
-    downloadedAssets.set(name, length)
-    updateDownloadProgress()
+  const metadata = nativeDistribution?.assets.get(url.href)
+  if (!metadata) throw new Error(`Compiler asset metadata is missing: ${url.pathname}`)
+  return downloadCompilerAsset(url, metadata, {
+    cache,
+    onSource(cached) {
+      cachedAssets.set(name, cached)
+    },
+    onRetry() {
+      downloadedAssets.delete(name)
+      setLoadingIndeterminate("Retrying TypeScript download...", "")
+    },
+    onProgress(length) {
+      downloadedAssets.set(name, length)
+      updateDownloadProgress()
+    },
   })
-  await cacheWrite
-  return bytes
-}
-
-async function readResponseBytes(
-  response: Response,
-  onProgress: (length: number) => void
-): Promise<Uint8Array<ArrayBuffer>> {
-  if (!response.body) {
-    const bytes = new Uint8Array(await response.arrayBuffer())
-    onProgress(bytes.length)
-    return bytes
-  }
-
-  const chunks: Uint8Array[] = []
-  const reader = response.body.getReader()
-  let length = 0
-  for (;;) {
-    const { done, value } = await reader.read()
-    if (done) break
-    chunks.push(value)
-    length += value.length
-    onProgress(length)
-  }
-
-  const bytes = new Uint8Array(length)
-  let offset = 0
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset)
-    offset += chunk.length
-  }
-  return bytes
 }
 
 function getAssetCache() {
@@ -2630,6 +2603,9 @@ function renderStatus() {
     loader.hidden = false
     loader.dataset.state = "error"
     loadingMessage.textContent = failure
+    loadingProgress.hidden = true
+    loadingDetail.textContent = ""
+    retryStartupButton.hidden = false
     return
   }
   if (!compilerReady) {
diff --git a/packages/playground-v2/src/native-compiler.test.ts b/packages/playground-v2/src/native-compiler.test.ts
index bc12142d73e8..c30ec6c9cd42 100644
--- a/packages/playground-v2/src/native-compiler.test.ts
+++ b/packages/playground-v2/src/native-compiler.test.ts
@@ -23,6 +23,95 @@ import {
 import { createStradaFileSystem, parseStradaConfig } from "./strada-project"
 import { createPlaygroundV2Query } from "../../typescriptlang-org/src/lib/createPlaygroundV2Query"
 import { decodeCompressedHash, projectMarkdown, type ExportProject } from "./exporter"
+import { downloadCompilerAsset } from "./compiler-assets"
+
+test("compiler downloads discard corrupt cached bytes and retry interrupted or incomplete responses", async () => {
+  const url = new URL("https://example.test/tsc.wasm")
+  const bytes = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0])
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))
+  const metadata = { size: bytes.length, integrity: `sha256-${Buffer.from(digest).toString("base64")}` }
+  const originalFetch = globalThis.fetch
+  const requests: RequestCache[] = []
+  const writes: Response[] = []
+  let deleted = 0
+  let retries = 0
+  const corrupt = new Response(new Uint8Array(bytes.length))
+  const cache = {
+    match: async () => corrupt,
+    delete: async () => {
+      deleted++
+      return true
+    },
+    put: async (_url: unknown, response: Response) => {
+      writes.push(response)
+    },
+  }
+  globalThis.fetch = async (_url, init) => {
+    requests.push(init?.cache ?? "default")
+    if (requests.length === 1) throw new TypeError("Connection interrupted")
+    return new Response(requests.length === 2 ? bytes.slice(0, -1) : bytes, {
+      headers: { "content-encoding": "gzip" },
+    })
+  }
+  try {
+    const result = await downloadCompilerAsset(url, metadata, {
+      cache,
+      onProgress() {},
+      onSource() {},
+      onRetry() {
+        retries++
+      },
+    })
+    assert.deepEqual(result, bytes)
+    assert.equal(deleted, 1)
+    assert.equal(retries, 2)
+    assert.deepEqual(requests, ["no-store", "no-store", "no-store"])
+    assert.equal(writes.length, 1)
+    assert.deepEqual(new Uint8Array(await writes[0].arrayBuffer()), bytes)
+    assert.equal(writes[0].headers.get("content-encoding"), null)
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
+
+test("compiler download retries are bounded and never cache a bad transfer", async () => {
+  const originalFetch = globalThis.fetch
+  let requests = 0
+  let writes = 0
+  globalThis.fetch = async () => {
+    requests++
+    return new Response(new Uint8Array(1))
+  }
+  try {
+    await assert.rejects(
+      () =>
+        downloadCompilerAsset(
+          new URL("https://example.test/tsc.wasm"),
+          {
+            size: 2,
+            integrity: `sha256-${"A".repeat(43)}=`,
+          },
+          {
+            cache: {
+              match: async () => undefined,
+              delete: async () => false,
+              put: async () => {
+                writes++
+              },
+            },
+            onProgress() {},
+            onSource() {},
+            onRetry() {},
+          }
+        ),
+      /Incomplete compiler download/
+    )
+    assert.equal(requests, 3)
+    assert.equal(writes, 0)
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
 
 test("the legacy handoff serializes effective options with its own compiler and retains the requested channel", () => {
   const ts: typeof import("typescript") = createRequire(import.meta.url)("typescript")
diff --git a/packages/playground-v2/src/styles.css b/packages/playground-v2/src/styles.css
index 013312f2f5a9..0fdd72c9eed0 100644
--- a/packages/playground-v2/src/styles.css
+++ b/packages/playground-v2/src/styles.css
@@ -1203,8 +1203,13 @@ code {
   accent-color: #3178c6;
 }
 
-.loading-overlay[data-state="error"] progress {
-  accent-color: #c63131;
+.loading-overlay[data-state="error"] .loading-card {
+  pointer-events: auto;
+}
+
+.loading-overlay[data-state="error"] progress,
+.loading-overlay[data-state="error"] .lds-grid {
+  display: none;
 }
 
 .loading-overlay small {
diff --git a/packages/playground-v2/src/tsgo-lsp.ts b/packages/playground-v2/src/tsgo-lsp.ts
index 28ca98c2e222..9effec2a13f3 100644
--- a/packages/playground-v2/src/tsgo-lsp.ts
+++ b/packages/playground-v2/src/tsgo-lsp.ts
@@ -377,7 +377,9 @@ export function registerPlaygroundLanguages() {
 
 export function startTsgoLsp(options: StartTsgoLspOptions) {
   if (!crossOriginIsolated) {
-    throw new Error("The TypeScript language server requires cross-origin isolation; reload once to activate it.")
+    throw new Error(
+      "This browser cannot enable the TypeScript language service. Open this page in your system browser, or choose TypeScript 6."
+    )
   }
 
   readPackageFile = options.readPackageFile
diff --git a/patches/coi-serviceworker@0.1.7.patch b/patches/coi-serviceworker@0.1.7.patch
new file mode 100644
index 000000000000..d902f3a9ea3e
--- /dev/null
+++ b/patches/coi-serviceworker@0.1.7.patch
@@ -0,0 +1,21 @@
+diff --git a/coi-serviceworker.js b/coi-serviceworker.js
+index 72cc646784292087f7a5226fd49c18ce55d689b0..b6aa7b8c036c336fc73e1d44fd7b64baa479d7b8 100644
+--- a/coi-serviceworker.js
++++ b/coi-serviceworker.js
+@@ -54,7 +54,6 @@ if (typeof window === 'undefined') {
+                         headers: newHeaders,
+                     });
+                 })
+-                .catch((e) => console.error(e))
+         );
+     });
+ 
+diff --git a/coi-serviceworker.min.js b/coi-serviceworker.min.js
+index e1fb9a79d84598d1f680f37f8b8a24284ab50663..0e7b73430c5505cbb94d25754f92bdc908b3a34d 100644
+--- a/coi-serviceworker.min.js
++++ b/coi-serviceworker.min.js
+@@ -1,2 +1,2 @@
+ /*! coi-serviceworker v0.1.7 - Guido Zuidhof and contributors, licensed under MIT */
+-let coepCredentialless=!1;"undefined"==typeof window?(self.addEventListener("install",(()=>self.skipWaiting())),self.addEventListener("activate",(e=>e.waitUntil(self.clients.claim()))),self.addEventListener("message",(e=>{e.data&&("deregister"===e.data.type?self.registration.unregister().then((()=>self.clients.matchAll())).then((e=>{e.forEach((e=>e.navigate(e.url)))})):"coepCredentialless"===e.data.type&&(coepCredentialless=e.data.value))})),self.addEventListener("fetch",(function(e){const r=e.request;if("only-if-cached"===r.cache&&"same-origin"!==r.mode)return;const s=coepCredentialless&&"no-cors"===r.mode?new Request(r,{credentials:"omit"}):r;e.respondWith(fetch(s).then((e=>{if(0===e.status)return e;const r=new Headers(e.headers);return r.set("Cross-Origin-Embedder-Policy",coepCredentialless?"credentialless":"require-corp"),coepCredentialless||r.set("Cross-Origin-Resource-Policy","cross-origin"),r.set("Cross-Origin-Opener-Policy","same-origin"),new Response(e.body,{status:e.status,statusText:e.statusText,headers:r})})).catch((e=>console.error(e))))}))):(()=>{const e={shouldRegister:()=>!0,shouldDeregister:()=>!1,coepCredentialless:()=>!(window.chrome||window.netscape),doReload:()=>window.location.reload(),quiet:!1,...window.coi},r=navigator;r.serviceWorker&&r.serviceWorker.controller&&(r.serviceWorker.controller.postMessage({type:"coepCredentialless",value:e.coepCredentialless()}),e.shouldDeregister()&&r.serviceWorker.controller.postMessage({type:"deregister"})),!1===window.crossOriginIsolated&&e.shouldRegister()&&(window.isSecureContext?r.serviceWorker&&r.serviceWorker.register(window.document.currentScript.src).then((s=>{!e.quiet&&console.log("COOP/COEP Service Worker registered",s.scope),s.addEventListener("updatefound",(()=>{!e.quiet&&console.log("Reloading page to make use of updated COOP/COEP Service Worker."),e.doReload()})),s.active&&!r.serviceWorker.controller&&(!e.quiet&&console.log("Reloading page to make use of COOP/COEP Service Worker."),e.doReload())}),(r=>{!e.quiet&&console.error("COOP/COEP Service Worker failed to register:",r)})):!e.quiet&&console.log("COOP/COEP Service Worker not registered, a secure context is required."))})();
+\ No newline at end of file
++let coepCredentialless=!1;"undefined"==typeof window?(self.addEventListener("install",(()=>self.skipWaiting())),self.addEventListener("activate",(e=>e.waitUntil(self.clients.claim()))),self.addEventListener("message",(e=>{e.data&&("deregister"===e.data.type?self.registration.unregister().then((()=>self.clients.matchAll())).then((e=>{e.forEach((e=>e.navigate(e.url)))})):"coepCredentialless"===e.data.type&&(coepCredentialless=e.data.value))})),self.addEventListener("fetch",(function(e){const r=e.request;if("only-if-cached"===r.cache&&"same-origin"!==r.mode)return;const s=coepCredentialless&&"no-cors"===r.mode?new Request(r,{credentials:"omit"}):r;e.respondWith(fetch(s).then((e=>{if(0===e.status)return e;const r=new Headers(e.headers);return r.set("Cross-Origin-Embedder-Policy",coepCredentialless?"credentialless":"require-corp"),coepCredentialless||r.set("Cross-Origin-Resource-Policy","cross-origin"),r.set("Cross-Origin-Opener-Policy","same-origin"),new Response(e.body,{status:e.status,statusText:e.statusText,headers:r})})))}))):(()=>{const e={shouldRegister:()=>!0,shouldDeregister:()=>!1,coepCredentialless:()=>!(window.chrome||window.netscape),doReload:()=>window.location.reload(),quiet:!1,...window.coi},r=navigator;r.serviceWorker&&r.serviceWorker.controller&&(r.serviceWorker.controller.postMessage({type:"coepCredentialless",value:e.coepCredentialless()}),e.shouldDeregister()&&r.serviceWorker.controller.postMessage({type:"deregister"})),!1===window.crossOriginIsolated&&e.shouldRegister()&&(window.isSecureContext?r.serviceWorker&&r.serviceWorker.register(window.document.currentScript.src).then((s=>{!e.quiet&&console.log("COOP/COEP Service Worker registered",s.scope),s.addEventListener("updatefound",(()=>{!e.quiet&&console.log("Reloading page to make use of updated COOP/COEP Service Worker."),e.doReload()})),s.active&&!r.serviceWorker.controller&&(!e.quiet&&console.log("Reloading page to make use of COOP/COEP Service Worker."),e.doReload())}),(r=>{!e.quiet&&console.error("COOP/COEP Service Worker failed to register:",r)})):!e.quiet&&console.log("COOP/COEP Service Worker not registered, a secure context is required."))})();
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 11053c5522c5..d36413e19ed6 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -23,6 +23,9 @@ patchedDependencies:
   '@vscode/monaco-lsp-client@0.1.0':
     hash: 2adc8bf0b3596826d330832fc1ca5385179508eab8541c404f94c460b01115a0
     path: patches/@vscode__monaco-lsp-client@0.1.0.patch
+  coi-serviceworker@0.1.7:
+    hash: 714b4adc6ff6ecd02825ea3646eae7d2f84ef6ea33d2023e8e03d1d236243e2f
+    path: patches/coi-serviceworker@0.1.7.patch
   gatsby-remark-shiki-twoslash@3.0.38:
     hash: 5584d3c994349e1a6796ab8e22811fc912fad257e9ad818930836c458ab23640
     path: patches/gatsby-remark-shiki-twoslash@3.0.38.patch
@@ -202,7 +205,7 @@ importers:
         version: https://codeload.github.com/microsoft/monaco-editor/tar.gz/13f0c872dcf352815cc28d92dfff496c9839ea5c#path:/monaco-lsp-client(patch_hash=2adc8bf0b3596826d330832fc1ca5385179508eab8541c404f94c460b01115a0)(monaco-editor-core@0.56.0(patch_hash=1c45ae6c6762c6bf4f146baa58185da1d009024dcb8c66f57801a81813073d78))(ws@8.19.0)
       coi-serviceworker:
         specifier: ^0.1.7
-        version: 0.1.7
+        version: 0.1.7(patch_hash=714b4adc6ff6ecd02825ea3646eae7d2f84ef6ea33d2023e8e03d1d236243e2f)
       hack-font:
         specifier: ^3.3.0
         version: 3.3.0
@@ -14443,7 +14446,7 @@ snapshots:
 
   co@4.6.0: {}
 
-  coi-serviceworker@0.1.7: {}
+  coi-serviceworker@0.1.7(patch_hash=714b4adc6ff6ecd02825ea3646eae7d2f84ef6ea33d2023e8e03d1d236243e2f): {}
 
   collect-v8-coverage@1.0.3: {}