fix(R): detect x64 R on Windows ARM via exit codes (#13822)

* fix: detect x64 R on Windows ARM via exit codes

When x64 R crashes on Windows ARM, detect specific exit codes and provide
helpful error message instead of generic "check your R installation".

Detects two crash scenarios:
- Native ARM hardware: -1073741569 (STATUS_NOT_SUPPORTED)
- Windows ARM VM on Mac: -1073741819 (STATUS_ACCESS_VIOLATION)

Both occur when rmarkdown package loads under x64 emulation. R script
completes successfully and produces YAML before crashing during cleanup.

These error codes are unique to x64 R on ARM Windows, so checking them
directly is sufficient without needing to verify ARM hardware via Windows API.

Closes #8730
Related: #13790

* docs: add issue and test repo links to ARM detection comment

Add references to issue #8730 and quarto-windows-arm test repository
in code comments to help future contributors understand the context.

* fix: improve Windows ARM x64 R error message

Make error message more actionable:
- Show detected error code
- Explain x64 R on Windows ARM issue
- Provide step-by-step fix instructions
- Link to issue #8730 for context

* fix: prevent duplicate Windows ARM x64 R error message

Use errorOnce() instead of rethrowing WindowsArmX64RError to prevent
duplicate error messages when printCallRDiagnostics() calls
knitrCapabilities() again. Returns undefined like other knitrCapabilities
errors without changing general error handling in callR().

* refactor: extract x64-on-ARM check into throwIfX64ROnArm()

Extract x64 R crash detection into helper function for better code
organization. Function name clearly indicates it throws on detection.

* docs: add changelog entry for Windows ARM x64 R detection

Author: cderv

news/changelog-1.9.md

@@ -100,6 +100,7 @@ All changes included in 1.9:
 
 ## Other fixes and improvements
 
+- ([#8730](https://github.com/quarto-dev/quarto-cli/issues/8730)): Detect x64 R crashes on Windows ARM and provide helpful error message directing users to install native ARM64 R instead of showing generic "check your R installation" error.
 - ([#13402](https://github.com/quarto-dev/quarto-cli/issues/13402)): `nfpm` (<https://nfpm.goreleaser.com/>) is now used to create the `.deb` package, and new `.rpm` package. Both Linux packages are also now built for `x86_64` (`amd64`) and `aarch64` (`arm64`) architectures.
 - ([#13528](https://github.com/quarto-dev/quarto-cli/pull/13528)): Adds support for table specification using nested lists and the `list-table` class.
 - ([#13575](https://github.com/quarto-dev/quarto-cli/pull/13575)): Improve CPU architecture detection/reporting in macOS to allow quarto to run in virtualized environments such as OpenAI's `codex`.

src/core/knitr.ts

@@ -11,6 +11,7 @@ import { rBinaryPath, resourcePath } from "./resources.ts";
 import { readYamlFromString } from "./yaml.ts";
 import { coerce, satisfies } from "semver/mod.ts";
 import { debug } from "../deno_ral/log.ts";
+import { errorOnce } from "./log.ts";
 
 export interface KnitrCapabilities {
   versionMajor: number;
@@ -68,6 +69,36 @@ export async function checkRBinary() {
   }
 }
 
+export class WindowsArmX64RError extends Error {
+  constructor(msg: string) {
+    super(msg);
+  }
+}
+
+// Check for x64 R crashes on ARM Windows
+// These specific error codes only occur when x64 R crashes on ARM Windows
+// See: https://github.com/quarto-dev/quarto-cli/issues/8730
+//      https://github.com/cderv/quarto-windows-arm
+function throwIfX64ROnArm(exitCode: number): void {
+  const isX64RCrashOnArm =
+    exitCode === -1073741569 ||  // STATUS_NOT_SUPPORTED (native ARM hardware)
+    exitCode === -1073741819;    // STATUS_ACCESS_VIOLATION (Windows ARM VM on Mac)
+
+  if (isX64RCrashOnArm) {
+    throw new WindowsArmX64RError(
+      `R process crashed with known error code (${exitCode}).\n\n` +
+        "This typically indicates x64 R running on Windows 11 ARM.\n" +
+        "x64 R runs under emulation and is not reliable for Quarto.\n\n" +
+        "To fix this issue:\n" +
+        "1. Check your R version with: Rscript -e \"R.version$platform\"\n" +
+        "2. If it shows 'x86_64-w64-mingw32', you need ARM64 R\n" +
+        "3. Install native ARM64 R: https://blog.r-project.org/2024/04/23/r-on-64-bit-arm-windows/\n" +
+        "4. If needed, set QUARTO_R environment variable to point to ARM64 Rscript\n\n" +
+        "More context on this issue: https://github.com/quarto-dev/quarto-cli/issues/8730",
+    );
+  }
+}
+
 export async function knitrCapabilities(rBin: string | undefined) {
   if (!rBin) return undefined;
   try {
@@ -115,9 +146,17 @@ export async function knitrCapabilities(rBin: string | undefined) {
       if (result.stderr) {
         debug(`    with stderr from R:\n${result.stderr}`);
       }
+
+      throwIfX64ROnArm(result.code);
+
+      return undefined;
+    }
+  } catch (e) {
+    // Log x64-on-ARM errors once, then return undefined like other errors
+    if (e instanceof WindowsArmX64RError) {
+      errorOnce(e.message);
       return undefined;
     }
-  } catch {
     debug(
       `\n++ Error while running 'capabilities/knitr.R' ${
         rBin ? "with " + rBin : ""