@diagrammo/dgmo 0.49.0 → 0.50.0

package/dist/countdown.js

@@ -0,0 +1,450 @@
+// src/countdown/resolve.ts
+var DAY_MS = 864e5;
+var WEEK_MS = 7 * DAY_MS;
+function ordinalWord(n) {
+  const abs = Math.abs(n);
+  const tens = abs % 100;
+  let suffix = "th";
+  if (tens < 11 || tens > 13) {
+    const ones = abs % 10;
+    suffix = ones === 1 ? "st" : ones === 2 ? "nd" : ones === 3 ? "rd" : "th";
+  }
+  return `${n}${suffix}`;
+}
+function applyOrdinalTemplate(template, n) {
+  return template.replace(/\bNth\b/g, ordinalWord(n)).replace(/\bN\b/g, String(n));
+}
+function dayStart(ms) {
+  const d = new Date(ms);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+function nthWeekdayOfMonth(year, month, weekday, nth, hour, minute) {
+  if (nth < 0) {
+    const last = new Date(year, month + 1, 0).getDate();
+    for (let d = last; d >= 1; d--) {
+      if (new Date(year, month, d).getDay() === weekday) {
+        return new Date(year, month, d, hour, minute).getTime();
+      }
+    }
+    return null;
+  }
+  const firstDow = new Date(year, month, 1).getDay();
+  const offset = (weekday - firstDow + 7) % 7;
+  const day = 1 + offset + (nth - 1) * 7;
+  if (day > new Date(year, month + 1, 0).getDate()) return null;
+  return new Date(year, month, day, hour, minute).getTime();
+}
+function resolveNext(rule, now) {
+  const nowD = new Date(now);
+  const { hour, minute } = rule;
+  const passes = rule.allDay ? (t) => dayStart(t) >= dayStart(now) : (t) => t > now;
+  const dayExists = (y, m, d) => new Date(y, m, d).getMonth() === m;
+  switch (rule.kind) {
+    case "month-day": {
+      const month = rule.month;
+      const day = rule.day;
+      for (let y = nowD.getFullYear(); ; y++) {
+        if (!dayExists(y, month, day)) continue;
+        const t = new Date(y, month, day, hour, minute).getTime();
+        if (passes(t)) return t;
+      }
+    }
+    case "nth-weekday":
+    case "last-weekday": {
+      const weekday = rule.weekday;
+      const nth = rule.kind === "last-weekday" ? -1 : rule.nth;
+      let y = nowD.getFullYear();
+      let m = nowD.getMonth();
+      for (let i = 0; i < 24; i++) {
+        const t = nthWeekdayOfMonth(y, m, weekday, nth, hour, minute);
+        if (t !== null && passes(t)) return t;
+        m++;
+        if (m > 11) {
+          m = 0;
+          y++;
+        }
+      }
+      return now + WEEK_MS;
+    }
+    case "weekly": {
+      const weekday = rule.weekday;
+      for (let i = 0; i < 8; i++) {
+        const d = new Date(
+          nowD.getFullYear(),
+          nowD.getMonth(),
+          nowD.getDate() + i,
+          hour,
+          minute
+        );
+        if (d.getDay() === weekday && passes(d.getTime())) return d.getTime();
+      }
+      return now + WEEK_MS;
+    }
+    case "interval": {
+      const n = rule.intervalN ?? 1;
+      const anchor = rule.anchorMs ?? now;
+      if (rule.intervalUnit === "month") {
+        const a = new Date(anchor);
+        const day = a.getDate();
+        for (let k = 0; ; k++) {
+          const y = a.getFullYear();
+          const m = a.getMonth() + k * n;
+          const yy = y + Math.floor(m / 12);
+          const mm = (m % 12 + 12) % 12;
+          if (!dayExists(yy, mm, day)) continue;
+          const t2 = new Date(yy, mm, day, hour, minute).getTime();
+          if (passes(t2)) return t2;
+        }
+      }
+      const step = (rule.intervalUnit === "week" ? WEEK_MS : DAY_MS) * n;
+      let t = anchor;
+      if (!passes(t)) {
+        const k = Math.max(0, Math.floor((now - anchor) / step));
+        t = anchor + k * step;
+        while (!passes(t)) t += step;
+      }
+      return t;
+    }
+  }
+}
+function ordinalFor(resolvedMs, since) {
+  return new Date(resolvedMs).getFullYear() - since;
+}
+function roundBy(value, mode) {
+  return mode === "down" ? Math.floor(value) : mode === "nearest" ? Math.round(value) : Math.ceil(value);
+}
+function pad2(n) {
+  return n < 10 ? "0" + n : String(n);
+}
+function plural(n, unit) {
+  return `${n} ${unit}${n === 1 ? "" : "s"}`;
+}
+function formatCount(remainingMs, opts) {
+  const { units, round, fields } = opts;
+  if (units === "days")
+    return plural(roundBy(remainingMs / DAY_MS, round), "day");
+  if (units === "weeks")
+    return plural(roundBy(remainingMs / WEEK_MS, round), "week");
+  const totalSec = Math.floor(remainingMs / 1e3);
+  if (units === "clock") {
+    const h2 = Math.floor(totalSec / 3600);
+    const m2 = Math.floor(totalSec % 3600 / 60);
+    const s2 = totalSec % 60;
+    return `${pad2(h2)}:${pad2(m2)}:${pad2(s2)}`;
+  }
+  if (units === "words") {
+    const days2 = Math.ceil(remainingMs / DAY_MS);
+    if (days2 <= 0) return "now";
+    if (days2 === 1) return "tomorrow";
+    if (days2 < 14) return `${days2} days`;
+    if (days2 < 60) return `${Math.round(days2 / 7)} weeks`;
+    return `${Math.round(days2 / 30)} months`;
+  }
+  const days = Math.floor(totalSec / 86400);
+  const h = Math.floor(totalSec % 86400 / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  const has = (f) => fields.includes(f);
+  const clockParts = [];
+  if (has("h")) clockParts.push(pad2(h));
+  if (has("m")) clockParts.push(pad2(m));
+  if (has("s")) clockParts.push(pad2(s));
+  const clock = clockParts.join(":");
+  const dayPrefix = has("d") && days > 0 ? `${days}d${clock ? " " : ""}` : "";
+  return dayPrefix + clock || plural(days, "day");
+}
+function formatWordsDetail(remainingMs) {
+  const totalMin = Math.floor(Math.max(0, remainingMs) / 6e4);
+  const d = Math.floor(totalMin / 1440);
+  const h = Math.floor(totalMin % 1440 / 60);
+  const m = totalMin % 60;
+  const parts = [];
+  if (d > 0) parts.push(`${d} day${d === 1 ? "" : "s"}`);
+  if (d > 0 || h > 0) parts.push(`${h} hour${h === 1 ? "" : "s"}`);
+  parts.push(`${m} minute${m === 1 ? "" : "s"}`);
+  return parts.join(" ");
+}
+function breakdown(nowMs, targetMs) {
+  const n = new Date(nowMs);
+  const t = new Date(targetMs);
+  let y = t.getFullYear() - n.getFullYear();
+  let mo = t.getMonth() - n.getMonth();
+  let d = t.getDate() - n.getDate();
+  let h = t.getHours() - n.getHours();
+  let mi = t.getMinutes() - n.getMinutes();
+  let s = t.getSeconds() - n.getSeconds();
+  if (s < 0) {
+    s += 60;
+    mi--;
+  }
+  if (mi < 0) {
+    mi += 60;
+    h--;
+  }
+  if (h < 0) {
+    h += 24;
+    d--;
+  }
+  if (d < 0) {
+    d += new Date(t.getFullYear(), t.getMonth(), 0).getDate();
+    mo--;
+  }
+  if (mo < 0) {
+    mo += 12;
+    y--;
+  }
+  return { years: y, months: mo, days: d, hours: h, minutes: mi, seconds: s };
+}
+function humanUnits(nowMs, targetMs) {
+  const b = breakdown(nowMs, targetMs);
+  return [
+    [b.years, "year"],
+    [b.months, "month"],
+    [b.days, "day"],
+    [b.hours, "hour"],
+    [b.minutes, "minute"]
+  ];
+}
+function formatHuman(nowMs, targetMs) {
+  const units = humanUnits(nowMs, targetMs);
+  let i = 0;
+  while (i < units.length - 1 && units[i][0] === 0) i++;
+  const rest = units.slice(i);
+  const say = (arr) => arr.map(([n, u]) => `${n} ${u}${n === 1 ? "" : "s"}`).join(", ");
+  const primary = rest.slice(0, 2).filter((p, idx) => p[0] > 0 || idx === 0);
+  const secondary = rest.slice(2).filter((p) => p[0] > 0);
+  return { big: say(primary) || "now", sub: say(secondary) };
+}
+function formatCompound(nowMs, targetMs, maxUnits = 2) {
+  const all = humanUnits(nowMs, targetMs);
+  let i = 0;
+  while (i < all.length - 1 && all[i][0] === 0) i++;
+  const chosen = all.slice(i, i + maxUnits).filter((p, idx) => p[0] > 0 || idx === 0);
+  if (!chosen.length) return "now";
+  return chosen.map(([n, u]) => `${n} ${u}${n === 1 ? "" : "s"}`).join(", ");
+}
+var WEEKDAY_ABBR = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTH_ABBR = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function formatDate(ms) {
+  const d = new Date(ms);
+  return `${WEEKDAY_ABBR[d.getDay()]} ${MONTH_ABBR[d.getMonth()]} ${d.getDate()} ${d.getFullYear()}`;
+}
+function formatFooter(resolvedMs, hasTime) {
+  const parts = [formatDate(resolvedMs)];
+  if (hasTime) {
+    const d = new Date(resolvedMs);
+    parts.push(`${pad2(d.getHours())}:${pad2(d.getMinutes())}`);
+  }
+  return parts.join(" \xB7 ");
+}
+
+// src/countdown/ticker.ts
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+function dayStartLocal(ms) {
+  const d = new Date(ms);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+function dayDeltaLocal(aMs, bMs) {
+  const a = new Date(aMs);
+  const b = new Date(bMs);
+  const a0 = new Date(a.getFullYear(), a.getMonth(), a.getDate()).getTime();
+  const b0 = new Date(b.getFullYear(), b.getMonth(), b.getDate()).getTime();
+  return Math.round((b0 - a0) / DAY_MS);
+}
+function pad22(n) {
+  return n < 10 ? "0" + n : String(n);
+}
+function polar(cx, cy, r, deg) {
+  const a = (deg - 90) * Math.PI / 180;
+  return [cx + r * Math.cos(a), cy + r * Math.sin(a)];
+}
+function arcPath(cx, cy, r, frac) {
+  frac = Math.max(0, Math.min(0.9999, frac));
+  const [x0, y0] = polar(cx, cy, r, 0);
+  const [x1, y1] = polar(cx, cy, r, frac * 360);
+  return `M ${x0} ${y0} A ${r} ${r} 0 ${frac > 0.5 ? 1 : 0} 1 ${x1} ${y1}`;
+}
+function updateGauges(svg, remaining) {
+  const rem = Math.abs(remaining);
+  const vals = {
+    h: Math.floor(rem / 36e5),
+    m: Math.floor(rem % 36e5 / 6e4),
+    s: Math.floor(rem % 6e4 / 1e3)
+  };
+  const fracs = {
+    h: vals["h"] % 24 / 24,
+    m: vals["m"] / 60,
+    s: vals["s"] / 60
+  };
+  svg.querySelectorAll("[data-dgmo-gauge-val]").forEach((el) => {
+    const k = el.getAttribute("data-dgmo-gauge-val");
+    const v = pad22(vals[k] ?? 0);
+    if (el.textContent !== v) el.textContent = v;
+  });
+  svg.querySelectorAll("[data-dgmo-gauge-arc]").forEach((el) => {
+    const k = el.getAttribute("data-dgmo-gauge-arc");
+    const cx = Number(el.getAttribute("data-cx"));
+    const cy = Number(el.getAttribute("data-cy"));
+    const r = Number(el.getAttribute("data-r"));
+    const f = fracs[k] ?? 0;
+    el.setAttribute("d", f > 1e-3 ? arcPath(cx, cy, r, f) : "");
+  });
+  const cap = svg.querySelector("[data-dgmo-gauge-caption]");
+  if (cap) {
+    const t = remaining >= 0 ? "TO GO" : "AGO";
+    if (cap.textContent !== t) cap.textContent = t;
+  }
+}
+function targetToMs(target) {
+  const s = target.trim();
+  if (DATE_ONLY_RE.test(s)) {
+    const p = s.split("-").map(Number);
+    return new Date(p[0], p[1] - 1, p[2]).getTime();
+  }
+  const t = new Date(s).getTime();
+  return Number.isFinite(t) ? t : null;
+}
+function readRule(node) {
+  const kind = node.getAttribute("data-dgmo-recur-kind");
+  if (!kind) return null;
+  const num = (name) => {
+    const v = node.getAttribute(name);
+    return v === null ? void 0 : Number(v);
+  };
+  return {
+    kind,
+    month: num("data-dgmo-recur-month"),
+    day: num("data-dgmo-recur-day"),
+    nth: num("data-dgmo-recur-nth"),
+    weekday: num("data-dgmo-recur-weekday"),
+    hour: num("data-dgmo-recur-hour") ?? 0,
+    minute: num("data-dgmo-recur-minute") ?? 0,
+    allDay: node.getAttribute("data-dgmo-recur-allday") !== "0",
+    intervalN: num("data-dgmo-recur-interval-n"),
+    intervalUnit: node.getAttribute("data-dgmo-recur-interval-unit") ?? void 0,
+    anchorMs: num("data-dgmo-recur-anchor")
+  };
+}
+function sameLocalDay(a, b) {
+  const x = new Date(a);
+  const y = new Date(b);
+  return x.getFullYear() === y.getFullYear() && x.getMonth() === y.getMonth() && x.getDate() === y.getDate();
+}
+function readFields(node) {
+  const raw = node.getAttribute("data-dgmo-countdown-fields");
+  if (!raw) return ["d", "h", "m", "s"];
+  return raw.split(",").filter((f) => ["d", "h", "m", "s"].includes(f));
+}
+function updateNode(node, now) {
+  const rule = readRule(node);
+  const units = node.getAttribute("data-dgmo-countdown-units") || "days";
+  const round = node.getAttribute("data-dgmo-countdown-round") || "up";
+  const fields = readFields(node);
+  const onDay = node.getAttribute("data-dgmo-countdown-onday");
+  const title = node.getAttribute("data-dgmo-countdown-title");
+  let resolvedMs;
+  let expiredNow = false;
+  if (rule) {
+    resolvedMs = resolveNext(rule, now);
+  } else {
+    const target = node.getAttribute("data-dgmo-countdown");
+    resolvedMs = target ? targetToMs(target) : null;
+    if (resolvedMs !== null && resolvedMs - now <= 0) expiredNow = true;
+  }
+  if (resolvedMs === null) return;
+  const remaining = resolvedMs - now;
+  const sinceAttr = node.getAttribute("data-dgmo-countdown-since");
+  const custom = node.getAttribute("data-dgmo-countdown-expired");
+  const hasTime = node.getAttribute("data-dgmo-countdown-hastime") === "1";
+  const frozen = expiredNow && custom !== null;
+  const clockFinale = hasTime && !frozen && dayDeltaLocal(now, resolvedMs) <= 0;
+  let text;
+  if (frozen) {
+    text = custom;
+  } else if (clockFinale) {
+    const clock = formatCount(Math.abs(remaining), {
+      units: "clock",
+      round,
+      fields
+    });
+    text = remaining < 0 ? `${clock} ago` : clock;
+  } else if (expiredNow) {
+    if (units === "compound" || units === "human")
+      text = `${formatCompound(resolvedMs, now)} ago`;
+    else {
+      const elapsed = -remaining;
+      text = elapsed <= 0 ? "Now!" : `${formatCount(elapsed, { units, round, fields })} ago`;
+    }
+  } else if (rule && sameLocalDay(resolvedMs, now)) {
+    text = onDay ?? "Today!";
+  } else if (units === "human") {
+    text = hasTime ? formatHuman(now, resolvedMs).big : formatHuman(dayStartLocal(now), dayStartLocal(resolvedMs)).big;
+  } else if (units === "compound") {
+    text = formatCompound(now, resolvedMs);
+  } else {
+    text = formatCount(Math.max(0, remaining), { units, round, fields });
+  }
+  if (node.textContent !== text) node.textContent = text;
+  node.setAttribute(
+    "aria-label",
+    title ? `${title}: ${text}` : expiredNow ? text : `${text} remaining`
+  );
+  const svg = node.ownerSVGElement ?? node.closest("svg");
+  if (!svg) return;
+  const footer = svg.querySelector("[data-dgmo-countdown-footer]");
+  if (footer && !expiredNow) {
+    const hasTime2 = node.getAttribute("data-dgmo-countdown-hastime") === "1";
+    footer.textContent = formatFooter(resolvedMs, hasTime2);
+  }
+  const eyebrowEl = svg.querySelector("[data-dgmo-countdown-eyebrow]");
+  if (eyebrowEl && sinceAttr) {
+    const tpl = node.getAttribute("data-dgmo-countdown-since-label") || "Nth";
+    eyebrowEl.textContent = applyOrdinalTemplate(
+      tpl,
+      ordinalFor(resolvedMs, Number(sinceAttr))
+    );
+  }
+  const detail = svg.querySelector("[data-dgmo-countdown-detail]");
+  if (detail && !expiredNow && !clockFinale) {
+    if (units === "words") {
+      detail.textContent = formatWordsDetail(Math.max(0, remaining));
+    } else if (units === "human" && remaining > 0) {
+      detail.textContent = hasTime ? formatCount(remaining, { units: "clock", round, fields }) : formatHuman(dayStartLocal(now), dayStartLocal(resolvedMs)).sub;
+    }
+  }
+  if (clockFinale) updateGauges(svg, remaining);
+  const stamp = svg.querySelector("[data-dgmo-countdown-asof]");
+  if (stamp && stamp.parentNode) stamp.parentNode.removeChild(stamp);
+}
+function tickCountdowns(root = document) {
+  if (typeof document === "undefined") return;
+  const now = Date.now();
+  root.querySelectorAll("[data-dgmo-countdown]").forEach((node) => updateNode(node, now));
+}
+var intervalStarted = false;
+function startCountdowns(root = document) {
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  tickCountdowns(root);
+  if (intervalStarted) return;
+  intervalStarted = true;
+  window.setInterval(() => tickCountdowns(document), 1e3);
+}
+export {
+  DAY_MS,
+  startCountdowns,
+  tickCountdowns
+};
+//# sourceMappingURL=countdown.js.map

package/dist/dgmo-router-QOMFCOOV.js

@@ -0,0 +1,84 @@
+import {
+  CHART_TYPE_DESCRIPTIONS,
+  chartTypeParsers,
+  getAllChartTypes,
+  getRenderCategory,
+  isExtendedChartType,
+  knownChartTypeIds,
+  looksLikeC4,
+  looksLikeGantt,
+  parseDgmo,
+  parseDgmoChartType
+} from "./chunk-JFYIP7XU.js";
+import "./chunk-Q4V4XQWV.js";
+import "./chunk-BTUTZMPT.js";
+import "./chunk-YNRDWYZP.js";
+import "./chunk-3XPUDB7B.js";
+import "./chunk-FL4IOQ37.js";
+import "./chunk-PGEGPSCZ.js";
+import "./chunk-DMJJ3CEQ.js";
+import "./chunk-BDXC7MDK.js";
+import "./chunk-XDXNDSKO.js";
+import "./chunk-OHQEMBLI.js";
+import "./chunk-TSA237IM.js";
+import "./chunk-6IAA2QQ2.js";
+import "./chunk-YZLMKW4T.js";
+import "./chunk-3P2DKJCG.js";
+import "./chunk-3LKM6FMW.js";
+import "./chunk-OTP5KVLO.js";
+import "./chunk-YB3FW24O.js";
+import "./chunk-NNAAJVBU.js";
+import "./chunk-XMVQ5F4M.js";
+import "./chunk-UXOSVCLJ.js";
+import "./chunk-FB2WHOEQ.js";
+import "./chunk-U2HGPLZS.js";
+import "./chunk-SU2VBK4L.js";
+import "./chunk-5JSWBPZZ.js";
+import "./chunk-XHVV4NVW.js";
+import "./chunk-WWN566I7.js";
+import "./chunk-O4VUFXIH.js";
+import "./chunk-QQJUTGQH.js";
+import "./chunk-S5GRONXL.js";
+import "./chunk-2JJ2KNPI.js";
+import "./chunk-O76UD6VJ.js";
+import "./chunk-A3WQVFBS.js";
+import "./chunk-6M5PJFQG.js";
+import "./chunk-L3UHP6TD.js";
+import "./chunk-USZW2HHU.js";
+import "./chunk-7G2ER4CY.js";
+import "./chunk-I7F2A35O.js";
+import "./chunk-6BFZKBGD.js";
+import "./chunk-I4IFRCUB.js";
+import "./chunk-URSQLCTR.js";
+import "./chunk-IYULMRBE.js";
+import "./chunk-R3XI2VC7.js";
+import "./chunk-P6T66CCZ.js";
+import "./chunk-T4BRO3Z6.js";
+import "./chunk-C3Z4DX3V.js";
+import "./chunk-WCUHAQKB.js";
+import "./chunk-GBE54KY6.js";
+import "./chunk-I46X5VUA.js";
+import "./chunk-2C56LEML.js";
+import "./chunk-NXMESY4J.js";
+import "./chunk-GL5UZ6NY.js";
+import "./chunk-SCHXJTZL.js";
+import "./chunk-FMDSF3OV.js";
+import "./chunk-FFUN5D66.js";
+import "./chunk-NOTA6TEI.js";
+import "./chunk-OTAL43EH.js";
+import "./chunk-TLVIHFRO.js";
+import "./chunk-CXK4DZH3.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  CHART_TYPE_DESCRIPTIONS,
+  chartTypeParsers,
+  getAllChartTypes,
+  getRenderCategory,
+  isExtendedChartType,
+  knownChartTypeIds,
+  looksLikeC4,
+  looksLikeGantt,
+  parseDgmo,
+  parseDgmoChartType
+};
+//# sourceMappingURL=dgmo-router-QOMFCOOV.js.map

package/dist/{dimensions-WSIJXT5Q.js → dimensions-P5FSX2QN.js}

@@ -1,8 +1,8 @@
 import {
   mapContentAspect,
   mapExportDimensions
-} from "./chunk-UWDO3O52.js";
-import "./chunk-YM2BSPYW.js";
+} from "./chunk-JZNMXEIV.js";
+import "./chunk-X2NMFTG3.js";
 import "./chunk-I5IGB56C.js";
 import "./chunk-HGN652MU.js";
 import "./chunk-7UEMZREK.js";
@@ -10,8 +10,8 @@ import "./chunk-A4GOY3PE.js";
 import "./chunk-HQCHYB5F.js";
 import "./chunk-5LWQH6QV.js";
 import "./chunk-P6T66CCZ.js";
-import "./chunk-HBVD67XG.js";
-import "./chunk-ZNQX6QWH.js";
+import "./chunk-WCUHAQKB.js";
+import "./chunk-OTAL43EH.js";
 import "./chunk-TLVIHFRO.js";
 import "./chunk-CXK4DZH3.js";
 import "./chunk-5WRI5ZAA.js";
@@ -19,4 +19,4 @@ export {
   mapContentAspect,
   mapExportDimensions
 };
-//# sourceMappingURL=dimensions-WSIJXT5Q.js.map
+//# sourceMappingURL=dimensions-P5FSX2QN.js.map

package/dist/editor.js

@@ -139,6 +139,17 @@ var DIRECTIVES_REGISTRY = [
   { token: "import", category: "directive" },
   { token: "hide", category: "directive" },
   { token: "direction", category: "directive" },
+  // ── Clock ────────────────────────────────────────────────
+  // The board's flat directives — highlight-only (the parser validates them
+  // inline, no extractable Set). `no-title` + `direction` are already listed
+  // above (shared). Values (analog is a bare flag; color-by's
+  // place|work|daylight|time|none) highlight as plain tokens.
+  { token: "analog", category: "directive" },
+  { token: "hours", category: "directive" },
+  { token: "days", category: "directive" },
+  { token: "no-sun", category: "directive" },
+  { token: "time-24", category: "directive" },
+  { token: "color-by", category: "directive" },
   // ── Boxes-and-lines ──────────────────────────────────────
   // `heat <Label> [low] [high]` is the value→colour ramp directive, but `heat`
   // is NOT registered as a directive keyword: it is dual-use with the `heat:`
@@ -231,6 +242,17 @@ var DIRECTIVES_REGISTRY = [
   { token: "scrubber-trials", category: "directive" },
   { token: "start-date", category: "directive" },
   { token: "end-date", category: "directive" },
+  // ── Goal ─────────────────────────────────────────────────
+  // Mode flags, value-key leaders, and opt-outs. `now`/`target` collide with
+  // label prose ("start now", "on target"), but the arrow-label demotion pass
+  // (see highlight-api LABEL_WORD_NODES) treats any keyword-bearing label as
+  // text and demotes them, so they highlight only as line leaders.
+  { token: "thermometer", category: "directive" },
+  { token: "gauge", category: "directive" },
+  { token: "now", category: "directive" },
+  { token: "target", category: "directive" },
+  { token: "no-note", category: "directive" },
+  { token: "no-auto-color", category: "directive" },
   // ── Control-flow + wireframe element keywords (CONTROL) ──
   { token: "if", category: "control" },
   { token: "else", category: "control" },
@@ -272,7 +294,19 @@ var DIRECTIVES_REGISTRY = [
   { token: "date", category: "modifier" },
   { token: "timestamp", category: "modifier" },
   { token: "float", category: "modifier" },
-  { token: "decimal", category: "modifier" }
+  { token: "decimal", category: "modifier" },
+  // ── Bracket ──────────────────────────────────────────────
+  // `beats` / `vs` are the infix match keywords; the rest are line directives.
+  // (`seed` and `no-legend` already appear above — shared, not re-listed.)
+  { token: "beats", category: "control" },
+  { token: "vs", category: "control" },
+  { token: "rounds", category: "directive" },
+  { token: "accent", category: "directive" },
+  { token: "no-round", category: "modifier" },
+  { token: "no-rounds", category: "modifier" },
+  { token: "single-elim", category: "modifier" },
+  { token: "double-elim", category: "modifier" },
+  { token: "seeded", category: "modifier" }
 ];
 function tokensWhere(pred) {
   const out = /* @__PURE__ */ new Set();
@@ -325,6 +359,7 @@ var CHART_TYPES = /* @__PURE__ */ new Set([
   "c4",
   "state",
   "sitemap",
+  "bracket",
   "infra",
   "gantt",
   "pert",
@@ -339,6 +374,9 @@ var CHART_TYPES = /* @__PURE__ */ new Set([
   "ring",
   "treemap",
   "block",
+  "goal",
+  "countdown",
+  "clock",
   "sketch",
   "raci",
   "cycle",