Fix nested theorem numbering by stepping counter at frame start

Move frame-counter.step() to the beginning of each frame body so that
child counters (e.g. corollary inside theorem) inherit the correct
parent number. Remove the +1 adjustment in display-number since the
counter is already at the right value when here() is evaluated.
Update theorion-display-number to use the metadata location (after
the step) for accurate counter reads. Add regression test.

Co-authored-by: OrangeX4 <34951714+OrangeX4@users.noreply.github.com>

Author: Copilot

core.typ

@@ -258,7 +258,21 @@
     return ""
   } else {
     assert(type(el.numbering) == function, message: "The numbering must be a function with get-loc.")
-    let res = (el.numbering)(get-loc: () => el.location())
+    // Use the metadata location (placed inside the frame body, after the counter step)
+    // so that the counter value is already correct and no "+1" adjustment is needed.
+    // The first <theorion-frame-metadata> after el.location() is always this frame's
+    // own metadata, because the metadata is emitted as the very first content inside
+    // the figure body (right after the step label).  Any later metadata elements
+    // belong to subsequent frames.
+    let get-loc = () => {
+      let metadata-els = query(selector(<theorion-frame-metadata>).after(el.location()))
+      if metadata-els.len() > 0 {
+        metadata-els.first().location()
+      } else {
+        el.location()
+      }
+    }
+    let res = (el.numbering)(get-loc: get-loc)
     if type(res) == dictionary {
       assert(
         "kind" in res and "value" in res and res.at("kind") == "static",
@@ -304,13 +318,13 @@
   let supplement-i18n = theorion-i18n(supplement-map)
   let display-number(get-loc: here, .._args) = (counter: frame-counter, ..args) => context {
     let loc = get-loc()
-    // We need to add 1 to the counter value.
+    // The counter is stepped at the beginning of the frame body, before this location,
+    // so the value already reflects the current frame's number.
     let counter-value = if type(counter) == dictionary {
       (counter.at)(loc)
     } else {
       counter.at(loc)
     }
-    counter-value = counter-value.slice(0, -1) + (counter-value.at(-1) + 1,)
     std.numbering(get-numbering(get-loc()), ..counter-value)
   }
 
@@ -337,6 +351,11 @@
     outlined: outlined,
     numbering: if number == auto { numbering } else { (..args) => (kind: "static", value: number) },
     {
+      // Step the counter first so that nested child-counter frames (e.g. a corollary
+      // placed inside a theorem body) can inherit the correct parent number.
+      if numbering != none and number == auto {
+        (frame-counter.step)()
+      }
       [#metadata((
           identifier: identifier,
           number: number,
@@ -362,10 +381,6 @@
         ..args,
         body,
       )
-      // Update the counter.
-      if numbering != none and number == auto {
-        (frame-counter.step)()
-      }
     },
   )
   /// Frame without the counter.

tests/issues/i-nested-numbering/ref/1.png

@@ -0,0 +1,25 @@
+/// Test: nested theorem numbering - corollary inside theorem inherits parent number
+#import "/lib.typ": *
+#import cosmos.fancy: *
+
+#set page(width: 300pt, height: auto, margin: (x: 15pt, y: 15pt))
+#set heading(numbering: "1.1")
+
+#show: show-theorion
+
+= Nested Numbering
+
+#theorem()[
+  #corollary()[Corollary inside Theorem 1 (should be 1.1.1)]
+]
+
+#theorem()[
+  #corollary()[Corollary inside Theorem 2 (should be 1.2.1)]
+]
+
+= Multiple Corollaries
+
+#theorem()[
+  #corollary()[First corollary (2.1.1)]
+  #corollary()[Second corollary (2.1.2)]
+]