@airmark/quiver 0.28.0 → 0.29.0

package/quills/usaf_memo/0.3.0/packages/tonguetoquill-usaf-memo/src/body.typ

@@ -0,0 +1,364 @@
+// body.typ: Paragraph body rendering for USAF memorandum sections
+//
+// This module implements the visual rendering of AFH 33-337 compliant
+// paragraph bodies with proper numbering, nesting, and formatting.
+
+#import "config.typ": *
+#import "utils.typ": *
+#import "primitives.typ": render-memo-table
+
+// =============================================================================
+// PARAGRAPH NUMBERING UTILITIES
+// =============================================================================
+
+/// Gets the numbering format for a specific paragraph level.
+///
+/// - level (int): Paragraph nesting level (0-based)
+/// -> str | function
+#let get-paragraph-numbering-format(level) = {
+  paragraph-config.numbering-formats.at(level, default: "i.")
+}
+
+/// Calculates indentation for USAF-style paragraphs from explicit counter values.
+///
+/// - level (int): Paragraph nesting level (0-based)
+/// - level-counts (dictionary): Maps level index strings to their current counter values
+/// -> length
+#let calculate-indent-from-counts(level, level-counts) = {
+  if level == 0 {
+    return 0pt
+  }
+  let total-indent = 0pt
+  for ancestor-level in range(level) {
+    let ancestor-value = level-counts.at(str(ancestor-level), default: 1)
+    let ancestor-format = get-paragraph-numbering-format(ancestor-level)
+    let ancestor-number = numbering(ancestor-format, ancestor-value)
+    total-indent += measure([#ancestor-number#"  "]).width
+  }
+  total-indent
+}
+
+/// Calculates fixed indentation for DAF paragraph levels.
+///
+/// First nested level starts at `nested-first-level-indent` (1in); deeper levels
+/// add `nested-step` (0.5in) per additional depth.
+///
+/// - level (int): Paragraph nesting level (0-based)
+/// -> length
+#let calculate-daf-indent(level) = {
+  if level <= 0 {
+    return 0pt
+  }
+  daf-paragraph.nested-first-level-indent + (level - 1) * daf-paragraph.nested-step
+}
+
+/// Resets counter entries from `start` upward to 1 in the level-counts dictionary.
+#let reset-levels-from(level-counts, start, max-levels) = {
+  for child in range(start, max-levels) {
+    level-counts.insert(str(child), 1)
+  }
+  level-counts
+}
+
+/// Formats a paragraph (or continuation) with a given indent strategy.
+///
+/// - body (content): Paragraph content
+/// - level (int): Nesting level (0-based)
+/// - level-counts (dictionary): Current counter values per level
+/// - indent-fn (function): `(level, level-counts) -> length`
+/// - continuation (bool): If true, adds number-label width to alignment
+/// -> content
+#let format-par(body, level, level-counts, indent-fn, continuation: false) = {
+  let indent-width = indent-fn(level, level-counts)
+  if continuation {
+    let current-value = level-counts.at(str(level), default: 1)
+    let number-text = numbering(get-paragraph-numbering-format(level), current-value)
+    [#h(indent-width + measure([#number-text#"  "]).width)#body]
+  } else {
+    let current-value = level-counts.at(str(level), default: 1)
+    let number-text = numbering(get-paragraph-numbering-format(level), current-value)
+    [#h(indent-width)#number-text#"  "#body]
+  }
+}
+
+// =============================================================================
+// PARAGRAPH BODY RENDERING
+// =============================================================================
+// AFH 33-337 "The Text of the Official Memorandum" §1-12 specifies:
+// - Single-space text, double-space between paragraphs
+// - Number and letter each paragraph and subparagraph
+// - "A single paragraph is not numbered" (§2)
+// - First paragraph flush left, never indented
+// - Indent sub-paragraphs to align with first character of parent paragraph text
+#let render-body(content, memo-style: "usaf") = {
+  let PAR_BUFFER = state("PAR_BUFFER")
+  PAR_BUFFER.update(())
+  let NEST_DOWN = counter("NEST_DOWN")
+  NEST_DOWN.update(0)
+  let NEST_UP = counter("NEST_UP")
+  NEST_UP.update(0)
+  let IS_HEADING = state("IS_HEADING")
+  IS_HEADING.update(false)
+  // Tracks whether the next paragraph is the first block in a list item.
+  // When true, the next `show par` captures a numbered item; subsequent
+  // paragraphs within the same item are continuations (no new number).
+  let ITEM_FIRST_PAR = state("ITEM_FIRST_PAR")
+  ITEM_FIRST_PAR.update(false)
+
+  // The first pass parses paragraphs, list items, etc. into standardized arrays
+  let first_pass = {
+    // Collect pars with nesting level
+    show par: p => context {
+      let nest_level = NEST_DOWN.get().at(0) - NEST_UP.get().at(0)
+      let is_heading = IS_HEADING.get()
+      let is_first_par = ITEM_FIRST_PAR.get()
+
+      // Determine if this is a continuation block within a multi-block list item.
+      // A continuation is a non-first paragraph inside a list item (nest_level > 0).
+      let is_continuation = nest_level > 0 and not is_first_par
+
+      PAR_BUFFER.update(pars => {
+        pars.push((
+          content: text([#p.body]),
+          nest_level: nest_level,
+          kind: if is_heading { "heading" } else if is_continuation { "continuation" } else { "par" },
+        ))
+        pars
+      })
+
+      // After the first paragraph of a list item, mark subsequent ones as continuations
+      if nest_level > 0 and is_first_par {
+        ITEM_FIRST_PAR.update(false)
+      }
+
+      p
+    }
+    // Collect tables — captured as-is without paragraph numbering
+    show table: t => context {
+      PAR_BUFFER.update(pars => {
+        pars.push((
+          content: t,
+          nest_level: -1,
+          kind: "table",
+        ))
+        pars
+      })
+      t
+    }
+    {
+      show heading: h => {
+        IS_HEADING.update(true)
+        [#parbreak()#h.body#parbreak()]
+        IS_HEADING.update(false)
+      }
+
+      // Convert list/enum items to pars
+      // Note: No context wrapper here - state updates don't need it and cause
+      // layout convergence issues with many list items
+      show enum.item: it => {
+        NEST_DOWN.step()
+        ITEM_FIRST_PAR.update(true)
+        [#parbreak()#it.body#parbreak()]
+        NEST_UP.step()
+      }
+      show list.item: it => {
+        NEST_DOWN.step()
+        ITEM_FIRST_PAR.update(true)
+        [#parbreak()#it.body#parbreak()]
+        NEST_UP.step()
+      }
+
+      {
+        // Typst bug bandaid:
+        // `show par` will not collect wrappers unless there is content outside
+        // Add zero width space to always have content outside of wrapper
+        show strong: it => {
+          [#it#sym.zws]
+        }
+        show emph: it => {
+          [#it#sym.zws]
+        }
+        show underline: it => {
+          [#it#sym.zws]
+        }
+        show raw: it => {
+          [#it#sym.zws]
+        }
+        [#content#parbreak()]
+      }
+    }
+  }
+  // Use place() to prevent hidden content from affecting layout flow
+  place(hide(first_pass))
+
+  // Second pass: consume par buffer
+  //
+  // PAR_BUFFER item dictionary layout:
+  //   item.content    — the paragraph body or table element
+  //   item.nest_level — nesting depth (−1 for tables)
+  //   item.kind       — "par", "heading", "table", or "continuation"
+  context {
+    let heading_buffer = none
+    let heading_level = 0
+    // Filter out zero-width paragraphs so that an empty body (e.g. empty
+    // string from a KIND with no text) emits nothing and collapses to zero
+    // vertical space. Tables are always kept regardless of measured width.
+    let items = PAR_BUFFER.get().filter(item =>
+      item.kind == "table" or measure(item.content).width > 0pt
+    )
+    if items.len() == 0 { return }
+    // Only top-level paragraphs count for AFH 33-337 §2 numbering purposes
+    let par_count = items.filter(item => item.kind == "par").len()
+    let total_count = items.len()
+
+    // Track paragraph numbers per level manually to avoid nested-context
+    // counter propagation issues.  Dictionary maps level index (as string)
+    // to the current counter value at that level.
+    let max-levels = paragraph-config.numbering-formats.len()
+    let level-counts = (:)
+    for lvl in range(max-levels) {
+      level-counts.insert(str(lvl), 1)
+    }
+
+    let i = 0
+    let any_emitted = false
+    for item in items {
+      i += 1
+      let kind = item.kind
+      let item_content = item.content
+
+      // A buffered heading runs into this element only when the two belong to
+      // the same item: a later block of this list item ("continuation"), or,
+      // at top level, the next paragraph. The first block of the *next* item,
+      // a table (nest_level −1, so the level test alone excludes it), and
+      // another heading all fail the test, and each would otherwise carry the
+      // heading's text somewhere it was not authored. Those emit the heading
+      // on its own line, the treatment a heading before a table takes.
+      if heading_buffer != none {
+        let runs_in = (
+          kind != "heading"
+            and item.nest_level == heading_level
+            and (heading_level == 0 or kind == "continuation")
+        )
+        if runs_in {
+          item_content = [#strong[#heading_buffer.] #item_content]
+        } else {
+          if any_emitted { blank-line() }
+          strong[#heading_buffer.]
+          any_emitted = true
+        }
+        heading_buffer = none
+      }
+
+      // Buffer this heading for the next element to run into. The level it was
+      // captured at rides along: the run-in test needs it, and the buffer is
+      // read one iteration later, by which time `item` is the *next* element.
+      if kind == "heading" {
+        heading_buffer = item_content
+        heading_level = item.nest_level
+        continue
+      }
+
+      // Format based on element kind
+      let nest_level = item.nest_level
+      let indent-fn = if memo-style == "daf" {
+        (level, _counts) => calculate-daf-indent(level)
+      } else {
+        (level, counts) => calculate-indent-from-counts(level, counts)
+      }
+      let final_par = {
+        if kind == "table" {
+          render-memo-table(item_content)
+        } else if kind == "continuation" {
+          // Continuation block within a multi-block list item:
+          // indent to align with preceding numbered paragraph's text, no new number.
+          // level-counts still holds the value of the preceding numbered paragraph.
+          if memo-style == "daf" and nest_level == 0 {
+            item_content
+          } else {
+            format-par(item_content, nest_level, level-counts, indent-fn, continuation: true)
+          }
+        } else if memo-style == "daf" {
+          if nest_level > 0 {
+            let par = format-par(item_content, nest_level, level-counts, indent-fn)
+            level-counts.insert(str(nest_level), level-counts.at(str(nest_level), default: 1) + 1)
+            level-counts = reset-levels-from(level-counts, nest_level + 1, max-levels)
+            par
+          } else {
+            // DAF top-level paragraphs are unnumbered and first-line indented.
+            // Reset nested counters so each new top-level paragraph restarts children.
+            level-counts = reset-levels-from(level-counts, 0, max-levels)
+            [#h(daf-paragraph.top-first-line-indent)#item_content]
+          }
+        } else if par_count > 1 {
+          // Apply paragraph numbering per AFH 33-337 §2
+          let par = format-par(item_content, nest_level, level-counts, indent-fn)
+          level-counts.insert(str(nest_level), level-counts.at(str(nest_level)) + 1)
+          level-counts = reset-levels-from(level-counts, nest_level + 1, max-levels)
+          par
+        } else {
+          // AFH 33-337 §2: "A single paragraph is not numbered"
+          item_content
+        }
+      }
+
+      // Blank line between paragraphs. The header→body gap (i.e. before
+      // the first emitted paragraph) is the caller's responsibility —
+      // emitting it here would put the v() inside a nested
+      // `context { for … }` block, where it does not combine with the
+      // preceding header section's block-spacing the same way as a
+      // top-level blank-line() call.
+      // AFH 33-337 §11 rule applied below: "Avoid dividing a paragraph of
+      // less than four lines between two pages"
+      if any_emitted { blank-line() }
+      any_emitted = true
+      if i == total_count {
+        let available_width = page.width - spacing.margin * 2
+
+        // Use the shared measured line stride used by blank-line spacing.
+        let line_height = {
+          let cached = LINE_STRIDE.get()
+          if cached != none {
+            cached
+          } else {
+            let one-line = measure(par(spacing: 0pt)[x]).height
+            measure(par(spacing: 0pt)[x#linebreak()x]).height - one-line
+          }
+        }
+        // Calculate last item's height
+        let par_height = measure(final_par, width: available_width).height
+
+        let estimated_lines = calc.ceil(par_height / line_height)
+
+        if estimated_lines < 4 {
+          // Short content (< 4 lines): make sticky to keep with signature
+          block(sticky: true)[#final_par]
+        } else {
+          // Longer content (≥ 4 lines): use default breaking behavior
+          block(breakable: true)[#final_par]
+        }
+      } else {
+        // Wrap every non-last emission in a plain block so the document-wide
+        // `set block(above: spacing.line)` rule contributes the same 0.5em
+        // gap above every paragraph, including the first (matching the
+        // single-paragraph case which always passes through the
+        // `i == total_count` branch) and middle paragraphs (so the gap
+        // between the 1st and 2nd doesn't shrink relative to the gap
+        // between the 2nd-to-last and last). Bare emission would skip
+        // `block.above` entirely and visibly compress the spacing.
+        block[#final_par]
+      }
+    }
+
+    // A heading with nothing after it never ran into anything, and the buffer
+    // dies with the loop unless it is drained here. Sticky for the same reason
+    // the last item is: a standalone heading is one line, so it keeps with the
+    // signature block rather than opening a page alone.
+    if heading_buffer != none {
+      if any_emitted { blank-line() }
+      block(sticky: true)[#strong[#heading_buffer.]]
+    }
+  }
+}
+
+

package/quills/usaf_memo/0.3.0/packages/tonguetoquill-usaf-memo/src/config.typ

@@ -0,0 +1,78 @@
+// config.typ: Configuration constants and defaults for USAF memorandum template
+//
+// This module defines core configuration values that implement AFH 33-337 Chapter 14
+// formatting requirements for official USAF memorandums.
+
+// =============================================================================
+// SPACING CONSTANTS
+// =============================================================================
+// AFH 33-337 specifies precise spacing requirements throughout Chapter 14
+
+#let spacing = (
+  line: .5em, // Internal line spacing for readability (`par.leading`; gap between line boxes)
+  tab: 0.5in, // Tab stop for multi-column recipient alignment
+  margin: 1in, // AFH 33-337 §4: "Use 1-inch margins on the left, right and bottom"
+)
+
+// =============================================================================
+// TYPOGRAPHY DEFAULTS
+// =============================================================================
+// AFH 33-337 §5: "Use 12 point Times New Roman font for text"
+
+#let DEFAULT_LETTERHEAD_FONTS = ("Copperplate CC", "NimbusRomNo9L")
+#let DEFAULT_BODY_FONTS = ("NimbusRomNo9L",)  // AFH 33-337 §5: Times New Roman required; NimbusRomNo9L is a metric-compatible clone
+// Static monospace face for raw/code text. Liberation Mono is metric-compatible with
+// Courier New; only the regular weight is bundled (no bold or italic variants).
+#let DEFAULT_MONO_FONTS = ("Liberation Mono",)
+#let LETTERHEAD_COLOR = rgb("#355e93")  // Faded USAF blue for letterhead
+
+// =============================================================================
+// PARAGRAPH CONFIGURATION
+// =============================================================================
+// AFH 33-337 "The Text of the Official Memorandum" §2:
+// "Number and letter each paragraph and subparagraph"
+// Hierarchical numbering: 1., a., (1), (a), etc.
+
+#let paragraph-config = (
+  counter-prefix: "par-counter-",
+  // AFH 33-337 §2: Hierarchical paragraph numbering format
+  // Level 0: 1., 2., 3. | Level 1: a., b., c. | Level 2: (1), (2), (3) | Level 3: (a), (b), (c)
+  numbering-formats: ("1.", "a.", "(1)", "(a)", n => underline(str(n)), n => underline(str(n))),
+)
+
+// DAF (Headquarters) memo body: first-line indent for unnumbered paragraphs; nested
+// items start at 1in, then +0.5in per additional nesting depth.
+#let daf-paragraph = (
+  top-first-line-indent: 0.5in,
+  nested-first-level-indent: 1in,
+  nested-step: 0.5in,
+)
+
+// =============================================================================
+// COUNTERS
+// =============================================================================
+
+#let counters = (
+  indorsement: counter("indorsement"),
+)
+
+// =============================================================================
+// CLASSIFICATION COLORS
+// =============================================================================
+// AFH 33-337 §3: "Follow AFI 31-401, Information Security Program Management,
+// applicable executive orders and DoD guidance for the necessary markings on
+// classified correspondence."
+// Color values follow DoD/CAPCO standard classification marking colors:
+//   - TOP SECRET: orange  (#FF671F)
+//   - SECRET: red         (#C8102E)
+//   - CONFIDENTIAL: black (per project style guide)
+//   - CUI: black          (DoDM 5200.48; per project style guide)
+//   - UNCLASSIFIED: green (#007A33)
+
+#let CLASSIFICATION_COLORS = (
+  "TOP SECRET": rgb(255, 103, 31),
+  "SECRET": rgb(200, 16, 46),
+  "CONFIDENTIAL": rgb(0, 0, 0),
+  "CUI": rgb(0, 0, 0),
+  "UNCLASSIFIED": rgb(0, 122, 51),
+)

package/quills/usaf_memo/0.3.0/packages/tonguetoquill-usaf-memo/src/frontmatter.typ

@@ -0,0 +1,242 @@
+// frontmatter.typ: Frontmatter show rule for USAF memorandum
+//
+// This module implements the frontmatter (heading section) of a USAF memorandum
+// per AFH 33-337 Chapter 14 "The Heading Section". It handles:
+// - Page setup with proper margins
+// - Letterhead rendering
+// - Date, MEMORANDUM FOR, FROM, SUBJECT, and References placement
+// - Classification markings in headers/footers
+
+#import "primitives.typ": *
+
+#let frontmatter(
+  subject: none,
+  memo_for: none,
+  memo_from: none,
+  date: none,
+  references: none,
+  letterhead_title: "DEPARTMENT OF THE AIR FORCE",
+  letterhead_caption: "[YOUR SQUADRON/UNIT NAME]",
+  letterhead_seal: none,
+  letterhead_seal_subtitle: none, // optional line under seal (9pt bold caps); ignored if no seal
+  letterhead_emblem: none, // optional image placed opposite the seal (right side)
+  letterhead_emblem_height: 1in, // emblem fit-box height; reduce for shorter emblems
+  letterhead_font: DEFAULT_LETTERHEAD_FONTS,
+  body_font: DEFAULT_BODY_FONTS,
+  font_size: 12pt,
+  memo_for_cols: 3,
+  classification_level: none,
+  dissemination: none,
+  cui_controlled_by: none,
+  cui_category: none,
+  cui_limited_dissemination: none,
+  cui_poc: none,
+  footer_tag_line: none,
+  memo_style: "usaf",
+  it,
+) = {
+  assert(subject != none, message: "subject is required")
+  assert(memo_for != none, message: "memo_for is required")
+  assert(
+    memo_style in ("usaf", "daf"),
+    message: "memo_style must be \"usaf\" or \"daf\"",
+  )
+
+  let actual_date = if date == none { datetime.today() } else { date }
+
+  // The banner is `LEVEL` or `LEVEL//SUFFIX`. `classification_level` is an enum
+  // (a `str`), but `dissemination` is a `plaintext` field and so arrives as
+  // content, which `str + str` cannot absorb — the marking is assembled as
+  // content instead, keeping the suffix's glyphs click-navigable on every page
+  // the banner repeats on.
+  let classification_marking = if classification_level == none or type(classification_level) != str {
+    none
+  } else {
+    let base = classification_level.trim()
+    if base == "" {
+      none
+    } else if falsey(dissemination) {
+      [#base]
+    } else {
+      // `//` is a line comment in Typst markup, so the separator is
+      // interpolated as a string rather than written literally. The suffix is
+      // boxed so the markup block's edge newlines do not read as a space and
+      // split the banner into `CUI// NF`.
+      let separator = "//"
+      [#base#separator#box(upper(dissemination))]
+    }
+  }
+  let classification_color = get-classification-level-color(classification_level)
+
+  // Build the CUI designation indicator block (DoDM 5200.48, Table 1), shown
+  // only for CUI when at least one indicator field is set. Rendered as a
+  // bottom-right page-1 float (see placement below).
+  let cui_indicator = if (
+    classification_level != none
+    and type(classification_level) == str
+    and classification_level.trim().starts-with("CUI")
+  ) {
+    // Each indicator is a `plaintext` field, so it arrives as content when set
+    // and as `""` when blank — `falsey` is the shape-agnostic presence test
+    // that the former `type(..) == str and ..trim() != ""` guard replaces.
+    let lines = ()
+    if not falsey(cui_controlled_by) {
+      lines.push([Controlled By: #cui_controlled_by])
+    }
+    if not falsey(cui_category) {
+      lines.push([CUI Category: #cui_category])
+    }
+    if not falsey(cui_limited_dissemination) {
+      lines.push([LDC: #upper(cui_limited_dissemination)])
+    }
+    if not falsey(cui_poc) {
+      lines.push([POC: #cui_poc])
+    }
+    if lines.len() > 0 { lines.join(linebreak()) } else { none }
+  } else {
+    none
+  }
+
+  // Document-wide typography settings (inlined from configure())
+  set par(leading: spacing.line, spacing: spacing.line, justify: false)
+  set block(above: spacing.line, below: 0em, spacing: 0em)
+  set text(font: body_font, size: font_size, fallback: true)
+  show raw: set text(font: DEFAULT_MONO_FONTS)  // Static monospace face for inline code and code blocks
+
+  set page(
+    paper: "us-letter",
+    // AFH 33-337 §4: "Use 1-inch margins on the left, right and bottom"
+    margin: (
+      left: spacing.margin,
+      right: spacing.margin,
+      top: spacing.margin,
+      bottom: spacing.margin,
+    ),
+    header: {
+      // AFH 33-337 "Page numbering" §12: "The first page of a memorandum is never numbered.
+      // Number the succeeding pages starting with page 2. Place page numbers 0.5-inch from
+      // the top of the page, flush with the right margin."
+      context if counter(page).get().first() > 1 {
+        place(
+          dy: +.5in,
+          block(
+            width: 100%,
+            align(right, text(12pt)[#counter(page).display()]),
+          ),
+        )
+      }
+
+      if classification_marking != none {
+        place(
+          top + center,
+          dy: 0.375in,
+          text(12pt, font: DEFAULT_BODY_FONTS, fill: classification_color)[#strong(classification_marking)],
+        )
+      }
+    },
+    footer: {
+      if classification_marking != none {
+        place(
+          bottom + center,
+          dy: -.375in,
+          text(12pt, font: DEFAULT_BODY_FONTS, fill: classification_color)[#strong(classification_marking)],
+        )
+      }
+
+      if not falsey(footer_tag_line) {
+        place(
+          bottom + center,
+          dy: -0.625in,
+          align(center)[
+            #text(fill: LETTERHEAD_COLOR, font: "cinzel", size: 15pt)[#footer_tag_line]
+          ],
+        )
+      }
+    },
+  )
+
+  // DoDM 5200.48 §3: CUI designation indicator block — page 1 only, bottom-right
+  // corner, dropped into the 0.5in page-edge band. Emitted as a bottom float so
+  // it (1) reserves flow space, raising page 1's effective bottom margin so body
+  // text never overlaps it, and (2) stays pinned to page 1 — as the first flow
+  // content it can never be bumped to page 2.
+  if cui_indicator != none {
+    context {
+      // The box shrink-wraps to its widest line; `set align(left)` keeps the
+      // text flush-left within it, overriding the `align(right)` the placement
+      // below imposes.
+      let indicator_box = box({
+        set text(font: DEFAULT_BODY_FONTS, size: 10pt)
+        set par(leading: 0.4em, spacing: 0pt)
+        set align(left)
+        cui_indicator
+      })
+      // Reserve only the part of the block inside the text area (`reserved`):
+      // float a box of that height, then `place` the full block inside it pushed
+      // down by `overhang` so the surplus overflows into the edge band. (A bare
+      // `box(height: reserved, indicator_box)` overflows *upward* into the body
+      // instead.) The inner `place` adds no size, so the box stays `reserved`
+      // tall and the block's bottom lands 0.5in from the page edge.
+      let overhang = spacing.margin - 0.5in
+      let reserved = measure(indicator_box).height - overhang
+      place(
+        bottom + right,
+        float: true,
+        // Slide the right edge into the page-edge band, 0.5in from the border;
+        // the inner place right-aligns the block to that edge.
+        dx: spacing.margin - 0.5in,
+        // Minimum gap to the body's last line; the actual gap is larger when the
+        // next paragraph can't fit above the block and breaks to the next page.
+        clearance: spacing.line,
+        box(height: reserved, place(bottom + right, dy: overhang, indicator_box)),
+      )
+    }
+  }
+
+  render-letterhead(
+    letterhead_title,
+    letterhead_caption,
+    letterhead_font,
+    letterhead-seal: letterhead_seal,
+    letterhead-seal-subtitle: letterhead_seal_subtitle,
+    letterhead-emblem: letterhead_emblem,
+    letterhead-emblem-height: letterhead_emblem_height,
+  )
+
+  // AFH 33-337 "Date": "Place the date 1 inch from the right edge, 1.75 inches from the top"
+  // Since we have a 1-inch top margin, we need (1.75in - margin) vertical space
+  v(1.75in - spacing.margin)
+
+  // Measure and cache body line stride once for body line-count heuristics.
+  context {
+    let one-line = measure(par(spacing: 0pt)[x]).height
+    let line-stride = measure(par(spacing: 0pt)[x#linebreak()x]).height - one-line
+    LINE_STRIDE.update(line-stride)
+  }
+
+  [#metadata((
+    subject: subject,
+    original_date: actual_date,
+    original_from: first-or-value(memo_from),
+    body_font: body_font,
+    font_size: font_size,
+    memo_style: memo_style,
+  )) <usaf-memo-config>]
+
+  render-date-section(actual_date, memo-style: memo_style)
+  render-for-section(memo_for, memo_for_cols)
+  if not falsey(memo_from) { render-from-section(memo_from) }
+  // Blank entries are dropped first so a stub `- ` left under `references:`
+  // cannot pass as the lone reference and render an empty `()` after the subject.
+  let refs = compact-references(references)
+  let single-ref = if refs.len() == 1 { refs.at(0) } else { none }
+  render-subject-section(subject, inline-reference: single-ref)
+  render-references-section(refs)
+
+  // AFH 33-337: "Begin text on second line below subject/references".
+  // Emitted here (not inside body.typ) so the v() lands at the same lexical
+  // level as the preceding header sections and combines correctly with their
+  // block spacing.
+  blank-line()
+  it
+}