@airmark/quiver 0.35.7 → 0.36.0

package/quills/cyber_career_plan/0.1.0/plate.typ

@@ -1,4 +1,4 @@
-#import "@local/quillmark-helper:0.1.0": data, roster
+#import "@local/quillmark-helper:0.2.0" as qm
 
 // ─── tokens ──────────────────────────────────────────────────────────────────
 // Grays only, and none lighter than a copier holds: the chart is read from a
@@ -29,7 +29,7 @@
 #set block(spacing: 0pt)
 #set par(spacing: 0pt)
 
-#let officer = data.at("name", default: "").trim()
+#let officer = qm.data.at("name", default: "").trim()
 #set document(
   title: if officer == "" { "Career Plan" } else { "Career Plan — " + officer },
   author: officer,
@@ -68,24 +68,25 @@
 #let show-date(d) = if d == none { none } else { d.display("[day padding:none] [month repr:short] [year]") }
 
 // ─── inputs ──────────────────────────────────────────────────────────────────
-#let quals = data.qualifications
-#let comm-yg = data.commissioning_yg
+#let quals = qm.data.qualifications
+#let comm-yg = qm.data.commissioning_yg
 // 0 is read as blank: it was this field's blank before the field took `?`.
-#let adj-yg = { let v = data.at("adjusted_yg", default: none); if v == 0 { none } else { v } }
+#let adj-yg = { let v = qm.data.at("adjusted_yg", default: none); if v == 0 { none } else { v } }
 #let adjusted = adj-yg != none and adj-yg != comm-yg
 #let board-yg = if adjusted { adj-yg } else { comm-yg }
+#let yg-field = if adjusted { "adjusted_yg" } else { "commissioning_yg" }
 // A required year not yet filled in arrives as 0. With no start year the window
 // opens on the year group; with neither, as on a new chart, the axis counts
 // from YG+0 and prints no calendar years rather than the years 0 to 11. With a
 // start year but no year group there is nothing to count the ladder from, so
 // the axis prints calendar years alone and no milestone is drawn.
-#let start-year = if data.timeline_start_year == 0 { board-yg } else { data.timeline_start_year }
+#let start-year = if qm.data.timeline_start_year == 0 { board-yg } else { qm.data.timeline_start_year }
 #let dated = start-year != 0
 #let laddered = board-yg != 0 or not dated
 #let yg-offset(k) = if k < 0 [YG#k] else [YG+#k]
 // Eighteen is the widest the marks hold their columns at, and the schema cannot
 // bound an integer, so a wider window draws at eighteen.
-#let years = calc.clamp(data.timeline_years, 1, 18)
+#let years = calc.clamp(qm.data.timeline_years, 1, 18)
 #let cols = years * 2
 #let last-year = start-year + years - 1
 #let window-end = if dated [#last-year] else { yg-offset(last-year - board-yg) }
@@ -101,17 +102,17 @@
 #let cycle-of(col) = if calc.rem(col, 2) == 0 { "Winter" } else { "Summer" }
 #let col-of(year, cycle) = (year - start-year) * 2 + if cycle == "Winter" { 0 } else { 1 }
 
-#let afsc = or-none(data.afsc)
-#let duty = or-none(data.duty_title)
-#let unit = or-none(data.unit)
-#let move-year = data.at("move_year", default: none)
+#let afsc = or-none(qm.data.afsc)
+#let duty = or-none(qm.data.duty_title)
+#let unit = or-none(qm.data.unit)
+#let move-year = qm.data.at("move_year", default: none)
 
 // Where the vectors branch. Everything left of it is the assignment you hold
 // now, which is the same on every row, so it is drawn once across all of them.
 // A move before the window is kept where it falls, so the tours after it are
 // laid from their real start and cut at the left edge rather than shifted.
-#let move-col = if move-year == none { 0 } else { col-of(move-year, data.move_cycle) }
-#let current-span = if data.vectors.len() == 0 { 0 } else { calc.clamp(move-col, 0, cols) }
+#let move-col = if move-year == none { 0 } else { col-of(move-year, qm.data.move_cycle) }
+#let current-span = if qm.data.vectors.len() == 0 { 0 } else { calc.clamp(move-col, 0, cols) }
 
 // ─── the ladder ──────────────────────────────────────────────────────────────
 // Every 17X board and school gate, as an offset from the year group, counted
@@ -149,14 +150,18 @@
 // A board prints heaviest, since it is a date you are ranked against; a course
 // is a seat, and prints plain. A board holds to one line: at eighteen years
 // "Lt Col board" runs a little into YG+13, which the ladder leaves empty.
+// A click on a gate opens the tick that marks it done, or, on a board, the
+// year group it counts from.
+#let gate-field(by) = if by.len() > 0 { quals.at("$path") + "education." + by.first() } else { yg-field }
 #let gate-mark(g) = {
-  let plain-mark(body, ..style) = box(inset: (x: 0.5pt, y: 2pt), text(size: mark-size, ..style, body))
+  let claim(body) = qm.region(gate-field(g.by), body)
+  let plain-mark(body, ..style) = box(inset: (x: 0.5pt, y: 2pt), text(size: mark-size, ..style, claim(body)))
   if g.overdue {
     plain-mark([#g.name, due #g.year], weight: 600, style: "italic")
   } else if g.done {
     plain-mark(strike(stroke: 0.5pt + mute, g.name), fill: mute)
   } else if g.board {
-    box(fill: ink, inset: (x: mark-inset, y: 2pt), text(size: mark-size, weight: 700, fill: white, g.name.replace(" ", "\u{a0}")))
+    claim(box(fill: ink, inset: (x: mark-inset, y: 2pt), text(size: mark-size, weight: 700, fill: white, g.name.replace(" ", "\u{a0}"))))
   } else {
     plain-mark(g.name, fill: mute)
   }
@@ -165,7 +170,7 @@
 // A window is one span over its looks in the chart, split by year and named
 // once. Looks already past are history and the span opens at the left edge;
 // looks past the window run it open into the right.
-#let window-mark(w, shown) = {
+#let window-mark(w, shown) = qm.region(gate-field(w.by), {
   let paint = if w.done { mute } else { ink }
   let edge = 0.5pt + paint
   box(
@@ -186,7 +191,7 @@
       }),
     ),
   )
-}
+})
 
 // ─── vectors ─────────────────────────────────────────────────────────────────
 #let ranks = ("Primary", "Alternate", "Backup")
@@ -224,8 +229,9 @@
   })
 }
 
-#let vectors = data.vectors.enumerate().map(((i, v)) => (
+#let vectors = qm.data.vectors.enumerate().map(((i, v)) => (
   rank: ranks.at(i, default: "Vector " + str(i + 1)),
+  path: v.at("$path"),
   track: or-none(v.track),
   // A length is rounded to the half-year first; one that rounds outside 0.5 to
   // 4 draws at the nearer end under a dagger the legend explains, since the
@@ -233,6 +239,7 @@
   placed: lay(v.tours.map(t => {
     let halves = int(calc.round(float(t.years) * 2))
     (
+      path: t.at("$path"),
       title: trim(t.title),
       span: calc.clamp(halves, 1, 8),
       out-of-range: halves < 1 or halves > 8,
@@ -252,10 +259,13 @@
 // each line as full as it will go, so "JFHQ-C" never strands its "C" and a word
 // too long for the block rules the setting out rather than running past its
 // edge. A note holds to one line, and turned up the side nothing breaks.
-#let block-text(title, notes, ..style) = layout(size => {
+#let block-text(title, notes, field: none, ..style) = layout(size => {
   let (w, h) = (size.width, size.height)
   let words = plain(title).split(" ").filter(x => x != "")
-  let face(s, body) = text(size: s, weight: 600, ..style, body)
+  let face(s, body) = {
+    let run = text(size: s, weight: 600, ..style, body)
+    if field == none { run } else { qm.region(field, run) }
+  }
   // The title in lines no wider than `room`, or in one line given none.
   let lines(s, room) = words.fold((), (out, x) => {
     if out.len() > 0 and (room == none or measure(face(s, out.last() + " " + x)).width <= room) {
@@ -263,7 +273,7 @@
     } else { out + (x,) }
   })
   let typeset((s, n), room) = (
-    ..if words.len() > 0 { (face(s, lines(s, room).join(linebreak())),) },
+    ..if words.len() > 0 { (face(s, lines(s, room).map(l => [#l]).join(linebreak())),) },
     ..if n != none { (text(size: micro, fill: mute, n),) },
   ).join(linebreak(), default: [])
   let within(c, room, w, h) = { let m = measure(typeset(c, room)); m.width <= w and m.height <= h }
@@ -297,7 +307,8 @@
   if calc.rem(span, 2) == 0 { [#int(years) yr] } else { [#years yr] }
 }
 
-#let constraints = data.constraints.map(c => (
+#let constraints = qm.data.constraints.map(c => (
+  path: c.at("$path"),
   note: trim(c.note),
   through: c.through,
   end: calc.min(cols, (c.through - start-year + 1) * 2),
@@ -327,18 +338,18 @@
   }
 })
 #let facts = (
-  ("Year group", if board-yg != 0 [#board-yg], if adjusted [adjusted from #comm-yg]),
-  ("Date of rank", show-date(data.date_of_rank), none),
-  ("Arrived station", show-date(data.date_arrived_station), none),
+  ("Year group", yg-field, if board-yg != 0 [#board-yg], if adjusted { qm.region("commissioning_yg")[adjusted from #comm-yg] }),
+  ("Date of rank", "date_of_rank", show-date(qm.data.date_of_rank), none),
+  ("Arrived station", "date_arrived_station", show-date(qm.data.date_arrived_station), none),
   // A degree marked "(in progress)" says so in a note under it, as the year
   // group's adjustment does, rather than breaking inside the parenthesis.
   {
-    let degree = or-none(data.advanced_degree)
+    let degree = or-none(qm.data.advanced_degree)
     let flat = plain(degree).trim()
     let mark = "(in progress)"
     if degree != none and flat.ends-with(mark) and flat.len() > mark.len() {
-      ("Advanced degree", flat.slice(0, -mark.len()).trim(), [in progress])
-    } else { ("Advanced degree", degree, none) }
+      ("Advanced degree", "advanced_degree", flat.slice(0, -mark.len()).trim(), [in progress])
+    } else { ("Advanced degree", "advanced_degree", degree, none) }
   },
 )
 #grid(
@@ -347,14 +358,14 @@
   row-gutter: 3pt,
   align: (_, y) => if y == 0 { bottom } else { top },
   // Raised clear of the line under it by the depth of its descenders.
-  pad(bottom: 3pt, text(size: display, weight: 800, tracking: -0.3pt, officer)),
-  ..facts.map(((name, ..)) => eyebrow(name)),
+  qm.region("name", pad(bottom: 3pt, text(size: display, weight: 800, tracking: -0.3pt)[#officer])),
+  ..facts.map(((name, field, ..)) => qm.region(field, eyebrow(name))),
   identity,
-  ..facts.map(((_, value, note)) => stack(
+  ..facts.map(((_, field, value, note)) => qm.region(field, stack(
     spacing: 3pt,
-    text(size: lead, weight: 500, top-edge: hang, if value == none { dash } else { value }),
+    text(size: lead, weight: 500, top-edge: hang, if value == none { dash } else [#value]),
     ..if note != none { (text(size: micro, fill: mute, note),) },
-  )),
+  ))),
 )
 
 // ═══ PLAN ════════════════════════════════════════════════════════════════════
@@ -367,13 +378,17 @@
 // the axis
 #rows.push(table.cell[])
 #for i in range(years) {
-  let offset = yg-offset(start-year + i - board-yg)
+  let offset = qm.region(yg-field, yg-offset(start-year + i - board-yg))
+  let year = qm.region(
+    if i == years - 1 { "timeline_years" } else { "timeline_start_year" },
+    text(weight: 700)[#(start-year + i)],
+  )
   rows.push(table.cell(colspan: 2, stroke: (bottom: 0.7pt + ink), inset: (x: 3pt, bottom: 3pt))[
     #if not dated { text(weight: 700, offset) } else if laddered [
-      #text(weight: 700)[#(start-year + i)]
+      #year
       #linebreak()
       #text(size: micro, fill: mute, offset)
-    ] else { text(weight: 700)[#(start-year + i)] }
+    ] else { year }
   ])
 }
 
@@ -383,11 +398,11 @@
 // on past its end, on one line, over nothing; one too long for that as well is
 // cut at whichever edge leaves more of it, the bar's end or the page's.
 #for (i, c) in constraints.enumerate() {
-  rows.push(if i == 0 { row-label[Constraints] } else { table.cell[] })
-  let note = [#text(size: micro, weight: 600)[#c.note]#text(size: micro, fill: mute)[#(" · through " + str(c.through))]]
+  rows.push(if i == 0 { row-label(qm.region("constraints")[Constraints]) } else { table.cell[] })
+  let note = [#text(size: micro, weight: 600)[#c.note]#qm.region(c.path + "through", text(size: micro, fill: mute)[#(" · through " + str(c.through))])]
   // The first stands clear of the axis, which would otherwise close its top.
   rows.push(table.cell(colspan: c.end, inset: (x: 1pt, top: if i == 0 { 3pt } else { 0.5pt }, bottom: 0.5pt))[
-    #layout(size => {
+    #qm.region(c.path.slice(0, -1), layout(size => {
       // A bar that runs past the window is left open at its end, since the
       // window's edge is not where it stops.
       let open = c.through > last-year
@@ -399,7 +414,7 @@
       box(width: 100%, height: 8.5pt, stroke: (bottom: constraint-stroke, right: if open { none } else { constraint-stroke }))
       // Clipped across only: the inset keeps the ascenders and descenders.
       place(left + bottom, dx: dx, box(width: calc.max(0pt, room), inset: (y: 2pt), clip: true, box(width: 10in, note)))
-    })
+    }))
   ])
   rows += empty(cols - c.end)
 }
@@ -410,7 +425,7 @@
 #let lanes = if spans.len() > 0 { 2 } else { 1 }
 #rows.push(table.cell(rowspan: lanes, align: left + horizon, stack(
   spacing: 3pt,
-  rail-label[Eligibility],
+  qm.region(yg-field, rail-label[Eligibility]),
   ..gates.filter(g => g.overdue).map(gate-mark),
 )))
 #for i in range(years) {
@@ -433,7 +448,7 @@
 // hold the way one does; with nothing left, the header still names the job. The
 // unit is left to the header throughout. A move past the window leaves the
 // block open at the window's edge, as a tour the window cuts is.
-#let current-block = block(
+#let current-block = qm.region("move_year", block(
   width: 100%,
   height: 100%,
   stroke: (
@@ -445,9 +460,10 @@
   inset: (x: 3pt, y: 2pt),
   block-text(
     if duty != none { duty } else { [Current assignment] },
-    ([Current · to #data.move_cycle #move-year], [to #data.move_cycle #move-year]),
+    ([Current · to #qm.ink(qm.data, "move_cycle") #move-year], [to #qm.ink(qm.data, "move_cycle") #move-year]),
+    field: "duty_title",
   ),
-)
+))
 
 // One row per vector. Its label says which it is, so every duty tour takes the
 // one shade, and a school goes unshaded: a year in a classroom does not read as
@@ -460,10 +476,10 @@
   if beyond.len() > 0 { sub.push([+#beyond.len() past #window-end]) }
 
   rows.push(table.cell(stroke: top-rule, inset: (right: 5pt, y: 3pt))[
-    #block(width: 100%, height: 100%, track-label(
+    #qm.region(v.path + "track", block(width: 100%, height: 100%, track-label(
       if v.track != none { v.track } else { [#v.rank] },
       if sub.len() > 0 { sub.join[ · ] },
-    ))
+    )))
   ])
 
   if rank == 0 and current-span > 0 {
@@ -486,7 +502,7 @@
       // The block is drawn inside its cell rather than as the cell's fill, so
       // adjacent tours part by a gap and an edge. A tour the window cuts runs
       // to the window's edge with that end open.
-      #block(
+      #qm.region(p.tour.path.slice(0, -1), block(
         width: 100%,
         height: 100%,
         fill: if p.tour.school { none } else { shade },
@@ -499,10 +515,11 @@
         inset: (x: 3pt, y: 2pt),
         block-text(
           p.tour.title,
-          range(notes.len(), 0, step: -1).map(n => notes.slice(0, n).join[ · ]),
+          range(notes.len(), 0, step: -1).map(n => qm.region(p.tour.path + "years", notes.slice(0, n).join[ · ])),
+          field: p.tour.path + "title",
           style: if p.tour.school { "italic" } else { "normal" },
         ),
-      )
+      ))
     ])
     at = p.from + p.drawn
   }
@@ -539,7 +556,7 @@
   block(above: 5pt, pad(left: rail, grid(
     columns: (1fr, auto),
     text(size: micro, fill: mute, legend.join(h(12pt), default: [])),
-    if ahead > 0 { text(size: micro, fill: mute)[#ahead more milestone#if ahead > 1 [s] past #window-end] },
+    if ahead > 0 { qm.region(yg-field, text(size: micro, fill: mute)[#ahead more milestone#if ahead > 1 [s] past #window-end]) },
   )))
 }
 
@@ -555,19 +572,19 @@
 // open boxes say what has not been done yet as plainly as the filled ones say
 // what has. What is held leads its row, and a member holds together on its line.
 #let vocabulary = (
-  ("Leadership & command", roster(quals, "command")),
-  ("Operations", roster(quals, "operations")),
-  ("Staff & functional", roster(quals, "staff")),
-  ("Education & PME", roster(quals, "education")),
+  ("Leadership & command", "command"),
+  ("Operations", "operations"),
+  ("Staff & functional", "staff"),
+  ("Education & PME", "education"),
 )
-#let member(m) = box[
+#let member(m) = qm.region(m.path, box[
   #let detail = if m.held { m.value.detail } else { "" }
   #if m.held { held-mark } else { open-mark }#h(3pt)#text(
     weight: if m.held { 600 } else { 400 },
     fill: if m.held { ink } else { mute },
     m.title,
   )#if not blank(detail) [#h(2pt)#text(size: micro, style: "italic", fill: mute, trim(detail))]
-]
+])
 #let members-row(rows) = {
   (rows.filter(m => m.held) + rows.filter(m => not m.held)).map(member).join([#h(10pt) ])
 }
@@ -576,9 +593,9 @@
 // Reviewer strat on any row, that column goes rather than printing empty. The
 // rows are set at the record's size, so the table reads as one of its rows. A
 // year not yet filled in arrives as 0, sorts last and prints a dash.
-#let strats = data.stratifications.sorted(key: s => -s.year)
+#let strats = qm.data.stratifications.sorted(key: s => -s.year)
 #let any-hlr = strats.any(s => not blank(s.hlr))
-#let strat-cell(v) = if blank(v) { dash } else { trim(v) }
+#let strat-cell(s, key) = qm.region(s.at("$path") + key, if blank(s.at(key)) { dash } else { trim(s.at(key)) })
 #let strats-table = table(
   columns: (auto,) * (if any-hlr { 3 } else { 2 }),
   column-gutter: 16pt,
@@ -586,21 +603,26 @@
   stroke: none,
   table.header([], eyebrow[Rater], ..if any-hlr { (eyebrow[HLR],) }),
   ..strats.map(s => (
-    if s.year == 0 { dash } else { text(weight: 700)[#s.year] },
-    strat-cell(s.rater),
-    ..if any-hlr { (strat-cell(s.hlr),) },
+    qm.region(s.at("$path") + "year", if s.year == 0 { dash } else { text(weight: 700, qm.ink(s, "year")) }),
+    strat-cell(s, "rater"),
+    ..if any-hlr { (strat-cell(s, "hlr"),) },
   )).flatten(),
 )
 
 // The two things a board reads first, the stratifications and the awards,
 // lead; the experience follows.
-#let listed(name, lines) = if lines.len() > 0 { (([#name], lines.map(trim).join[ · ]),) }
+// Each row's label claims the field the row prints, so a click on it opens that
+// field as a click on the row does.
+#let listed(name, field) = {
+  let lines = qm.data.at(field)
+  if lines.len() > 0 { (([#name], field, lines.map(trim).join[ · ]),) }
+}
 #let record = (
-  ..if strats.len() > 0 { (([Stratifications], strats-table),) },
-  ..listed("Awards", data.awards),
-  ..vocabulary.map(((name, members)) => ([#name], members-row(members))),
-  ..listed("Certifications", data.certifications),
-  ..listed("Deployments", data.deployments),
+  ..if strats.len() > 0 { (([Stratifications], "stratifications", qm.region("stratifications", strats-table)),) },
+  ..listed("Awards", "awards"),
+  ..vocabulary.map(((name, key)) => ([#name], quals.at("$path") + key, members-row(qm.roster(quals, key)))),
+  ..listed("Certifications", "certifications"),
+  ..listed("Deployments", "deployments"),
 )
 
 #divider(14pt)
@@ -609,7 +631,7 @@
   grid(
     columns: (rail, 1fr),
     row-gutter: 7pt,
-    ..record.map(((name, body)) => (rail-label(name), body)).flatten(),
+    ..record.map(((name, field, body)) => (rail-label(qm.region(field, name)), body)).flatten(),
   )
 }
 
@@ -632,7 +654,7 @@
 // Every line box is exactly one pitch tall with its baseline at the same drop,
 // so the typed notes land on the rules however many lines they run to, and the
 // rail's label sits on the first.
-#let typed = data.at("$body", default: "")
+#let typed = qm.data.at("$body", default: "")
 #let on-ruling(body) = {
   set text(top-edge: baseline-drop, bottom-edge: baseline-drop - pitch)
   set par(leading: 0pt, spacing: 0pt)
@@ -673,7 +695,7 @@
   block(breakable: false, width: 100%, height: calc.max(room, need), {
     grid(
       columns: (rail, 1fr),
-      on-ruling(rail-label[Notes]),
+      on-ruling(qm.region("$body", rail-label[Notes])),
       block(width: 100%, { ruling(rules); notes }),
     )
     place(bottom + left, signature)

package/quills/daf1206/0.1.0/plate.typ

@@ -1,4 +1,4 @@
-#import "@local/quillmark-helper:0.1.0": data
+#import "@local/quillmark-helper:0.2.0" as qm
 #import "@local/typst-daf1206:0.1.0": form
 
 #set text(font: "NimbusRomNo9L")
@@ -6,39 +6,39 @@
 // Map snake_case Quill `data` keys to generated `form.typ` parameter names.
 #let vals = (:)
 
-#if data.award != "" { vals.insert("AWARD", data.award) }
-#if data.category_if_applicable != "" { vals.insert("CATEGORY_If_Applicable", data.category_if_applicable) }
-#if data.award_period != "" { vals.insert("AWARD_PERIOD", data.award_period) }
-#if data.rankname_of_nominee != "" {
-  vals.insert("RANKNAME_OF_NOMINEE_First_Middle_Initial_Last", data.rankname_of_nominee)
-  vals.insert("RANKNAME_OF_NOMINEE_First_Middle_Initial_Last_2", data.rankname_of_nominee)
+#if qm.data.award != "" { vals.insert("AWARD", qm.data.award) }
+#if qm.data.category_if_applicable != "" { vals.insert("CATEGORY_If_Applicable", qm.data.category_if_applicable) }
+#if qm.data.award_period != "" { vals.insert("AWARD_PERIOD", qm.data.award_period) }
+#if qm.data.rankname_of_nominee != "" {
+  vals.insert("RANKNAME_OF_NOMINEE_First_Middle_Initial_Last", qm.data.rankname_of_nominee)
+  vals.insert("RANKNAME_OF_NOMINEE_First_Middle_Initial_Last_2", qm.data.rankname_of_nominee)
 }
-#if data.majcom_fldcom_foa_or_dru != "" { vals.insert("MAJCOM_FLDCOM_FOA_OR_DRU", data.majcom_fldcom_foa_or_dru) }
-#if data.dafsc_duty_title != "" { vals.insert("DAFSCDUTY_TITLE", data.dafsc_duty_title) }
-#if data.nominees_telephone_dsn_commercial != "" {
-  vals.insert("NOMINEES_TELEPHONE__DSN__Commercial", data.nominees_telephone_dsn_commercial)
+#if qm.data.majcom_fldcom_foa_or_dru != "" { vals.insert("MAJCOM_FLDCOM_FOA_OR_DRU", qm.data.majcom_fldcom_foa_or_dru) }
+#if qm.data.dafsc_duty_title != "" { vals.insert("DAFSCDUTY_TITLE", qm.data.dafsc_duty_title) }
+#if qm.data.nominees_telephone_dsn_commercial != "" {
+  vals.insert("NOMINEES_TELEPHONE__DSN__Commercial", qm.data.nominees_telephone_dsn_commercial)
 }
-#if data.unit_office_symbol_street_address_base_state_zip != "" {
+#if qm.data.unit_office_symbol_street_address_base_state_zip != "" {
   vals.insert(
     "UNITOFFICE_SYMBOLSTREET_ADDRESSBASESTATEZIP_CODE",
-    data.unit_office_symbol_street_address_base_state_zip,
+    qm.data.unit_office_symbol_street_address_base_state_zip,
   )
 }
-#if data.unit_commander_rank_name_and_telephone != "" {
+#if qm.data.unit_commander_rank_name_and_telephone != "" {
   vals.insert(
     "RANKNAME_OF_UNIT_COMMANDER_First_Middle_Initial_LastCOMMANDERS_TELEPHONE_DSN__Commercial",
-    data.unit_commander_rank_name_and_telephone,
+    qm.data.unit_commander_rank_name_and_telephone,
   )
 }
-#if "$body" in data {
+#if "$body" in qm.data {
   vals.insert(
     "SPECIFIC_ACCOMPLISHMENTS_Use_Performance_Statements_IAW_DAFMAN_362806",
-    data.at("$body"),
+    qm.data.at("$body"),
   )
 }
 
 #let continued-key = "SPECIFIC_ACCOMPLISHMENTS_Use_Performance_Statements_IAW_DAFMAN_362806_Continued"
-#for card in data.at("$cards") {
+#for card in qm.data.at("$cards") {
   if card.at("$kind", default: none) == "accomplishments_continued" and continued-key not in vals and "$body" in card {
     vals.insert(continued-key, card.at("$body"))
   }

package/quills/daf4392/0.1.0/Quill.yaml

@@ -106,43 +106,38 @@ card_kinds:
   itinerary:
     title: Proposed Travel Itinerary
     description: "One leg of your trip. The form holds up to 10."
-    ui:
-      groups: [itinerary_entry]
     body:
       enabled: false
-    fields:
-      date:
-        type: date
-        default: ""
-        ui:
-          group: itinerary_entry
-          compact: true
-        description: "The date of this leg."
-      departure_point:
-        type: string
-        default: ""
-        ui:
-          group: itinerary_entry
-          compact: true
-        description: "Where this leg starts."
-      arrival_point:
-        type: string
-        default: ""
-        ui:
-          group: itinerary_entry
-          compact: true
-        description: "Where this leg ends."
-      rest_length:
-        type: string
-        default: ""
-        ui:
-          group: itinerary_entry
-          compact: true
-        description: "How long you'll stay."
-      mileage:
-        type: string
-        default: ""
-        ui:
-          group: itinerary_entry
-          compact: true
-        description: "Approximate miles for this leg. Leave blank for flights."
+    sections:
+      itinerary_entry:
+        fields:
+          date:
+            type: date
+            default: ""
+            ui:
+              compact: true
+            description: "The date of this leg."
+          departure_point:
+            type: string
+            default: ""
+            ui:
+              compact: true
+            description: "Where this leg starts."
+          arrival_point:
+            type: string
+            default: ""
+            ui:
+              compact: true
+            description: "Where this leg ends."
+          rest_length:
+            type: string
+            default: ""
+            ui:
+              compact: true
+            description: "How long you'll stay."
+          mileage:
+            type: string
+            default: ""
+            ui:
+              compact: true
+            description: "Approximate miles for this leg. Leave blank for flights."

package/quills/daf4392/0.1.0/plate.typ

@@ -1,4 +1,4 @@
-#import "@local/quillmark-helper:0.1.0": data
+#import "@local/quillmark-helper:0.2.0" as qm
 #import "@local/daf4392page2-pkg:0.1.0": form
 
 #set text(font: "NimbusRomNo9L")
@@ -7,18 +7,18 @@
 #let vals = (:)
 
 // Mode of Transportation — enum string drives one of six checkboxes.
-#let mode = data.transportation_mode
+#let mode = qm.data.transportation_mode
 #if mode != "" { vals.insert("mode_" + mode, true) }
 
 // Header row
-#if data.departure_date != none { vals.insert("departure_date", data.departure_date) }
-#if data.final_destination != "" { vals.insert("final_destination", data.final_destination) }
+#if qm.data.departure_date != none { vals.insert("departure_date", qm.data.departure_date) }
+#if qm.data.final_destination != "" { vals.insert("final_destination", qm.data.final_destination) }
 
 // Proposed Travel Itinerary — one card per row, up to 10 rows.
 #let itin-cols = ("date", "departure_point", "arrival_point", "rest_length", "mileage")
 #{
   let row = 0
-  for card in data.at("$cards", default: ()) {
+  for card in qm.data.at("$cards", default: ()) {
     if card.at("$kind", default: none) == "itinerary" and row < 10 {
       let n = str(row + 1)
       for col in itin-cols {
@@ -33,27 +33,27 @@
 
 // Flight info — bold label prefixes a tentative/confirmed flight number.
 #{
-  let d = str(data.dept_flight_num)
+  let d = str(qm.data.dept_flight_num)
   if d != "" { vals.insert("dept_flight", [#text(weight: "bold")[Dept Flight:] #d]) }
-  let a = str(data.arrival_flight_num)
+  let a = str(qm.data.arrival_flight_num)
   if a != "" { vals.insert("arrival_flight", [#text(weight: "bold")[Arr Flight:] #a]) }
 }
 
 // Notes
-#if data.notes != "" { vals.insert("notes", data.notes) }
+#if qm.data.notes != "" { vals.insert("notes", qm.data.notes) }
 
 // Acknowledgements
-#if data.organization != "" { vals.insert("organization", data.organization) }
-#if data.briefed_date != none { vals.insert("briefed_date", data.briefed_date) }
-#if data.briefee_name != "" { vals.insert("briefee_name", data.briefee_name) }
-#if data.briefee_grade != "" { vals.insert("briefee_grade", data.briefee_grade) }
-#if data.briefer_name != "" { vals.insert("briefer_name", data.briefer_name) }
-#if data.briefer_grade != "" { vals.insert("briefer_grade", data.briefer_grade) }
+#if qm.data.organization != "" { vals.insert("organization", qm.data.organization) }
+#if qm.data.briefed_date != none { vals.insert("briefed_date", qm.data.briefed_date) }
+#if qm.data.briefee_name != "" { vals.insert("briefee_name", qm.data.briefee_name) }
+#if qm.data.briefee_grade != "" { vals.insert("briefee_grade", qm.data.briefee_grade) }
+#if qm.data.briefer_name != "" { vals.insert("briefer_name", qm.data.briefer_name) }
+#if qm.data.briefer_grade != "" { vals.insert("briefer_grade", qm.data.briefer_grade) }
 
 // Emergency contact — bold label prefixes a "name: phone" pair.
 #{
-  let en = str(data.emergency_contact_name)
-  let ep = str(data.emergency_contact_phone)
+  let en = str(qm.data.emergency_contact_name)
+  let ep = str(qm.data.emergency_contact_phone)
   let contact = if en != "" and ep != "" { en + ": " + ep } else if en != "" { en } else { ep }
   if contact != "" {
     vals.insert("emergency_contact", [#text(weight: "bold")[EMERGENCY CONTACT:] #contact])