fix(R): detect and handle x64 R on Windows ARM

Detects x64 R running on Windows ARM and provides helpful error message
with ARM64 R download guidance instead of generic installation message.

Implementation details:
- Parses YAML output to detect architecture mismatch
- Uses custom WindowsArmX64RError for type-safe error handling
- Detects in both success and failure paths (emulation is intermittent)
- Ensures error displays in quarto check output

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: cderv

src/core/knitr.ts

@@ -11,13 +11,15 @@ 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 { isWindows } from "../deno_ral/platform.ts";
 
 export interface KnitrCapabilities {
   versionMajor: number;
   versionMinor: number;
   versionPatch: number;
   home: string;
   libPaths: string[];
+  platform?: string;
   packages: KnitrRequiredPackages;
 }
 
@@ -68,6 +70,29 @@ export async function checkRBinary() {
   }
 }
 
+export class WindowsArmX64RError extends Error {
+  constructor(msg: string) {
+    super(msg);
+  }
+}
+
+function checkWindowsArmR(platform: string | undefined): void {
+  if (!platform) return;
+
+  const isWindowsArm = isWindows && Deno.build.arch === "aarch64";
+  const isX64R = platform.includes("x86_64") || platform.includes("i386");
+
+  if (isWindowsArm && isX64R) {
+    throw new WindowsArmX64RError(
+      "x64 R detected on Windows ARM.\n\n" +
+        "x64 R runs under emulation and is not reliable for Quarto.\n" +
+        "Please install native ARM64 R. \n" +
+        "Read about R on 64-bit Windows ARM at https://blog.r-project.org/2024/04/23/r-on-64-bit-arm-windows/\n" +
+        "After installation, set QUARTO_R environment variable if the correct version is not correctly found.",
+    );
+  }
+}
+
 export async function knitrCapabilities(rBin: string | undefined) {
   if (!rBin) return undefined;
   try {
@@ -105,6 +130,8 @@ export async function knitrCapabilities(rBin: string | undefined) {
           Object.values(pkgVersRequirement["rmarkdown"]).join(" "),
         )
         : false;
+
+      checkWindowsArmR(caps.platform);
       return caps;
     } else {
       debug("\n++ Problem with results of knitr capabilities check.");
@@ -115,9 +142,35 @@ export async function knitrCapabilities(rBin: string | undefined) {
       if (result.stderr) {
         debug(`    with stderr from R:\n${result.stderr}`);
       }
+
+      // Check if this is x64 R on Windows ARM
+      if (result.stdout) {
+        try {
+          const yamlMatch = result.stdout.match(
+            /--- YAML_START ---(.*)--- YAML_END ---/s,
+          );
+          if (yamlMatch) {
+            const yamlLines = yamlMatch[1];
+            const caps = readYamlFromString(yamlLines) as KnitrCapabilities;
+            checkWindowsArmR(caps.platform);
+          }
+        } catch (e) {
+          // If it's our specific x64-on-ARM error, rethrow it
+          if (e instanceof WindowsArmX64RError) {
+            throw e;
+          }
+          // Otherwise YAML parse failed, continue to return undefined
+          debug("    Failed to parse YAML for architecture detection");
+        }
+      }
+
       return undefined;
     }
-  } catch {
+  } catch (e) {
+    // Rethrow x64-on-ARM errors - these have helpful messages
+    if (e instanceof WindowsArmX64RError) {
+      throw e;
+    }
     debug(
       `\n++ Error while running 'capabilities/knitr.R' ${
         rBin ? "with " + rBin : ""
@@ -136,6 +189,12 @@ export function knitrCapabilitiesMessage(caps: KnitrCapabilities, indent = "") {
   for (const path of caps.libPaths) {
     lines.push(`  - ${path}`);
   }
+
+  // Show platform information if available
+  if (caps.platform) {
+    lines.push(`Platform: ${caps.platform}`);
+  }
+
   lines.push(`knitr: ${caps.packages.knitr || "(None)"}`);
   if (caps.packages.knitr && !caps.packages.knitrVersOk) {
     lines.push(

src/execute/rmd.ts

@@ -26,6 +26,7 @@ import {
   knitrCapabilitiesMessage,
   knitrInstallationMessage,
   rInstallationMessage,
+  WindowsArmX64RError,
 } from "../core/knitr.ts";
 import {
   DependenciesOptions,
@@ -139,13 +140,23 @@ title: "Title"
     const kMessage = "Checking R installation...........";
     let caps: KnitrCapabilities | undefined;
     let rBin: string | undefined;
+    let x64ArmError: WindowsArmX64RError | undefined;
     const json: Record<string, unknown> = {};
     if (conf.jsonResult) {
       (conf.jsonResult.tools as Record<string, unknown>).knitr = json;
     }
     const knitrCb = async () => {
       rBin = await checkRBinary();
-      caps = await knitrCapabilities(rBin);
+      try {
+        caps = await knitrCapabilities(rBin);
+      } catch (e) {
+        if (e instanceof WindowsArmX64RError) {
+          x64ArmError = e;
+          // Don't rethrow - let caps stay undefined but capture error
+        } else {
+          throw e; // Rethrow other errors
+        }
+      }
     };
     if (conf.jsonResult) {
       await knitrCb();
@@ -205,6 +216,16 @@ title: "Title"
       checkInfoMsg(msg);
       json["installed"] = false;
       checkInfoMsg("");
+    } else if (x64ArmError) {
+      // x64 R on Windows ARM detected - show specific error
+      json["installed"] = false;
+      checkCompleteMessage(kMessage + "(None)\n");
+      const errorLines = x64ArmError.message.split("\n");
+      errorLines.forEach((line) => {
+        checkInfoMsg(line);
+      });
+      json["error"] = x64ArmError.message;
+      checkInfoMsg("");
     } else if (caps === undefined) {
       json["installed"] = false;
       checkCompleteMessage(kMessage + "(None)\n");

src/resources/capabilities/knitr.R

@@ -8,6 +8,7 @@ cat("libPaths:\n")
 for (lib in .libPaths()) {
   cat(paste0('  - ', shQuote(lib)), "\n")
 }
+cat("platform:", R.version[['platform']], "\n")
 cat("packages:\n")
 cat("  knitr: ")
 if (requireNamespace("knitr", quietly = TRUE)) {