Code echo is hoisted out of a `layout` div when the cell is nested inside another div

[mcanouil]

I have:

• searched the issue tracker for similar issues
• installed the latest version of Quarto CLI
• formatted my issue following the Bug Reports guide

Bug description

Reported by @rchaput in https://github.com/orgs/quarto-dev/discussions/14824.

When an executable cell is placed inside a div that is itself inside a div with a layout attribute, the echoed source of the cell is moved out of the layout and emitted before the whole layout panel.
Only the cell outputs stay inside the layout cell.

A static code block in the same position is left in place.
The difference in treatment comes from the cell-code class that the engine adds to the echo of an executable cell.
This makes the behaviour depend on whether the code block came from execution, not on the document structure the author wrote.

Two further effects follow from the same move:

• Any class on the div that contained the cell is lost for the echo.
  In the RevealJS case of the discussion, the echo is inside ::: {.fragment} but is never shown as a fragment.
• Document order is broken, because the echo is placed before content that the author wrote before it.

The behaviour is not specific to RevealJS or to Jupyter.
It reproduces with format: html and with the knitr engine.

Steps to reproduce

---
title: Test code fragments in Revealjs
format: revealjs
---

## Slide 1

:::: {layout="[50, 50]"}
::: {}
- A list of items
- That should appear on the left side
:::

::: {.fragment}
A code fragment that should appear on the right side

```{python}
#| echo: true
print("Hello from Python")
```
:::
::::

The same result occurs with format: html, and with an {r} cell on the knitr engine.

Actual behavior

The echoed code block is emitted as a sibling before <div class="quarto-layout-panel">.

<section id="slide-1" class="slide level2">
<h2>Slide 1</h2>
<div class="sourceCode cell-code" id="cb1">...print("Hello from Python")...</div>
<div class="quarto-layout-panel" data-layout="[50, 50]">
<div class="quarto-layout-row">
<div class="quarto-layout-cell" ...>
<ul>
<li>A list of items</li>
<li>That should appear on the left side</li>
</ul>
</div>
<div class="fragment quarto-layout-cell" ...>
<p>A code fragment that should appear on the right side</p>
<div class="cell" data-execution_count="1">
<div class="cell-output cell-output-stdout">
<pre><code>Hello from Python</code></pre>
</div>
</div>
</div>
</div>
</div>
</section>

For comparison, the same document with a static ```python block instead of the executable cell keeps the code block inside the layout cell.

Expected behavior

The echoed code block stays inside the layout cell, next to its outputs, in the order the author wrote it.
It keeps the classes of the div that contains it, so .fragment applies to it in RevealJS.

Your environment

• IDE: none, run from the terminal.
• OS: macOS 26.6.2 (build 25G83).

Quarto check output

$ quarto check
Quarto 99.9.9
[✓] Checking environment information...
      Quarto cache location: /Users/mcanouil/Library/Caches/quarto
[✓] Checking versions of quarto binary dependencies...
      Pandoc version 3.10.0: OK
      Dart Sass version 1.101.0: OK
      Deno version 2.7.14: OK
      Typst version 0.15.1: OK
[✓] Checking versions of quarto dependencies......OK
[✓] Checking Quarto installation......OK
      Version: 99.9.9
      commit: 7eebb00b94674e7f7c6b23c2e994b352b912e7c5
      Path: /Users/mcanouil/Projects/quarto-dev/quarto-cli/package/dist/bin
[✓] Checking tools....................OK
      TinyTeX: v2026.07
      Chrome Headless Shell: (not installed)
      VeraPDF: (not installed)
[✓] Checking LaTeX....................OK
      Using: TinyTex
      Path: /Users/mcanouil/Library/TinyTeX/bin/universal-darwin
      Version: 2026
[✓] Checking Chrome Headless....................OK
      Using: Chrome from QUARTO_CHROMIUM
      Path: /Applications/Brave Browser.app/Contents/MacOS/Brave Browser
[✓] Checking basic markdown render....OK
[✓] Checking R installation...........OK
      Version: 4.6.1
      Path: /Library/Frameworks/R.framework/Versions/4.6/Resources
      knitr: 1.51
      rmarkdown: 2.31
[✓] Checking Knitr engine render......OK
[✓] Checking Python 3 installation....OK
      Version: 3.12.13
      Jupyter: 5.9.1
      Kernels: julia-1.12, python3
[✓] Checking Jupyter engine render....OK

[mcanouil]

Root cause analysis (LLM-assisted), traced against main at commit 7eebb00.

layout_panels turns any div with a layout attribute into a PanelLayout.
The test is attr_requires_panel_layout, which looks only at the attribute, so it accepts a hand-authored div as well as a computational cell.

• quarto-cli/src/resources/filters/layout/layout.lua

  Lines 15 to 31 in 7eebb00

  	Div = function(div)
  	if not attr_requires_panel_layout(div.attr) then
  	return nil
  	end
  	local nested_layout = false
  	_quarto.ast.walk(div, {
  	PanelLayout = function()
  	nested_layout = true
  	end
  	})
  	-- if we are nested then we assume the layout
  	-- has been handled by the child
  	if nested_layout then
  	return nil
  	end
  	local preamble, cells = partition_cells(div)
  	local layout = layout_cells(div, cells)

partition_cells then splits the content of that div into a preamble and the list of layout cells.
is_preamble_block selects every CodeBlock that has the cell-code class.
That class is exactly what the engine adds to the echo of an executable cell, which is why a static code block is not affected.

• quarto-cli/src/resources/filters/layout/layout.lua

  Lines 81 to 86 in 7eebb00

  	local function is_preamble_block(el)
  	return (el.t == "CodeBlock" and el.attr.classes:includes("cell-code")) or
  	(is_regular_node(el, "Div") and
  	(el.attr.classes:includes("cell-output-stderr") or
  	el.attr.classes:includes("cell-annotation")))
  	end

The decisive step is the recursive walk.
When a top-level block of the layout div is a div, partition_cells walks the full subtree, appends every matching CodeBlock to preamble, and returns {} to delete it in place.
The comment above the walk states that the block is expected to be cell scaffolding such as cell-output-display.
A hand-authored div such as ::: {.fragment} is not cell scaffolding, but the walk descends into it as well.

• quarto-cli/src/resources/filters/layout/layout.lua

  Lines 119 to 130 in 7eebb00

  	if subfloat == nil and is_regular_node(block, "Div") then
  	-- https://github.com/quarto-dev/quarto-cli/issues/4370
  	-- there can exist code blocks to be lifted into preamble deep inside divs, we need
  	-- to walk the div to find them
  	cell_div = _quarto.ast.walk(block, {
  	CodeBlock = function(code_block)
  	if is_preamble_block(code_block) then
  	handle_preamble_codeblock(code_block)
  	return {}
  	end
  	end
  	}) or pandoc.Div({}) -- unnecessary but the Lua analyzer doesn't know it

The renderer then emits the preamble before the panel, which produces the observed order.

• quarto-cli/src/resources/filters/layout/html.lua

  Lines 99 to 107 in 7eebb00

  	local preamble = panel_layout.preamble
  	if preamble == nil then
  	return rendered_panel
  	end
  	local result = pandoc.Blocks({})
  	panel_insert_preamble(result, preamble)
  	result:insert(rendered_panel)
  	return result

The lost .fragment follows from the same step.
The class is on the div that the code block is removed from, and nothing puts it back on the block after the move.

The walk was added in c4ab028 for #4370, which is a LaTeX constraint: \begin{Shaded} does not work inside the \raisebox{} that the LaTeX layout uses.
In that issue the layout div holds .cell divs directly, so the walk descends one level only.
The lift is applied to every format, and HTML has no equivalent constraint, as the static code block case shows.

A possible fix is to stop the recursion at divs that are not cell scaffolding (cell, cell-output-*, cell-annotation), or to apply the lift only for LaTeX output.
Neither option has been tested against the LaTeX case of #4370.

[cscheid]

I believe this is intentional to make the behavior of code that generates multiple plots a bit more consistent with features like code annotations, etc. IIRC, the rationale was that

• rmarkdown and knitr outputs default to interleaving code and plots
• quarto wants fancier layouts that reconfigure the location of plots and will often expect code to be in the same "shape" as in the original doc

If we maintained the code output for fancy layouts as it were, it would be a lot harder to do the manipulations we need to do.

Overall, "unexpected output, but working as intended".

[mcanouil]

I did recall something like that, but wasn't fully sure and I found nothing in the codebase clearly stating so.

I'm not sure how to make things better for layout vs. columns especially in Reveal.js, whether it needs a new design wit q2 for "layout" (columns/rows/grid across formats) or some kind of documentation enhancement.
I switch between native Pandoc columns and Quarto layout with no clear rules on when to use which as it's very tricky in a multi-formats setup. (I might end up making an extension at some point)