@@ -15,10 +15,10 @@ describe("wideOrderedListMarkerDigits", () => {
     expect(wideOrderedListMarkerDigits(`${numberedList(60)}\n\ntext\n\n${numberedList(50)}`)).toBe(
       0,
     );
-    const withSubLists = Array.from(
-      { length: 60 },
-      (_, index) => `${index + 1}. item\n   1. sub\n   2. sub`,
-    ).join("\n");
+    const withSubLists = Array.from({ length: 60 }, (_, index) => {
+      const indent = " ".repeat(String(index + 1).length + 2);
+      return `${index + 1}. item\n${indent}1. sub\n${indent}2. sub`;
+    }).join("\n");
     expect(wideOrderedListMarkerDigits(withSubLists)).toBe(0);
   });
 
@@ -33,6 +33,10 @@ describe("wideOrderedListMarkerDigits", () => {
     expect(wideOrderedListMarkerDigits(numberedList(101, () => "1."))).toBe(3);
     expect(wideOrderedListMarkerDigits(`${numberedList(60)}\n\n${numberedList(50)}`)).toBe(3);
     expect(wideOrderedListMarkerDigits("99. first\n[^note]: text\n1. second")).toBe(3);
+    expect(wideOrderedListMarkerDigits("99. first\n 1. second")).toBe(3);
+    expect(wideOrderedListMarkerDigits("> 99. first\n>  1. second")).toBe(3);
+    // Under a two-digit marker a three-space indent is not nested, so it counts on.
+    expect(wideOrderedListMarkerDigits("98. a\n   1. b\n   1. c")).toBe(3);
     expect(wideOrderedListMarkerDigits("007. agent")).toBe(0);
   });
 
@@ -41,6 +45,8 @@ describe("wideOrderedListMarkerDigits", () => {
     expect(wideOrderedListMarkerDigits("> > 250. quoted")).toBe(3);
     expect(wideOrderedListMarkerDigits("1. a\n\n   100. nested")).toBe(3);
     expect(wideOrderedListMarkerDigits("    code\n\n100. item")).toBe(3);
+    expect(wideOrderedListMarkerDigits("100. 1. nested")).toBe(3);
+    expect(wideOrderedListMarkerDigits("99. 1. nested\n1. next")).toBe(3);
   });
 
   it("stays linear on long runs of bullets and spaces", () => {
@@ -51,5 +57,10 @@ describe("wideOrderedListMarkerDigits", () => {
     expect(wideOrderedListMarkerDigits("- a\n\n```\n123456789. example\n```")).toBe(0);
     expect(wideOrderedListMarkerDigits("~~~~\n250. a\n~~~\n300. b\n~~~~\n1. c")).toBe(0);
     expect(wideOrderedListMarkerDigits("```\n250. a\n```\n\n150. b")).toBe(3);
+    expect(wideOrderedListMarkerDigits("1. ```sh\n   250. a\n   ```\n\n150. b")).toBe(3);
+    expect(wideOrderedListMarkerDigits("- ```text\n  code\n  ```\n\n100. item")).toBe(3);
+    expect(wideOrderedListMarkerDigits("```text\n```js\n```\n\n100. item")).toBe(3);
+    expect(wideOrderedListMarkerDigits("> ```text\n> 123456789. example\n> ```\n\n- a")).toBe(0);
+    expect(wideOrderedListMarkerDigits("```\n    ```\n250. still code\n```\n1. a")).toBe(0);
   });
 });
@@ -1,10 +1,92 @@
-// A line the renderer could read as an ordered-list item, including one nested
-// after quote or list markers. Group 1 is everything before the number, so its
-// length tells nested lists apart. Indented code also matches; that only widens.
-// Each repeat starts with a marker or `>`, which keeps matching linear.
-const ORDERED_MARKER_LINE =
-  /^([ \t>]*(?:(?:[-+*]|\d{1,9}[.)])[ \t]+(?:>[ \t>]*)?)*)(\d{1,9})[.)](?:[ \t\r]|$)/;
-const CODE_FENCE = /^ {0,3}(`{3,}|~{3,})/;
+interface ListMarker {
+  readonly column: number;
+  readonly contentColumn: number;
+  readonly number: number;
+}
+
+interface LinePrefix {
+  readonly quoteDepth: number;
+  /** Whether any bullet or ordered-list marker opens the line. */
+  readonly hasListMarker: boolean;
+  readonly orderedMarkers: ReadonlyArray<ListMarker>;
+  /** Column where the innermost container's content starts. */
+  readonly contentColumn: number;
+  readonly restColumn: number;
+  readonly rest: string;
+}
+
+const isBlank = (char: string | undefined) => char === " " || char === "\t";
+const isDigit = (char: string | undefined) => char !== undefined && char >= "0" && char <= "9";
+
+// Walks the quote, bullet, and ordered-list markers at the start of a line,
+// with tab stops of 4. Content starts 1-4 columns after a marker, as in CommonMark.
+function readLinePrefix(line: string): LinePrefix {
+  const orderedMarkers: ListMarker[] = [];
+  let quoteDepth = 0;
+  let hasListMarker = false;
+  let index = 0;
+  let column = 0;
+  let contentColumn = 0;
+  // Set after a list marker until the following spaces fix its content column.
+  let pending: { markerEnd: number; number: number | null; column: number } | null = null;
+  for (;;) {
+    while (isBlank(line[index])) {
+      column = line[index] === "\t" ? column + 4 - (column % 4) : column + 1;
+      index += 1;
+    }
+    if (pending) {
+      const gap = column - pending.markerEnd;
+      contentColumn = gap >= 1 && gap <= 4 && index < line.length ? column : pending.markerEnd + 1;
+      if (pending.number !== null) {
+        orderedMarkers.push({ column: pending.column, contentColumn, number: pending.number });
+      }
+      pending = null;
+    }
+    const markerColumn = column;
+    const char = line[index];
+    if (char === ">") {
+      quoteDepth += 1;
+      index += 1;
+      column += 1;
+      contentColumn = column + (isBlank(line[index]) ? 1 : 0);
+      continue;
+    }
+    if ((char === "-" || char === "+" || char === "*") && isBlank(line[index + 1])) {
+      hasListMarker = true;
+      index += 1;
+      column += 1;
+      pending = { markerEnd: column, number: null, column: markerColumn };
+      continue;
+    }
+    let digitsEnd = index;
+    while (digitsEnd - index < 9 && isDigit(line[digitsEnd])) digitsEnd += 1;
+    const delimiter = line[digitsEnd];
+    const after = line[digitsEnd + 1];
+    if (
+      digitsEnd > index &&
+      (delimiter === "." || delimiter === ")") &&
+      (isBlank(after) || after === undefined || after === "\r")
+    ) {
+      hasListMarker = true;
+      column += digitsEnd + 1 - index;
+      const number = Number(line.slice(index, digitsEnd));
+      index = digitsEnd + 1;
+      pending = { markerEnd: column, number, column: markerColumn };
+      continue;
+    }
+    return {
+      quoteDepth,
+      hasListMarker,
+      orderedMarkers,
+      contentColumn,
+      restColumn: column,
+      rest: line.slice(index),
+    };
+  }
+}
+
+const FENCE_OPENER = /^(`{3,}|~{3,})(.*)$/;
+const FENCE_CLOSER = /^(`{3,}|~{3,})[ \t\r]*$/;
 
 /**
  * Digit count of the widest number the renderer could draw for an ordered list
@@ -13,34 +95,61 @@ const CODE_FENCE = /^ {0,3}(`{3,}|~{3,})/;
  * Lists number their items up from the first marker, so each item counts as at
  * least one more than the previous item of its list. This is one cheap pass
  * while a reply streams. When a line is ambiguous it keeps counting, so it can
- * overestimate (a slightly wider gutter) but never clip a number.
+ * overestimate (a slightly wider gutter) but should not clip a number.
  */
 export function wideOrderedListMarkerDigits(markdown: string): number {
-  // Last number per open list, keyed by the marker's column.
-  const lists = new Map<number, number>();
-  let openFence: string | null = null;
+  // Open ordered lists, outermost first.
+  let lists: Array<{ contentColumn: number; number: number }> = [];
+  let fence: { char: string; length: number; quoteDepth: number; column: number } | null = null;
   let afterBlankLine = false;
   let widest = 0;
   for (const line of markdown.split("\n")) {
-    const fence = CODE_FENCE.exec(line)?.[1];
-    if (openFence !== null) {
-      if (fence && fence[0] === openFence[0] && fence.length >= openFence.length) openFence = null;
-      continue;
+    const prefix = readLinePrefix(line);
+    if (fence !== null) {
+      // A fence ends at its closer, or when the quote holding it ends.
+      if (prefix.quoteDepth >= fence.quoteDepth) {
+        const closer = FENCE_CLOSER.exec(prefix.rest)?.[1];
+        if (
+          !prefix.hasListMarker &&
+          prefix.restColumn - fence.column <= 3 &&
+          closer?.[0] === fence.char &&
+          closer.length >= fence.length
+        ) {
+          fence = null;
+        }
+        continue;
+      }
+      fence = null;
     }
-    if (fence) {
-      openFence = fence;
-      continue;
+    for (const marker of prefix.orderedMarkers) {
+      // Leave lists whose items this marker sits outside of.
+      while (lists.length >= 2 && marker.column < lists[lists.length - 2]!.contentColumn) {
+        lists.pop();
+      }
+      const list = lists.at(-1);
+      if (list && marker.column < list.contentColumn) {
+        list.number = Math.max(marker.number, list.number + 1);
+        list.contentColumn = marker.contentColumn;
+      } else {
+        lists.push({ contentColumn: marker.contentColumn, number: marker.number });
+      }
+      widest = Math.max(widest, lists.at(-1)!.number);
     }
-    const marker = ORDERED_MARKER_LINE.exec(line);
-    if (marker) {
-      const column = marker[1]!.length;
-      for (const key of lists.keys()) if (key > column) lists.delete(key);
-      const number = Math.max(Number(marker[2]), (lists.get(column) ?? -1) + 1);
-      lists.set(column, number);
-      widest = Math.max(widest, number);
-    } else if (afterBlankLine && /^[^ \t\r]/.test(line)) {
+    const opener = FENCE_OPENER.exec(prefix.rest);
+    if (
+      opener &&
+      prefix.restColumn - prefix.contentColumn <= 3 &&
+      !(opener[1]!.startsWith("`") && opener[2]!.includes("`"))
+    ) {
+      fence = {
+        char: opener[1]![0]!,
+        length: opener[1]!.length,
+        quoteDepth: prefix.quoteDepth,
+        column: prefix.restColumn,
+      };
+    } else if (afterBlankLine && !prefix.hasListMarker && /^[^ \t\r]/.test(line)) {
       // Unindented text after a blank line cannot belong to any list item.
-      lists.clear();
+      lists = [];
     }
     afterBlankLine = line.trim() === "";
   }