How to get the number of the first and last paragraph on a page and show the result in the header?

[a_w]

I’m trying to layout pages that contain numbered paragraphs and want to give the reader a better overview where they are (e.g. site contains paragraphs 1–7). Something like this:

What I’m struggling with: Paragraphs that span multiple pages and finding the best possible solution overall. Paragraphs can contain linebreaks and formatting and being able to link to them would be cool in the future.

My first approach of counting the elements was mistaken thinking, as the content itself is already numbered (differences in numbering/doubled numbers). I’ve also realized that wrapping the elements like #par[id: "1", lorem(50)] doesn’t bring obvious benefits in comparison to #par(1)[1.]~#lorem(50) (par numbers attached to the following content) in terms of querying.

My current quite sorry working example is:

Code

#set page(width: 100mm, height: 100mm)

#let par(id: none, body) = {
  show heading.where(level: 4): it => {
    set text(weight: "regular")
    [#strong(id + ". ")] + it.body
  }
  heading(level: 4, supplement: id)[#body]
}

#show heading.where(level: 1): it => {
  pagebreak(weak: true)
  it
}

#set page(
  header: {
    context {
      // Getting current Chapter title (supplement)
      let headings = query(selector(heading.where(level: 1)))
      let h = headings.filter(h => h.location().page() <= here().page()).last()
      if h != none {
        h.supplement
      }

      // Get paragraphs on current page
      let paragraphs = query(selector(heading.where(level: 4))).filter(h4 => here().page() == h4.location().page())
      
      if paragraphs.len() == 0 { } else if paragraphs.last() == paragraphs.first() {
        [ ] + paragraphs.first().supplement
      } else {
        [ ] + paragraphs.first().supplement + "-" + paragraphs.last().supplement
      }
  }},
)

#heading(level: 1, supplement: "A-Chapter")[This is Chapter A]
#par(id: "1", lorem(50))
#par(id: "2", lorem(20))
#par(id: "3", lorem(150))

#heading(level: 1, supplement: "B-Chapter")[This is Chapter B]
#par(id: "11", lorem(50))
#par(id: "12", lorem(20))

#heading(level: 1, supplement: "C-Chapter")[This is Chapter C]
#par(id: "21a", lorem(50))

This leads to:

What I actually like about the approach: #par(id: "1", lorem(50)) the id as a string gives total control over the ID it can also be I. or 22a whenever needed. Even though I have to “abuse” supplement to access it. Using the headline also makes the paragraphs potentially linkable.

What my questions are:

• How can I use state (or something else?) to carry the last paragraph number to the following page(s) theoretically a paragraph could span multiple pages?

• I don’t feel this is the best solution to achieve what I want. I’m fluctuating between “this is overengineered” (maybe I could just get the highest ID without querying) and this is stupid (setting ID as string, than using supplement). Is there overall a better approach?

Help and guidance greatly appreciated I just couldn’t figure it out :x

[bluss]

No idea about the bigger picture, but for the particular problem, maybe this works.

Tag some id information at the start of every paragraph

[#metadata((id: id))<par>]

In the header, if there’s nothing else, remember the last seen start of paragraph

let previous_paragraphs = query(selector(<par>).before(here()))
if paragraphs.len() == 0 and previous_paragraphs.len() > 0 {
  [ (#previous_paragraphs.last().value.id;)]
}

Note that there is already a built-in element called par, so your function should probably have a different name.

Now that I think of it, your existing approach also gives you another way to solve it - filter on page but use <= instead of == for page, and take the last. Should have the same effect without needing to add metadata elements.

[sijo]

That works if you know there cannot be a page without paragraph… If this case must also be handled you probably need the metadata, for example:

#set page(
  width: 100mm,
  height: 100mm,
  header: context {
    let id(x) = if x.func() == heading { x.body } else { x.value }
    let pars = query(heading.where(level: 4).or(<h4-end>))
      .filter(x => x.location().page() == here().page())
      .map(id)
      .dedup()
    if pars.len() == 0 {
      // No paragraph starting or ending on this page
      // -> check if a paragraph starts before and ends after this page
      let prev = query(heading.where(level: 4).before(here()))
      let next = query(selector(<h4-end>).after(here()))
      if prev.len() == 0 or next.len() == 0 {
        return none
      }
      if prev.last().body != next.first().value {
        return none
      }
      return prev.last().body
    }
    if pars.len() == 1 {
      return pars.first()
    }
    return [#pars.first() -- #pars.last()]
  },
)

#show heading.where(level: 4): it => it.body + h(1em)

#let my-par(id: none, body) = {
  parbreak()
  if id != none {
    heading(level: 4, id)
  }
  body
  box[#metadata([#id])<h4-end>]
}

#heading(level: 1, supplement: "A-Chapter")[This is Chapter A]
#my-par(id: "1", lorem(50))
#my-par(id: "2", lorem(20))
#my-par(id: "3", lorem(150))

#heading(level: 1, supplement: "B-Chapter")[This is Chapter B]
#my-par(id: "11", lorem(50))
#my-par(id: "12", lorem(180))

#heading(level: 1, supplement: "B-Chapter")[This is Chapter C]
#my-par(id: "21a", lorem(50))

Compared to the original solution, this uses the level-4 heading just for the paragraph number rather than the whole paragraph. I think that’s much cleaner, and then you can use the usual styling system to change the appearance of the paragraph number.

It could be technically feasible to add the numbering with a par show rule, so that actual paragraphs are automatically numbered as you want (instead of calling a custom-defined par function). But it’s tricky to work with par show rules, and it becomes a pain when your document has paragraphs that should not be numbered (for example in a table or long caption). So the explicit call for each paragraph is probably better.

[a_w]

@bluss this is certainly an interesting idea and an alternative to state(), which I thought would be probably necessary. And you are of course right that my #par needs to be renamed. Thanks.

@sijo Omg, nice… thanks! This is already quite close to what I wanted to achieve. Querying between the headlines instead of the pages has the added benefit that I don’t have to force pagebreak the chapters to get it right. I wish I was as capable with using query and I wholeheartedly agree using the heading only for the number is indeed much cleaner and probably avoids downstream problems.

May I ask a follow-up: How would you handle the 3 – 11 case or 12 – 21a case where the paragraph numbers cross chapters?

What do you think of the supplement workaround for the short chapter titles?

[Andrew]

I’m not sure if you want more like in the sample page or more like in your example, so I copied the sample page:

code

#let header = context {
  let page = here().page()
  place(right + bottom)[#page]
  let headings = {
    query(heading.where(level: 4)).filter(x => x.location().page() == page)
  }
  let current-headings = headings.map(x => int(x.body.text))
  if current-headings.len() == 0 {
    let pars = query(<par>).filter(x => x.location().page() == page)
    if pars.len() == 0 { return }
    let last-headings = query(heading.where(level: 4).before(here()))
    if last-headings.len() == 0 { return }
    current-headings = (last-headings.last().body.text,)
  }
  if current-headings.len() == 1 { current-headings = current-headings * 2 }
  let (a, b) = (current-headings.first(), current-headings.last())
  place(center + bottom)[Nr. #(a)---#b.]
}

#let decorative-lines = context {
  let line(start, len, ..args) = std.line(start: start, length: len, ..args)
  let top = page.margin.top
  let left = page.margin.left
  // Vertical line
  let length = page.height - page.margin.top - page.margin.bottom
  place(center, line((0%, top + 1mm), length - 1mm, angle: 90deg))
  // Horizontal line
  let length = page.width - page.margin.left - page.margin.right
  place(line((left, top - 3mm), length, stroke: 3pt))
}

#set page(
  width: 270mm,
  height: 250mm,
  margin: (top: 2cm, rest: 1cm),
  columns: 2,
  background: decorative-lines,
  header: header,
)
#set columns(gutter: 3mm * 2)
#set par(justify: true, first-line-indent: (amount: 1em, all: true))
// #show par: it => [#it<par>] // Doesn't work.
#show par: it => [#metadata(none)<par>#it<par>#metadata(none)<par>]

#show heading.where(level: 4): set align(center)
#show heading.where(level: 4): set text(1.5em)
#show heading.where(level: 4): it => block(box(it) + ".")

#(pagebreak() * 118)

==== 210
#lorem(50)

#lorem(20)

#lorem(40)

#lorem(30)

==== 211
#lorem(50)

#lorem(50)

==== 212
#lorem(50)

#lorem(50)

#lorem(60)

#lorem(40)

#lorem(90)

==== 213
#lorem(70)

==== 214
#lorem(90)

#lorem(90)

This is a code with manual numbering sections, which makes sense, but it’s very easy to miscount.

You can add this assertion to keep yourself in check:

#let header = context {
  let page = here().page()
  place(right + bottom)[#page]
  let all-headings = query(heading.where(level: 4))
  if all-headings.len() == 0 { return }
  assert(int(all-headings.last().body.text) == all-headings.len())
  let headings = {

I can change ==== 69 to #section-break, but I don’t know enough details of the ideal output.

[sijo]

The supplement thing is rather hacky, it could cause problems with outlines or references. So I’d rather use a custom heading command that adds “short title” metadata that can be retrieved in the header:

#set page(
  width: 100mm,
  height: 100mm,
  header: context {
    let id(x) = if x.func() == heading { x.body } else { x.value }
    // Returns content showing short chapter title and paragraph number
    let chap-id(x) = {
      let shorts = query(selector(<h1-short>).before(x.location()))
      if shorts.len() == 0 {
        id(x)
      } else [
        #shorts.last().value: #id(x)
      ]
    }
    let pars = query(heading.where(level: 4).or(<h4-end>))
      .filter(x => x.location().page() == here().page())
      .dedup(key: x => id(x))
    if pars.len() == 0 {
      // No paragraph starting or ending on this page
      // -> check if a paragraph starts before and ends after this page
      let prev = query(heading.where(level: 4).before(here()))
      let next = query(selector(<h4-end>).after(here()))
      if prev.len() == 0 or next.len() == 0 {
        return none
      }
      if prev.last().body != next.first().value {
        return none
      }
      return chap-id(prev.last())
    }
    if pars.len() == 1 {
      return chap-id(pars.first())
    }
    return [#chap-id(pars.first()) -- #chap-id(pars.last())]
  },
)

#show heading.where(level: 4): it => it.body + h(1em)

#let my-par(id: none, body) = {
  parbreak()
  if id != none {
    heading(level: 4, id)
  }
  body
  box[#metadata([#id])<h4-end>]
}

#let my-h1(short: none, ..args) = {
  heading(level: 1, ..args)
  [#metadata(short)<h1-short>]
}

#my-h1(short: "A-Chapter")[This is Chapter A]
#my-par(id: "1", lorem(50))
#my-par(id: "2", lorem(20))
#my-par(id: "3", lorem(150))

#my-h1(short: "B-Chapter")[This is Chapter B]
#my-par(id: "11", lorem(50))
#my-par(id: "12", lorem(20))

#my-h1(short: "C-Chapter")[This is Chapter C]
#my-par(id: "21a", lorem(150))

You might want to do something smarter when the first and last paragraph on a page are in the same chapter, rather than showing the same short title twice…

[a_w]

@sijo this is so helpful, thank you very much! I just tried actually implementing it and I think I ran into one edge case: When two chapters end up on the same page, it looks like this:

Instead of A-Chapter 1 – B-Chapter 1

Even if #shorts.last() should still resolve to B-Chapter? I tried but I couldn’t figure out if it is the query or the access to chap-id that causes this case to fail.

@Andrew thanks so much for this additional approach, I will play around with the example too because #metadata(none)<par>#it<par>#metadata(none)<par> is a very interesting approach as well… this forum is so great and so humbling – I could never have come up with the idea of a label-wrapper (actually: I could never have come up with ANY of this, but the idea is especially “oh, wow, this is possible?”).

[sijo]

Ah that’s because of the dedup call which only checks the id. I’ve refactored the code a bit to avoid that, also using two metadata values per paragraph to simplify the logic:

#let get-chap-short(x) = {
  let shorts = query(selector(<h1-short>).before(x.location()))
  return shorts.at(-1, default: none)
}

#let short-and-id(x) = {
  let short = get-chap-short(x)
  return (short: short.value, id: x.value)
}

#let format-header(a, b) = {
  if b == none or b == a {
    return [#a.short: #a.id]
  }
  if a.short == b.short {
    return [#a.short: #a.id -- #b.id]
  }
  return [#a.short: #a.id -- #b.short: #b.id]
}

#set page(
  width: 100mm,
  height: 100mm,
  header: context {
    let pars = query(selector.or(<h4-start>, <h4-end>))
      .filter(x => x.location().page() == here().page())
      .map(short-and-id)
      .dedup()
    if pars.len() == 0 {
      // No paragraph starting or ending on this page
      // -> check if a paragraph starts before and ends after this page
      let prevs = query(selector(<h4-start>).before(here()))
      let nexts = query(selector(<h4-end>).after(here()))
      if prevs.len() == 0 or nexts.len() == 0 {
        return none
      }
      let prev = short-and-id(prevs.last())
      let next = short-and-id(nexts.first())
      if prev != next { // should not happen
        return none
      }
      return format-header(prev, next)
    }
    return format-header(pars.first(), pars.at(-1, default: none))
  },
)

#show heading.where(level: 4): it => it.body + h(1em)

#let my-par(id: none, body) = par({
  [#metadata([#id])<h4-start>]
  if id != none {
    heading(level: 4, id)
  }
  body
  [#metadata([#id])<h4-end>]
})

#let my-h1(short: none, ..args) = {
  heading(level: 1, ..args)
  [#metadata(short)<h1-short>]
}

#my-h1(short: "A-Chapter")[This is Chapter A]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-h1(short: "B-Chapter")[This is Chapter B]
#my-par(id: "1", lorem(50))
#my-par(id: "2", lorem(20))

#pagebreak()

#my-h1(short: "C-Chapter")[This is Chapter C]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-par(id: "3", lorem(150))

#my-h1(short: "D-Chapter")[This is Chapter D]
#my-par(id: "11", lorem(50))
#my-par(id: "11a", lorem(20))

[a_w]

Again thank you very much for your effort @sijo, works like a charm while implementing I noticed that I oversimplied my example by a factor that now plays a role, since the solution is now way different than I anticipated. I actually have Chapter › Subchapter › Paragraph or in other words Section › Chapter › Paragraph I could more or less solve it by going back to the page-based query for the section (“less” because it only works for chapters on new pages, which is ok in my case).

So basically:

#let get-section-short() = {
  let sections = query(selector(<h1-short>))
  let s = sections.filter(h => h.location().page() <= here().page()).last()
  if s != none {
    s.value
  }
}

#let format-header(a, b) = {
  if b == none or b == a {
    return [#get-section-short() --- #a.short: #a.id]
  }
  if a.short == b.short {
    return [#get-section-short() ---  #a.short: #a.id -- #b.id]
  }
  return [#get-section-short() --- #a.short: #a.id -- #b.short: #b.id]
}

// h1 for section, h2 for chapter
#let my-h1(short: none, ..args) = {
  heading(level: 1, ..args)
  [#metadata(short)<h1-short>]
}
#let my-h2(short: none, ..args) = {
  heading(level: 2, ..args)
  [#metadata(short)<h2-short>]
}

Full Code

#let get-section-short() = {
  let sections = query(selector(<h1-short>))
  let s = sections.filter(h => h.location().page() <= here().page()).last()
  if s != none {
    s.value
  }
}

#let get-chap-short(x) = {
  let shorts = query(selector(<h2-short>).before(x.location()))
  return shorts.at(-1, default: none)
}

#let short-and-id(x) = {
  let short = get-chap-short(x)
  return (short: short.value, id: x.value)
}

#let format-header(a, b) = {
  if b == none or b == a {
    return [#get-section-short() --- #a.short: #a.id]
  }
  if a.short == b.short {
    return [#get-section-short() ---  #a.short: #a.id -- #b.id]
  }
  return [#get-section-short() --- #a.short: #a.id -- #b.short: #b.id]
}

#set page(
  width: 100mm,
  height: 100mm,
  header: context {
    let pars = query(selector.or(<h4-start>, <h4-end>))
      .filter(x => x.location().page() == here().page())
      .map(short-and-id)
      .dedup()
    if pars.len() == 0 {
      // No paragraph starting or ending on this page
      // -> check if a paragraph starts before and ends after this page
      let prevs = query(selector(<h4-start>).before(here()))
      let nexts = query(selector(<h4-end>).after(here()))
      if prevs.len() == 0 or nexts.len() == 0 {
        return none
      }
      let prev = short-and-id(prevs.last())
      let next = short-and-id(nexts.first())
      if prev != next { // should not happen
        return none
      }
      return format-header(prev, next)
    }
    return format-header(pars.first(), pars.at(-1, default: none))
  },
)

#show heading.where(level: 4): it => it.body + h(1em)

#let my-par(id: none, body) = par({
  [#metadata([#id])<h4-start>]
  if id != none {
    heading(level: 4, id)
  }
  body
  [#metadata([#id])<h4-end>]
})

#let my-h1(short: none, ..args) = {
  heading(level: 1, ..args)
  [#metadata(short)<h1-short>]
}
#let my-h2(short: none, ..args) = {
  heading(level: 2, ..args)
  [#metadata(short)<h2-short>]
}

#my-h1(short: "I. Section")[This is I. Section]
#my-h2(short: "A-Chapter")[This is Chapter A]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-h2(short: "B-Chapter")[This is Chapter B]
#my-par(id: "1", lorem(50))
#my-par(id: "2", lorem(20))

#pagebreak()

#my-h1(short: "II. Section")[This is II. Section]
#my-h2(short: "C-Chapter")[This is Chapter C]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-par(id: "3", lorem(150))

#my-h2(short: "D-Chapter")[This is Chapter D]
#my-par(id: "11", lorem(50))
#my-par(id: "11a", lorem(20))

#my-h1(short: "III. Section")[This is III. Section]
#my-h2(short: "E-Chapter")[This is Chapter E]
#my-par(id: "11", lorem(50))
#my-par(id: "11a", lorem(20))

This works ok and fails only in cases where the section doesn’t start on a new page, like so:

If this requires significant restructuring, I’ll just use the solution as is. But if it’s doable with a reasonable addition to short-and-id() would you mind showing me for peace of mind, please? (Disclaimer: My problems is when I see the double-x-variable-filter.map.depup combination my brain goes into Homer’s brain monkey with cymbals mode.)

[sijo]

I think the proper fix is to change short-and-id to include the section short:

#let get-short(label, x) = {
  let shorts = query(selector(label).before(x.location()))
  return shorts.at(-1, default: none)
}

#let shorts-and-id(x) = {
  let h1 = get-short(<h1-short>, x)
  let h2 = get-short(<h2-short>, x)
  return (h1: h1.value, h2: h2.value, id: x.value)
}

#let header-content(a, b) = {
  if b == none or b == a {
    return [#a.h1: #a.h2: #a.id]
  }
  if a.h1 == b.h1 {
    if a.h2 == b.h2 {
      return [#a.h1: #a.h2: #a.id -- #b.id]
    }
    return [#a.h1: #a.h2: #a.id -- #b.h2: #b.id]
  }
  return [#a.h1: #a.h2: #a.id -- #b.h1: #b.h2: #b.id]
}

#let format-header(a, b) = {
  set text(0.8em)
  header-content(a, b)
}

#set page(
  width: 100mm,
  height: 100mm,
  header: context {
    let pars = query(selector.or(<h4-start>, <h4-end>))
      .filter(x => x.location().page() == here().page())
      .map(shorts-and-id)
    if pars.len() == 0 {
      // No paragraph starting or ending on this page
      // -> check if a paragraph starts before and ends after this page
      let prevs = query(selector(<h4-start>).before(here()))
      let nexts = query(selector(<h4-end>).after(here()))
      if prevs.len() == 0 or nexts.len() == 0 {
        return none
      }
      let prev = shorts-and-id(prevs.last())
      let next = shorts-and-id(nexts.first())
      if prev != next { // should not happen
        return none
      }
      return format-header(prev, next)
    }
    return format-header(pars.first(), pars.at(-1, default: none))
  },
)

#show heading.where(level: 4): it => it.body + h(1em)

#let my-par(id: none, body) = par({
  [#metadata([#id])<h4-start>]
  if id != none {
    heading(level: 4, id)
  }
  body
  [#metadata([#id])<h4-end>]
})

#let my-h1(short: none, ..args) = {
  heading(level: 1, ..args)
  [#metadata(short)<h1-short>]
}
#let my-h2(short: none, ..args) = {
  heading(level: 2, ..args)
  [#metadata(short)<h2-short>]
}

#my-h1(short: "I. Section")[This is I. Section]
#my-h2(short: "A-Chapter")[This is Chapter A]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-h2(short: "B-Chapter")[This is Chapter B]
#my-par(id: "1", lorem(50))
#my-par(id: "2", lorem(20))

#pagebreak()

#my-h1(short: "II. Section")[This is II. Section]
#my-h2(short: "C-Chapter")[This is Chapter C]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-par(id: "3", lorem(150))

#my-h2(short: "D-Chapter")[This is Chapter D]
#my-par(id: "11", lorem(50))
#my-par(id: "11a", lorem(20))

#my-h1(short: "III. Section")[This is III. Section]
#my-h2(short: "E-Chapter")[This is Chapter E]
#my-par(id: "11", lorem(20))

[a_w]

Looks really good now and the exceptions are way more maintainable. Thank you for taking the time to even refactor the approach!

Of course I managed to overlook two more edge cases but I’ve tried to catch them as good as I could… just–again–not very elegantly: I have chapters that contain no numbered paragraphs like the preface and text-only chapters in between as well.

I tried to catch them like this:

// Preface case
// Get last section headline
      if prevs.len() == 0 or nexts.len() == 0 {
        return query(selector(<h1-short>)).filter(x => x.location().page() <= here().page()).last().value
      }

// In-between case
// Get last section + chapter headline
      if prev != next { // should not happen
        return query(selector(<h1-short>)).filter(x => x.location().page() <= here().page()).last().value + " " + query(selector(<h2-short>)).filter(x => x.location().page() <= here().page()).last().value
      }

// Split exceptions in header-content
  if b == none {
    return [#a.h1: #a.h2] //to leave wrong ID away
  }
  if b == a {
    return [#a.h1: #a.h2: #a.id]
  }

Full Code

#let get-short(label, x) = {
  let shorts = query(selector(label).before(x.location()))
  return shorts.at(-1, default: none)
}

#let shorts-and-id(x) = {
  let h1 = get-short(<h1-short>, x)
  let h2 = get-short(<h2-short>, x)
  return (h1: h1.value, h2: h2.value, id: x.value)
}

#let header-content(a, b) = {
  if b == none {
    return [#a.h1: #a.h2]
  }
  if b == a {
    return [#a.h1: #a.h2: #a.id]
  }
  if a.h1 == b.h1 {
    if a.h2 == b.h2 {
      return [#a.h1: #a.h2: #a.id -- #b.id]
    }
    return [#a.h1: #a.h2: #a.id -- #b.h2: #b.id]
  }
  return [#a.h1: #a.h2: #a.id -- #b.h1: #b.h2: #b.id]
}

#set page(
  width: 100mm,
  height: 100mm,
  header: context {
    let pars = query(selector.or(<h4-start>, <h4-end>))
      .filter(x => x.location().page() == here().page())
      .map(shorts-and-id)
      .dedup()
    if pars.len() == 0 {
      // No paragraph starting or ending on this page
      // -> check if a paragraph starts before and ends after this page
      let prevs = query(selector(<h4-start>).before(here()))
      let nexts = query(selector(<h4-end>).after(here()))
      if prevs.len() == 0 or nexts.len() == 0 {
        return query(selector(<h1-short>)).filter(x => x.location().page() <= here().page()).last().value
      }
      let prev = shorts-and-id(prevs.last())
      let next = shorts-and-id(nexts.first())
      if prev != next { // should not happen
        return query(selector(<h1-short>)).filter(x => x.location().page() <= here().page()).last().value + " " + query(selector(<h2-short>)).filter(x => x.location().page() <= here().page()).last().value
      }
      return header-content(prev, next)
    }
    return header-content(pars.first(), pars.at(-1, default: none))
  },
)

#show heading.where(level: 4): it => it.body + h(1em)

#let my-par(id: none, body) = par({
  [#metadata([#id])<h4-start>]
  if id != none {
    heading(level: 4, id)
  }
  body
  [#metadata([#id])<h4-end>]
})

#let my-h1(short: none, ..args) = {
  heading(level: 1, ..args)
  [#metadata(short)<h1-short>]
}
#let my-h2(short: none, ..args) = {
  heading(level: 2, ..args)
  [#metadata(short)<h2-short>]
}

#my-h1(short: "Preface")[Preface]
Preface content #lorem(50)
#pagebreak()

#my-h1(short: "I. Section")[This is I. Section]
#my-h2(short: "A-Chapter")[This is Chapter A]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-h2(short: "B-Chapter")[This is Chapter B]
#my-par(id: "1", lorem(50))
#my-par(id: "2", lorem(20))

#pagebreak()

#my-h1(short: "II. Section")[This is II. Section]
#my-h2(short: "C-Chapter")[This is Chapter C]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(20))
#my-par(id: "3", lorem(150))

#my-h2(short: "D-Chapter")[This is Chapter D]
#my-par(id: "11", lorem(50))
#my-par(id: "11a", lorem(20))

#my-h1(short: "III. Section")[This is III. Section]
#my-h2(short: "E-Chapter")[This is Chapter E]
#my-par(id: "11", lorem(50))
#my-par(id: "11a", lorem(20))

#my-h2(short: "F-Chapter")[This is Chapter F]
Regular Content #lorem(200)

#my-h2(short: "G-Chapter")[This is Chapter G]
Regular Content #lorem(100)

#my-h2(short: "H-Chapter")[This is Chapter H]
#my-par(id: "1", lorem(50))
#my-par(id: "2", lorem(20))

Resulting in:

It’s probably not a very “clean” solution. This is for learning purposes only now and I’m sorry to keep bothering you, but if I may: How would you have solved this? (I’m quite confident this is the last issue I have with this, since it basically works already thanks to your help!)

[a_w]

After happily thinking that I’ve successfully implemented the solution, I ran into (or created) one more edge case: In my real-world example, the paragraphs are inline, so:

1. First paragraph 2. Second one

instead of

1. First paragraph
2. Second one

It didn’t recognize it at first because it only creates a problem when the last “paragraph” (which is text()) doesn’t flow onto the next page. (Disclaimer: I’m not even sure I fully get the problem). But the case looks like so:

Can I adapt the prev/next query or adapt the element while keeping it “inline” to get this case right?

let prevs = query(selector(<h4-start>).before(here()))
let nexts = query(selector(<h4-end>).after(here()))

#let my-par(id: none, body) = text({
  [#metadata([#id])<h4-start>]
  if id != none {
    heading(level: 4, id)
  }
  body
  [#metadata([#id])<h4-end>]
  // hide("​") // ← 🥴 Uncomment to fix the issue
})

The best fix I was able to come up with is to end a zero-width space at the end of my paragraph. But I’d like to understand the problem and maybe fix it in a non-hacky way if possible.

Full Code Example

#let get-short(label, x) = {
  let shorts = query(selector(label).before(x.location()))
  return shorts.at(-1, default: none)
}

#let shorts-and-id(x) = {
  let h1 = get-short(<h1-short>, x)
  let h2 = get-short(<h2-short>, x)
  return (h1: h1.value, h2: h2.value, id: x.value)
}

#let header-content(a, b) = {
  if b == none {
    return [#a.h1: #a.h2]
  }
  if b == a {
    return [#a.h1: #a.h2: #a.id]
  }
  if a.h1 == b.h1 {
    if a.h2 == b.h2 {
      return [#a.h1: #a.h2: #a.id -- #b.id]
    }
    return [#a.h1: #a.h2: #a.id -- #b.h2: #b.id]
  }
  return [#a.h1: #a.h2: #a.id -- #b.h1: #b.h2: #b.id]
}

#set page(
  width: 100mm,
  height: 100mm,
  header: context {
    let pars = query(selector.or(<h4-start>, <h4-end>))
      .filter(x => x.location().page() == here().page())
      .map(shorts-and-id)
      .dedup()
    if pars.len() == 0 {
      // No paragraph starting or ending on this page
      // -> check if a paragraph starts before and ends after this page
      let prevs = query(selector(<h4-start>).before(here()))
      let nexts = query(selector(<h4-end>).after(here()))
      if prevs.len() == 0 or nexts.len() == 0 {
        // ↓ 🥴 Still looking for improvement here too
        return query(selector(<h1-short>)).filter(x => x.location().page() <= here().page()).last().value 
      }
      let prev = shorts-and-id(prevs.last())
      let next = shorts-and-id(nexts.first())
      if prev != next { // should not happen
        // ↓ 🥴 Still looking for improvement here too 
        return query(selector(<h1-short>)).filter(x => x.location().page() <= here().page()).last().value + " " + query(selector(<h2-short>)).filter(x => x.location().page() <= here().page()).last().value
      }
      return header-content(prev, next)
    }
    return header-content(pars.first(), pars.at(-1, default: none))
  },
)

#show heading.where(level: 4): it => it.body + h(1em)

// Change text() to par() here ↓ to see the difference
#let my-par(id: none, body) = text({
  [#metadata([#id])<h4-start>]
  if id != none {
    heading(level: 4, id)
  }
  body
  [#metadata([#id])<h4-end>]
  // hide("​") // ← 🥴 Uncomment to fix the issue
})

#let my-h1(short: none, ..args) = {
  heading(level: 1, ..args)
  [#metadata(short)<h1-short>]
}
#let my-h2(short: none, ..args) = {
  heading(level: 2, ..args)
  [#metadata(short)<h2-short>]
}

#my-h1(short: "Preface")[Preface]
Preface content #lorem(50)
#pagebreak()

#my-h1(short: "I. Section")[This is I. Section]
#my-h2(short: "A-Chapter")[This is Chapter A]
#my-par(id: "1", lorem(20))
#my-par(id: "2", lorem(50))

//#my-h2(short: "B-Chapter")[This is Chapter B]
#text(red, "Counter remains at 2–5 ↑ despite (2) ending on the last page")
#my-par(id: "3", lorem(50))
#my-par(id: "4", lorem(20))
#my-par(id: "5", lorem(40))
#text(green, "Counts 5 ↑ correctly if it crosses the page ")

// #my-h1(short: "II. Section")[This is II. Section]
// #my-h2(short: "C-Chapter")[This is Chapter C]
// #my-par(id: "1", lorem(20))
// #my-par(id: "2", lorem(20))
// #my-par(id: "3", lorem(50))

// #my-h2(short: "D-Chapter")[This is Chapter D]
// #my-par(id: "11", lorem(50))
// #my-par(id: "11a", lorem(20))

// #my-h1(short: "III. Section")[This is III. Section]
// #my-h2(short: "E-Chapter")[This is Chapter E]
// #my-par(id: "11", lorem(50))
// #my-par(id: "11a", lorem(20))

// #my-h2(short: "F-Chapter")[This is Chapter F]
// Regular Content #lorem(200)

// #my-h2(short: "G-Chapter")[This is Chapter G]
// Regular Content #lorem(100)

// #my-h2(short: "H-Chapter")[This is Chapter H]
// #my-par(id: "1", lorem(50))
// #my-par(id: "2", lorem(20))