@popcraft/kit 0.25.0 → 0.26.0

package/src/templates/themes/holidays-shared.ts

@@ -0,0 +1,903 @@
+// What the holidays pack draws with: vectors boxed tight round what they draw (so a resized copy is worked out again,
+// not stretched), and the small pictures each holiday is made of — baubles and pine, a menorah and dreidels,
+// fireworks, hearts and roses, eggs and tulips, pumpkins and bats, maple leaves and wheat, diyas, marigolds and
+// rangoli, crescents and lanterns, plum blossom and red lanterns. Every picture is plain path data in the parent's
+// px, coloured by the template through a palette role. Only this pack's own things live here; anything general is
+// in templates/src/shared.
+
+import type { VectorPath, VectorPoint } from '@/lib/document/types'
+import type { Kit, VariantSpec } from '../kit'
+import { pt3, r3, rng, type P } from '../shared/draw'
+
+type VectorOpts = Parameters<Kit['vector']>[5]
+
+// ── Placing drawings ──
+
+/** `paths` (in the parent's px) boxed tight: the box, and the paths moved into it, handles and all. */
+export function boxTight(paths: VectorPath[]): { x: number; y: number; width: number; height: number; paths: VectorPath[] } {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity
+  for (const p of paths) for (const q of p.points) {
+    for (const c of [q, q.handleIn, q.handleOut]) if (c) { x0 = Math.min(x0, c.x); y0 = Math.min(y0, c.y); x1 = Math.max(x1, c.x); y1 = Math.max(y1, c.y) }
+  }
+  x0 = Math.floor(x0); y0 = Math.floor(y0)
+  const mv = (q: { x: number; y: number }) => pt3(q.x - x0, q.y - y0)
+  const moved = paths.map(p => ({ ...p, points: p.points.map(q => ({ ...q, ...mv(q), ...(q.handleIn ? { handleIn: mv(q.handleIn) } : {}), ...(q.handleOut ? { handleOut: mv(q.handleOut) } : {}) })) }))
+  return { x: x0, y: y0, width: Math.max(1, Math.ceil(x1 - x0)), height: Math.max(1, Math.ceil(y1 - y0)), paths: moved }
+}
+
+/** A drawing as named layers: what `draw` makes once, and `redraw` patches in a resized copy. */
+export interface Drawn { name: string; paths: VectorPath[]; color: string; o?: VectorOpts }
+
+/** Draw every part of `parts` on `parent`, each a vector boxed tight round its paths. Empty parts are skipped. */
+export function draw(k: Kit, parent: string, parts: readonly Drawn[]): string[] {
+  return parts.filter(p => p.paths.length).map(p => {
+    const b = boxTight(p.paths)
+    return k.vector(parent, b.width, b.height, b.paths, p.color, { name: p.name, ...p.o, absolute: { x: b.x, y: b.y } })
+  })
+}
+
+/**
+ * The same drawing worked out for a copy of another size: each layer named as a part, in order, takes the part's box
+ * and paths (magic resize stretches a vector's box but not its paths).
+ */
+export function redraw(k: Kit, root: string, parts: readonly Drawn[]) {
+  const seen = new Map<string, number>()
+  for (const p of parts.filter(q => q.paths.length)) {
+    const i = seen.get(p.name) ?? 0
+    seen.set(p.name, i + 1)
+    const id = k.named(root, p.name)[i]
+    if (!id) continue
+    const b = boxTight(p.paths)
+    const w = p.o?.strokeWidth
+    const strokes = (k.node(id) as { strokes?: { width: unknown }[] }).strokes ?? []
+    k.patch(id, { x: b.x, y: b.y, width: b.width, height: b.height, paths: b.paths, ...(w !== undefined ? { strokes: strokes.map(st => ({ ...st, width: w })) } : {}) } as never)
+  }
+}
+
+/** Restyle every layer named `layer` under `root`. */
+export function restyleAll(k: Kit, root: string, pairs: readonly (readonly [string, string])[]) {
+  for (const [layer, style] of pairs) for (const n of k.named(root, layer)) k.restyle(n, style)
+}
+
+/** Scale the height of every spacer named `Gap` under `root` by `s`. */
+export function scaleGaps(k: Kit, root: string, s: number) {
+  for (const n of k.named(root, 'Gap')) k.patch(n, { height: Math.max(2, Math.round(k.node(n).height * s)) })
+}
+
+/**
+ * A print size made from the master: the art worked out again at the new size, the padding scaled from the master's
+ * by the ratio of widths, the gaps scaled, and the type restyled.
+ */
+export function printVariant(preset: string, o: { art: (w: number, h: number) => Drawn[]; pad: { top: number; right: number; bottom: number; left: number }; masterWidth: number; styles?: readonly (readonly [string, string])[]; more?: (k: Kit, id: string, s: number) => void }): VariantSpec {
+  return {
+    preset,
+    adjust: (k, id) => {
+      const { width: w, height: h } = k.node(id)
+      const s = w / o.masterWidth
+      redraw(k, id, o.art(w, h))
+      k.patch(id, { padding: { top: Math.round(o.pad.top * s), right: Math.round(o.pad.right * s), bottom: Math.round(o.pad.bottom * s), left: Math.round(o.pad.left * s) } })
+      restyleAll(k, id, o.styles ?? [])
+      scaleGaps(k, id, s)
+      o.more?.(k, id, s)
+    },
+  }
+}
+
+// ── Basic shapes ──
+
+const C = 0.5523
+
+/** A closed ellipse through four points with handles. */
+export function disc(cx: number, cy: number, r: number, ry = r): VectorPath {
+  return { closed: true, points: [
+    { ...pt3(cx, cy - ry), handleIn: pt3(cx - r * C, cy - ry), handleOut: pt3(cx + r * C, cy - ry) },
+    { ...pt3(cx + r, cy), handleIn: pt3(cx + r, cy - ry * C), handleOut: pt3(cx + r, cy + ry * C) },
+    { ...pt3(cx, cy + ry), handleIn: pt3(cx + r * C, cy + ry), handleOut: pt3(cx - r * C, cy + ry) },
+    { ...pt3(cx - r, cy), handleIn: pt3(cx - r, cy + ry * C), handleOut: pt3(cx - r, cy - ry * C) },
+  ] }
+}
+
+/** A rectangle with round corners of radius `r`. */
+export function roundRect(x: number, y: number, w: number, h: number, r: number): VectorPath {
+  r = Math.min(r, w / 2, h / 2)
+  const k = r * (1 - C)
+  return { closed: true, points: [
+    { ...pt3(x + r, y), handleIn: pt3(x + k, y) }, { ...pt3(x + w - r, y), handleOut: pt3(x + w - k, y) },
+    { ...pt3(x + w, y + r), handleIn: pt3(x + w, y + k) }, { ...pt3(x + w, y + h - r), handleOut: pt3(x + w, y + h - k) },
+    { ...pt3(x + w - r, y + h), handleIn: pt3(x + w - k, y + h) }, { ...pt3(x + r, y + h), handleOut: pt3(x + k, y + h) },
+    { ...pt3(x, y + h - r), handleIn: pt3(x, y + h - k) }, { ...pt3(x, y + r), handleOut: pt3(x, y + k) },
+  ] }
+}
+
+/** A plain rectangle. */
+export const rectPath = (x: number, y: number, w: number, h: number): VectorPath => ({ closed: true, points: [pt3(x, y), pt3(x + w, y), pt3(x + w, y + h), pt3(x, y + h)] })
+
+/** A straight stroke. */
+export const seg = (a: P, b: P): VectorPath => ({ closed: false, points: [pt3(a.x, a.y), pt3(b.x, b.y)] })
+
+/** A polygon through `pts`. */
+export const polyP = (pts: P[], closed = true): VectorPath => ({ closed, points: pts.map(p => pt3(p.x, p.y)) })
+
+/** A point at `a` radians and `r` from (cx, cy). */
+const at = (cx: number, cy: number, r: number, a: number): P => ({ x: cx + Math.cos(a) * r, y: cy + Math.sin(a) * r })
+
+/** An open arc of a circle from angle `a0` to `a1`, as a polyline of `n` steps. */
+export function arc(cx: number, cy: number, r: number, a0: number, a1: number, n = 16, ry = r): VectorPath {
+  return { closed: false, points: Array.from({ length: n + 1 }, (_, i) => { const a = a0 + ((a1 - a0) * i) / n; return pt3(cx + Math.cos(a) * r, cy + Math.sin(a) * ry) }) }
+}
+
+/** An n-pointed star (outer radius `R`, inner `r`), its first point up. */
+export function starPath(cx: number, cy: number, R: number, r = R * 0.42, n = 5, turn = 0): VectorPath {
+  return polyP(Array.from({ length: n * 2 }, (_, i) => at(cx, cy, i % 2 ? r : R, -Math.PI / 2 + turn + (i * Math.PI) / n)))
+}
+
+/** A four-pointed sparkle with curved sides. */
+export function sparkle(cx: number, cy: number, s: number, pinch = 0.18): VectorPath {
+  const q = s * pinch
+  const pts: VectorPoint[] = []
+  for (let i = 0; i < 4; i++) {
+    const a = -Math.PI / 2 + (i * Math.PI) / 2
+    const tip = at(cx, cy, s, a)
+    pts.push({ ...pt3(tip.x, tip.y) })
+    const mid = at(cx, cy, q, a + Math.PI / 4)
+    pts.push({ ...pt3(mid.x, mid.y) })
+  }
+  return { closed: true, points: pts }
+}
+
+/** A heart, `s` wide, its point at the bottom, tilted by `turn` radians. */
+export function heart(cx: number, cy: number, s: number, turn = 0): VectorPath {
+  const u = s / 2
+  const raw: [number, number, [number, number]?, [number, number]?][] = [
+    [0, -0.45, [-0.08, -0.85], [0.08, -0.85]],
+    [0.62, -0.78, [0.32, -1.0], [0.95, -0.55]],
+    [0.98, -0.18, [1.02, -0.45], [0.92, 0.18]],
+    [0, 0.95, [0.45, 0.55], [-0.45, 0.55]],
+    [-0.98, -0.18, [-0.92, 0.18], [-1.02, -0.45]],
+    [-0.62, -0.78, [-0.95, -0.55], [-0.32, -1.0]],
+  ]
+  const c = Math.cos(turn), sn = Math.sin(turn)
+  const tr = (x: number, y: number) => pt3(cx + (x * c - y * sn) * u, cy + (x * sn + y * c) * u + u * 0.08)
+  // handleIn is the control before the point, handleOut after (clockwise).
+  return { closed: true, points: raw.map(([x, y, hi, ho]) => ({ ...tr(x, y), ...(hi ? { handleIn: tr(hi[0], hi[1]) } : {}), ...(ho ? { handleOut: tr(ho[0], ho[1]) } : {}) })) }
+}
+
+/** A pointed leaf from `base`, `len` long and `w` wide, pointing at `angle` (radians, 0 = right). */
+export function leaf(base: P, len: number, w: number, angle: number): VectorPath {
+  const c = Math.cos(angle), s = Math.sin(angle)
+  const p = (u: number, v: number) => pt3(base.x + u * c - v * s, base.y + u * s + v * c)
+  return { closed: true, points: [
+    { ...p(0, 0), handleIn: p(len * 0.3, w * 0.62), handleOut: p(len * 0.3, -w * 0.62) },
+    { ...p(len, 0), handleIn: p(len * 0.72, -w * 0.5), handleOut: p(len * 0.72, w * 0.5) },
+  ] }
+}
+
+/** A rounded petal (a teardrop from the centre outwards). */
+export function petal(base: P, len: number, w: number, angle: number): VectorPath {
+  const c = Math.cos(angle), s = Math.sin(angle)
+  const p = (u: number, v: number) => pt3(base.x + u * c - v * s, base.y + u * s + v * c)
+  return { closed: true, points: [
+    { ...p(0, 0), handleIn: p(len * 0.15, w * 0.5), handleOut: p(len * 0.15, -w * 0.5) },
+    { ...p(len, 0), handleIn: p(len * 1.02, -w * 0.62), handleOut: p(len * 1.02, w * 0.62) },
+  ] }
+}
+
+/** A flame (a teardrop pointing up), `w` wide and `h` tall, standing on (cx, cy). */
+export function flame(cx: number, cy: number, w: number, h: number): VectorPath {
+  return { closed: true, points: [
+    { ...pt3(cx, cy - h), handleIn: pt3(cx - w * 0.1, cy - h * 0.7), handleOut: pt3(cx + w * 0.1, cy - h * 0.7) },
+    { ...pt3(cx + w / 2, cy - h * 0.28), handleIn: pt3(cx + w * 0.5, cy - h * 0.5), handleOut: pt3(cx + w * 0.5, cy - h * 0.05) },
+    { ...pt3(cx, cy), handleIn: pt3(cx + w * 0.3, cy), handleOut: pt3(cx - w * 0.3, cy) },
+    { ...pt3(cx - w / 2, cy - h * 0.28), handleIn: pt3(cx - w * 0.5, cy - h * 0.05), handleOut: pt3(cx - w * 0.5, cy - h * 0.5) },
+  ] }
+}
+
+/** A crescent moon, `r` its radius, the bite `bite` (0…1) of it taken from the `side` (1 = bite on the right). */
+export function crescent(cx: number, cy: number, r: number, bite = 0.62, side = 1, turn = 0): VectorPath {
+  // The outer arc, then the inner (a larger circle offset to the side) back along the bite.
+  const d = r * bite, R2 = r * 0.92
+  const pts: P[] = []
+  // Where the two circles cross.
+  const x = (r * r - R2 * R2 + d * d) / (2 * d), y = Math.sqrt(Math.max(0, r * r - x * x))
+  const a0 = Math.atan2(y, x), a1 = Math.atan2(-y, x)
+  for (let i = 0; i <= 28; i++) { const a = a0 + ((a1 + 2 * Math.PI - a0) * i) / 28; pts.push({ x: Math.cos(a) * r, y: Math.sin(a) * r }) }
+  const b0 = Math.atan2(-y, x - d), b1 = Math.atan2(y, x - d)
+  // Back along the inner circle's near side (through its leftmost point, angle π).
+  const span = (b1 > b0 ? b1 - 2 * Math.PI : b1) - b0
+  for (let i = 1; i < 20; i++) { const a = b0 + (span * i) / 20; pts.push({ x: d + Math.cos(a) * R2, y: Math.sin(a) * R2 }) }
+  const c = Math.cos(turn), s = Math.sin(turn)
+  return polyP(pts.map(p => ({ x: cx + side * (p.x * c - p.y * s), y: cy + p.x * s + p.y * c })))
+}
+
+/** Scattered confetti over a `w` × `h` box: little bars and dots, kept off the `keepOut` boxes. */
+export function confetti(w: number, h: number, n: number, seed: number, size = 10, keepOut: readonly { x: number; y: number; w: number; h: number }[] = []): { bars: VectorPath[]; dots: VectorPath[] } {
+  const r = rng(seed), bars: VectorPath[] = [], dots: VectorPath[] = []
+  for (let i = 0, made = 0; made < n && i < n * 8; i++) {
+    const x = r() * w, y = r() * h
+    if (keepOut.some(b => x > b.x && x < b.x + b.w && y > b.y && y < b.y + b.h)) continue
+    made++
+    if (r() < 0.6) {
+      const a = r() * Math.PI, l = size * (0.7 + r() * 0.8), t = size * 0.32
+      const c = Math.cos(a), s = Math.sin(a)
+      const p = (u: number, v: number) => ({ x: x + u * c - v * s, y: y + u * s + v * c })
+      bars.push(polyP([p(-l / 2, -t / 2), p(l / 2, -t / 2), p(l / 2, t / 2), p(-l / 2, t / 2)]))
+    } else dots.push(disc(x, y, size * (0.22 + r() * 0.2)))
+  }
+  return { bars, dots }
+}
+
+/** Specks of grain over a `w` × `h` box (paper fibre, chalk, sparkle dust). */
+export function specks(w: number, h: number, n: number, seed: number, size = 2): VectorPath[] {
+  const r = rng(seed)
+  return Array.from({ length: n }, () => { const x = r() * w, y = r() * h, s = size * (0.5 + r()); return polyP([{ x, y }, { x: x + s, y: y + r() * s * 0.4 }, { x: x + s * 0.5, y: y + s }]) })
+}
+
+/** A box. */
+export interface Rect { x: number; y: number; w: number; h: number }
+
+/**
+ * The bands of a `w` × `h` sheet round a box kept clear for type: above it, below it, and the two margins beside it.
+ * Scatter (snow, confetti, stars) is drawn as one layer per band, so no layer's box lies under the words: the
+ * contrast check reads a layer's whole box as the ground of any text over it.
+ */
+export function bandsAround(w: number, h: number, keep: Rect, bleed = 0): Rect[] {
+  return [
+    { x: -bleed, y: -bleed, w: w + 2 * bleed, h: keep.y + bleed },
+    { x: -bleed, y: keep.y + keep.h, w: w + 2 * bleed, h: h - keep.y - keep.h + bleed },
+    { x: -bleed, y: keep.y, w: keep.x + bleed, h: keep.h },
+    { x: keep.x + keep.w, y: keep.y, w: w - keep.x - keep.w + bleed, h: keep.h },
+  ].filter(b => b.w > 2 && b.h > 2)
+}
+
+/** One part per band: `paths(band, i)` drawn in each, under the same name. */
+export function perBand(name: string, color: string, bands: readonly Rect[], paths: (b: Rect, i: number) => VectorPath[], o?: VectorOpts): Drawn[] {
+  return bands.map((b, i) => ({ name, color, paths: paths(b, i), ...(o ? { o } : {}) }))
+}
+
+/** Specks scattered over one band. */
+export const specksIn = (b: Rect, density: number, seed: number, size = 2) => specks(b.w, b.h, Math.max(1, Math.round((b.w * b.h) / density)), seed, size).map(p => ({ ...p, points: p.points.map(q => pt3(q.x + b.x, q.y + b.y)) }))
+
+/**
+ * A small ornament between two rules (a lozenge, a star, a heart…), as a component: the pack's dividers and
+ * kicker flourishes, so a person restyles every one at once.
+ */
+export function flourishComponent(k: Kit, name: string, role: string, mark: VectorPath, o: { rule?: number; size?: number; gap?: number } = {}) {
+  if (k.hasComponent(name)) return
+  const size = o.size ?? 9
+  k.component(name, { direction: 'HORIZONTAL', width: 'HUG', gap: o.gap ?? 6, align: 'CENTER' }, id => {
+    k.rect(id, o.rule ?? 28, 1, role, { name: 'Rule' })
+    const b = boxTight([mark])
+    k.vector(id, size, size * (b.height / Math.max(1, b.width)), b.paths.map(p => ({ ...p, points: p.points.map(q => scalePt(q, size / Math.max(1, b.width))) })), role, { name: 'Mark' })
+    k.rect(id, o.rule ?? 28, 1, role, { name: 'Rule' })
+  })
+}
+
+const scalePt = (q: VectorPoint, f: number): VectorPoint => ({ ...q, ...pt3(q.x * f, q.y * f), ...(q.handleIn ? { handleIn: pt3(q.handleIn.x * f, q.handleIn.y * f) } : {}), ...(q.handleOut ? { handleOut: pt3(q.handleOut.x * f, q.handleOut.y * f) } : {}) })
+
+// ── Christmas ──
+
+/** A glass bauble hanging from `top`: its body, its cap, the hook and a band across it. */
+export function bauble(cx: number, top: number, r: number, o: { string?: number } = {}): { body: VectorPath[]; cap: VectorPath[]; band: VectorPath[]; shine: VectorPath[]; string: VectorPath[]; shade: VectorPath[] } {
+  const s = o.string ?? 0
+  const cy = top + s + r * 0.28 + r
+  return {
+    string: s > 0 ? [seg({ x: cx, y: top }, { x: cx, y: top + s })] : [],
+    cap: [rectPath(cx - r * 0.2, top + s, r * 0.4, r * 0.3), disc(cx, top + s - r * 0.04, r * 0.09)],
+    body: [disc(cx, cy, r)],
+    band: [arc(cx, cy, r * 0.98, Math.PI * 0.05, Math.PI * 0.95, 14, r * 0.3), arc(cx, cy + r * 0.1, r * 0.99, Math.PI * 0.08, Math.PI * 0.92, 14, r * 0.42)].map(p => ({ ...p })),
+    shine: [leaf({ x: cx - r * 0.62, y: cy - r * 0.05 }, r * 0.55, r * 0.16, -1.25), disc(cx - r * 0.42, cy - r * 0.62, r * 0.07)],
+    shade: [crescent(cx, cy, r, 0.36, -1, -0.75)],
+  }
+}
+
+/** A sprig of pine along a → b → c: a stem and fine needles in two tones. */
+export function pine(a: P, b: P, c: P, o: { needle: number; seed: number; density?: number }): { stem: VectorPath; dark: VectorPath[]; light: VectorPath[] } {
+  const r = rng(o.seed)
+  const n = Math.round(26 * (o.density ?? 1))
+  const pts = Array.from({ length: 13 }, (_, i) => along(a, b, c, i / 12).p)
+  const dark: VectorPath[] = [], light: VectorPath[] = []
+  for (let i = 0; i < n; i++) {
+    const t = 0.04 + (0.94 * i) / n
+    const { p, angle } = along(a, b, c, t)
+    const len = o.needle * (1 - t * 0.45) * (0.85 + r() * 0.3)
+    for (const side of [-1, 1]) {
+      const tilt = angle + side * (0.55 + r() * 0.2)
+      const end = at(p.x, p.y, len, tilt)
+      ;((i + (side > 0 ? 1 : 0)) % 2 ? dark : light).push(seg(p, end))
+    }
+  }
+  return { stem: polyP(pts, false), dark, light }
+}
+
+/** A holly leaf with spines, `len` long, pointing at `angle`. */
+export function holly(base: P, len: number, angle: number): VectorPath {
+  const c = Math.cos(angle), s = Math.sin(angle)
+  const p = (u: number, v: number) => ({ x: base.x + u * c - v * s, y: base.y + u * s + v * c })
+  const w = len * 0.24, pts: P[] = [p(0, 0)]
+  for (let i = 1; i <= 4; i++) { const u = (len * i) / 5; const bulge = Math.sin((Math.PI * i) / 5) * w; pts.push(p(u - len * 0.08, bulge * 0.55), p(u, bulge * 1.05)) }
+  pts.push(p(len, 0))
+  for (let i = 4; i >= 1; i--) { const u = (len * i) / 5; const bulge = Math.sin((Math.PI * i) / 5) * w; pts.push(p(u, -bulge * 1.05), p(u - len * 0.08, -bulge * 0.55)) }
+  return polyP(pts)
+}
+
+/** A six-armed snowflake of strokes, radius `r`. */
+export function snowflake(cx: number, cy: number, r: number, turn = 0): VectorPath[] {
+  const out: VectorPath[] = []
+  for (let i = 0; i < 6; i++) {
+    const a = turn + (i * Math.PI) / 3
+    out.push(seg({ x: cx, y: cy }, at(cx, cy, r, a)))
+    for (const f of [0.45, 0.72]) {
+      const p = at(cx, cy, r * f, a), l = r * (f < 0.6 ? 0.3 : 0.2)
+      out.push(seg(p, at(p.x, p.y, l, a + 0.75)), seg(p, at(p.x, p.y, l, a - 0.75)))
+    }
+  }
+  return out
+}
+
+/** A point and its direction along a quadratic curve a → b → c at `t`. */
+export function along(a: P, b: P, c: P, t: number): { p: P; angle: number } {
+  const u = 1 - t
+  const p = { x: u * u * a.x + 2 * u * t * b.x + t * t * c.x, y: u * u * a.y + 2 * u * t * b.y + t * t * c.y }
+  const d = { x: 2 * u * (b.x - a.x) + 2 * t * (c.x - b.x), y: 2 * u * (b.y - a.y) + 2 * t * (c.y - b.y) }
+  return { p, angle: Math.atan2(d.y, d.x) }
+}
+
+/** A quadratic curve a → b → c as an open polyline of `n` steps. */
+export const quad = (a: P, b: P, c: P, n = 20): VectorPath => polyP(Array.from({ length: n + 1 }, (_, i) => along(a, b, c, i / n).p), false)
+
+/** A sprig of leaves along a → b → c, in two tones, with berries. */
+export function sprig(a: P, b: P, c: P, o: { leaves: number; size: number; seed: number; berries?: number; narrow?: number }): { stem: VectorPath; dark: VectorPath[]; light: VectorPath[]; berries: VectorPath[] } {
+  const r = rng(o.seed)
+  const dark: VectorPath[] = [], light: VectorPath[] = [], berries: VectorPath[] = []
+  for (let i = 0; i < o.leaves; i++) {
+    const t = 0.08 + (0.9 * i) / o.leaves
+    const { p, angle } = along(a, b, c, t)
+    const len = o.size * (1 - t * 0.5) * (0.85 + r() * 0.3), w = len * (o.narrow ?? 0.42)
+    for (const side of [-1, 1]) (side < 0 === (i % 2 === 0) ? dark : light).push(leaf(p, len, w, angle + side * (0.75 + r() * 0.25)))
+  }
+  const tip = along(a, b, c, 1)
+  dark.push(leaf(tip.p, o.size * 0.55, o.size * 0.22, tip.angle))
+  for (let i = 0; i < (o.berries ?? 0); i++) {
+    const { p, angle } = along(a, b, c, 0.2 + r() * 0.65)
+    const off = (r() > 0.5 ? 1 : -1) * o.size * 0.42
+    berries.push(disc(p.x - Math.sin(angle) * off, p.y + Math.cos(angle) * off, o.size * 0.1))
+  }
+  return { stem: quad(a, b, c), dark, light, berries }
+}
+
+// ── Hanukkah ──
+
+/**
+ * A hanukkiah (the Hanukkah menorah) of nine branches standing on `base` (the middle of its foot), `w` wide and `h`
+ * tall to the cups, the shamash in the middle standing higher. Candles stand only for the nights so far, placed
+ * from the right as they are, and every one placed is lit, the shamash too. Returns the stand (strokes), its foot,
+ * the candles, the empty cups and the flames.
+ */
+export function menorah(cx: number, base: number, w: number, h: number, nights = 8): { stand: VectorPath[]; candles: VectorPath[]; flames: VectorPath[]; foot: VectorPath[]; cups: VectorPath[] } {
+  const stand: VectorPath[] = [], candles: VectorPath[] = [], flames: VectorPath[] = [], cups: VectorPath[] = []
+  const cupY = base - h, armBase = base - h * 0.32
+  const step = w / 8
+  stand.push(seg({ x: cx, y: base - h * 0.06 }, { x: cx, y: cupY - h * 0.1 }))
+  for (let i = 1; i <= 4; i++) stand.push(arc(cx, cupY, step * i, 0, Math.PI, 18, armBase - cupY))
+  const foot = [polyP([{ x: cx - w * 0.2, y: base }, { x: cx + w * 0.2, y: base }, { x: cx + w * 0.05, y: base - h * 0.08 }, { x: cx - w * 0.05, y: base - h * 0.08 }])]
+  const cw = step * 0.34, ch = h * 0.3
+  for (let i = -4; i <= 4; i++) {
+    const x = cx + i * step, top = i === 0 ? cupY - h * 0.1 : cupY
+    cups.push(rectPath(x - cw * 0.85, top - h * 0.03, cw * 1.7, h * 0.04))
+    // Night one is the far right (as you face it), then leftwards.
+    const rank = i > 0 ? 4 - i : 3 - i
+    if (i !== 0 && rank >= nights) continue
+    candles.push(rectPath(x - cw / 2, top - h * 0.03 - ch, cw, ch))
+    flames.push(flame(x, top - h * 0.03 - ch - h * 0.015, cw * 1.25, ch * 0.62))
+  }
+  return { stand, candles, flames, foot, cups }
+}
+
+/** A dreidel, `s` tall, tilted by `turn`: its body, its handle and the panel the letter would sit on. */
+export function dreidel(cx: number, cy: number, s: number, turn = 0): { body: VectorPath[]; side: VectorPath[]; handle: VectorPath[] } {
+  const c = Math.cos(turn), sn = Math.sin(turn)
+  const p = (x: number, y: number) => ({ x: cx + (x * c - y * sn) * s, y: cy + (x * sn + y * c) * s })
+  return {
+    handle: [polyP([p(-0.06, -0.62), p(0.06, -0.62), p(0.06, -0.3), p(-0.06, -0.3)])],
+    body: [polyP([p(-0.3, -0.3), p(0.22, -0.3), p(0.22, 0.18), p(0, 0.5), p(-0.3, 0.18)])],
+    side: [polyP([p(0.22, -0.3), p(0.36, -0.36), p(0.36, 0.1), p(0, 0.5), p(0.22, 0.18)])],
+  }
+}
+
+/** A six-pointed star of two interlaced triangles, as outlines. */
+export function starOfDavid(cx: number, cy: number, r: number): VectorPath[] {
+  const tri = (off: number) => polyP([0, 1, 2].map(i => at(cx, cy, r, -Math.PI / 2 + off + (i * 2 * Math.PI) / 3)))
+  return [tri(0), tri(Math.PI / 3)]
+}
+
+/** A gold coin of gelt: a disc and an inner rim. */
+export const gelt = (cx: number, cy: number, r: number) => ({ coin: [disc(cx, cy, r)], rim: [disc(cx, cy, r * 0.78)] })
+
+// ── New Year's Eve ──
+
+/** A firework: `n` rays from `r0` to `r1`, each ending in a spark, and a ring of dots. */
+export function burst(cx: number, cy: number, r1: number, n = 18, seed = 1, r0 = r1 * 0.25): { rays: VectorPath[]; sparks: VectorPath[] } {
+  const r = rng(seed), rays: VectorPath[] = [], sparks: VectorPath[] = []
+  for (let i = 0; i < n; i++) {
+    const a = (i * 2 * Math.PI) / n + (r() - 0.5) * 0.12
+    const len = r1 * (0.82 + r() * 0.18)
+    const p0 = at(cx, cy, r0, a), p1 = at(cx, cy, len, a)
+    // A slight droop, as a spark falls.
+    rays.push({ closed: false, points: [pt3(p0.x, p0.y), { ...pt3(p1.x, p1.y + len * 0.04), handleIn: pt3((p0.x + p1.x) / 2, (p0.y + p1.y) / 2 - len * 0.03) }] })
+    const e = at(cx, cy, len * 1.08, a)
+    sparks.push(disc(e.x, e.y + len * 0.05, r1 * 0.022))
+    if (i % 2 === 0) { const m = at(cx, cy, len * 0.62, a + Math.PI / n); sparks.push(disc(m.x, m.y, r1 * 0.014)) }
+  }
+  return { rays, sparks }
+}
+
+/** A champagne coupe, `s` tall, its foot on (cx, base): the bowl, the stem and foot, and the wine in it. */
+export function coupe(cx: number, base: number, s: number, tilt = 0): { glass: VectorPath[]; wine: VectorPath[] } {
+  const c = Math.cos(tilt), sn = Math.sin(tilt)
+  const p = (x: number, y: number) => pt3(cx + (x * c - y * sn) * s, base + (x * sn + y * c) * s)
+  const bowl: VectorPath = { closed: true, points: [
+    { ...p(-0.42, -0.92) }, { ...p(0.42, -0.92), handleOut: p(0.4, -0.66) },
+    { ...p(0.04, -0.6), handleIn: p(0.22, -0.6) }, { ...p(-0.04, -0.6), handleOut: p(-0.22, -0.6) },
+    { ...p(-0.42, -0.92), handleIn: p(-0.4, -0.66) },
+  ] }
+  return {
+    glass: [bowl, polyP([p(-0.025, -0.6), p(0.025, -0.6), p(0.025, -0.06), p(-0.025, -0.06)].map(q => ({ x: q.x, y: q.y }))), disc(p(0, -0.03).x, p(0, -0.03).y, 0.26 * s, 0.045 * s)],
+    wine: [{ closed: true, points: [{ ...p(-0.36, -0.86) }, { ...p(0.36, -0.86), handleOut: p(0.34, -0.66) }, { ...p(0, -0.63), handleIn: p(0.2, -0.63), handleOut: p(-0.2, -0.63) }, { ...p(-0.36, -0.86), handleIn: p(-0.34, -0.66) }] }],
+  }
+}
+
+/** A curling streamer from `a` across `len`, waving `amp` up and down `waves` times. */
+export function streamer(a: P, len: number, angle: number, amp: number, waves: number): VectorPath {
+  const c = Math.cos(angle), s = Math.sin(angle)
+  const n = Math.round(waves * 10)
+  return polyP(Array.from({ length: n + 1 }, (_, i) => { const u = (len * i) / n, v = Math.sin((i / n) * waves * 2 * Math.PI) * amp; return { x: a.x + u * c - v * s, y: a.y + u * s + v * c } }), false)
+}
+
+/** A clock face: the ring, twelve ticks and two hands at five to midnight. */
+export function clock(cx: number, cy: number, r: number): { ring: VectorPath[]; ticks: VectorPath[]; hands: VectorPath[] } {
+  const ticks = Array.from({ length: 12 }, (_, i) => { const a = (i * Math.PI) / 6; return seg(at(cx, cy, r * (i % 3 ? 0.84 : 0.76), a), at(cx, cy, r * 0.92, a)) })
+  return { ring: [disc(cx, cy, r)], ticks, hands: [seg({ x: cx, y: cy }, at(cx, cy, r * 0.5, -Math.PI / 2 - 0.08)), seg({ x: cx, y: cy }, at(cx, cy, r * 0.74, -Math.PI / 2 - (Math.PI / 6) * 0.5))] }
+}
+
+// ── Valentine's Day ──
+
+/**
+ * A rose from above, `r` across: an outer ring of broad overlapping petals, a middle ring, a tight heart and a
+ * swirl of strokes into the centre. `inner` is the middle ring and the heart together, for a two-tone rose.
+ */
+export function rose(cx: number, cy: number, r: number, seed = 1): { outer: VectorPath[]; inner: VectorPath[]; mid: VectorPath[]; core: VectorPath[]; swirl: VectorPath[] } {
+  const rr = rng(seed)
+  const ring = (n: number, R: number, off: number) => Array.from({ length: n }, (_, i) => {
+    const a = off + (i * 2 * Math.PI) / n + (rr() - 0.5) * 0.25
+    const p = at(cx, cy, R * 0.5, a)
+    return disc(p.x, p.y, R * 0.56, R * 0.5)
+  })
+  const outer = ring(7, r, rr() * 6)
+  const mid = ring(5, r * 0.66, rr() * 6)
+  const core = [disc(cx, cy, r * 0.34)]
+  const swirl = Array.from({ length: 3 }, (_, i) => arc(cx, cy, r * (0.12 + i * 0.09), i * 2.1, i * 2.1 + 3.6, 12))
+  return { outer, inner: [...mid, ...core], mid, core, swirl }
+}
+
+// ── Easter and spring ──
+
+/** An egg, `w` wide and `h` tall, its middle at (cx, cy), tilted by `turn`. */
+export function egg(cx: number, cy: number, w: number, h: number, turn = 0): VectorPath {
+  const c = Math.cos(turn), s = Math.sin(turn)
+  const p = (x: number, y: number) => pt3(cx + (x * c - y * s), cy + (x * s + y * c))
+  const a = w / 2, top = -h * 0.55, bot = h * 0.45
+  return { closed: true, points: [
+    { ...p(0, top), handleIn: p(-a * 0.58, top), handleOut: p(a * 0.58, top) },
+    { ...p(a, h * 0.08), handleIn: p(a, top * 0.55), handleOut: p(a, bot * 0.62) },
+    { ...p(0, bot), handleIn: p(a * 0.56, bot), handleOut: p(-a * 0.56, bot) },
+    { ...p(-a, h * 0.08), handleIn: p(-a, bot * 0.62), handleOut: p(-a, top * 0.55) },
+  ] }
+}
+
+/** The bands painted on an egg: a zigzag and two lines across it, and dots, clipped to the egg's width by eye. */
+export function eggBands(cx: number, cy: number, w: number, h: number, turn = 0, kind: 'zigzag' | 'dots' | 'waves' = 'zigzag'): { lines: VectorPath[]; dots: VectorPath[] } {
+  const c = Math.cos(turn), s = Math.sin(turn)
+  const p = (x: number, y: number) => ({ x: cx + (x * c - y * s), y: cy + (x * s + y * c) })
+  // Half the egg's width at height y (an ellipse-ish profile, wider below the middle).
+  const half = (y: number) => { const t = (y + h * 0.05) / (h * 0.52); return (w / 2) * Math.sqrt(Math.max(0, 1 - t * t)) * 0.96 }
+  const lines: VectorPath[] = [], dots: VectorPath[] = []
+  const band = (y: number) => { const hw = half(y); lines.push(polyP(Array.from({ length: 9 }, (_, i) => p(-hw + (2 * hw * i) / 8, y + Math.sin((i / 8) * Math.PI) * h * 0.035)), false)) }
+  band(-h * 0.12); band(h * 0.14)
+  if (kind === 'zigzag') { const hw = half(0); lines.push(polyP(Array.from({ length: 11 }, (_, i) => p(-hw * 0.92 + (1.84 * hw * i) / 10, (i % 2 ? -1 : 1) * h * 0.06 + h * 0.01)), false)) }
+  if (kind === 'waves') { const hw = half(0); lines.push(polyP(Array.from({ length: 25 }, (_, i) => p(-hw * 0.94 + (1.88 * hw * i) / 24, Math.sin(i * 0.8) * h * 0.045 + h * 0.01)), false)) }
+  if (kind === 'dots') { const hw = half(0); for (let i = 0; i < 5; i++) { const q = p(-hw * 0.7 + (1.4 * hw * i) / 4, h * 0.01); dots.push(disc(q.x, q.y, w * 0.055)) } }
+  for (const y of [-h * 0.33, h * 0.32]) { const hw = half(y) * 0.6; for (let i = 0; i < 3; i++) { const q = p(-hw + hw * i, y); dots.push(disc(q.x, q.y, w * 0.035)) } }
+  return { lines, dots }
+}
+
+/** A tulip on a stem from (x, ground), `h` tall: the cup, the stem and two leaves. */
+export function tulip(x: number, ground: number, h: number, lean = 0): { cup: VectorPath[]; stem: VectorPath[]; leaves: VectorPath[] } {
+  const topX = x + lean * h, topY = ground - h
+  const w = h * 0.2
+  const cup: VectorPath = { closed: true, points: [
+    { ...pt3(topX - w / 2, topY - w * 0.9) }, { ...pt3(topX - w * 0.18, topY - w * 0.45) }, { ...pt3(topX, topY - w * 1.0) },
+    { ...pt3(topX + w * 0.18, topY - w * 0.45) }, { ...pt3(topX + w / 2, topY - w * 0.9), handleOut: pt3(topX + w * 0.62, topY - w * 0.1) },
+    { ...pt3(topX, topY + w * 0.12), handleIn: pt3(topX + w * 0.42, topY + w * 0.12), handleOut: pt3(topX - w * 0.42, topY + w * 0.12) },
+    { ...pt3(topX - w / 2, topY - w * 0.9), handleIn: pt3(topX - w * 0.62, topY - w * 0.1) },
+  ] }
+  return {
+    cup: [cup],
+    stem: [{ closed: false, points: [pt3(x, ground), { ...pt3(topX, topY), handleIn: pt3(x + lean * h * 0.2, ground - h * 0.6) }] }],
+    leaves: [leaf({ x, y: ground }, h * 0.55, h * 0.14, -Math.PI / 2 - 0.35), leaf({ x, y: ground }, h * 0.42, h * 0.12, -Math.PI / 2 + 0.42)],
+  }
+}
+
+/** A tuft of grass blades along the ground from x0 to x1. */
+export function grass(x0: number, x1: number, ground: number, h: number, seed: number, n = 30): VectorPath[] {
+  const r = rng(seed)
+  return Array.from({ length: n }, (_, i) => {
+    const x = x0 + ((x1 - x0) * (i + r() * 0.8)) / n, hh = h * (0.5 + r() * 0.6), lean = (r() - 0.5) * hh * 0.5, w = h * 0.06
+    return { closed: true, points: [pt3(x - w, ground), { ...pt3(x + lean, ground - hh), handleIn: pt3(x - w * 0.5, ground - hh * 0.5) }, { ...pt3(x + w, ground), handleIn: pt3(x + w * 0.4, ground - hh * 0.5) }] }
+  })
+}
+
+/** A sitting rabbit seen from behind and the side, as one silhouette made of discs and ears, `s` tall. */
+export function rabbit(cx: number, ground: number, s: number, facing = 1): { body: VectorPath[]; tail: VectorPath[] } {
+  const f = facing
+  return {
+    body: [
+      disc(cx, ground - s * 0.27, s * 0.3, s * 0.27),
+      disc(cx + f * s * 0.2, ground - s * 0.56, s * 0.15, s * 0.14),
+      leaf({ x: cx + f * s * 0.17, y: ground - s * 0.64 }, s * 0.38, s * 0.12, -Math.PI / 2 - f * 0.25),
+      leaf({ x: cx + f * s * 0.25, y: ground - s * 0.64 }, s * 0.36, s * 0.11, -Math.PI / 2 + f * 0.05),
+      disc(cx + f * s * 0.2, ground - s * 0.04, s * 0.12, s * 0.05),
+    ],
+    tail: [disc(cx - f * s * 0.29, ground - s * 0.16, s * 0.07)],
+  }
+}
+
+// ── Halloween ──
+
+/** A pumpkin, `w` wide and `h` tall, sitting on (cx, ground): its lobes, the creases between, its stem and a curl. */
+export function pumpkin(cx: number, ground: number, w: number, h: number): { lobes: VectorPath[]; creases: VectorPath[]; stem: VectorPath[] } {
+  const cy = ground - h / 2
+  const lobes = [disc(cx - w * 0.27, cy, w * 0.25, h / 2), disc(cx + w * 0.27, cy, w * 0.25, h / 2), disc(cx - w * 0.12, cy, w * 0.24, h / 2 * 1.01), disc(cx + w * 0.12, cy, w * 0.24, h / 2 * 1.01), disc(cx, cy, w * 0.2, h / 2 * 1.02)]
+  const creases = [-0.2, -0.07, 0.07, 0.2].map(f => ({ closed: false, points: [pt3(cx + w * f * 0.7, cy - h * 0.42), { ...pt3(cx + w * f * 0.7, cy + h * 0.42), handleIn: pt3(cx + w * f * 1.35, cy) }] }))
+  const stem: VectorPath = { closed: true, points: [pt3(cx - w * 0.05, cy - h * 0.44), { ...pt3(cx - w * 0.03, cy - h * 0.66), handleIn: pt3(cx - w * 0.06, cy - h * 0.56) }, pt3(cx + w * 0.07, cy - h * 0.7), { ...pt3(cx + w * 0.05, cy - h * 0.44), handleIn: pt3(cx + w * 0.02, cy - h * 0.58) }] }
+  return { lobes, creases, stem: [stem] }
+}
+
+/** A jack-o'-lantern's face cut into a pumpkin `w` wide at (cx, cy): two triangle eyes, a nose and a toothy grin. */
+export function jackFace(cx: number, cy: number, w: number): VectorPath[] {
+  const u = w / 100
+  const tri = (x: number, y: number, s: number, up = true) => polyP(up ? [{ x: cx + (x - s) * u, y: cy + (y + s * 0.7) * u }, { x: cx + (x + s) * u, y: cy + (y + s * 0.7) * u }, { x: cx + x * u, y: cy + (y - s) * u }] : [{ x: cx + (x - s) * u, y: cy + (y - s * 0.6) * u }, { x: cx + (x + s) * u, y: cy + (y - s * 0.6) * u }, { x: cx + x * u, y: cy + (y + s * 0.6) * u }])
+  const mouth = polyP([[-32, 8], [-20, 14], [-14, 9], [-6, 16], [6, 16], [14, 9], [20, 14], [32, 8], [24, 24], [10, 28], [6, 22], [-6, 22], [-10, 28], [-24, 24]].map(([x, y]) => ({ x: cx + x * u, y: cy + y * u })))
+  return [tri(-17, -12, 10), tri(17, -12, 10), tri(0, 0, 5, true), mouth]
+}
+
+/** A bat with scalloped wings, `s` across. */
+export function bat(cx: number, cy: number, s: number, flap = 0): VectorPath {
+  const u = s / 100, f = flap * 10
+  const pts: [number, number][] = [[0, -8], [4, -14], [6, -6], [14, -10 - f], [30, -18 - f], [50, -12 - f], [44, -2], [36, 2], [30, 8], [20, 4], [12, 12], [4, 6], [0, 12]]
+  const full = [...pts, ...pts.slice(1, -1).reverse().map(([x, y]) => [-x, y] as [number, number])]
+  return polyP(full.map(([x, y]) => ({ x: cx + x * u, y: cy + y * u })))
+}
+
+/** A spider's web in a corner: spokes from (cx, cy) between angles a0 and a1, and sagging threads across them. */
+export function web(cx: number, cy: number, r: number, a0: number, a1: number, spokes = 7, rings = 6): VectorPath[] {
+  const out: VectorPath[] = []
+  const angles = Array.from({ length: spokes }, (_, i) => a0 + ((a1 - a0) * i) / (spokes - 1))
+  for (const a of angles) out.push(seg({ x: cx, y: cy }, at(cx, cy, r, a)))
+  for (let j = 1; j <= rings; j++) {
+    const rr = (r * j) / (rings + 0.4)
+    for (let i = 0; i < spokes - 1; i++) {
+      const p0 = at(cx, cy, rr, angles[i]), p1 = at(cx, cy, rr, angles[i + 1]), m = at(cx, cy, rr * 0.86, (angles[i] + angles[i + 1]) / 2)
+      out.push({ closed: false, points: [pt3(p0.x, p0.y), { ...pt3(p1.x, p1.y), handleIn: pt3(m.x, m.y) }] })
+    }
+  }
+  return out
+}
+
+/** A ghost, `s` tall, with a wavy hem: the sheet and its two eyes and mouth. */
+export function ghost(cx: number, top: number, s: number): { sheet: VectorPath[]; face: VectorPath[] } {
+  const w = s * 0.62, bot = top + s
+  const pts: VectorPoint[] = [{ ...pt3(cx - w / 2, bot - s * 0.05), handleOut: pt3(cx - w / 2, top + s * 0.2) }, { ...pt3(cx, top), handleIn: pt3(cx - w / 2, top), handleOut: pt3(cx + w / 2, top) }, { ...pt3(cx + w / 2, bot - s * 0.05), handleIn: pt3(cx + w / 2, top + s * 0.2) }]
+  for (let i = 1; i <= 4; i++) { const x = cx + w / 2 - (w * i) / 4; pts.push({ ...pt3(x, bot - (i % 2 ? 0 : s * 0.08)), handleIn: pt3(x + w / 8, bot + (i % 2 ? s * 0.04 : -s * 0.12)) }) }
+  return { sheet: [{ closed: true, points: pts }], face: [disc(cx - w * 0.16, top + s * 0.32, s * 0.05, s * 0.07), disc(cx + w * 0.16, top + s * 0.32, s * 0.05, s * 0.07), disc(cx, top + s * 0.5, s * 0.06, s * 0.08)] }
+}
+
+/** A piece of candy corn, `s` tall: its three bands. */
+export function candyCorn(cx: number, cy: number, s: number, turn = 0): { base: VectorPath[]; mid: VectorPath[]; tip: VectorPath[] } {
+  const c = Math.cos(turn), sn = Math.sin(turn)
+  const p = (x: number, y: number) => ({ x: cx + (x * c - y * sn) * s, y: cy + (x * sn + y * c) * s })
+  const band = (y0: number, y1: number) => { const w0 = 0.36 * (y0 + 0.5), w1 = 0.36 * (y1 + 0.5); return polyP([p(-w0, y0), p(w0, y0), p(w1, y1), p(-w1, y1)]) }
+  return { tip: [polyP([p(0, -0.5), p(0.12, -0.17), p(-0.12, -0.17)])], mid: [band(-0.17, 0.15)], base: [{ ...band(0.15, 0.48) }] }
+}
+
+// ── Thanksgiving and autumn ──
+
+/** A maple leaf, `s` across, its stem down, turned by `turn`. */
+export function maple(cx: number, cy: number, s: number, turn = 0): VectorPath[] {
+  const u = s / 100, c = Math.cos(turn), sn = Math.sin(turn)
+  const raw: [number, number][] = [[0, -50], [8, -30], [18, -36], [16, -14], [38, -26], [34, -14], [48, -10], [30, 4], [36, 14], [14, 12], [10, 22], [4, 18], [2, 40], [-2, 40], [-4, 18], [-10, 22], [-14, 12], [-36, 14], [-30, 4], [-48, -10], [-34, -14], [-38, -26], [-16, -14], [-18, -36], [-8, -30]]
+  const p = ([x, y]: [number, number]) => ({ x: cx + (x * c - y * sn) * u, y: cy + (x * sn + y * c) * u })
+  return [polyP(raw.map(p))]
+}
+
+/** A maple leaf's veins, to lay over it in a darker tone. */
+export function mapleVeins(cx: number, cy: number, s: number, turn = 0): VectorPath[] {
+  const u = s / 100, c = Math.cos(turn), sn = Math.sin(turn)
+  const p = (x: number, y: number) => ({ x: cx + (x * c - y * sn) * u, y: cy + (x * sn + y * c) * u })
+  return [seg(p(0, 36), p(0, -42)), seg(p(0, 14), p(36, -20)), seg(p(0, 14), p(-36, -20)), seg(p(0, 20), p(28, 10)), seg(p(0, 20), p(-28, 10))]
+}
+
+/** An oak leaf with rounded lobes, `len` long, pointing at `angle`. */
+export function oak(base: P, len: number, angle: number): VectorPath {
+  const c = Math.cos(angle), s = Math.sin(angle)
+  const p = (u: number, v: number) => ({ x: base.x + u * c - v * s, y: base.y + u * s + v * c })
+  const pts: P[] = [p(0, 0)]
+  const lobes = 4
+  for (let i = 0; i < lobes; i++) { const u0 = len * (0.12 + (i * 0.8) / lobes), u1 = u0 + (len * 0.8) / lobes / 2, w = len * 0.26 * (1 - i * 0.12); pts.push(p(u0, w * 0.45), p(u1, w), p(u0 + (len * 0.8) / lobes, w * 0.42)) }
+  pts.push(p(len, 0))
+  for (let i = lobes - 1; i >= 0; i--) { const u0 = len * (0.12 + (i * 0.8) / lobes), u1 = u0 + (len * 0.8) / lobes / 2, w = len * 0.26 * (1 - i * 0.12); pts.push(p(u0 + (len * 0.8) / lobes, -w * 0.42), p(u1, -w), p(u0, -w * 0.45)) }
+  return smoothP(pts, 0.18)
+}
+
+/** A closed curve through `pts`. */
+export function smoothP(pts: P[], tension = 0.2): VectorPath {
+  const n = pts.length
+  return { closed: true, points: pts.map((p, i) => { const a = pts[(i - 1 + n) % n], b = pts[(i + 1) % n], tx = (b.x - a.x) * tension, ty = (b.y - a.y) * tension; return { ...pt3(p.x, p.y), handleIn: pt3(p.x - tx, p.y - ty), handleOut: pt3(p.x + tx, p.y + ty) } }) }
+}
+
+/** A stalk of wheat from (x, ground) up to its ear, `h` tall: the stalk and the grains. */
+export function wheat(x: number, ground: number, h: number, lean = 0): { stalk: VectorPath[]; grains: VectorPath[] } {
+  const top = { x: x + lean * h, y: ground - h }
+  const grains: VectorPath[] = []
+  const angle = Math.atan2(top.y - ground, top.x - x)
+  for (let i = 0; i < 7; i++) {
+    const t = 0.66 + i * 0.05
+    const p = { x: x + (top.x - x) * t, y: ground + (top.y - ground) * t }
+    const len = h * 0.1 * (1 - i * 0.06)
+    grains.push(petal(p, len, len * 0.5, angle - 0.5), petal(p, len, len * 0.5, angle + 0.5))
+  }
+  grains.push(petal(top, h * 0.08, h * 0.04, angle))
+  return { stalk: [{ closed: false, points: [pt3(x, ground), { ...pt3(top.x, top.y), handleIn: pt3(x + lean * h * 0.3, ground - h * 0.5) }] }], grains }
+}
+
+/** An acorn, `s` tall: its nut, its cap and the stalk. */
+export function acorn(cx: number, cy: number, s: number, turn = 0): { nut: VectorPath[]; cap: VectorPath[] } {
+  const c = Math.cos(turn), sn = Math.sin(turn)
+  const tr = (x: number, y: number) => ({ x: cx + (x * c - y * sn) * s, y: cy + (x * sn + y * c) * s })
+  const nut = egg(cx, cy + s * 0.12, s * 0.5, s * 0.66, turn + Math.PI)
+  const cap = smoothP([tr(-0.3, -0.1), tr(-0.28, -0.26), tr(0, -0.34), tr(0.28, -0.26), tr(0.3, -0.1), tr(0, -0.06)], 0.2)
+  return { nut: [nut], cap: [cap, polyP([tr(-0.03, -0.32), tr(0.03, -0.32), tr(0.06, -0.46), tr(0.01, -0.46)])] }
+}
+
+// ── Diwali ──
+
+/** A clay diya, `w` wide, sitting on (cx, ground): its bowl, the painted rim, and the flame with its glow. */
+export function diya(cx: number, ground: number, w: number): { bowl: VectorPath[]; rim: VectorPath[]; flame: VectorPath[]; core: VectorPath[] } {
+  const h = w * 0.36, top = ground - h
+  const bowl: VectorPath = { closed: true, points: [
+    { ...pt3(cx - w / 2, top) }, { ...pt3(cx + w * 0.38, top) }, { ...pt3(cx + w * 0.58, top - h * 0.28) },
+    { ...pt3(cx + w * 0.42, top + h * 0.3), handleOut: pt3(cx + w * 0.3, ground + h * 0.05) },
+    { ...pt3(cx - w * 0.1, ground), handleIn: pt3(cx + w * 0.15, ground + h * 0.02), handleOut: pt3(cx - w * 0.38, ground) },
+    { ...pt3(cx - w / 2, top), handleIn: pt3(cx - w * 0.52, top + h * 0.6) },
+  ] }
+  const rim = [polyP([{ x: cx - w * 0.47, y: top + h * 0.12 }, { x: cx + w * 0.4, y: top + h * 0.12 }, { x: cx + w * 0.37, y: top + h * 0.26 }, { x: cx - w * 0.45, y: top + h * 0.26 }])]
+  const fx = cx + w * 0.5, fy = top - h * 0.22
+  return { bowl: [bowl], rim, flame: [flame(fx, fy, w * 0.2, w * 0.5)], core: [flame(fx, fy - w * 0.02, w * 0.09, w * 0.24)] }
+}
+
+/** A marigold bloom: a ruff of petals in two rings and a dark heart. */
+export function marigold(cx: number, cy: number, r: number, seed = 1): { outer: VectorPath[]; inner: VectorPath[] } {
+  const rr = rng(seed)
+  const ring = (R: number, n: number, off: number) => Array.from({ length: n }, (_, i) => { const a = off + (i * 2 * Math.PI) / n; const p = at(cx, cy, R * (0.92 + rr() * 0.12), a); return disc(p.x, p.y, r * 0.3) })
+  return { outer: ring(r * 0.7, 12, 0), inner: [...ring(r * 0.36, 7, 0.3), disc(cx, cy, r * 0.36)] }
+}
+
+/**
+ * A rangoli: rings of petals, lozenges and dots about (cx, cy), `R` across. Returns its layers from the back, each
+ * for its own colour.
+ */
+export function rangoli(cx: number, cy: number, R: number, petals = 8): { outer: VectorPath[]; middle: VectorPath[]; inner: VectorPath[]; dots: VectorPath[]; heart: VectorPath[] } {
+  const outer: VectorPath[] = [], middle: VectorPath[] = [], inner: VectorPath[] = [], dots: VectorPath[] = []
+  for (let i = 0; i < petals * 2; i++) { const a = (i * Math.PI) / petals; outer.push(petal(at(cx, cy, R * 0.42, a), R * 0.56, R * 0.3, a)) }
+  for (let i = 0; i < petals; i++) { const a = (i * 2 * Math.PI) / petals + Math.PI / petals; middle.push(petal(at(cx, cy, R * 0.18, a), R * 0.5, R * 0.36, a)) }
+  for (let i = 0; i < petals; i++) { const a = (i * 2 * Math.PI) / petals; inner.push(petal({ x: cx, y: cy }, R * 0.36, R * 0.2, a)) }
+  for (let i = 0; i < petals * 4; i++) { const a = (i * Math.PI) / (petals * 2); const p = at(cx, cy, R * 1.04, a); dots.push(disc(p.x, p.y, R * 0.022)) }
+  for (let i = 0; i < petals * 2; i++) { const a = (i * Math.PI) / petals + Math.PI / (petals * 2); const p = at(cx, cy, R * 0.78, a); dots.push(disc(p.x, p.y, R * 0.03)) }
+  return { outer, middle, inner, dots, heart: [disc(cx, cy, R * 0.12)] }
+}
+
+/**
+ * A toran across the top of a `w` wide frame: a string that dips between hooks, marigolds hung from it and pairs of
+ * mango leaves between them.
+ */
+export function toran(x0: number, x1: number, y: number, sag: number, n: number, r: number, seed = 3): { string: VectorPath[]; blooms: { outer: VectorPath[]; inner: VectorPath[] }; leaves: VectorPath[] } {
+  const string: VectorPath[] = [], outer: VectorPath[] = [], inner: VectorPath[] = [], leaves: VectorPath[] = []
+  const span = (x1 - x0) / n
+  for (let i = 0; i < n; i++) {
+    const a = { x: x0 + span * i, y }, b = { x: x0 + span * (i + 1), y }, m = { x: (a.x + b.x) / 2, y: y + sag * 2 }
+    string.push(quad(a, m, b, 12))
+    const lowest = along(a, m, b, 0.5).p
+    const g = marigold(lowest.x, lowest.y + r * 0.6, r, seed + i)
+    outer.push(...g.outer); inner.push(...g.inner)
+    for (const t of [0.25, 0.75]) { const p = along(a, m, b, t).p; leaves.push(leaf(p, r * 2.3, r * 0.75, Math.PI / 2 + (t < 0.5 ? 0.15 : -0.15))) }
+  }
+  return { string, blooms: { outer, inner }, leaves }
+}
+
+// ── Eid ──
+
+/** An eight-pointed star of two squares (the khatam), radius `r`. */
+export function eightStar(cx: number, cy: number, r: number): VectorPath {
+  return starPath(cx, cy, r, r * 0.76, 8, Math.PI / 8)
+}
+
+/**
+ * A hanging lantern (fanous), `s` tall from its ring at (cx, top): the ring and chain, the domed cap, the glass body
+ * with its frame, the glow inside and the foot.
+ */
+export function fanous(cx: number, top: number, s: number): { metal: VectorPath[]; glass: VectorPath[]; frame: VectorPath[]; glow: VectorPath[] } {
+  const u = s / 100
+  const y = (v: number) => top + v * u, x = (v: number) => cx + v * u
+  const metal = [
+    disc(cx, y(3), 3 * u),
+    polyP([{ x: x(-3), y: y(6) }, { x: x(3), y: y(6) }, { x: x(2), y: y(14) }, { x: x(-2), y: y(14) }]),
+    { closed: true, points: [pt3(x(-16), y(26)), { ...pt3(x(0), y(13)), handleIn: pt3(x(-14), y(15)), handleOut: pt3(x(14), y(15)) }, pt3(x(16), y(26))] } as VectorPath,
+    polyP([{ x: x(-20), y: y(26) }, { x: x(20), y: y(26) }, { x: x(18), y: y(30) }, { x: x(-18), y: y(30) }]),
+    polyP([{ x: x(-18), y: y(74) }, { x: x(18), y: y(74) }, { x: x(10), y: y(84) }, { x: x(-10), y: y(84) }]),
+    polyP([{ x: x(-4), y: y(84) }, { x: x(4), y: y(84) }, { x: x(0), y: y(97) }]),
+  ]
+  const glass = [polyP([{ x: x(-17), y: y(30) }, { x: x(17), y: y(30) }, { x: x(22), y: y(52) }, { x: x(17), y: y(74) }, { x: x(-17), y: y(74) }, { x: x(-22), y: y(52) }])]
+  const frame = [seg({ x: x(-6), y: y(30) }, { x: x(-6), y: y(74) }), seg({ x: x(6), y: y(30) }, { x: x(6), y: y(74) }), seg({ x: x(-22), y: y(52) }, { x: x(22), y: y(52) }),
+    { closed: false, points: [pt3(x(-6), y(44)), { ...pt3(x(6), y(44)), handleIn: pt3(x(0), y(36)) }] }, { closed: false, points: [pt3(x(-6), y(66)), { ...pt3(x(6), y(66)), handleIn: pt3(x(0), y(58)) }] }]
+  return { metal, glass, frame, glow: [flame(cx, y(70), 12 * u, 26 * u)] }
+}
+
+/** A pointed (ogee-topped) arch, `w` wide, standing on y = `base` with its springing at `spring` and its tip at `tip`. */
+export function archPath(cx: number, w: number, base: number, spring: number, tip: number): VectorPath {
+  const l = cx - w / 2, r = cx + w / 2
+  return { closed: true, points: [
+    pt3(l, base), { ...pt3(l, spring), handleOut: pt3(l, spring - (spring - tip) * 0.55) },
+    { ...pt3(cx, tip), handleIn: pt3(cx - w * 0.12, tip + (spring - tip) * 0.35), handleOut: pt3(cx + w * 0.12, tip + (spring - tip) * 0.35) },
+    { ...pt3(r, spring), handleIn: pt3(r, spring - (spring - tip) * 0.55) }, pt3(r, base),
+  ] }
+}
+
+/** A field of eight-pointed stars on a grid, with small lozenges between them (a tile pattern), over a `w` × `h` box. */
+export function tilePattern(w: number, h: number, step: number, x0 = 0, y0 = 0): { stars: VectorPath[]; joins: VectorPath[] } {
+  const stars: VectorPath[] = [], joins: VectorPath[] = []
+  for (let y = y0; y < h + step; y += step) for (let x = x0; x < w + step; x += step) {
+    stars.push(eightStar(x, y, step * 0.3))
+    const m = { x: x + step / 2, y: y + step / 2 }
+    joins.push(polyP([{ x: m.x, y: m.y - step * 0.12 }, { x: m.x + step * 0.12, y: m.y }, { x: m.x, y: m.y + step * 0.12 }, { x: m.x - step * 0.12, y: m.y }]))
+  }
+  return { stars, joins }
+}
+
+// ── Lunar New Year ──
+
+/** A round red lantern, `w` wide, hanging from (cx, top): the cord, the caps, the body, its ribs and the tassel. */
+export function redLantern(cx: number, top: number, w: number, cord = 0): { cord: VectorPath[]; caps: VectorPath[]; body: VectorPath[]; ribs: VectorPath[]; tassel: VectorPath[] } {
+  const h = w * 0.82, y0 = top + cord + w * 0.08, cy = y0 + h / 2
+  const ribs: VectorPath[] = []
+  for (const f of [-0.62, -0.3, 0, 0.3, 0.62]) ribs.push({ closed: false, points: [pt3(cx + f * w * 0.32, y0 + h * 0.03), { ...pt3(cx + f * w * 0.32, y0 + h * 0.97), handleIn: pt3(cx + f * w * 0.62, cy) }] })
+  const tTop = y0 + h + w * 0.07
+  return {
+    cord: cord > 0 ? [seg({ x: cx, y: top }, { x: cx, y: top + cord })] : [],
+    caps: [rectPath(cx - w * 0.22, y0 - w * 0.07, w * 0.44, w * 0.1), rectPath(cx - w * 0.22, y0 + h - w * 0.03, w * 0.44, w * 0.1)],
+    body: [disc(cx, cy, w / 2, h / 2)],
+    ribs,
+    tassel: [rectPath(cx - w * 0.04, tTop, w * 0.08, w * 0.06), polyP([{ x: cx - w * 0.06, y: tTop + w * 0.06 }, { x: cx + w * 0.06, y: tTop + w * 0.06 }, { x: cx + w * 0.1, y: tTop + w * 0.42 }, { x: cx - w * 0.1, y: tTop + w * 0.42 }])],
+  }
+}
+
+/** A plum blossom: five round petals and a heart of stamens. */
+export function plum(cx: number, cy: number, r: number, turn = 0): { petals: VectorPath[]; heart: VectorPath[] } {
+  const petals = Array.from({ length: 5 }, (_, i) => { const a = turn + (i * 2 * Math.PI) / 5; const p = at(cx, cy, r * 0.55, a); return disc(p.x, p.y, r * 0.48) })
+  return { petals, heart: [disc(cx, cy, r * 0.22)] }
+}
+
+/** A gnarled branch: a main limb through `pts` with twigs off it. Returns the strokes, thick and thin. */
+export function branch(pts: P[], seed: number, twigs = 5, len = 60): { limb: VectorPath[]; twigs: VectorPath[]; ends: P[] } {
+  const r = rng(seed)
+  const limb = [polyP(pts, false)]
+  const tw: VectorPath[] = [], ends: P[] = [pts[pts.length - 1]]
+  for (let i = 0; i < twigs; i++) {
+    const j = 1 + Math.floor(r() * (pts.length - 2))
+    const a = pts[j - 1], b = pts[j], t = r()
+    const p = { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t }
+    const dir = Math.atan2(b.y - a.y, b.x - a.x) + (r() > 0.5 ? 1 : -1) * (0.5 + r() * 0.5)
+    const l = len * (0.5 + r() * 0.6)
+    const e = at(p.x, p.y, l, dir), m = at(p.x, p.y, l * 0.5, dir + 0.2)
+    tw.push(polyP([p, m, e], false))
+    ends.push(e, m)
+  }
+  return { limb, twigs: tw, ends }
+}
+
+/** An auspicious cloud (xiangyun): three curls on a flat tail, as one stroke, `s` wide. */
+export function cloudCurl(x: number, y: number, s: number, flip = 1): VectorPath[] {
+  const u = s / 100
+  const curl = (cx: number, cy: number, r: number, dir: number) => polyP(Array.from({ length: 22 }, (_, i) => { const t = i / 21; const a = dir * (Math.PI * 0.2 + t * Math.PI * 1.9); const rr = r * (1 - t * 0.6); return { x: x + flip * (cx + Math.cos(a + Math.PI) * rr) * u, y: y + (cy + Math.sin(a + Math.PI) * rr) * u } }), false)
+  return [curl(30, 0, 22, 1), curl(62, -4, 18, -1), curl(48, -20, 14, 1), polyP([{ x: x + flip * 8 * u, y: y + 22 * u }, { x: x + flip * 96 * u, y: y + 22 * u }], false)]
+}
+
+/** A cash coin: a disc with a square hole (drawn as a square in the ground's colour on top). */
+export function coin(cx: number, cy: number, r: number): { coin: VectorPath[]; hole: VectorPath[]; rim: VectorPath[] } {
+  return { coin: [disc(cx, cy, r)], rim: [disc(cx, cy, r * 0.82)], hole: [rectPath(cx - r * 0.24, cy - r * 0.24, r * 0.48, r * 0.48)] }
+}
+
+/** A string of firecrackers hanging from (cx, top): the cord and `n` crackers in pairs. */
+export function firecrackers(cx: number, top: number, n: number, s: number): { cord: VectorPath[]; crackers: VectorPath[]; tips: VectorPath[] } {
+  const crackers: VectorPath[] = [], tips: VectorPath[] = []
+  for (let i = 0; i < n; i++) {
+    const y = top + s * 0.5 + i * s * 0.55, side = i % 2 ? 1 : -1
+    const c = Math.cos(side * 0.5), sn = Math.sin(side * 0.5)
+    const p = (u: number, v: number) => ({ x: cx + u * c - v * sn, y: y + u * sn + v * c })
+    crackers.push(polyP([p(0, -s * 0.1), p(side * s * 0.6, -s * 0.1), p(side * s * 0.6, s * 0.1), p(0, s * 0.1)]))
+    tips.push(polyP([p(side * s * 0.6, -s * 0.1), p(side * s * 0.68, -s * 0.1), p(side * s * 0.68, s * 0.1), p(side * s * 0.6, s * 0.1)]))
+  }
+  return { cord: [seg({ x: cx, y: top }, { x: cx, y: top + s * 0.5 + n * s * 0.55 })], crackers, tips }
+}
+
+// ── Print helpers ──
+
+/** A border of short dashes round a `w` × `h` box at inset `m` (a stitch, a cut line). */
+export function dashedFrame(w: number, h: number, m: number, r = 0): VectorPath[] {
+  return [r > 0 ? roundRect(m, m, w - 2 * m, h - 2 * m, r) : rectPath(m, m, w - 2 * m, h - 2 * m)]
+}
+
+/** Two fine rules, one inside the other, round a `w` × `h` box at insets `m` and `m + gap`. */
+export function doubleRule(w: number, h: number, m: number, gap: number, r = 0): VectorPath[] {
+  return [r ? roundRect(m, m, w - 2 * m, h - 2 * m, r) : rectPath(m, m, w - 2 * m, h - 2 * m), r ? roundRect(m + gap, m + gap, w - 2 * (m + gap), h - 2 * (m + gap), Math.max(0, r - gap)) : rectPath(m + gap, m + gap, w - 2 * (m + gap), h - 2 * (m + gap))]
+}
+
+/** A seeded maze of `cols` × `rows` cells at (x, y), `cell` px each, with an entrance top left and an exit bottom right. */
+export function maze(x: number, y: number, cols: number, rows: number, cell: number, seed: number): VectorPath[] {
+  const r = rng(seed)
+  // Walls: right[c][r] and bottom[c][r] true while standing.
+  const right = Array.from({ length: cols }, () => Array<boolean>(rows).fill(true))
+  const bottom = Array.from({ length: cols }, () => Array<boolean>(rows).fill(true))
+  const seen = Array.from({ length: cols }, () => Array<boolean>(rows).fill(false))
+  const stack: [number, number][] = [[0, 0]]
+  seen[0][0] = true
+  while (stack.length) {
+    const [c, w] = stack[stack.length - 1]
+    const next = ([[1, 0], [-1, 0], [0, 1], [0, -1]] as const).map(([dc, dr]) => [c + dc, w + dr] as [number, number]).filter(([a, b]) => a >= 0 && b >= 0 && a < cols && b < rows && !seen[a][b])
+    if (!next.length) { stack.pop(); continue }
+    const [a, b] = next[Math.floor(r() * next.length)]
+    if (a > c) right[c][w] = false; else if (a < c) right[a][b] = false; else if (b > w) bottom[c][w] = false; else bottom[a][b] = false
+    seen[a][b] = true
+    stack.push([a, b])
+  }
+  const out: VectorPath[] = []
+  // The outer walls, with the gaps.
+  out.push(seg({ x: x + cell, y }, { x: x + cols * cell, y }), seg({ x, y }, { x, y: y + rows * cell }))
+  out.push(seg({ x, y: y + rows * cell }, { x: x + (cols - 1) * cell, y: y + rows * cell }), seg({ x: x + cols * cell, y }, { x: x + cols * cell, y: y + rows * cell }))
+  for (let c = 0; c < cols; c++) for (let w = 0; w < rows; w++) {
+    if (right[c][w] && c < cols - 1) out.push(seg({ x: x + (c + 1) * cell, y: y + w * cell }, { x: x + (c + 1) * cell, y: y + (w + 1) * cell }))
+    if (bottom[c][w] && w < rows - 1) out.push(seg({ x: x + c * cell, y: y + (w + 1) * cell }, { x: x + (c + 1) * cell, y: y + (w + 1) * cell }))
+  }
+  return out
+}
+
+/** A word-search grid: the `words` hidden across, down and diagonally in a `n` × `n` grid, the rest filled at random. */
+export function wordSearch(words: readonly string[], n: number, seed: number): string[] {
+  const r = rng(seed)
+  const g: string[][] = Array.from({ length: n }, () => Array<string>(n).fill(''))
+  const dirs = [[1, 0], [0, 1], [1, 1], [1, -1]] as const
+  for (const word of words) {
+    const w = word.toUpperCase().replace(/[^A-Z]/g, '')
+    for (let tries = 0; tries < 400; tries++) {
+      const [dx, dy] = dirs[Math.floor(r() * dirs.length)]
+      const x = Math.floor(r() * n), y = Math.floor(r() * n)
+      const ex = x + dx * (w.length - 1), ey = y + dy * (w.length - 1)
+      if (ex < 0 || ex >= n || ey < 0 || ey >= n) continue
+      if ([...w].some((ch, i) => { const c = g[y + dy * i][x + dx * i]; return c && c !== ch })) continue
+      ;[...w].forEach((ch, i) => { g[y + dy * i][x + dx * i] = ch })
+      break
+    }
+  }
+  const A = 'ABCDEFGHIJKLMNOPRSTUWY'
+  return g.map(row => row.map(c => c || A[Math.floor(r() * A.length)]).join(' '))
+}
+
+export { r3, rng, pt3, type P }