refactored debug rendering

migrated contextual variables to CeTZ context shared-state
adapted participant rendering

.gitea/workflows/ci.yaml

@@ -1,31 +0,0 @@
-name: CI
-on:
-  push:
-    branches: [ main, dev ]
-  pull_request:
-    branches: [ main, dev ]
-
-jobs:
-  tests:
-    runs-on: ubuntu-latest
-    container: catthehacker/ubuntu:rust-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install tytanic
-        run: cargo binstall tytanic@0.2.2
-
-      - name: Run test suite
-        run: tt run
-
-      - name: Archive artifacts
-        uses: https://gitea.com/actions/gitea-upload-artifact@v4
-        if: always()
-        with:
-          name: artifacts
-          path: |
-            tests/**/diff/*.png
-            tests/**/out/*.png
-            tests/**/ref/*.png
-          retention-days: 5

docs/notes.typ

@@ -5,15 +5,13 @@
 /// - color (color): The note's color
 /// - shape (str): The note's shape (see @@SHAPES for accepted values)
 /// - aligned (bool): True if the note is aligned with another note, in which case `side` must be `"over"`, false otherwise
-/// - allow-overlap (bool): If set to `false`, the note will try to reserve space in the column to avoid overlapping with neighboring participants. If set to `true`, the not will overlap other participants
 #let _note(
   side,
   content,
   pos: none,
   color: rgb("#FEFFDD"),
   shape: "default",
-  aligned: false,
-  allow-overlap: true
+  aligned: false
 ) = {}
 
 /// Accepted values for `shape` argument of @@_note()

justfile

@@ -9,10 +9,4 @@ manual:
 
 gallery:
   for f in "{{gallery_dir}}"/*.typ; do typst c --root . "$f" "${f%typ}pdf"; done
-  for f in "{{gallery_dir}}"/readme/*.typ; do typst c --root . "$f" "${f%typ}png"; done
-
-test *filter:
-  tt run {{filter}}
-
-update-test *filter:
-  tt update {{filter}}
+  for f in "{{gallery_dir}}"/readme/*.typ; do typst c --root . "$f" "${f%typ}png"; done

src/cetz.typ

@@ -1 +1 @@
-#import "@preview/cetz:0.4.0": *
+#import "@preview/cetz:0.3.4": *

src/consts.typ

@@ -27,10 +27,4 @@
 #let COL-DESTRUCTION = rgb("#A80238")
 #let COL-GRP-NAME = rgb("#EEEEEE")
 #let COL-SEP-NAME = rgb("#EEEEEE")
-#let COL-NOTE = rgb("#FEFFDD")
-
-#let default-style = (
-  y-space: 10pt,
-  fill: rgb("#EEEEEE"),
-  stroke: black + 1pt,
-)
+#let COL-NOTE = rgb("#FEFFDD")

src/core/draw/delay.typ

@@ -1,30 +1,12 @@
-#import "/src/cetz.typ": draw, styles
-
-#import "/src/core/utils.typ": get-ctx, normalize-units, set-ctx
-
-#let delay-default-style = (
-  stroke: (
-    dash: "loosely-dotted",
-    paint: gray.darken(40%),
-    thickness: .8pt
-  ),
-  size: 30pt
-)
+#import "../utils.typ": get-ctx, set-ctx
+#import "../../cetz.typ": draw
 
 #let render(delay) = get-ctx(ctx => {
-  let style = styles.resolve(
-    ctx.style,
-    merge: delay.style,
-    root: "delay",
-    base: delay-default-style
-  )
-  let size = normalize-units(style.size)
-
   let y0 = ctx.y
-  let y1 = ctx.y - size
+  let y1 = ctx.y - delay.size
   for (i, line) in ctx.lifelines.enumerate() {
-    line.events.push((type: "delay-start", y: y0))
-    line.events.push((type: "delay-end", y: y1, stroke: style.stroke))
+    line.lines.push(("delay-start", y0))
+    line.lines.push(("delay-end", y1))
     ctx.lifelines.at(i) = line
   }
   if delay.name != none {
@@ -32,13 +14,13 @@
     let x1 = ctx.x-pos.last()
     draw.content(
       ((x0 + x1) / 2, (y0 + y1) / 2),
-      anchor: "mid",
+      anchor: "center",
       delay.name
     )
   }
-  
+  ctx.y = y1
   set-ctx(c => {
-    c.y = y1
+    c.y = ctx.y
     c.lifelines = ctx.lifelines
     return c
   })

src/core/draw/event.typ

@@ -1,28 +1,28 @@
-#import "/src/consts.typ": *
-#import "/src/core/utils.typ": get-ctx, set-ctx
+#import "../utils.typ": get-ctx, set-ctx
+#import "../../consts.typ": *
 
 #let render(evt) = get-ctx(ctx => {
   let par-name = evt.participant
   let i = ctx.pars-i.at(par-name)
   let par = ctx.participants.at(i)
   let line = ctx.lifelines.at(i)
-  let entry = (type: evt.event, y: ctx.y)
+  let entry = (evt.event, ctx.y)
 
   if evt.event == "disable" {
     line.level -= 1
   } else if evt.event == "enable" {
     line.level += 1
-    entry.insert("style", evt.lifeline-style)
+    entry.push(evt.lifeline-style)
   } else if evt.event == "create" {
     ctx.y -= CREATE-OFFSET
-    entry.y = ctx.y
+    entry.at(1) = ctx.y
     (par.draw)(par, y: ctx.y)
   } else if evt.event == "destroy" {
   } else {
     panic("Unknown event '" + evt.event + "'")
   }
 
-  line.events.push(entry)
+  line.lines.push(entry)
   set-ctx(c => {
     c.lifelines.at(i) = line
     c.y = ctx.y

src/core/draw/group.typ

@@ -1,68 +1,31 @@
-#import "/src/cetz.typ": draw, styles
-
-#import "/src/consts.typ": *
-#import "/src/core/utils.typ": expand-parent-group, get-ctx, normalize-units, set-ctx
-
-#let group-default-style = (
-  name: (
-    inset: (
-      x: 5pt,
-      y: 3pt
-    ),
-    stroke: auto,
-    fill: auto
-  ),
-  desc: (
-    inset: 3pt
-  ),
-  divider: (dash: (2pt, 1pt), thickness: .5pt),
-  padding: 10pt,
-  stroke: auto
-)
+#import "../utils.typ": get-ctx, set-ctx
+#import "../../consts.typ": *
+#import "../../cetz.typ": draw
 
 #let render-start(grp) = get-ctx(ctx => {
-  let style = styles.resolve(
-    ctx.style,
-    merge: grp.style,
-    root: "group",
-    base: group-default-style
-  )
-
   let grp = grp
-  grp.insert("resolved-style", style)
-  ctx.y -= ctx.style.y-space
-
-  let name = box(
-    text(grp.name, weight: "bold"),
-    inset: style.name.inset
+  ctx.y -= Y-SPACE
+  let m = measure(
+    box(
+      grp.name,
+      inset: (
+        left: 5pt,
+        right: 5pt,
+        top: 3pt,
+        bottom: 3pt
+      ),
+    )
   )
-  grp.insert("rendered-name", name)
-
-  let desc = box(
-    text([\[#grp.desc\]], weight: "bold", size: .8em),
-    inset: style.desc.inset
-  )
-  grp.insert("rendered-desc", desc)
-
-  let m = measure(name)
   ctx.groups = ctx.groups.map(g => {
-    if g.group.min-i == grp.min-i { g.start-lvl += 1 }
-    if g.group.max-i == grp.max-i { g.end-lvl += 1 }
+    if g.at(1).min-i == grp.min-i { g.at(2) += 1 }
+    if g.at(1).max-i == grp.max-i { g.at(3) += 1 }
     g
   })
   if grp.grp-type == "alt" {
     grp.insert("elses", ())
   }
-  ctx.groups.push((
-    start-y: ctx.y,
-    group: grp,
-    start-lvl: 0,
-    end-lvl: 0,
-    min-x: ctx.x-pos.at(grp.min-i) - 10,
-    max-x: ctx.x-pos.at(grp.max-i) + 10
-  ))
+  ctx.groups.push((ctx.y, grp, 0, 0))
   ctx.y -= m.height / 1pt
-  ctx.y += ctx.style.y-space / 2
 
   set-ctx(c => {
     c.y = ctx.y
@@ -73,75 +36,65 @@
 
 
 #let draw-group(x0, x1, y0, y1, group) = {
-  let style = group.resolved-style
-  let name = group.rendered-name
-  let desc = group.rendered-desc
-  let m = measure(name)
-  let w = m.width / 1pt
-  let h = m.height / 1pt
+  let name = text(group.name, weight: "bold")
+  let m = measure(box(name))
+  let w = m.width / 1pt + 15
+  let h = m.height / 1pt + 6
   draw.rect(
     (x0, y0),
-    (x1, y1),
-    stroke: style.stroke
+    (x1, y1)
   )
-
-  let x1 = x0 + w
-  let x2 = x1 + 5
-  draw.line(
-    (x0, y0),
-    (x2, y0),
-    (x2, y0 - h / 2),
-    (x1, y0 - h),
-    (x0, y0 - h),
-    stroke: style.name.stroke,
-    fill: style.name.fill,
-    close: true
+  draw.merge-path(
+    fill: COL-GRP-NAME,
+    close: true,
+    {
+      draw.line(
+        (x0, y0),
+        (x0 + w, y0),
+        (x0 + w, y0 - h / 2),
+        (x0 + w - 5, y0 - h),
+        (x0, y0 - h)
+      )
+    }
   )
   draw.content(
     (x0, y0),
     name,
-    anchor: "north-west"
+    anchor: "north-west",
+    padding: (left: 5pt, right: 10pt, top: 3pt, bottom: 3pt)
   )
 
   if group.desc != none {
     draw.content(
-      (x2, y0),
-      desc,
-      anchor: "north-west"
+      (x0 + w, y0),
+      text([\[#group.desc\]], weight: "bold", size: .8em),
+      anchor: "north-west",
+      padding: 3pt
     )
   }
 }
 
 #let draw-else(x0, x1, y, elmt) = {
-  let style = elmt.resolved-style
   draw.line(
     (x0, y),
     (x1, y),
-    stroke: style.divider
+    stroke: (dash: (2pt, 1pt), thickness: .5pt)
   )
   draw.content(
     (x0, y),
-    elmt.rendered-desc,
-    anchor: "north-west"
+    text([\[#elmt.desc\]], weight: "bold", size: .8em),
+    anchor: "north-west",
+    padding: 3pt
   )
 }
 
 #let render-end(group) = get-ctx(ctx => {
-  let y = ctx.y - ctx.style.y-space / 2
-  ctx.y -= ctx.style.y-space / 2
-  let (
-    start-y,
-    group,
-    start-lvl,
-    end-lvl,
-    min-x,
-    max-x
-  ) = ctx.groups.pop()
-  let padding = normalize-units(group.resolved-style.padding)
-  let x0 = min-x - padding
-  let x1 = max-x + padding
+  ctx.y -= Y-SPACE
+  let (start-y, group, start-lvl, end-lvl) = ctx.groups.pop()
+  let x0 = ctx.x-pos.at(group.min-i) - start-lvl * 10 - 20
+  let x1 = ctx.x-pos.at(group.max-i) + end-lvl * 10 + 20
   
-  draw-group(x0, x1, start-y, y, group)
+  draw-group(x0, x1, start-y, ctx.y, group)
 
   if group.grp-type == "alt" {
     for (else-y, else-elmt) in group.elses {
@@ -154,37 +107,14 @@
     c.groups = ctx.groups
     return c
   })
-
-  expand-parent-group(x0, x1)
 })
 
-#let render-else(else_) = get-ctx(ctx => {
-  let group = ctx.groups.last().group
-  let style = styles.resolve(
-    ctx.style,
-    merge: group.style,
-    root: "group",
-    base: group-default-style
-  )
-  ctx.y -= ctx.style.y-space / 2
-
-  let desc = box(
-    text([\[#else_.desc\]], weight: "bold", size: .8em),
-    inset: style.desc.inset
-  )
-  let m = measure(desc)
-  let else_ = else_
-  else_.insert("resolved-style", style)
-  else_.insert("rendered-desc", desc)
-  ctx.groups.last().group.elses.push((
+#let render-else(else_) = set-ctx(ctx => {
+  ctx.y -= Y-SPACE
+  let m = measure(text([\[#else_.desc\]], weight: "bold", size: .8em))
+  ctx.groups.last().at(1).elses.push((
     ctx.y, else_
   ))
   ctx.y -= m.height / 1pt
-  ctx.y += ctx.style.y-space / 2
-  
-  set-ctx(c => {
-    c.y = ctx.y
-    c.groups = ctx.groups
-    return c
-  })
+  return ctx
 })

src/core/draw/note.typ

@@ -1,7 +1,6 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/consts.typ": *
-#import "/src/core/utils.typ": get-ctx, set-ctx, expand-parent-group
+#import "../../consts.typ": *
+#import "../utils.typ": get-ctx, set-ctx
+#import "../../cetz.typ": draw
 
 #let get-size(note) = {
   let PAD = if note.shape == "hex" {NOTE-HEX-PAD} else {NOTE-PAD}
@@ -49,6 +48,10 @@
   return box(note.content, inset: inset)
 }
 
+#let pre-render(note) = {
+  
+}
+
 #let render(note, y: auto, forced: false) = {
   if not note.linked {
     if not note.aligned {
@@ -107,22 +110,21 @@
     let y1 = y0 - h
 
     if note.shape == "default" {
-      draw.line(
-        (x0, y0),
-        (x1, y0),
-        (x2, y0 - NOTE-CORNER-SIZE),
-        (x2, y1),
-        (x0, y1),
+      draw.merge-path(
         stroke: black + .5pt,
         fill: note.color,
-        close: true
-      )
-      draw.line(
-        (x1, y0),
-        (x1, y0 - NOTE-CORNER-SIZE),
-        (x2, y0 - NOTE-CORNER-SIZE),
-        stroke: black + .5pt
+        close: true,
+        {
+          draw.line(
+            (x0, y0),
+            (x1, y0),
+            (x2, y0 - NOTE-CORNER-SIZE),
+            (x2, y1),
+            (x0, y1)
+          )
+        }
       )
+      draw.line((x1, y0), (x1, y0 - NOTE-CORNER-SIZE), (x2, y0 - NOTE-CORNER-SIZE), stroke: black + .5pt)
     } else if note.shape == "rect" {
       draw.rect(
         (x0, y0),
@@ -134,16 +136,20 @@
       let lx = x0 + PAD.last()
       let rx = x2 - PAD.last()
       let my = (y0 + y1) / 2
-      draw.line(
-        (lx, y0),
-        (rx, y0),
-        (x2, my),
-        (rx, y1),
-        (lx, y1),
-        (x0, my),
+      draw.merge-path(
         stroke: black + .5pt,
         fill: note.color,
-        close: true
+        close: true,
+        {
+          draw.line(
+            (lx, y0),
+            (rx, y0),
+            (x2, my),
+            (rx, y1),
+            (lx, y1),
+            (x0, my),
+          )
+        }
       )
     }
 
@@ -159,7 +165,5 @@
         return c
       })
     }
-
-    expand-parent-group(x0, x2)
   })
 }

src/core/draw/participant.typ

@@ -1,112 +1,315 @@
-#import "/src/cetz.typ": draw, styles
-
-#import "/src/consts.typ": *
-#import "/src/core/utils.typ": get-ctx, get-style, is-elmt, set-ctx
-
-#import "participant/default.typ" as shape-default
-#import "participant/actor.typ" as shape-actor
-#import "participant/boundary.typ" as shape-boundary
-#import "participant/control.typ" as shape-control
-#import "participant/entity.typ" as shape-entity
-#import "participant/database.typ" as shape-database
-#import "participant/collections.typ" as shape-collections
-#import "participant/queue.typ" as shape-queue
-#import "participant/custom.typ" as shape-custom
-
-#let shapes = {
-  let from-module(mod) = {
-    let p = "participant/default.typ"
-    return (mod.name: (
-      get-size: mod.get-size,
-      render: mod.render,
-      default-style: mod.default-style
-    ))
-  }
-  from-module(shape-default)
-  from-module(shape-actor)
-  from-module(shape-boundary)
-  from-module(shape-control)
-  from-module(shape-entity)
-  from-module(shape-database)
-  from-module(shape-collections)
-  from-module(shape-queue)
-  from-module(shape-custom)
-}
-
-#let participant-default-style = (
-  fill: auto,
-  stroke: black + .5pt,
-  from-start: true,
-  show-bottom: true,
-  show-top: true,
-  shape: "participant",
-  track: (
-    dash: "dashed",
-    paint: gray.darken(40%),
-    thickness: .5pt
-  )
-)
-
-#let resolve-style(ctx, par) = {
-  let style = styles.resolve(
-    ctx.style,
-    merge: par.style,
-    root: "participant",
-    base: participant-default-style
-  )
-  let shape-style = shapes.at(style.shape, default: (:))
-                          .at("default-style", default: (:))
-  style = styles.resolve(
-    ctx.style,
-    merge: style,
-    base: shape-style
-  )
-  return style
-}
-
-#let pre-resolve-styles(ctx, elements, participants) = {
-  let idx = (:)
-  for (i, par) in participants.enumerate() {
-    par.insert("resolved-style", resolve-style(ctx, par))
-    participants.at(i) = par
-    idx.insert(par.name, i)
-  }
-  for (i, elmt) in elements.enumerate() {
-    if type(elmt) == function {
-      ctx = elmt(ctx).ctx
-    } else if is-elmt(elmt) {
-      if elmt.type == par {
-        let style = resolve-style(ctx, elmt)
-        elements.at(i).insert("resolved-style", style)
-        let i = idx.at(elmt.name)
-        participants.at(i).resolved-style = style
-      }
-    }
-  }
-  return (elements, participants)
-}
+#import "../../consts.typ": *
+#import "../../cetz.typ": draw
+#import "../utils.typ": get-ctx, set-ctx, get-style
 
 #let get-size(par) = {
   if par.invisible {
     return (width: 0pt, height: 0pt)
   }
-  let style = par.resolved-style
-  let func = shapes.at(style.shape).get-size
-  return func(par)
+  let m = measure(box(par.display-name))
+  let w = m.width
+  let h = m.height
+  let (shape-w, shape-h) = (
+    participant: (w + PAR-PAD.last() * 2, h + PAR-PAD.first() * 2),
+    actor: (ACTOR-WIDTH * 1pt, ACTOR-WIDTH * 2pt + SYM-GAP * 1pt + h),
+    boundary: (BOUNDARY-HEIGHT * 2pt, BOUNDARY-HEIGHT * 1pt + SYM-GAP * 1pt + h),
+    control: (CONTROL-HEIGHT * 1pt, CONTROL-HEIGHT * 1pt + SYM-GAP * 1pt + h),
+    entity: (ENTITY-HEIGHT * 1pt, ENTITY-HEIGHT * 1pt + 2pt + SYM-GAP * 1pt + h),
+    database: (DATABASE-WIDTH * 1pt, DATABASE-WIDTH * 4pt / 3 + SYM-GAP * 1pt + h),
+    collections: (
+      w + COLLECTIONS-PAD.last() * 2 + calc.abs(COLLECTIONS-DX) * 1pt,
+      h + COLLECTIONS-PAD.first() * 2 + calc.abs(COLLECTIONS-DY) * 1pt,
+    ),
+    queue: (
+      w + QUEUE-PAD.last() * 2 + 3 * (h + QUEUE-PAD.first() * 2) / 4,
+      h + QUEUE-PAD.first() * 2
+    ),
+    custom: (
+      measure(par.custom-image).width,
+      measure(par.custom-image).height + SYM-GAP * 1pt + h
+    )
+  ).at(par.shape)
+
+  return (
+    width: calc.max(w, shape-w),
+    height: calc.max(h, shape-h)
+  )
 }
 
-#let render(par, y: 0, bottom: false) = get-ctx(ctx => {
-  let style = resolve-style(ctx, par)
-  let func = shapes.at(style.shape).render
-  let par = par
-  par.resolved-style = style
-  func(ctx.x-pos.at(par.i), y, par, bottom)
+#let _render-participant(x, y, p, m, bottom) = {
+  let w = m.width / 1pt
+  let h = m.height / 1pt
+  let x0 = x - w / 2 - PAR-PAD.last() / 1pt
+  let x1 = x + w / 2 + PAR-PAD.last() / 1pt
+  let y0 = y + h + PAR-PAD.first() / 1pt * 2
+  if bottom {
+    y0 = y
+  }
+  let y1 = y0 - h - PAR-PAD.first() / 1pt * 2
+
+  draw.rect(
+    (x0, y0),
+    (x1, y1),
+    radius: 2pt,
+    fill: p.color,
+    stroke: black + .5pt
+  )
+  draw.content(
+    ((x0 + x1) / 2, (y0 + y1) / 2),
+    p.display-name,
+    anchor: "center"
+  )
+}
+
+#let _render-actor(x, y, p, m, bottom) = {
+  let w2 = ACTOR-WIDTH / 2
+  let head-r = ACTOR-WIDTH / 4
+  let height = ACTOR-WIDTH * 2
+  let arms-y = height * 0.375
+
+  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + height + SYM-GAP}
+  draw.circle(
+    (x, y0 - head-r),
+    radius: head-r,
+    fill: p.color,
+    stroke: black + .5pt
+  )
+  draw.line((x, y0 - head-r * 2), (x, y0 - height + w2), stroke: black + .5pt)
+  draw.line((x - w2, y0 - arms-y), (x + w2, y0 - arms-y), stroke: black + .5pt)
+  draw.line((x - w2, y0 - height), (x, y0 - height + w2), (x + w2, y0 - height), stroke: black + .5pt)
+  draw.content(
+    (x, y),
+    p.display-name,
+    anchor: if bottom {"north"} else {"south"}
+  )
+}
+
+#let _render-boundary(x, y, p, m, bottom) = {
+  let circle-r = BOUNDARY-HEIGHT / 2
+  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + BOUNDARY-HEIGHT + SYM-GAP}
+  let x0 = x - BOUNDARY-HEIGHT
+  let y1 = y0 - circle-r
+  let y2 = y0 - BOUNDARY-HEIGHT
+
+  draw.circle(
+    (x + circle-r, y1),
+    radius: circle-r,
+    fill: p.color,
+    stroke: black + .5pt
+  )
+  draw.line(
+    (x0, y0), (x0, y2),
+    stroke: black + .5pt
+  )
+  draw.line(
+    (x0, y1), (x, y1),
+    stroke: black + .5pt
+  )
+  draw.content(
+    (x, y),
+    p.display-name,
+    anchor: if bottom {"north"} else {"south"}
+  )
+}
+
+#let _render-control(x, y, p, m, bottom) = {
+  let r = CONTROL-HEIGHT / 2
+  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + CONTROL-HEIGHT + SYM-GAP}
+
+  draw.circle(
+    (x, y0 - r),
+    radius: r,
+    fill: p.color,
+    stroke: black + .5pt
+  )
+  draw.mark((x, y0), (x - r / 2, y0), symbol: "stealth", fill: black)
+  draw.content(
+    (x, y),
+    p.display-name,
+    anchor: if bottom {"north"} else {"south"}
+  )
+}
+
+#let _render-entity(x, y, p, m, bottom) = {
+  let r = ENTITY-HEIGHT / 2
+  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + ENTITY-HEIGHT + SYM-GAP}
+  let y1 = y0 - ENTITY-HEIGHT - 1.5
+
+  draw.circle(
+    (x, y0 - r),
+    radius: r,
+    fill: p.color,
+    stroke: black + .5pt
+  )
+  draw.line(
+    (x - r, y1),
+    (x + r, y1),
+    stroke: black + .5pt
+  )
+  draw.content(
+    (x, y),
+    p.display-name,
+    anchor: if bottom {"north"} else {"south"}
+  )
+}
+
+#let _render-database(x, y, p, m, bottom) = {
+  let height = DATABASE-WIDTH * 4 / 3
+  let rx = DATABASE-WIDTH / 2
+  let ry = rx / 2
+  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + height + SYM-GAP}
+  let y1 = y0 - height
+
+  draw.merge-path(
+    close: true,
+    fill: p.color,
+    stroke: black + .5pt,
+    {
+      draw.bezier((x - rx, y0 - ry), (x, y0), (x - rx, y0 - ry/2), (x - rx/2, y0))
+      draw.bezier((), (x + rx, y0 - ry), (x + rx/2, y0), (x + rx, y0 - ry/2))
+      draw.line((), (x + rx, y1 + ry))
+      draw.bezier((), (x, y1), (x + rx, y1 + ry/2), (x + rx/2, y1))
+      draw.bezier((), (x - rx, y1 + ry), (x - rx/2, y1), (x - rx, y1 + ry/2))
+    }
+  )
+  draw.merge-path(
+    stroke: black + .5pt,
+    {
+      draw.bezier((x - rx, y0 - ry), (x, y0 - ry*2), (x - rx, y0 - 3*ry/2), (x - rx/2, y0 - ry*2))
+      draw.bezier((), (x + rx, y0 - ry), (x + rx/2, y0 - ry*2), (x + rx, y0 - 3*ry/2))
+    }
+  )
+  draw.content(
+    (x, y),
+    p.display-name,
+    anchor: if bottom {"north"} else {"south"}
+  )
+}
+
+#let _render-collections(x, y, p, m, bottom) = {
+  let w = m.width / 1pt
+  let h = m.height / 1pt
+  let dx = COLLECTIONS-DX
+  let dy = COLLECTIONS-DY
+  let total-w = w + PAR-PAD.last() * 2 / 1pt + calc.abs(dx)
+  let total-h = h + PAR-PAD.first() * 2 / 1pt + calc.abs(dy)
+
+  let x0 = x - total-w / 2
+  let x1 = x0 + calc.abs(dx)
+  let x3 = x0 + total-w
+  let x2 = x3 - calc.abs(dx)
+  
+  let y0 = if bottom {y} else {y + total-h}
+  let y1 = y0 - calc.abs(dy)
+  let y3 = y0 - total-h
+  let y2 = y3 + calc.abs(dy)
+
+  let r1 = (x1, y0, x3, y2)
+  let r2 = (x0, y1, x2, y3)
+
+  if dx < 0 {
+    r1.at(0) = x0
+    r1.at(2) = x2
+    r2.at(0) = x1
+    r2.at(2) = x3
+  }
+
+  if dy < 0 {
+    r1.at(1) = y1
+    r1.at(3) = y3
+    r2.at(1) = y0
+    r2.at(3) = y2
+  }
+  draw.rect(
+    (r1.at(0), r1.at(1)),
+    (r1.at(2), r1.at(3)),
+    fill: p.color,
+    stroke: black + .5pt
+  )
+  draw.rect(
+    (r2.at(0), r2.at(1)),
+    (r2.at(2), r2.at(3)),
+    fill: p.color,
+    stroke: black + .5pt
+  )
+  
+  draw.content(
+    ((r2.at(0) + r2.at(2)) / 2, (r2.at(1) + r2.at(3)) / 2),
+    p.display-name,
+    anchor: "center"
+  )
+}
+
+#let _render-queue(x, y, p, m, bottom) = {
+  let w = (m.width + QUEUE-PAD.last() * 2) / 1pt
+  let h = (m.height + QUEUE-PAD.first() * 2) / 1pt
+  let total-h = h
+  let ry = total-h / 2
+  let rx = ry / 2
+  let total-w = w + 3 + 3 * rx
+
+  let x0 = x - total-w / 2
+  let y0 = if bottom {y} else {y + total-h}
+  let y1 = y0 - total-h
+  let x-left = x0 + rx
+  let x-right = x-left + w + rx
+  draw.merge-path(
+    close: true,
+    fill: p.color,
+    stroke: black + .5pt,
+    {
+      draw.bezier((x-right, y0), (x-right + rx, y0 - ry), (x-right + rx/2, y0), (x-right + rx, y0 - ry/2))
+      draw.bezier((), (x-right, y1), (x-right + rx, y1 + ry/2), (x-right + rx/2, y1))
+      draw.line((), (x-left, y1))
+      draw.bezier((), (x-left - rx, y0 - ry), (x-left - rx/2, y1), (x-left - rx, y1 + ry/2))
+      draw.bezier((), (x-left, y0), (x-left - rx, y0 - ry/2), (x-left - rx/2, y0))
+    }
+  )
+  draw.merge-path(
+    stroke: black + .5pt,
+    {
+      draw.bezier((x-right, y0), (x-right - rx, y0 - ry), (x-right - rx/2, y0), (x-right - rx, y0 - ry/2))
+      draw.bezier((), (x-right, y1), (x-right - rx, y1 + ry/2), (x-right - rx/2, y1))
+    }
+  )
+  draw.content(
+    ((x-left + x-right - rx) / 2, y0 - ry),
+    p.display-name,
+    anchor: "center"
+  )
+}
+
+#let _render-custom(x, y, p, m, bottom) = {
+  let image-m = measure(p.custom-image)
+  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + image-m.height / 1pt + SYM-GAP}
+  draw.content((x - image-m.width / 2pt, y0), p.custom-image, anchor: "north-west")
+  draw.content(
+    (x, y),
+    p.display-name,
+    anchor: if bottom {"north"} else {"south"}
+  )
+}
+
+#let render(par, y: 0, bottom: false) = draw.group(cetz-ctx => {
+  let ctx = cetz-ctx.shared-state.chronos
+  let m = measure(box(par.display-name))
+  let func = (
+    participant: _render-participant,
+    actor: _render-actor,
+    boundary: _render-boundary,
+    control: _render-control,
+    entity: _render-entity,
+    database: _render-database,
+    collections: _render-collections,
+    queue: _render-queue,
+    custom: _render-custom,
+  ).at(par.shape)
+  func(ctx.x-pos.at(par.i), y, par, m, bottom)
 },)
 
 #let render-lifelines() = get-ctx(ctx => {
   let participants = ctx.participants
   for p in participants.filter(p => not p.invisible) {
-    let style = p.resolved-style
     let x = ctx.x-pos.at(p.i)
 
     // Draw vertical line
@@ -114,61 +317,66 @@
 
     let rects = ()
     let destructions = ()
-    let stack = ()
+    let lines = ()
 
     // Compute lifeline rectangles + destruction positions
-    for event in ctx.lifelines.at(p.i).events {
-      if event.type == "create" {
+    for line in ctx.lifelines.at(p.i).lines {
+      let event = line.first()
+      if event == "create" {
         last-y = line.at(1)
 
-      } else if event.type == "enable" {
-        if stack.len() == 0 {
+      } else if event == "enable" {
+        if lines.len() == 0 {
           draw.line(
             (x, last-y),
-            (x, event.y),
-            stroke: style.track
+            (x, line.at(1)),
+            stroke: p.line-stroke
           )
         }
-        stack.push(event)
+        lines.push(line)
       
-      } else if event.type == "disable" or event.type == "destroy" {
+      } else if event == "disable" or event == "destroy" {
         let lvl = 0
-        if stack.len() != 0 {
-          let e = stack.pop()
-          lvl = stack.len()
+        if lines.len() != 0 {
+          let l = lines.pop()
+          lvl = lines.len()
           rects.push((
             x + lvl * LIFELINE-W / 2,
-            e.y,
-            event.y,
-            e.style
+            l.at(1),
+            line.at(1),
+            l.at(2)
           ))
-          last-y = event.y
+          last-y = line.at(1)
         }
 
-        if event.type == "destroy" {
-          destructions.push((x + lvl * LIFELINE-W / 2, event.y))
+        if event == "destroy" {
+          destructions.push((x + lvl * LIFELINE-W / 2, line.at(1)))
         }
-      } else if event.type == "delay-start" {
+      } else if event == "delay-start" {
         draw.line(
           (x, last-y),
-          (x, event.y),
-          stroke: style.track
+          (x, line.at(1)),
+          stroke: p.line-stroke
         )
-        last-y = event.y
-      } else if event.type == "delay-end" {
+        last-y = line.at(1)
+      } else if event == "delay-end" {
         draw.line(
           (x, last-y),
-          (x, event.y),
-          stroke: event.stroke
+          (x, line.at(1)),
+          stroke: (
+            dash: "loosely-dotted",
+            paint: gray.darken(40%),
+            thickness: .8pt
+          )
         )
-        last-y = event.y
+        last-y = line.at(1)
       }
     }
 
     draw.line(
       (x, last-y),
       (x, ctx.y),
-      stroke: style.track
+      stroke: p.line-stroke
     )
 
     // Draw lifeline rectangles (reverse for bottom to top)
@@ -190,7 +398,7 @@
     }
 
     // Draw participants (end)
-    if style.show-bottom {
+    if p.show-bottom {
       (p.draw)(p, y: ctx.y, bottom: true)
     }
   }

src/core/draw/participant/actor.typ

@@ -1,75 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure, normalize-units
-
-#let name = "actor"
-
-#let render(x, y, p, bottom) = {
-  let m = normalize-measure(p.display-name)
-  let style = p.resolved-style
-  let spacing = normalize-units(style.spacing)
-  let width = normalize-units(style.width)
-  let height = width * 2
-  let w2 = width / 2
-  let head-r = width / 4
-  let arms-y = height * 0.375
-
-  let y0 = if bottom {
-    y - m.height - spacing
-  } else {
-    y + m.height + height + spacing
-  }
-
-  // Head
-  draw.circle(
-    (x, y0 - head-r),
-    radius: head-r,
-    fill: style.fill,
-    stroke: style.stroke
-  )
-
-  // Body
-  draw.line(
-    (x, y0 - head-r * 2),
-    (x, y0 - height + w2),
-    stroke: style.stroke
-  )
-  
-  // Arms
-  draw.line(
-    (x - w2, y0 - arms-y),
-    (x + w2, y0 - arms-y),
-    stroke: style.stroke
-  )
-
-  // Legs
-  draw.line(
-    (x - w2, y0 - height),
-    (x, y0 - height + w2),
-    (x + w2, y0 - height),
-    stroke: style.stroke
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"base"}
-  )
-}
-
-#let get-size(par) = {
-  let m = normalize-measure(par.display-name)
-
-  let width = normalize-units(par.resolved-style.width)
-  let height = width * 2
-  let spacing = normalize-units(par.resolved-style.spacing)
-
-  return (
-    width: calc.max(m.width, width),
-    height: height + spacing + m.height
-  )
-}
-
-#let default-style = (
-  width: 20pt,
-  spacing: 5pt
-)

src/core/draw/participant/boundary.typ

@@ -1,59 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure, normalize-units
-
-#let name = "boundary"
-
-#let render(x, y, p, bottom) = {
-  let m = normalize-measure(p.display-name)
-  let style = p.resolved-style
-  let height = normalize-units(style.height)
-  let spacing = normalize-units(style.spacing)
-  let circle-r = height / 2
-  let y0 = if bottom {
-    y - m.height - spacing
-  } else {
-    y + m.height + height + spacing
-  }
-  let x0 = x - height
-  let y1 = y0 - circle-r
-  let y2 = y0 - height
-
-  draw.circle(
-    (x + circle-r, y1),
-    radius: circle-r,
-    fill: style.fill,
-    stroke: style.stroke
-  )
-  draw.line(
-    (x0, y0), (x0, y2),
-    stroke: style.stroke
-  )
-  draw.line(
-    (x0, y1), (x, y1),
-    stroke: style.stroke
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"base"}
-  )
-}
-
-#let get-size(par) = {
-  let m = normalize-measure(par.display-name)
-
-  let height = normalize-units(par.resolved-style.height)
-  let width = height * 2
-  let spacing = normalize-units(par.resolved-style.spacing)
-
-  return (
-    width: calc.max(m.width, width),
-    height: height + spacing + m.height
-  )
-}
-
-#let default-style = (
-  height: 20pt,
-  spacing: 5pt
-)

src/core/draw/participant/collections.typ

@@ -1,108 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure, normalize-units
-
-#let name = "collections"
-
-#let normalize-offset(offset) = {
-  let dx = 0pt
-  let dy = 0pt
-  if type(offset) == array {
-    if offset.len() >= 2 {
-      dx = offset.at(0)
-      dy = offset.at(1)
-    }
-  } else if type(offset) == dictionary {
-    dx = offset.at("dx", default: dx)
-    dy = offset.at("dx", default: dy)
-  } else {
-    dx = offset
-    dy = offset
-  }
-  return (
-    x: normalize-units(dx),
-    y: normalize-units(dy)
-  )
-}
-
-#let render(x, y, p, bottom) = {
-  let style = p.resolved-style
-  let name = box(
-    p.display-name,
-    inset: style.inset,
-    fill: style.fill,
-    stroke: style.stroke
-  )
-  let m = normalize-measure(name)
-  let offset = normalize-offset(style.offset)
-
-  let w = m.width
-  let h = m.height
-  let dx = offset.x
-  let dy = offset.y
-  let total-w = w + calc.abs(dx)
-  let total-h = h + calc.abs(dy)
-
-  let x0 = x - total-w / 2
-  let x1 = x0 + calc.abs(dx)
-  let x3 = x0 + total-w
-  let x2 = x3 - calc.abs(dx)
-  
-  let y0 = if bottom {y} else {y + total-h}
-  let y1 = y0 - calc.abs(dy)
-  let y3 = y0 - total-h
-  let y2 = y3 + calc.abs(dy)
-
-  let r1 = (x1, y0, x3, y2)
-  let r2 = (x0, y1, x2, y3)
-
-  if dx < 0 {
-    r1.at(0) = x0
-    r1.at(2) = x2
-    r2.at(0) = x1
-    r2.at(2) = x3
-  }
-
-  if dy < 0 {
-    r1.at(1) = y1
-    r1.at(3) = y3
-    r2.at(1) = y0
-    r2.at(3) = y2
-  }
-  draw.rect(
-    (r1.at(0), r1.at(1)),
-    (r1.at(2), r1.at(3)),
-    fill: style.fill,
-    stroke: style.stroke
-  )
-  
-  draw.content(
-    (
-      (r2.at(0) + r2.at(2)) / 2,
-      (r2.at(1) + r2.at(3)) / 2
-    ),
-    name,
-    anchor: "mid"
-  )
-}
-
-#let get-size(par) = {
-  let m = normalize-measure(box(
-    par.display-name,
-    inset: par.resolved-style.inset
-  ))
-  
-  let offset = normalize-offset(par.resolved-style.offset)
-  let dx = offset.x
-  let dy = offset.y
-
-  return (
-    width: m.width + calc.abs(dx),
-    height: m.height + calc.abs(dy)
-  )
-}
-
-#let default-style = (
-  inset: (x: 3pt, y: 5pt),
-  offset: (3pt, 3pt)
-)

src/core/draw/participant/control.typ

@@ -1,54 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure, normalize-units
-
-#let name = "control"
-
-#let render(x, y, p, bottom) = {
-  let m = normalize-measure(p.display-name)
-  let style = p.resolved-style
-  let size = normalize-units(style.size)
-  let spacing = normalize-units(style.spacing)
-  let r = size / 2
-  let y0 = if bottom {
-    y - m.height - spacing
-  } else {
-    y + m.height + size + spacing
-  }
-
-  draw.circle(
-    (x, y0 - r),
-    radius: r,
-    fill: style.fill,
-    stroke: style.stroke
-  )
-  let s = stroke(style.stroke)
-  draw.mark(
-    (x, y0), (x - r / 2, y0),
-    symbol: "stealth",
-    fill: s.paint,
-    stroke: s.paint
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"base"}
-  )
-}
-
-#let get-size(par) = {
-  let m = normalize-measure(par.display-name)
-
-  let size = normalize-units(par.resolved-style.size)
-  let spacing = normalize-units(par.resolved-style.spacing)
-
-  return (
-    width: calc.max(m.width, size),
-    height: size + spacing + m.height
-  )
-}
-
-#let default-style = (
-  size: 20pt,
-  spacing: 5pt
-)

src/core/draw/participant/custom.typ

@@ -1,43 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure, normalize-units
-
-#let name = "custom"
-
-#let render(x, y, p, bottom) = {
-  let style = p.resolved-style
-  let elmts = (style.image, p.display-name)
-  if bottom {
-    elmts = elmts.rev()
-  }
-  let shape = align(
-    center,
-    stack(
-      dir: ttb,
-      spacing: normalize-units(style.spacing) * 1pt,
-      ..elmts
-    )
-  )
-  let anchor = if bottom {"north"} else {"base"}
-  draw.content(
-    (x, y),
-    shape,
-    anchor: anchor
-  )
-}
-
-#let get-size(par) = {
-  let name-m = normalize-measure(par.display-name)
-  let img-m = normalize-measure(par.resolved-style.image)
-  let spacing = normalize-units(par.resolved-style.spacing)
-
-  return (
-    width: calc.max(name-m.width, img-m.width),
-    height: name-m.height + spacing + img-m.height
-  )
-}
-
-#let default-style = (
-  image: none,
-  spacing: 5pt
-)

src/core/draw/participant/database.typ

@@ -1,64 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure, normalize-units
-
-#let name = "database"
-
-#let render(x, y, p, bottom) = {
-  let m = normalize-measure(p.display-name)
-  let style = p.resolved-style
-  let width = normalize-units(style.width)
-  let spacing = normalize-units(style.spacing)
-  let height = width * 4 / 3
-  let rx = width / 2
-  let ry = rx / 2
-  let y0 = if bottom {
-    y - m.height - spacing
-  } else {
-    y + m.height + height + spacing
-  }
-  let y1 = y0 - height
-
-  draw.merge-path(
-    close: true,
-    fill: style.fill,
-    stroke: style.stroke,
-    {
-      draw.bezier((x - rx, y0 - ry), (x, y0), (x - rx, y0 - ry/2), (x - rx/2, y0))
-      draw.bezier((), (x + rx, y0 - ry), (x + rx/2, y0), (x + rx, y0 - ry/2))
-      draw.line((), (x + rx, y1 + ry))
-      draw.bezier((), (x, y1), (x + rx, y1 + ry/2), (x + rx/2, y1))
-      draw.bezier((), (x - rx, y1 + ry), (x - rx/2, y1), (x - rx, y1 + ry/2))
-    }
-  )
-  draw.merge-path(
-    stroke: style.stroke,
-    {
-      draw.bezier((x - rx, y0 - ry), (x, y0 - ry*2), (x - rx, y0 - 3*ry/2), (x - rx/2, y0 - ry*2))
-      draw.bezier((), (x + rx, y0 - ry), (x + rx/2, y0 - ry*2), (x + rx, y0 - 3*ry/2))
-    }
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"base"}
-  )
-}
-
-#let get-size(par) = {
-  let m = normalize-measure(par.display-name)
-
-  let width = normalize-units(par.resolved-style.width)
-  let height = width * 4 / 3
-  let spacing = normalize-units(par.resolved-style.spacing)
-
-  return (
-    width: calc.max(m.width, width),
-    height: height + spacing + m.height
-  )
-}
-
-#let default-style = (
-  width: 24pt,
-  spacing: 5pt
-)

src/core/draw/participant/default.typ

@@ -1,37 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure
-
-#let name = "participant"
-
-#let render(x, y, p, bottom) = {
-  let style = p.resolved-style
-  let name = box(
-    p.display-name,
-    inset: style.inset,
-    radius: style.radius,
-    fill: style.fill,
-    stroke: style.stroke
-  )
-  let anchor = if bottom {"north"} else {"base"}
-  draw.content(
-    (x, y),
-    name,
-    anchor: anchor
-  )
-}
-
-#let get-size(par) = {
-  return normalize-measure(box(
-    par.display-name,
-    inset: par.resolved-style.inset
-  ))
-}
-
-#let default-style = (
-  inset: (
-    x: 3pt,
-    y: 5pt
-  ),
-  radius: 2pt
-)

src/core/draw/participant/entity.typ

@@ -1,55 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure, normalize-units
-
-#let name = "entity"
-
-#let render(x, y, p, bottom) = {
-  let m = normalize-measure(p.display-name)
-  let style = p.resolved-style
-  let size = normalize-units(style.size)
-  let spacing = normalize-units(style.spacing)
-  let gap = normalize-units(style.gap)
-  let r = size / 2
-  let y0 = if bottom {
-    y - m.height - spacing
-  } else {
-    y + m.height + size + spacing
-  }
-  let y1 = y0 - size - gap
-
-  draw.circle(
-    (x, y0 - r),
-    radius: r,
-    fill: style.fill,
-    stroke: style.stroke
-  )
-  draw.line(
-    (x - r, y1),
-    (x + r, y1),
-    stroke: style.stroke
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"base"}
-  )
-}
-
-#let get-size(par) = {
-  let m = normalize-measure(par.display-name)
-
-  let size = normalize-units(par.resolved-style.size)
-  let spacing = normalize-units(par.resolved-style.spacing)
-
-  return (
-    width: calc.max(m.width, size),
-    height: size + spacing + m.height
-  )
-}
-
-#let default-style = (
-  size: 20pt,
-  gap: 1.5pt,
-  spacing: 5pt
-)

src/core/draw/participant/queue.typ

@@ -1,120 +0,0 @@
-#import "/src/cetz.typ": draw
-
-#import "/src/core/utils.typ": normalize-measure
-
-#let name = "queue"
-
-#let render(x, y, p, bottom) = {
-  let style = p.resolved-style
-  let m = normalize-measure(box(
-    p.display-name,
-    inset: style.inset
-  ))
-  
-  let w = m.width
-  let h = m.height
-  let ry = h / 2
-  let rx = ry / 2
-  let total-w = w + 3 * rx
-
-  let y0 = if bottom {y} else {y + h}
-  let y1 = y0 - h
-  let ym = y0 - ry
-
-  let xll = x - total-w / 2
-  let xrr = x + total-w / 2
-  let xlm = xll + rx
-  let xrm = xrr - rx
-  let xrl = xrm - rx
-  
-  /*
-   /A----------/B\   --- y0
-   Fh          G C   --- ym
-   \E----------\D/   --- y1
-  
-   ||          |||
-   ||          ||\-- xrr
-   ||          |\--- xrm
-   ||          \---- xrl
-   |\--------------- xlm
-   \---------------- xll
-  
-  h <-> G == w
-  F <-> h == rx
-  G <-> C == 2 * rx == ry
-  A <-> E == B <-> D == 2 * ry == h
-  */
-
-  draw.merge-path(
-    close: true,
-    fill: style.fill,
-    stroke: style.stroke,
-    {
-      draw.bezier(
-        (xrm, y0),
-        (xrr, ym),
-        (xrm + rx/2, y0),
-        (xrr, ym + ry/2)
-      )
-      draw.bezier(
-        (),
-        (xrm, y1),
-        (xrr, ym - ry/2),
-        (xrm + rx/2, y1)
-      )
-      draw.line((), (xlm, y1))
-      draw.bezier(
-        (),
-        (xll, ym),
-        (xlm - rx/2, y1),
-        (xll, ym - ry/2)
-      )
-      draw.bezier(
-        (),
-        (xlm, y0),
-        (xll, ym + ry/2),
-        (xlm - rx/2, y0)
-      )
-    }
-  )
-  draw.merge-path(
-    stroke: style.stroke,
-    {
-      draw.bezier(
-        (xrm, y0),
-        (xrl, ym),
-        (xrm - rx/2, y0),
-        (xrl, ym + ry/2)
-      )
-      draw.bezier(
-        (),
-        (xrm, y1),
-        (xrl, ym - ry/2),
-        (xrm - rx/2, y1)
-      )
-    }
-  )
-  draw.content(
-    ((xlm + xrl) / 2, ym),
-    p.display-name,
-    anchor: "mid"
-  )
-}
-
-#let get-size(par) = {
-  let m = normalize-measure(box(
-    par.display-name,
-    inset: par.resolved-style.inset
-  ))
-
-  let rx = m.height / 4
-
-  return (
-    width: m.width + 3 * rx,
-    height: m.height
-  )
-}
-
-#let default-style = (
-  inset: (x: 3pt, y: 5pt)
-)

src/core/draw/separator.typ

@@ -1,65 +1,46 @@
-#import "/src/cetz.typ": draw, styles
-
-#import "/src/consts.typ": *
-#import "/src/core/utils.typ": get-ctx, normalize-units, set-y
-
-#let separator-default-style = (
-  inset: (
-    x: 3pt, y: 5pt
-  ),
-  fill: auto,
-  stroke: auto,
-  gap: 3pt,
-  outset: 20pt
-)
+#import "../utils.typ": get-ctx, set-ctx
+#import "../../consts.typ": *
+#import "../../cetz.typ": draw
 
 #let render(sep) = get-ctx(ctx => {
-  let style = styles.resolve(
-    ctx.style,
-    merge: sep.style,
-    root: "separator",
-    base: separator-default-style
-  )
-  let gap = normalize-units(style.gap)
-  let outset = normalize-units(style.outset)
+  ctx.y -= Y-SPACE
 
-  ctx.y -= ctx.style.y-space
-
-  let x0 = ctx.x-pos.first() - outset
-  let x1 = ctx.x-pos.last() + outset
-  let name = box(
-    sep.name,
-    inset: style.inset,
-    stroke: style.stroke,
-    fill: style.fill
+  let x0 = ctx.x-pos.first() - 20
+  let x1 = ctx.x-pos.last() + 20
+  let m = measure(
+    box(
+      sep.name,
+      inset: (left: 3pt, right: 3pt, top: 5pt, bottom: 5pt)
+    )
   )
-  let m = measure(name)
   let w = m.width / 1pt
   let h = m.height / 1pt
   let cx = (x0 + x1) / 2
   let xl = cx - w / 2
   let xr = cx + w / 2
 
-  let y0 = ctx.y
-  let y2 = y0 - h
-  let y1 = (y0 + y2) / 2
-
-  let gap-y0 = y1 + gap / 2
-  let gap-y1 = gap-y0 - gap
-
+  ctx.y -= h / 2
   draw.rect(
-    (x0, gap-y0),
-    (x1, gap-y1),
+    (x0, ctx.y),
+    (x1, ctx.y - 3),
     stroke: none,
-    fill: style.fill
+    fill: white
   )
-  draw.line((x0, gap-y0), (x1, gap-y0))
-  draw.line((x0, gap-y1), (x1, gap-y1))
+  draw.line((x0, ctx.y), (x1, ctx.y))
+  ctx.y -= 3
+  draw.line((x0, ctx.y), (x1, ctx.y))
   draw.content(
-    (cx, y1),
-    name,
-    anchor: "mid"
+    ((x0 + x1) / 2, ctx.y + 1.5),
+    sep.name,
+    anchor: "center",
+    padding: (5pt, 3pt),
+    frame: "rect",
+    fill: COL-SEP-NAME
   )
+  ctx.y -= h / 2
 
-  set-y(y2)
+  set-ctx(c => {
+    c.y = ctx.y
+    return c
+  })
 })

src/core/draw/sequence.typ

@@ -1,8 +1,8 @@
-#import "/src/cetz.typ": draw, vector
-
+#import "../utils.typ": get-ctx, set-ctx
+#import "../../consts.typ": *
+#import "../../cetz.typ": draw, vector
 #import "note.typ"
-#import "/src/consts.typ": *
-#import "/src/core/utils.typ": get-ctx, set-ctx
+
 
 #let get-arrow-marks(sym, color) = {
   if sym == none {
@@ -15,10 +15,10 @@
     "": none,
     ">": (symbol: ">", fill: color),
     ">>": (symbol: "straight"),
-    "\\": (symbol: ">", fill: color, harpoon: true),
-    "\\\\": (symbol: "straight", harpoon: true),
-    "/": (symbol: ">", fill: color, harpoon: true, flip: true),
-    "//": (symbol: "straight", harpoon: true, flip: true),
+    "\\": (symbol: ">", fill: color, harpoon: true, flip: true),
+    "\\\\": (symbol: "straight", harpoon: true, flip: true),
+    "/": (symbol: ">", fill: color, harpoon: true),
+    "//": (symbol: "straight", harpoon: true),
     "x": none,
     "o": none,
   ).at(sym)
@@ -67,12 +67,9 @@
   if comment != none {
     h = calc.max(h, measure(comment).height / 1pt + 6)
   }
-  h = calc.max(
-    h,
-    ..seq.linked-notes.map(n => {
-      note.get-size(n).height / 2
-    })
-  )
+  if "linked-note" in seq {
+    h = calc.max(h, note.get-size(seq.linked-note).height / 2)
+  }
   ctx.y -= h
 
   let start-info = (
@@ -102,23 +99,23 @@
   if seq.disable-src {
     let src-line = ctx.lifelines.at(i1)
     src-line.level -= 1
-    src-line.events.push((type: "disable", y: start-info.y))
+    src-line.lines.push(("disable", start-info.y))
     ctx.lifelines.at(i1) = src-line
   }
   if seq.destroy-src {
     let src-line = ctx.lifelines.at(i1)
-    src-line.events.push((type: "destroy", y: start-info.y))
+    src-line.lines.push(("destroy", start-info.y))
     ctx.lifelines.at(i1) = src-line
   }
   if seq.disable-dst {
     let dst-line = ctx.lifelines.at(i2)
     dst-line.level -= 1
-    dst-line.events.push((type: "disable", y: end-info.y))
+    dst-line.lines.push(("disable", end-info.y))
     ctx.lifelines.at(i2) = dst-line
   }
   if seq.destroy-dst {
     let dst-line = ctx.lifelines.at(i2)
-    dst-line.events.push((type: "destroy", y: end-info.y))
+    dst-line.lines.push(("destroy", end-info.y))
     ctx.lifelines.at(i2) = dst-line
   }
   if seq.enable-dst {
@@ -168,8 +165,9 @@
   )
 
   let y0 = start-info.y
-  for n in seq.linked-notes {
-    (n.draw)(n, y: start-info.y, forced: true)
+  if "linked-note" in seq {
+    // TODO: adapt note.render
+    (seq.linked-note.draw)(seq.linked-note, y: start-info.y, forced: true)
   }
 
   let flip-mark = end-info.i <= start-info.i
@@ -341,23 +339,18 @@
 
   if seq.create-dst {
     let dst-line = ctx.lifelines.at(i2)
-    dst-line.events.push((type: "create", y: end-info.y))
+    dst-line.lines.push(("create", end-info.y))
     ctx.lifelines.at(i2) = dst-line
   }
   if seq.enable-dst {
     let dst-line = ctx.lifelines.at(i2)
-    dst-line.events.push((type: "enable", y: end-info.y, style: seq.lifeline-style))
+    dst-line.lines.push(("enable", end-info.y, seq.lifeline-style))
     ctx.lifelines.at(i2) = dst-line
   }
 
-  if seq.linked-notes.len() != 0 {
-    end-info.y = calc.min(
-      end-info.y,
-      y0 - calc.max(..seq.linked-notes.map(n => {
-        let m = note.get-size(n)
-        return m.height / 2
-      }))
-    )
+  if "linked-note" in seq {
+    let m = note.get-size(seq.linked-note)
+    end-info.y = calc.min(end-info.y, y0 - m.height / 2)
   }
 
   set-ctx(c => {

src/core/draw/sync.typ

@@ -1,4 +1,4 @@
-#import "/src/core/utils.typ": get-ctx, is-elmt, set-ctx
+#import "../utils.typ": get-ctx, set-ctx, is-elmt
 
 #let render(sync) = get-ctx(ctx => {
   set-ctx(c => {

src/core/renderer.typ

@@ -1,9 +1,14 @@
-#import "/src/cetz.typ": canvas, draw
-
-#import "draw/note.typ": get-box as get-note-box, get-size as get-note-size
-#import "draw/participant.typ"
+#import "/src/cetz.typ" as cetz: canvas, draw
 #import "utils.typ": *
-#import "/src/consts.typ": *
+#import "../group.typ"
+//#import "../participant.typ"
+//#import participant: PAR-SPECIALS
+#import "draw/participant.typ"
+#import "../sequence.typ"
+#import "../separator.typ"
+#import "../sync.typ"
+#import "../consts.typ": *
+#import "draw/note.typ": get-box as get-note-box, get-size as get-note-size
 
 #let DEBUG-INVISIBLE = false
 
@@ -82,12 +87,12 @@
   let (p1, p2) = (none, none)
   let cell = none
   if note.side == "left" {
-    p1 = note.pos2
+    p1 = "["
     p2 = note.pos
     cell = get-note-box(note)
   } else if note.side == "right" {
     p1 = note.pos
-    p2 = note.pos2
+    p2 = "]"
     cell = get-note-box(note)
   } else if note.side == "over" and note.aligned-with != none {
     let box1 = get-note-box(note)
@@ -155,7 +160,7 @@
     let m2 = participant.get-size(p2)
     let w1 = m1.width
     let w2 = m2.width
-    widths.push(w1 / 2 + w2 / 2 + PAR-SPACE)
+    widths.push(w1 / 2pt + w2 / 2pt + PAR-SPACE)
   }
   return widths
 }
@@ -220,7 +225,7 @@
 }
 
 /// Compute remaining widths for longer sequences (spanning multiple columns)
-#let long-seq-min-col-widths(participants, cells, widths) = {
+#let long-seq-min-col-widths(cells, widths) = {
   let widths = widths
   let multicol-cells = cells.filter(c => c.i2 - c.i1 > 1)
   multicol-cells = multicol-cells.sorted(key: c => {
@@ -228,23 +233,13 @@
   })
   for cell in multicol-cells {
     let m = measure(cell.cell)
-
-    let i1 = cell.i1
-    let i2 = cell.i2 - 1
-    let i = i2
-    if cell.i1 == 0 and participants.at(0).name == "[" {
-      i = 0
-      i1 += 1
-      i2 += 1
-    }
     let width = (
       m.width / 1pt +
       COMMENT-PAD -
-      widths.slice(i1, i2).sum()
+      widths.slice(cell.i1, cell.i2 - 1).sum()
     )
-    
-    widths.at(i) = calc.max(
-      widths.at(i), width
+    widths.at(cell.i2 - 1) = calc.max(
+      widths.at(cell.i2 - 1), width
     )
   }
   return widths
@@ -317,7 +312,7 @@
   widths = notes-min-col-widths(elements, widths, pars-i)
   widths = simple-seq-min-col-widths(cells, widths)
   widths = self-seq-min-col-widths(cells, widths)
-  widths = long-seq-min-col-widths(participants, cells, widths)
+  widths = long-seq-min-col-widths(cells, widths)
   widths = col-widths-add-lifelines(participants, widths)
   widths = process-col-elements(elements, widths, pars-i)
   return widths
@@ -326,12 +321,6 @@
 #let setup-ctx(participants, elements) = (ctx => {
   let state = ctx.at("shared-state", default: (:))
 
-  let (elements, participants) = participant.pre-resolve-styles(
-    extract-ctx(ctx, with-style: true),
-    elements,
-    participants
-  )
-
   let chronos-ctx = (
     participants: init-lifelines(participants),
     pars-i: get-participants-i(participants),
@@ -339,7 +328,7 @@
     groups: (),
     lifelines: participants.map(_ => (
       level: 0,
-      events: ()
+      lines: ()
     ))
   )
   chronos-ctx.insert(
@@ -388,8 +377,7 @@
   // Draw participants (start)
   get-ctx(ctx => {
     for p in ctx.participants {
-      let style = p.resolved-style
-      if style.from-start and not p.invisible and style.show-top {
+      if p.from-start and not p.invisible and p.show-top {
         (p.draw)(p)
       }
     }

src/core/setup.typ

@@ -1,7 +1,6 @@
+#import "utils.typ": is-elmt, get-group-span
+#import "../participant.typ": _exists as par-exists, _par
 #import "draw/group.typ": render-end as grp-render-end
-#import "utils.typ": get-group-span, is-elmt
-#import "/src/participant.typ": _exists as par-exists, _par
-#import "/src/sequence.typ": _seq
 
 #let flatten-group(elmts, i) = {
   let group = elmts.at(i)
@@ -126,8 +125,8 @@
     "linked",
     note.pos == none and note.side != "across"
   )
-  let names = ctx.participants.map(p => p.name)
   if note.pos == none and note.side != "across" {
+    let names = ctx.participants.map(p => p.name)
     let i1 = names.position(n => n == ctx.last-seq.p1)
     let i2 = names.position(n => n == ctx.last-seq.p2)
     let pars = (
@@ -141,8 +140,8 @@
       note.pos = pars.last().last()
     }
 
-    let seq = ctx.elmts.at(ctx.last-seq.i)
-    seq.linked-notes.push(note)
+    let seq = ctx.last-seq.seq
+    seq.insert("linked-note", note)
     ctx.elmts.at(ctx.last-seq.i) = seq
   }
   if note.aligned {
@@ -150,26 +149,10 @@
     n.aligned-with = note
     ctx.elmts.at(ctx.last-note.i) = n
   }
-
-  if note.side in ("left", "right") {
-    let i = names.position(n => n == note.pos)
-    let pos2 = note.pos
-    if note.side == "left" {
-      if i <= 0 or note.allow-overlap {
-        ctx.linked.push("[")
-        pos2 = "["
-      } else {
-        pos2 = names.at(i - 1)
-      }
-    } else if note.side == "right" {
-      if i >= names.len() - 1 or note.allow-overlap {
-        ctx.linked.push("]")
-        pos2 = "]"
-      } else {
-        pos2 = names.at(i + 1)
-      }
-    }
-    note.insert("pos2", pos2)
+  if note.side == "left" {
+    ctx.linked.push("[")
+  } else if note.side == "right" {
+    ctx.linked.push("]")
   }
 
   let pars = none

src/core/utils.typ

@@ -1,6 +1,4 @@
-#import "/src/cetz.typ": draw, styles
-
-#import "/src/consts.typ": default-style
+#import "../cetz.typ": draw
 
 #let is-elmt(elmt) = {
   if type(elmt) != dictionary {
@@ -21,15 +19,6 @@
   }
   panic("Unsupported type '" + str(type(value)) + "'")
 }
-
-#let normalize-measure(body) = {
-  let m = measure(body)
-  return (
-    width: normalize-units(m.width),
-    height: normalize-units(m.height)
-  )
-}
-
 #let get-participants-i(participants) = {
   let pars-i = (:)
   for (i, p) in participants.enumerate() {
@@ -44,9 +33,6 @@
   let pars-i = get-participants-i(participants)
 
   for elmt in group.elmts {
-    if not is-elmt(elmt) {
-      continue
-    }
     if elmt.type == "seq" {
       let i1 = pars-i.at(elmt.p1)
       let i2 = pars-i.at(elmt.p2)
@@ -107,47 +93,15 @@
   )
 })
 
-#let extract-ctx(cetz-ctx, with-style: false) = {
-  let state = cetz-ctx.at("shared-state", default: (:))
-  let ctx = state.at("chronos", default: (:))
-  if with-style {
-    ctx.style = styles.resolve(
-      cetz-ctx.style,
-      root: "chronos",
-      base: default-style
-    )
-    // Normalize because it is used very frequently
-    ctx.style.y-space = normalize-units(ctx.style.y-space)
-  }
-  return ctx
-}
-
 #let set-ctx(func) = draw.set-ctx(c => {
-  let ctx = extract-ctx(c)
+  let ctx = c.shared-state.chronos
   let new-ctx = func(ctx)
   assert(new-ctx != none, message: "set-ctx must return a context!")
-  let state = c.at("shared-state", default: (:))
-  state.chronos = new-ctx
-  c.shared-state = state
+  c.shared-state.chronos = new-ctx
   return c
 })
 
 #let get-ctx(func) = draw.get-ctx(c => {
-  let ctx = extract-ctx(c, with-style: true)
+  let ctx = c.shared-state.chronos
   func(ctx)
-})
-
-#let set-y(new-y) = set-ctx(c => {
-  c.y = new-y
-  return c
-})
-
-#let expand-parent-group(x0, x1) = set-ctx(ctx => {
-  if ctx.groups.len() != 0 {
-    let group = ctx.groups.last()
-    group.min-x = calc.min(group.min-x, x0)
-    group.max-x = calc.max(group.max-x, x1)
-    ctx.groups.last() = group
-  }
-  return ctx
-})
+})

src/diagram.typ

@@ -1,7 +1,44 @@
-#import "core/draw/event.typ": render as evt-render
-#import "core/renderer.typ": render
-#import "core/setup.typ": setup
 #import "core/utils.typ": fit-canvas, set-ctx
+#import "core/renderer.typ": render
+#import "participant.typ" as participant: _par, PAR-SPECIALS
+#import "sequence.typ": _seq
+#import "core/draw/event.typ": render as evt-render
+#import "core/setup.typ": setup
+
+#let gap-render(gap) = set-ctx(ctx => {
+  ctx.y -= gap.size
+  return ctx
+})
+
+#let _gap(size: 20) = {
+  return ((
+    type: "gap",
+    draw: gap-render,
+    size: size
+  ),)
+}
+
+#let _evt(participant, event) = {
+  return ((
+    type: "evt",
+    draw: evt-render,
+    participant: participant,
+    event: event,
+    lifeline-style: auto
+  ),)
+}
+
+#let _col(p1, p2, width: auto, margin: 0, min-width: 0, max-width: none) = {
+  return ((
+    type: "col",
+    p1: p1,
+    p2: p2,
+    width: width,
+    margin: margin,
+    min-width: min-width,
+    max-width: max-width
+  ),)
+}
 
 #let diagram(elements, width: auto) = {
   if elements == none {

src/group.typ

@@ -1,25 +1,25 @@
+#import "/src/cetz.typ": draw
+#import "consts.typ": *
 #import "core/draw/group.typ"
 
-#let _grp(name, desc: none, type: "default", elmts, ..style) = {
+#let _grp(name, desc: none, type: "default", elmts) = {
   return ((
     type: "grp",
     draw: group.render-start,
     name: name,
     desc: desc,
     grp-type: type,
-    elmts: elmts,
-    style: style.named()
+    elmts: elmts
   ),)
 }
 
-#let _alt(desc, elmts, ..elses-style) = {
+#let _alt(desc, elmts, ..args) = {
   let all-elmts = ()
   all-elmts += elmts
-  let elses = elses-style.pos()
-  let style = elses-style.named()
-  for i in range(0, elses.len(), step: 2) {
-    let else-desc = elses.at(i)
-    let else-elmts = elses.at(i + 1, default: ())
+  let args = args.pos()
+  for i in range(0, args.len(), step: 2) {
+    let else-desc = args.at(i)
+    let else-elmts = args.at(i + 1, default: ())
     all-elmts.push((
       type: "else",
       draw: group.render-else,
@@ -28,10 +28,10 @@
     all-elmts += else-elmts
   }
 
-  return _grp("alt", desc: desc, type: "alt", all-elmts, ..style)
+  return _grp("alt", desc: desc, type: "alt", all-elmts)
 }
 
-#let _loop(desc, min: none, max: auto, elmts, ..style) = {
+#let _loop(desc, min: none, max: auto, elmts) = {
   let name = "loop"
   if min != none {
     if max == auto {
@@ -39,7 +39,7 @@
     }
     name += "(" + str(min) + "," + str(max) + ")"
   }
-  _grp(name, desc: desc, type: "loop", elmts, ..style)
+  _grp(name, desc: desc, type: "loop", elmts)
 }
-#let _opt(desc, elmts, ..style) = _grp("opt", desc: desc, type: "opt", elmts, ..style.named())
-#let _break(desc, elmts, ..style) = _grp("break", desc: desc, type: "break", elmts, ..style.named())
+#let _opt(desc, elmts) = grp("opt", desc: desc, type: "opt", elmts)
+#let _break(desc, elmts) = grp("break", desc: desc, type: "break", elmts)

src/lib.typ

@@ -1,8 +1,9 @@
 #let version = version(0, 2, 2)
-#import "diagram.typ": diagram, from-plantuml
+#import "diagram.typ": diagram, from-plantuml, _gap, _evt, _col
 
 #import "sequence.typ": _seq, _ret
 #import "group.typ": _grp, _loop, _alt, _opt, _break
 #import "participant.typ": _par
-#import "misc.typ": _sep, _delay, _sync, _gap, _evt, _col
-#import "note.typ": _note
+#import "separator.typ": _sep, _delay
+#import "note.typ": _note
+#import "sync.typ": _sync

src/misc.typ

@@ -1,66 +0,0 @@
-#import "core/draw/delay.typ"
-#import "core/draw/event.typ": render as evt-render
-#import "core/draw/separator.typ"
-#import "core/draw/sync.typ"
-#import "core/utils.typ": set-ctx
-
-#let _sep(name, ..style) = {
-  return ((
-    type: "sep",
-    draw: separator.render,
-    name: name,
-    style: style.named()
-  ),)
-}
-
-#let _delay(name: none, ..style) = {
-  return ((
-    type: "delay",
-    draw: delay.render,
-    name: name,
-    style: style.named()
-  ),)
-}
-
-#let _sync(elmts) = {
-  return ((
-    type: "sync",
-    draw: sync.render,
-    elmts: elmts
-  ),)
-}
-
-#let gap-render(gap) = set-ctx(ctx => {
-  ctx.y -= gap.size
-  return ctx
-})
-
-#let _gap(size: 20) = {
-  return ((
-    type: "gap",
-    draw: gap-render,
-    size: size
-  ),)
-}
-
-#let _evt(participant, event) = {
-  return ((
-    type: "evt",
-    draw: evt-render,
-    participant: participant,
-    event: event,
-    lifeline-style: auto
-  ),)
-}
-
-#let _col(p1, p2, width: auto, margin: 0, min-width: 0, max-width: none) = {
-  return ((
-    type: "col",
-    p1: p1,
-    p2: p2,
-    width: width,
-    margin: margin,
-    min-width: min-width,
-    max-width: max-width
-  ),)
-}

src/note.typ

@@ -1,3 +1,4 @@
+#import "/src/cetz.typ": draw
 #import "consts.typ": *
 #import "core/draw/note.typ"
 
@@ -14,15 +15,7 @@
   "hex"
 )
 
-#let _note(
-  side,
-  content,
-  pos: none,
-  color: COL-NOTE,
-  shape: "default",
-  aligned: false,
-  allow-overlap: true
-) = {
+#let _note(side, content, pos: none, color: COL-NOTE, shape: "default", aligned: false) = {
   if side == "over" {
     if pos == none {
       panic("Pos cannot be none with side 'over'")
@@ -45,7 +38,6 @@
     color: color,
     shape: shape,
     aligned: aligned,
-    aligned-with: none,
-    allow-overlap: allow-overlap
+    aligned-with: none
   ),)
 }

src/participant.typ

@@ -1,6 +1,8 @@
-#import "core/draw/participant.typ"
+#import "/src/cetz.typ": draw
+#import "consts.typ": *
+#import "core/draw/participant.typ": render as par-render
 
-#let PAR-SPECIALS = ("?", "[", "]")
+#let PAR-SPECIALS = "?[]"
 #let SHAPES = (
   "participant",
   "actor",
@@ -17,21 +19,40 @@
 #let _par(
   name,
   display-name: auto,
+  from-start: true,
   invisible: false,
-  ..style
+  shape: "participant",
+  color: DEFAULT-COLOR,
+  line-stroke: (
+    dash: "dashed",
+    paint: gray.darken(40%),
+    thickness: .5pt
+  ),
+  custom-image: none,
+  show-bottom: true,
+  show-top: true,
 ) = {
+  if color == auto {
+    color = DEFAULT-COLOR
+  }
   return ((
     type: "par",
-    draw: participant.render,
+    draw: par-render,
     name: name,
     display-name: if display-name == auto {name} else {display-name},
-    invisible: false,
-    style: style.named()
+    from-start: from-start,
+    invisible: invisible,
+    shape: shape,
+    color: color,
+    line-stroke: line-stroke,
+    custom-image: custom-image,
+    show-bottom: show-bottom,
+    show-top: show-top
   ),)
 }
 
 #let _exists(participants, name) = {
-  if name in PAR-SPECIALS {
+  if name == "?" or name == "[" or name == "]" {
     return true
   }
 

src/separator.typ

@@ -0,0 +1,21 @@
+#import "/src/cetz.typ": draw
+#import "consts.typ": *
+#import "core/draw/separator.typ"
+#import "core/draw/delay.typ"
+
+#let _sep(name) = {
+  return ((
+    type: "sep",
+    draw: separator.render,
+    name: name
+  ),)
+}
+
+#let _delay(name: none, size: 30) = {
+  return ((
+    type: "delay",
+    draw: delay.render,
+    name: name,
+    size: size
+  ),)
+}

src/sequence.typ

@@ -1,3 +1,7 @@
+#import "/src/cetz.typ": draw, vector
+#import "consts.typ": *
+#import "participant.typ"
+#import "note.typ"
 #import "core/draw/sequence.typ"
 
 #let _seq(
@@ -38,8 +42,7 @@
     disable-src: disable-src,
     destroy-src: destroy-src,
     lifeline-style: lifeline-style,
-    slant: slant,
-    linked-notes: ()
+    slant: slant
   ),)
 }
 

src/sync.typ

@@ -0,0 +1,10 @@
+#import "sequence.typ"
+#import "core/draw/sync.typ"
+
+#let _sync(elmts) = {
+  return ((
+    type: "sync",
+    draw: sync.render,
+    elmts: elmts
+  ),)
+}

tests/empty/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/empty/test.typ

@@ -1,6 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({})
-
-#diagram(())

tests/group/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/group/test.typ

@@ -1,51 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _seq("Alice", "Bob", comment: "Authentication Request")
-
-  _alt(
-    "successful case", {
-      _seq("Bob", "Alice", comment: "Authentication Accepted")
-    },
-    "some kind of failure", {
-      _seq("Bob", "Alice", comment: "Authentication Failure")
-
-      _grp("My own label", desc: "My own label2", {
-        _seq("Alice", "Log", comment: "Log attack start")
-        _loop("1000 times", {
-          _seq("Alice", "Bob", comment: "DNS Attack")
-        })
-        _seq("Alice", "Log", comment: "Log attack end")
-      })
-    },
-    "Another type of failure", {
-      _seq("Bob", "Alice", comment: "Please repeat")
-    }
-  )
-})
-
-#pagebreak()
-
-#diagram({
-  _par("a", display-name: box(width: 1.5em, height: .5em), show-bottom: false)
-  _par("b", display-name: box(width: 1.5em, height: .5em), show-bottom: false)
-  _col("a", "b", width: 2cm)
-  _loop("a<1", min: 1, {
-    _seq("a", "b", end-tip: ">>")
-    _seq("b", "a", end-tip: ">>")
-  })
-  _seq("a", "b", end-tip: ">>")
-})
-
-#pagebreak()
-
-#diagram({
-  _par("A")
-  _par("B")
-  _col("A", "B", width: 3cm)
-  _seq("A", "B", enable-dst: true)
-  _alt([desc], {
-    _ret()
-  })
-})

tests/note/color/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/note/color/test.typ

@@ -1,13 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _par("a", display-name: "Alice")
-  _par("b", display-name: "Bob")
-
-  _note("left", [This is displayed\ left of Alice.], pos: "a", color: rgb("#00FFFF"))
-  _note("right", [This is displayed right of Alice.], pos: "a")
-  _note("over", [This is displayed over Alice.], pos: "a")
-  _note("over", [This is displayed\ over Bob and Alice.], pos: ("a", "b"), color: rgb("#FFAAAA"))
-  _note("over", [This is yet another\ example of\ a long note.], pos: ("a", "b"))
-})

tests/note/position/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/note/position/test.typ

@@ -1,49 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _par("a", display-name: "Alice")
-  _par("b", display-name: "Bob")
-
-  _seq("a", "b", comment: [hello])
-  _note("left", [this is a first note])
-
-  _seq("b", "a", comment: [ok])
-  _note("right", [this is another note])
-
-  _seq("b", "b", comment: [I am thinking])
-  _note("left", [a note\ can also be defined\ on several lines])
-})
-
-#pagebreak()
-
-#diagram({
-  _par("a", display-name: "Alice")
-  _par("b", display-name: "Bob")
-
-  _note("over", [initial state of Alice], pos: "a")
-  _note("over", [initial state of Bob], pos: "b")
-  _seq("b", "a", comment: [hello])
-})
-
-#pagebreak()
-
-#diagram({
-  _par("a", display-name: "Alice")
-  _par("b", display-name: "Bob")
-  _par("c", display-name: "Charlie")
-  _par("d", display-name: "Donald")
-  _par("e", display-name: "Eddie")
-
-  _note("across", [This note float above all participants])
-
-  _note("over", [initial state of Alice], pos: "a")
-  _note("over", [initial state of Bob the builder], pos: "b", aligned: true)
-
-  _note("over", [Note 1], pos: "a")
-  _note("over", [Note 2], pos: "b", aligned: true)
-  _note("over", [Note 3], pos: "c", aligned: true)
-
-  _seq("a", "d")
-  _note("over", [this is an extremely long note], pos: ("d", "e"))
-})

tests/note/shape/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/note/shape/test.typ

@@ -1,14 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _par("caller")
-  _par("server")
-
-  _seq("caller", "server", comment: [conReq])
-  _note("over", [idle], pos: "caller", shape: "hex")
-  _seq("server", "caller", comment: [conConf])
-  _note("over", ["r" as rectangle\ "h" as hexagon], pos: "server", shape: "rect")
-  _note("over", [this is\ on several\ lines], pos: "server", shape: "rect")
-  _note("over", [this is\ on several\ lines], pos: "caller", shape: "hex")
-})

tests/note/styled-body/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/note/styled-body/test.typ

@@ -1,33 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _par("a", display-name: [Alice])
-  _par("b", display-name: [The *Famous* Bob])
-
-  _seq("a", "b", comment: [hello #strike([there])])
-
-  _gap()
-  _seq("b", "a", comment: [ok])
-  _note("left", [
-    This is *bold*\
-    This is _italics_\
-    This is `monospaced`\
-    This is #strike([stroked])\
-    This is #underline([underlined])\
-    This is #underline([waved])\
-  ])
-
-  _seq("a", "b", comment: [A _well formatted_ message])
-  _note("right", [
-    This is #box(text([displayed], size: 18pt), fill: rgb("#5F9EA0"))\
-    #underline([left of]) Alice.
-  ], pos: "a")
-  _note("left", [
-    #underline([This], stroke: red) is #text([displayed], fill: rgb("#118888"))\
-    *#text([left of], fill: rgb("#800080")) #strike([Alice], stroke: red) Bob.*
-  ], pos: "b")
-  _note("over", [
-    #underline([This is hosted], stroke: rgb("#FF33FF")) by #box(baseline: 50%, image("/gallery/gitea.png", width: 1cm, height: 1cm, fit: "contain"))
-  ], pos: ("a", "b"))
-})

tests/participant/shapes/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/participant/shapes/test.typ

@@ -1,21 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-
-#let TYPST = image("/gallery/typst.png", width: 1.5cm, height: 1.5cm, fit: "contain")
-#let FERRIS = image("/gallery/ferris.png", width: 1.5cm, height: 1.5cm, fit: "contain")
-#let ME = image("/gallery/me.jpg", width: 1.5cm, height: 1.5cm, fit: "contain")
-
-#diagram({
-  _par("Foo", display-name: "Participant", shape: "participant")
-  _par("Foo1", display-name: "Actor", shape: "actor")
-  _par("Foo2", display-name: "Boundary", shape: "boundary")
-  _par("Foo3", display-name: "Control", shape: "control")
-  _par("Foo4", display-name: "Entity", shape: "entity")
-  _par("Foo5", display-name: "Database", shape: "database")
-  _par("Foo6", display-name: "Collections", shape: "collections")
-  _par("Foo7", display-name: "Queue", shape: "queue")
-  _par("Foo8", display-name: "Typst", shape: "custom", image: TYPST)
-  _par("Foo9", display-name: "Ferris", shape: "custom", image: FERRIS)
-  _par("Foo10", display-name: "Baryhobal", shape: "custom", image: ME)
-})

tests/sequence/comment-align/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/sequence/comment-align/test.typ

@@ -1,57 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _par("alice", display-name: "Alice")
-  _par("bob", display-name: "Bob")
-  _seq("alice", "bob", comment: "This is a very long comment")
-
-  // Left to right
-  _seq("alice", "bob", comment: "Start aligned", comment-align: "start")
-  _seq("alice", "bob", comment: "End aligned", comment-align: "end")
-  _seq("alice", "bob", comment: "Left aligned", comment-align: "left")
-  _seq("alice", "bob", comment: "Right aligned", comment-align: "right")
-  _seq("alice", "bob", comment: "Centered", comment-align: "center")
-  _gap()
-
-  // Right to left
-  _seq("bob", "alice", comment: "Start aligned", comment-align: "start")
-  _seq("bob", "alice", comment: "End aligned", comment-align: "end")
-  _seq("bob", "alice", comment: "Left aligned", comment-align: "left")
-  _seq("bob", "alice", comment: "Right aligned", comment-align: "right")
-  _seq("bob", "alice", comment: "Centered", comment-align: "center")
-  _gap()
-
-  // Slant left to right
-  _seq("alice", "bob", comment: "Start aligned", comment-align: "start", slant: 10)
-  _seq("alice", "bob", comment: "End aligned", comment-align: "end", slant: 10)
-  _seq("alice", "bob", comment: "Left aligned", comment-align: "left", slant: 10)
-  _seq("alice", "bob", comment: "Right aligned", comment-align: "right", slant: 10)
-  _seq("alice", "bob", comment: "Centered", comment-align: "center", slant: 10)
-  _gap()
-
-  // Slant right to left
-  _seq("bob", "alice", comment: "Start aligned", comment-align: "start", slant: 10)
-  _seq("bob", "alice", comment: "End aligned", comment-align: "end", slant: 10)
-  _seq("bob", "alice", comment: "Left aligned", comment-align: "left", slant: 10)
-  _seq("bob", "alice", comment: "Right aligned", comment-align: "right", slant: 10)
-  _seq("bob", "alice", comment: "Centered", comment-align: "center", slant: 10)
-})
-
-#pagebreak()
-
-#diagram({
-  _par("alice", display-name: "Alice")
-
-  _seq("alice", "alice", comment: "Start aligned", comment-align: "start")
-  _seq("alice", "alice", comment: "End aligned", comment-align: "end")
-  _seq("alice", "alice", comment: "Left aligned", comment-align: "left")
-  _seq("alice", "alice", comment: "Right aligned", comment-align: "right")
-  _seq("alice", "alice", comment: "Centered", comment-align: "center")
-
-  _seq("alice", "alice", comment: "Start aligned", comment-align: "start", flip: true)
-  _seq("alice", "alice", comment: "End aligned", comment-align: "end", flip: true)
-  _seq("alice", "alice", comment: "Left aligned", comment-align: "left", flip: true)
-  _seq("alice", "alice", comment: "Right aligned", comment-align: "right", flip: true)
-  _seq("alice", "alice", comment: "Centered", comment-align: "center", flip: true)
-})

tests/sequence/special-par/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/sequence/special-par/test.typ

@@ -1,12 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _seq("?", "Alice", comment: [?->\ *short* to actor1])
-  _seq("[", "Alice", comment: [\[->\ *from start* to actor1])
-  _seq("[", "Bob", comment: [\[->\ *from start* to actor2])
-  _seq("?", "Bob", comment: [?->\ *short* to actor2])
-  _seq("Alice", "]", comment: [->\]\ from actor1 *to end*])
-  _seq("Alice", "?", comment: [->?\ *short* from actor1])
-  _seq("Alice", "Bob", comment: [->\ from actor1 to actor2])
-})

tests/sequence/tips/.gitignore

@@ -1,4 +0,0 @@
-# generated by tytanic, do not edit
-
-diff/**
-out/**

tests/sequence/tips/test.typ

@@ -1,84 +0,0 @@
-#set page(width: auto, height: auto)
-#import "/src/lib.typ": *
-
-#diagram({
-  _par("a", display-name: "Alice")
-  _par("b", display-name: "Bob")
-
-  _seq("a", "b", end-tip: ">", comment: `->`)
-  _seq("a", "b", end-tip: ">>", comment: `->>`)
-  _seq("a", "b", end-tip: "\\", comment: `-\`)
-  _seq("a", "b", end-tip: "\\\\", comment: `-\\`)
-  _seq("a", "b", end-tip: "/", comment: `-/`)
-  _seq("a", "b", end-tip: "//", comment: `-//`)
-  _seq("a", "b", end-tip: "x", comment: `->x`)
-  _seq("a", "b", start-tip: "x", comment: `x->`)
-  _seq("a", "b", start-tip: "o", comment: `o->`)
-  _seq("a", "b", end-tip: ("o", ">"), comment: `->o`)
-  _seq("a", "b", start-tip: "o", end-tip: ("o", ">"), comment: `o->o`)
-  _seq("a", "b", start-tip: ">", end-tip: ">", comment: `<->`)
-  _seq("a", "b", start-tip: ("o", ">"), end-tip: ("o", ">"), comment: `o<->o`)
-  _seq("a", "b", start-tip: "x", end-tip: "x", comment: `x<->x`)
-  _seq("a", "b", end-tip: ("o", ">>"), comment: `->>o`)
-  _seq("a", "b", end-tip: ("o", "\\"), comment: `-\o`)
-  _seq("a", "b", end-tip: ("o", "\\\\"), comment: `-\\o`)
-  _seq("a", "b", end-tip: ("o", "/"), comment: `-/o`)
-  _seq("a", "b", end-tip: ("o", "//"), comment: `-//o`)
-  _seq("a", "b", start-tip: "x", end-tip: ("o", ">"), comment: `x->o`)
-})
-
-#pagebreak()
-
-#diagram({
-  _par("a", display-name: "Alice")
-  _par("b", display-name: "Bob")
-
-  _seq("b", "a", end-tip: ">", comment: `->`)
-  _seq("b", "a", end-tip: ">>", comment: `->>`)
-  _seq("b", "a", end-tip: "\\", comment: `-\`)
-  _seq("b", "a", end-tip: "\\\\", comment: `-\\`)
-  _seq("b", "a", end-tip: "/", comment: `-/`)
-  _seq("b", "a", end-tip: "//", comment: `-//`)
-  _seq("b", "a", end-tip: "x", comment: `->x`)
-  _seq("b", "a", start-tip: "x", comment: `x->`)
-  _seq("b", "a", start-tip: "o", comment: `o->`)
-  _seq("b", "a", end-tip: ("o", ">"), comment: `->o`)
-  _seq("b", "a", start-tip: "o", end-tip: ("o", ">"), comment: `o->o`)
-  _seq("b", "a", start-tip: ">", end-tip: ">", comment: `<->`)
-  _seq("b", "a", start-tip: ("o", ">"), end-tip: ("o", ">"), comment: `o<->o`)
-  _seq("b", "a", start-tip: "x", end-tip: "x", comment: `x<->x`)
-  _seq("b", "a", end-tip: ("o", ">>"), comment: `->>o`)
-  _seq("b", "a", end-tip: ("o", "\\"), comment: `-\o`)
-  _seq("b", "a", end-tip: ("o", "\\\\"), comment: `-\\o`)
-  _seq("b", "a", end-tip: ("o", "/"), comment: `-/o`)
-  _seq("b", "a", end-tip: ("o", "//"), comment: `-//o`)
-  _seq("b", "a", start-tip: "x", end-tip: ("o", ">"), comment: `x->o`)
-})
-
-#pagebreak()
-
-#diagram({
-  _par("a", display-name: "Alice")
-  _par("b", display-name: "Bob")
-
-  _seq("a", "a", end-tip: ">", comment: `->`)
-  _seq("a", "a", end-tip: ">>", comment: `->>`)
-  _seq("a", "a", end-tip: "\\", comment: `-\`)
-  _seq("a", "a", end-tip: "\\\\", comment: `-\\`)
-  _seq("a", "a", end-tip: "/", comment: `-/`)
-  _seq("a", "a", end-tip: "//", comment: `-//`)
-  _seq("a", "a", end-tip: "x", comment: `->x`)
-  _seq("a", "a", start-tip: "x", comment: `x->`)
-  _seq("a", "a", start-tip: "o", comment: `o->`)
-  _seq("a", "a", end-tip: ("o", ">"), comment: `->o`)
-  _seq("a", "a", start-tip: "o", end-tip: ("o", ">"), comment: `o->o`)
-  _seq("a", "a", start-tip: ">", end-tip: ">", comment: `<->`)
-  _seq("a", "a", start-tip: ("o", ">"), end-tip: ("o", ">"), comment: `o<->o`)
-  _seq("a", "a", start-tip: "x", end-tip: "x", comment: `x<->x`)
-  _seq("a", "a", end-tip: ("o", ">>"), comment: `->>o`)
-  _seq("a", "a", end-tip: ("o", "\\"), comment: `-\o`)
-  _seq("a", "a", end-tip: ("o", "\\\\"), comment: `-\\o`)
-  _seq("a", "a", end-tip: ("o", "/"), comment: `-/o`)
-  _seq("a", "a", end-tip: ("o", "//"), comment: `-//o`)
-  _seq("a", "a", start-tip: "x", end-tip: ("o", ">"), comment: `x->o`)
-})