Merge branch 'main' into chore/pandoc-3.6

Author: cderv

README.md

@@ -2,25 +2,25 @@
 
 # Quarto
 
-Quarto is an open-source scientific and technical publishing system built on [Pandoc](https://pandoc.org). Quarto documents are authored using [markdown](https://en.wikipedia.org/wiki/Markdown), an easy to write plain text format.
+Quarto is an open-source scientific and technical publishing system built on [Pandoc](https://pandoc.org). Quarto documents are authored using [Markdown](https://en.wikipedia.org/wiki/Markdown), an easy to write plain text format.
 
 In addition to the core capabilities of Pandoc, Quarto includes:
 
 1.  Embedding code and output from Python, R, Julia, and JavaScript via integration with [Jupyter](https://jupyter.org/), [Knitr](https://yihui.org/knitr/), and [Observable](https://github.com/observablehq/).
 
-2.  A variety of extensions to Pandoc markdown useful for technical writing including cross-references, sub-figures, layout panels, hoverable citations and footnotes, callouts, and more.
+2.  A variety of extensions to Pandoc Markdown useful for technical writing including cross-references, sub-figures, layout panels, hoverable citations and footnotes, callouts, and more.
 
 3.  A project system for rendering groups of documents at once, sharing options across documents, and producing aggregate output like [websites](https://quarto.org/docs/websites/) and [books](https://quarto.org/docs/books/).
 
 4.  Authoring using a wide variety of editors and notebooks including [JupyterLab](https://quarto.org/docs/tools/jupyter-lab.html), [RStudio](https://quarto.org/docs/tools/rstudio.html), and [VS Code](https://quarto.org/docs/tools/vscode.html).
 
-5.  A [visual markdown editor](https://quarto.org/docs/visual-editor/) that provides a productive writing interface for composing long-form documents.
+5.  A [visual Markdown editor](https://quarto.org/docs/visual-editor/) that provides a productive writing interface for composing long-form documents.
 
 Learn more about Quarto at <https://quarto.org>.
 
 ## Development Version
 
-To install the development version of the Quarto CLI, clone the quarto-cli repository then run the configure script for your platform (`configure.sh` for Linux/macOS or `configure.cmd` for Windows). For example:
+To install the development version of the Quarto CLI, clone the `quarto-cli` repository then run the configure script for your platform (`configure.sh` for Linux/macOS or `configure.cmd` for Windows). For example:
 
 ```bash
 git clone https://github.com/quarto-dev/quarto-cli

news/changelog-1.7.md

@@ -9,10 +9,15 @@ All changes included in 1.7:
 - ([#11752](https://github.com/quarto-dev/quarto-cli/issues/11752)): Fix regression with non-alphanumeric characters in `categories` preventing correct filtering of listing.
 - ([#11561](https://github.com/quarto-dev/quarto-cli/issues/11561)): Fix a regression with `$border-color` that impacted, callouts borders, tabset borders, and table borders of the defaults themes. `$border-color` is now correctly a mixed of `$body-color` and `$body-bg` even for the default theme.
 - ([#11943](https://github.com/quarto-dev/quarto-cli/issues/11943)): Fix callout title color on dark theme in revealjs following Revealjs update in quarto 1.6.
+- ([#12147](https://github.com/quarto-dev/quarto-cli/issues/12147)): for RevealJS format, `serif` and `simple` themes defaults back to have their heading color (`$presentation-heading-color`) to be the same as the body color (`$body-color`) as in Quarto 1.5.
+- ([#11659](https://github.com/quarto-dev/quarto-cli/pull/11659)): Julia engine: Fix escaping bug where paths containing spaces or backslashes break server startup on Windows.
 
 ## YAML validation
 
 - ([#11654](https://github.com/quarto-dev/quarto-cli/issues/11654)): Allow `page-inset` as value in `column` key for code cells.
+- ([#10251](https://github.com/quarto-dev/quarto-cli/issues/10251)): EJS template for website now uses proper object to get alt text for logo in sidebar.
+- ([#12151](https://github.com/quarto-dev/quarto-cli/issues/12151)): Fix YAML validation in computations cell on Windows.
+- ([#12151](https://github.com/quarto-dev/quarto-cli/pull/12151)): Basic YAML validation is now active in cell for document using Julia engine.
 
 ## Website projects
 
@@ -32,6 +37,10 @@ All changes included in 1.7:
 
 - ([#11608](https://github.com/quarto-dev/quarto-cli/pull/11608)): Do not issue error message when calling `quarto check info`.
 
+## `quarto convert`
+
+- ([#12042](https://github.com/quarto-dev/quarto-cli/issues/12042)): Preserve Markdown content that follows YAML metadata in a `raw` .ipynb cell.
+
 ## `html` format
 
 - ([#11860](https://github.com/quarto-dev/quarto-cli/issues/11860)): ES6 modules that import other local JS modules in documents with `embed-resources: true` are now correctly embedded.
@@ -56,6 +65,10 @@ All changes included in 1.7:
 - Update to Pandoc's template following Pandoc 3.6.3 support:
   - `article.jats_publishing` partials now support `author.roles`
 
+### Quarto PDF engine
+
+- ([#12194](https://github.com/quarto-dev/quarto-cli/issues/12194)): More specific checks added in log parsing to automatically find missing fonts.
+
 ## `typst` format
 
 - ([#11578](https://github.com/quarto-dev/quarto-cli/issues/11578)): Typst column layout widths use fractional `fr` units instead of percent `%` units for unitless and default widths in order to fill the enclosing block and not spill outside it.
@@ -84,8 +97,12 @@ All changes included in 1.7:
 
 ### `julia`
 
-- ([#11659](https://github.com/quarto-dev/quarto-cli/pull/11659)): Fix escaping bug where paths containing spaces or backslashes break server startup on Windows.
-- ([#12121](https://github.com/quarto-dev/quarto-cli/pull/12121)): Update QuartoNotebookRunner to 0.13.1. Support for evaluating Python cells via [PythonCall.jl](https://github.com/JuliaPy/PythonCall.jl) added.
+- ([#12121](https://github.com/quarto-dev/quarto-cli/pull/12121)): Update QuartoNotebookRunner to 0.14.0. Support for evaluating Python cells via [PythonCall.jl](https://github.com/JuliaPy/PythonCall.jl) added. Support for notebook caching via `execute.cache` added.
+- ([#12151](https://github.com/quarto-dev/quarto-cli/pull/12151)): Basic YAML validation is now active for document using Julia engine.
+
+### `jupyter`
+
+- ([#12114](https://github.com/quarto-dev/quarto-cli/issues/12114)): `JUPYTERCACHE` environment variable from [Jupyter cache CLI](https://jupyter-cache.readthedocs.io/en/latest/using/cli.html) is now respected by Quarto when `cache: true` is used. This environment variable allows to change the path of the cache directory.
 
 ## Other Fixes and Improvements
 
@@ -97,3 +114,4 @@ All changes included in 1.7:
 - ([#10532](https://github.com/quarto-dev/quarto-cli/issues/10532)): Quarto changed default of `--headless=old` to `--headless` as [Chrome 132 has removed old headless mode](https://developer.chrome.com/blog/removing-headless-old-from-chrome) and only support new mode. For using old mode, `QUARTO_CHROMIUM` could be set to a [new `chrome-headless-shell` binary](https://developer.chrome.com/blog/chrome-headless-shell) or too an older chrome version (between 128 and 132) and `QUARTO_CHROMIUM_HEADLESS_MODE` set to `old` for using old headless mode with that compatabitle version.
 - ([#10961](https://github.com/quarto-dev/quarto-cli/issues/10961)): Add more information on which Chrome Headless will be used in `quarto check install`. This is helpful to help debug mermaid issues.
 - ([#11951](https://github.com/quarto-dev/quarto-cli/issues/11951)): Raw LaTeX table without `tbl-` prefix label for using Quarto crossref are now correctly passed through unmodified.
+- ([#12117](https://github.com/quarto-dev/quarto-cli/issues/12117)): Color output to stdout and stderr is now correctly rendered for `html` format in the Jupyter and Julia engines.

package/src/common/patches/revealjs-theme-0001-simple.patch

@@ -28,7 +28,7 @@ index f0472d7b9..3b1e3cbdc 100644
 +$font-family-sans-serif: "Lato", sans-serif !default;
 +$body-color: #000 !default;
 +$presentation-heading-font: "News Cycle", sans-serif !default;
-+$presentation-heading-color: #000 !default;
++$presentation-heading-color: $body-color !default;
 +$presentation-heading-text-shadow: none !default;
 +$presentation-heading-text-transform: none !default;
 +$body-bg: #fff !default;

package/src/common/patches/revealjs-theme-0001-sky.patch

@@ -28,7 +28,7 @@ index 62a52b782..2debff7bc 100644
 +$font-family-sans-serif: "Open Sans", sans-serif !default;
 +$body-color: #333 !default;
 +$presentation-heading-font: "Quicksand", sans-serif !default;
-+$presentation-heading-color: #333 !default;
++$presentation-heading-color: $body-color !default;
 +$presentation-heading-letter-spacing: -0.08em !default;
 +$presentation-heading-text-shadow: none !default;
 +$body-bg: #f7fbfc !default;

src/command/convert/jupyter.ts

@@ -30,6 +30,7 @@ import {
   jupyterCellSrcAsLines,
   jupyterCellSrcAsStr,
 } from "../../core/jupyter/jupyter-shared.ts";
+import { assert } from "testing/asserts";
 
 export async function markdownToJupyterNotebook(
   file: string,
@@ -71,11 +72,15 @@ export async function jupyterNotebookToMarkdown(
         case "raw":
           // see if this is the front matter
           if (frontMatter === undefined) {
-            frontMatter = partitionYamlFrontMatter(
-              jupyterCellSrcAsStr(cell),
-            )?.yaml;
-            if (!frontMatter) {
-              md.push(...mdFromRawCell(cellWithOptions));
+            const { yaml: cellYaml, markdown: cellMarkdown } =
+              partitionYamlFrontMatter(
+                jupyterCellSrcAsStr(cell),
+              ) || {};
+            if (cellYaml) {
+              frontMatter = cellYaml;
+            }
+            if (cellMarkdown) {
+              md.push(cellMarkdown);
             }
           } else {
             md.push(...mdFromRawCell(cellWithOptions));
@@ -130,14 +135,22 @@ export async function jupyterNotebookToMarkdown(
     }
   }
 
+  // if we found front matter, then the markdown source will start with enough
+  // newlines for the front matter to have been detected in the first place.
+  // So we only need to add newlines if there was no front matter.
+  //
+  // If this invariant breaks, we have a bug of some kind, so let's just assert it
+  assert(frontMatter || !mdSource.match(/^\n\n/));
+  const maybeYamlMdBreak = frontMatter ? "" : "\n\n";
+
   // return yaml + markdown
   const yamlText = stringify(yaml, {
     indent: 2,
     lineWidth: -1,
     sortKeys: false,
     skipInvalid: true,
   });
-  return `---\n${yamlText}---\n\n${mdSource}`;
+  return `---\n${yamlText}---${maybeYamlMdBreak}${mdSource}`;
 }
 
 async function mdFromCodeCell(

src/command/render/freeze.ts

@@ -53,8 +53,10 @@ export function freezeExecuteResult(
   result: ExecuteResult,
 ) {
   // resolve includes within executeResult
+  // nb: Beware to not modify the original result object
   const innerResult = {
     ...result,
+    includes: result.includes ? { ...result.includes } : undefined,
   } as ExecuteResult;
   const resolveIncludes = (
     name: "include-in-header" | "include-before-body" | "include-after-body",

src/command/render/latexmk/parse-error.ts

@@ -209,8 +209,11 @@ function findMissingFonts(dir: string): string[] {
 }
 
 const formatFontFilter = (match: string, _text: string) => {
-  const base = basename(match);
-  return fontSearchTerm(base);
+  // Remove special prefix / suffix e.g. 'file:HaranoAjiMincho-Regular.otf:-kern;jfm=ujis'
+  // https://github.com/quarto-dev/quarto-cli/issues/12194
+  const base = basename(match).replace(/^.*?:|:.*$/g, "");
+  // return found file directly if it has an extension
+  return /[.]/.test(base) ? base : fontSearchTerm(base);
 };
 
 const estoPdfFilter = (_match: string, _text: string) => {
@@ -231,21 +234,20 @@ const packageMatchers = [
     regex: /.*!.+ error:.+\(file ([^)]+)\): .*/g,
     filter: formatFontFilter,
   },
-  {
-    regex: /.*Package widetext error: Install the ([^ ]+) package.*/g,
-    filter: (match: string, _text: string) => {
-      return `${match}.sty`;
-    },
-  },
   {
     regex: /.*Unable to find TFM file "([^"]+)".*/g,
     filter: formatFontFilter,
   },
   {
-    regex:
-      /.*! Package fontspec Error:\s+\(fontspec\)\s+The font "([^"]+)" cannot be\s+\(fontspec\)\s+found;+/g,
+    regex: /.*\(fontspec\)\s+The font "([^"]+)" cannot be.*/g,
     filter: formatFontFilter,
   },
+  {
+    regex: /.*Package widetext error: Install the ([^ ]+) package.*/g,
+    filter: (match: string, _text: string) => {
+      return `${match}.sty`;
+    },
+  },
   { regex: /.* File `(.+eps-converted-to.pdf)'.*/g, filter: estoPdfFilter },
   { regex: /.*xdvipdfmx:fatal: pdf_ref_obj.*/g, filter: estoPdfFilter },
 
@@ -303,7 +305,7 @@ function findMissingPackages(logFileText: string): string[] {
     packageMatcher.regex.lastIndex = 0;
   });
 
-  // dedpulicated list of packages to attempt to install
+  // dedulicated list of packages to attempt to install
   return ld.uniq(toInstall);
 }
 

src/core/debug/mutation-detector-proxy.ts

@@ -0,0 +1,65 @@
+/*
+ * mutation-detector-proxy
+ *
+ * Copyright (C) 2025 Posit Software, PBC
+ */
+
+export type DeepProxyChange = {
+  type: "update" | "delete";
+  path: (string | symbol)[];
+  oldValue: unknown;
+  newValue?: unknown;
+};
+
+export type OnChangeCallback = (change: DeepProxyChange) => void;
+
+export function mutationDetectorProxy<T extends object>(
+  obj: T,
+  onChange: OnChangeCallback,
+  path: (string | symbol)[] = [],
+): T {
+  return new Proxy(obj, {
+    get(target: T, property: string | symbol): any {
+      const value = Reflect.get(target, property);
+      if (value && typeof value === "object") {
+        return mutationDetectorProxy(
+          value,
+          onChange,
+          [...path, property],
+        );
+      }
+      return value;
+    },
+
+    set(target: T, property: string | symbol, value: any): boolean {
+      const oldValue = Reflect.get(target, property);
+      const result = Reflect.set(target, property, value);
+
+      if (result) {
+        onChange({
+          type: "update",
+          path: [...path, property],
+          oldValue,
+          newValue: value,
+        });
+      }
+
+      return result;
+    },
+
+    deleteProperty(target: T, property: string | symbol): boolean {
+      const oldValue = Reflect.get(target, property);
+      const result = Reflect.deleteProperty(target, property);
+
+      if (result) {
+        onChange({
+          type: "delete",
+          path: [...path, property],
+          oldValue,
+        });
+      }
+
+      return result;
+    },
+  });
+}

src/core/jupyter/jupyter.ts

@@ -1629,7 +1629,7 @@ async function mdFromCodeCell(
           }
           md.push(text.join(""));
         } else {
-          md.push(mdOutputStream(stream));
+          md.push(await mdOutputStream(stream, options));
         }
       } else if (output.output_type === "error") {
         md.push(await mdOutputError(output as JupyterOutputError, options));
@@ -1766,7 +1766,7 @@ function isMarkdown(output: JupyterOutput, options: JupyterToMarkdownOptions) {
   return isDisplayDataType(output, options, displayDataIsMarkdown);
 }
 
-function mdOutputStream(output: JupyterOutputStream) {
+async function mdOutputStream(output: JupyterOutputStream, options: JupyterToMarkdownOptions) {
   let text: string[] = [];
   if (typeof output.text === "string") {
     text = [output.text];
@@ -1781,14 +1781,23 @@ function mdOutputStream(output: JupyterOutputStream) {
         /<ipython-input.*?>:\d+:\s+/,
         "",
       );
-      return mdCodeOutput(
-        [firstLine, ...text.slice(1)].map(colors.stripColor),
-      );
+      text = [firstLine, ...text.slice(1)];
     }
   }
 
-  // normal default handling
-  return mdCodeOutput(text.map(colors.stripColor));
+  if (options.toHtml && text.some(hasAnsiEscapeCodes)) {
+    const linesHTML = await convertToHtmlSpans(text.join("\n"));
+    return mdMarkdownOutput(
+      [
+        "\n::: {.ansi-escaped-output}\n```{=html}\n<pre>",
+        linesHTML,
+        "</pre>\n```\n:::\n",
+      ],
+    );
+  } else {
+    // normal default behavior
+    return mdCodeOutput(text.map(colors.stripColor));
+  }
 }
 
 async function mdOutputError(
@@ -1864,8 +1873,8 @@ async function mdOutputDisplayData(
       // if output is invalid, warn and emit empty
       const data = output.data[mimeType] as unknown;
       if (!Array.isArray(data) || data.some((s) => typeof s !== "string")) {
-        return mdWarningOutput(`Unable to process text plain output data 
-which does not appear to be plain text: ${JSON.stringify(data)}`);
+        return await mdWarningOutput(`Unable to process text plain output data 
+which does not appear to be plain text: ${JSON.stringify(data)}`, options);
       }
       const lines = data as string[];
       // pandas inexplicably outputs html tables as text/plain with an enclosing single-quote
@@ -1900,9 +1909,10 @@ which does not appear to be plain text: ${JSON.stringify(data)}`);
   }
 
   // no type match found
-  return mdWarningOutput(
+  return await mdWarningOutput(
     "Unable to display output for mime type(s): " +
-      Object.keys(output.data).join(", "),
+    Object.keys(output.data).join(", "),
+    options,
   );
 }
 
@@ -2061,12 +2071,12 @@ function mdEnclosedOutput(begin: string, text: string[], end: string) {
   return md.join("");
 }
 
-function mdWarningOutput(msg: string) {
-  return mdOutputStream({
+async function mdWarningOutput(msg: string, options: JupyterToMarkdownOptions) {
+  return await mdOutputStream({
     output_type: "stream",
     name: "stderr",
     text: [msg],
-  });
+  }, options);
 }
 
 function isWarningOutput(output: JupyterOutput) {

src/core/lib/yaml-schema/chunk-metadata.ts

@@ -132,6 +132,16 @@ const jupyterEngineSchema = defineCached(
   },
   "engine-jupyter",
 );
+const juliaEnginesSchema = defineCached(
+  // deno-lint-ignore require-await
+  async () => {
+    return {
+      schema: makeEngineSchema("julia"),
+      errorHandlers: [],
+    };
+  },
+  "engine-julia",
+);
 
 export async function getEngineOptionsSchema(): Promise<
   Record<string, ConcreteSchema>
@@ -140,6 +150,7 @@ export async function getEngineOptionsSchema(): Promise<
     markdown: await markdownEngineSchema(),
     knitr: await knitrEngineSchema(),
     jupyter: await jupyterEngineSchema(),
+    julia: await juliaEnginesSchema(),
   };
 
   return obj;