@@ -3,6 +3,7 @@
 ## In this release
 
 - ([#14741](https://github.com/quarto-dev/quarto-cli/issues/14741)): Don't wrap the `longtable` environment of a cross-referenceable table in a `{ ... }` group. Pandoc emits that group to scope its `\def\LTcaptype{none}`, which Quarto removes when adding its own `\caption`; keeping the now-pointless group broke packages that move the environment out of the text flow, such as `endfloat` with `\DeclareDelayedFloatFlavor*{longtable}{table}`.
+- ([#14857](https://github.com/quarto-dev/quarto-cli/issues/14857)): Fix `quarto install chrome-headless-shell` (and `quarto install chromium`) failing with a 404 on Linux arm64 due to a stale Playwright CDN URL.
 
 ## In previous releases
 
 
@@ -130,19 +130,18 @@ export async function fetchLatestCftRelease(): Promise<CftStableRelease> {
 
 /** Parsed entry from Playwright's browsers.json for chromium-headless-shell. */
 export interface PlaywrightBrowserEntry {
-  revision: string;
   browserVersion: string;
 }
 
 // Source: https://github.com/microsoft/playwright/blob/main/packages/playwright-core/browsers.json
-// This file lists the browser revisions Playwright pins per release, including
+// This file lists the browser versions Playwright pins per release, including
 // chromium-headless-shell builds for linux arm64 that CfT does not provide.
 const kPlaywrightBrowsersJsonUrl =
   "https://raw.githubusercontent.com/microsoft/playwright/main/packages/playwright-core/browsers.json";
 
 /**
  * Fetch Playwright's browsers.json and extract the chromium-headless-shell entry.
- * Used as the version/revision source for arm64 Linux where CfT has no builds.
+ * Used as the version source for arm64 Linux where CfT has no builds.
  */
 export async function fetchPlaywrightBrowsersJson(): Promise<PlaywrightBrowserEntry> {
   let response: Response;
@@ -179,24 +178,26 @@ export async function fetchPlaywrightBrowsersJson(): Promise<PlaywrightBrowserEn
 
   // deno-lint-ignore no-explicit-any
   const entry = browsers.find((b: any) => b.name === "chromium-headless-shell");
-  if (!entry || !entry.revision || !entry.browserVersion) {
+  if (!entry || !entry.browserVersion) {
     throw new Error(
-      "Playwright browsers.json has no 'chromium-headless-shell' entry with revision and browserVersion",
+      "Playwright browsers.json has no 'chromium-headless-shell' entry with browserVersion",
     );
   }
 
   return {
-    revision: entry.revision,
     browserVersion: entry.browserVersion,
   };
 }
 
 /**
  * Construct the Playwright CDN download URL for chrome-headless-shell on linux arm64.
- * Uses the primary CDN mirror (cdn.playwright.dev).
+ * Uses the primary CDN mirror (cdn.playwright.dev). Matches Playwright's own
+ * registry (packages/playwright-core/src/server/registry/index.ts, cftUrl),
+ * which keys builds by browserVersion under the "cft" path, not the legacy
+ * revision-keyed "chromium" path.
  */
-export function playwrightCdnDownloadUrl(revision: string): string {
-  return `https://cdn.playwright.dev/builds/chromium/${revision}/chromium-headless-shell-linux-arm64.zip`;
+export function playwrightCdnDownloadUrl(browserVersion: string): string {
+  return `https://cdn.playwright.dev/builds/cft/${browserVersion}/linux-arm64/chrome-headless-shell-linux-arm64.zip`;
 }
 
 /**
 
@@ -18,22 +18,63 @@ import {
 
 const kVersionFileName = "version";
 
+/**
+ * Binary name used by the Playwright-hosted arm64 archives that predate
+ * Playwright's move to the browserVersion-keyed builds/cft/ CDN path. Those
+ * archives shipped Playwright's own package layout — chrome-linux/headless_shell
+ * — instead of the CfT layout every platform (arm64 included) gets today.
+ * Installs made in that window are still on disk and must stay detectable.
+ */
+const kLegacyPlaywrightBinaryName = "headless_shell";
+
+/**
+ * Whether the legacy Playwright arm64 layout is worth probing for on this host.
+ * isPlaywrightCdnPlatform() throws on unsupported os/arch combinations, in which
+ * case no Quarto-installed arm64 binary can exist here anyway.
+ */
+function hostMayHaveLegacyPlaywrightLayout(): boolean {
+  try {
+    return isPlaywrightCdnPlatform();
+  } catch {
+    return false;
+  }
+}
+
 /** Return the chrome-headless-shell install directory under quartoDataDir. */
 export function chromeHeadlessShellInstallDir(): string {
   return quartoDataDir("chrome-headless-shell");
 }
 
 /**
- * The executable name for chrome-headless-shell on the current platform.
- * CfT builds use "chrome-headless-shell", Playwright arm64 builds use "headless_shell".
- * Returns the CfT name if platform detection fails (unsupported platform).
+ * The executable name for chrome-headless-shell.
+ * The Playwright CDN arm64 mirror redirects to the same chrome-for-testing-public
+ * bucket used for every other platform, so it shares the "chrome-headless-shell"
+ * binary name too.
  */
 export function chromeHeadlessShellBinaryName(): string {
-  try {
-    return isPlaywrightCdnPlatform() ? "headless_shell" : "chrome-headless-shell";
-  } catch {
-    return "chrome-headless-shell";
+  return "chrome-headless-shell";
+}
+
+/**
+ * Locate the chrome-headless-shell binary inside an install directory.
+ * Prefers the current CfT layout; on arm64 Linux also accepts the legacy
+ * Playwright layout left behind by pre-CDN-migration installs.
+ *
+ * allowLegacyPlaywrightLayout defaults to host detection and exists as an
+ * explicit parameter so the arm64 branch is reachable from tests on any host.
+ */
+export function findChromeHeadlessShellExecutable(
+  dir: string,
+  allowLegacyPlaywrightLayout: boolean = hostMayHaveLegacyPlaywrightLayout(),
+): string | undefined {
+  const found = findChromeExecutable(dir, chromeHeadlessShellBinaryName());
+  if (found !== undefined) {
+    return found;
+  }
+  if (allowLegacyPlaywrightLayout) {
+    return findChromeExecutable(dir, kLegacyPlaywrightBinaryName);
   }
+  return undefined;
 }
 
 /**
@@ -45,7 +86,7 @@ export function chromeHeadlessShellExecutablePath(): string | undefined {
   if (!existsSync(dir)) {
     return undefined;
   }
-  return findChromeExecutable(dir, chromeHeadlessShellBinaryName());
+  return findChromeHeadlessShellExecutable(dir);
 }
 
 /** Record the installed version as a plain text file. */
@@ -64,7 +105,11 @@ export function readInstalledVersion(dir: string): string | undefined {
 }
 
 /** Check if chrome-headless-shell is installed in the given directory. */
-export function isInstalled(dir: string): boolean {
+export function isInstalled(
+  dir: string,
+  allowLegacyPlaywrightLayout?: boolean,
+): boolean {
   return existsSync(join(dir, kVersionFileName)) &&
-    findChromeExecutable(dir, chromeHeadlessShellBinaryName()) !== undefined;
+    findChromeHeadlessShellExecutable(dir, allowLegacyPlaywrightLayout) !==
+      undefined;
 }
@@ -58,7 +58,7 @@ async function latestRelease(): Promise<RemotePackageInfo> {
   if (isPlaywrightCdnPlatform(platformInfo)) {
     // arm64 Linux: use Playwright CDN
     const entry = await fetchPlaywrightBrowsersJson();
-    const url = playwrightCdnDownloadUrl(entry.revision);
+    const url = playwrightCdnDownloadUrl(entry.browserVersion);
     return {
       url,
       version: entry.browserVersion,
 
@@ -130,35 +130,11 @@ unitTest("findChromeExecutable - finds binary in nested structure", async () =>
   }
 });
 
-// Step 3b: findChromeExecutable() — Playwright arm64 layout
-// Skip on Windows: arm64 layout is Linux-only, no .exe extension.
-unitTest("findChromeExecutable - finds binary in Playwright arm64 layout", async () => {
-  if (isWindows) return; // arm64 layout is Linux-only
-  const tempDir = Deno.makeTempDirSync();
-  try {
-    // Playwright arm64 extracts to chrome-linux/headless_shell
-    const subdir = join(tempDir, "chrome-linux");
-    Deno.mkdirSync(subdir);
-    Deno.writeTextFileSync(join(subdir, "headless_shell"), "fake binary");
-
-    const found = findChromeExecutable(tempDir, "headless_shell");
-    assert(found !== undefined, "should find headless_shell in chrome-linux/");
-    assert(found!.endsWith("headless_shell"), `should end with headless_shell, got: ${found}`);
-  } finally {
-    safeRemoveSync(tempDir, { recursive: true });
-  }
-});
-
 // Playwright CDN tests
 // Skipped on CI: makes external HTTP calls to GitHub/Playwright CDN.
 // Same pattern as CfT API tests above — run locally to catch API contract changes.
 unitTest("fetchPlaywrightBrowsersJson - returns chromium-headless-shell entry", async () => {
   const entry = await fetchPlaywrightBrowsersJson();
-  assert(entry.revision, "revision should be non-empty");
-  assert(
-    /^\d+$/.test(entry.revision),
-    `revision should be numeric, got: ${entry.revision}`,
-  );
   assert(entry.browserVersion, "browserVersion should be non-empty");
   assert(
     /^\d+\.\d+\.\d+\.\d+$/.test(entry.browserVersion),
@@ -167,17 +143,17 @@ unitTest("fetchPlaywrightBrowsersJson - returns chromium-headless-shell entry",
 }, { ignore: runningInCI() });
 
 unitTest("playwrightCdnDownloadUrl - constructs correct arm64 URL", async () => {
-  const url = playwrightCdnDownloadUrl("1219");
+  const url = playwrightCdnDownloadUrl("121.0.6167.85");
   assert(
     url.startsWith("https://cdn.playwright.dev/"),
     `URL should start with cdn.playwright.dev, got: ${url}`,
   );
   assert(
-    url.includes("/builds/chromium/1219/"),
-    `URL should contain revision path, got: ${url}`,
+    url.includes("/builds/cft/121.0.6167.85/linux-arm64/"),
+    `URL should contain browserVersion path, got: ${url}`,
   );
   assert(
-    url.endsWith("chromium-headless-shell-linux-arm64.zip"),
+    url.endsWith("chrome-headless-shell-linux-arm64.zip"),
     `URL should end with arm64 zip name, got: ${url}`,
   );
 });