@diagrammo/dgmo 0.51.0 → 0.53.0

package/dist/state-renderer-TFEUOP4H.js

@@ -0,0 +1,38 @@
+import {
+  renderState,
+  renderStateForExport
+} from "./chunk-AHXIMHDQ.js";
+import "./chunk-PDKUANDZ.js";
+import "./chunk-3B2GXZCX.js";
+import "./chunk-LP7EC4MI.js";
+import "./chunk-3IUHKMJI.js";
+import "./chunk-6EK55ART.js";
+import "./chunk-UU6LUYUH.js";
+import "./chunk-5DH3KYFH.js";
+import "./chunk-3HDBAXF5.js";
+import "./chunk-BMR4CIEO.js";
+import "./chunk-3CIOJ5YJ.js";
+import "./chunk-YYVTBZZC.js";
+import "./chunk-W5KMNC5U.js";
+import "./chunk-774C2FF3.js";
+import "./chunk-A4GOY3PE.js";
+import "./chunk-6KFWC4CO.js";
+import "./chunk-AN2DQB3G.js";
+import "./chunk-JYDMBWRP.js";
+import "./chunk-4RGZFA7H.js";
+import "./chunk-4ASYQ347.js";
+import "./chunk-CMVZWP32.js";
+import "./chunk-NXMESY4J.js";
+import "./chunk-ZXUAPTCK.js";
+import "./chunk-QZAW5SFH.js";
+import "./chunk-WF64MW5G.js";
+import "./chunk-NOTA6TEI.js";
+import "./chunk-YJVA3QUU.js";
+import "./chunk-ZKPPI6BF.js";
+import "./chunk-4W2PE66Q.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  renderState,
+  renderStateForExport
+};
+//# sourceMappingURL=state-renderer-TFEUOP4H.js.map

package/dist/{themes-32xj5ZTW.d.ts → themes-tbBkIVsn.d.ts}

@@ -1,184 +1,4 @@
-type DgmoSeverity = 'error' | 'warning';
-interface DgmoError {
-    line: number;
-    column?: number;
-    message: string;
-    severity: DgmoSeverity;
-    /**
-     * Optional stable diagnostic code (e.g. 'E_ARROW_SUBSTRING_IN_LABEL').
-     * Additive; pre-existing diagnostics omit this field and existing
-     * substring-on-`.message` assertions keep working unchanged.
-     */
-    code?: string;
-}
-declare function makeDgmoError(line: number, message: string, severity?: DgmoSeverity, code?: string): DgmoError;
-/** Runtime params passed to `emit()` and forwarded to a message builder. */
-type DiagnosticParams = Record<string, unknown>;
-/**
- * Parameter type for a `DiagnosticSpec.message` builder body. Typed loosely
- * (`any`) on purpose: builders are hand-authored interpolation bags keyed by
- * ad-hoc names, and dgmo's tsconfig enables `noPropertyAccessFromIndexSignature`
- * (which forbids `p.name` dot-access on a `Record<string, unknown>`). Using
- * `any` here keeps builder bodies readable (`p.name`) instead of forcing
- * `p['name']` bracket access at every interpolation site.
- */
-type DiagnosticMessageParams = any;
-interface DiagnosticSpec {
-    /** Stable diagnostic code, e.g. `'E_MAP_UNKNOWN_PLACE'`. */
-    code: string;
-    /** Severity — must agree with the `E_`/`W_`/`I_` code prefix. */
-    severity: DgmoSeverity;
-    /** Owning chart type (`'map'`, `'swimlane'`, …) or `null` for universal/global codes. */
-    chartType: string | null;
-    /** Short human label for the catalog UI. */
-    title: string;
-    /**
-     * Canonical message wording. A plain string for static messages, or a
-     * builder `(params) => string` when the message interpolates runtime
-     * values. The builder must tolerate being called with `{}` so the
-     * catalog can show a representative message without live params.
-     */
-    message: string | ((params: DiagnosticMessageParams) => string);
-    /** Optional fix guidance shown alongside the message. */
-    hint?: string;
-    /** Minimal `.dgmo` source that triggers this diagnostic (for docs/console). */
-    example?: string;
-}
-/** Optional extras when emitting (currently just an explicit column). */
-interface EmitOptions {
-    column?: number;
-}
-/**
- * Emit a diagnostic from its `DiagnosticSpec`. The code, severity, and
- * canonical wording all come from the spec — call sites supply only the
- * line and the interpolation params, so the code/severity can never drift
- * out of sync with the declared spec. Replaces the per-parser
- * `push`/`err`/`fail` wrappers that each re-declared this shape.
- */
-declare function emit(spec: DiagnosticSpec, line: number, params?: DiagnosticParams, opts?: EmitOptions): DgmoError;
-declare function formatDgmoError(err: DgmoError): string;
-
-/**
- * Color definitions for a single mode (light or dark).
- * 10 semantic UI colors + 9 named accent colors = 19 total.
- *
- * `readonly` on every field (and the nested `colors` map) by design —
- * palettes flow from the registry into every renderer; nothing in the
- * pipeline should ever mutate a palette in place.
- */
-interface PaletteColors {
-    /** Main background (#eceff4 light / #2e3440 dark for Nord) */
-    readonly bg: string;
-    /** Cards, panels (#e5e9f0 / #3b4252) */
-    readonly surface: string;
-    /** Popovers, dropdowns (#e5e9f0 / #434c5e) */
-    readonly overlay: string;
-    /** Borders, dividers, muted (#d8dee9 / #4c566a) */
-    readonly border: string;
-    /** Primary text (#2e3440 / #eceff4) */
-    readonly text: string;
-    /** Secondary/diminished text (#4c566a / #d8dee9) */
-    readonly textMuted: string;
-    /**
-     * Light-mode arg for `contrastText()` when text is rendered on a
-     * tinted shape fill (e.g. `shapeFill()` output). Must guarantee
-     * ≥ 4.5:1 WCAG AA against any `shapeFill()` the palette can produce.
-     * Distinct from `colors.white` because palette-aesthetic anchors don't
-     * always meet contrast requirements (TD-5).
-     */
-    readonly textOnFillLight: string;
-    /** Dark-mode counterpart to `textOnFillLight`. */
-    readonly textOnFillDark: string;
-    /** Primary accent — buttons, links */
-    readonly primary: string;
-    /** Secondary accent */
-    readonly secondary: string;
-    /** Tertiary accent */
-    readonly accent: string;
-    /** Error/danger */
-    readonly destructive: string;
-    /**
-     * Used for: inline annotations (red), pie charts, cScale,
-     * series rotation, journey actors, Gantt tasks.
-     */
-    readonly colors: {
-        readonly red: string;
-        readonly orange: string;
-        readonly yellow: string;
-        readonly green: string;
-        readonly blue: string;
-        readonly purple: string;
-        readonly teal: string;
-        readonly cyan: string;
-        readonly gray: string;
-        readonly black: string;
-        readonly white: string;
-    };
-}
-/**
- * Complete palette definition. One object per color scheme.
- * This is what palette authors create — the single artifact for NFR1.
- *
- * Palettes are immutable from the consumer's perspective; the registry
- * hands out the same frozen-shape object on every `getPalette(id)`.
- */
-interface PaletteConfig {
-    /** Registry key: 'nord', 'slate', 'catppuccin' */
-    readonly id: string;
-    /** Display name: 'Nord', 'Slate', 'Catppuccin' */
-    readonly name: string;
-    /** Light mode color definitions */
-    readonly light: PaletteColors;
-    /** Dark mode color definitions */
-    readonly dark: PaletteColors;
-}
-
-/** A single entry inside a tag group: `Value color` */
-interface TagEntry {
-    readonly value: string;
-    readonly color: string;
-    /**
-     * The color NAME the author wrote (one of the recognized palette names),
-     * when the entry declared an explicit color. Absent for bare/auto-colored
-     * entries. `color` above is always the RESOLVED hex (auto and explicit are
-     * indistinguishable there); this preserves the authored-vs-auto distinction
-     * so a GUI editor can round-trip an explicit color through a reparse.
-     */
-    readonly authoredColor?: string;
-    readonly lineNumber: number;
-}
-/**
- * A tag group block: heading + entries.
- *
- * Parser internals build via `Writable<TagGroup>` from `utils/brand.ts`;
- * once returned to a chart-type parser, consumers see the readonly view.
- */
-interface TagGroup {
-    readonly name: string;
-    readonly alias?: string;
-    readonly entries: readonly TagEntry[];
-    /** Default value for nodes without explicit metadata. First entry unless another is marked `default`. */
-    readonly defaultValue?: string;
-    readonly lineNumber: number;
-}
-/**
- * DOM-safe key for a tag group — used wherever the group name becomes a
- * `data-tag-*` attribute suffix, an entity metadata key, or an `active-tag`
- * match target. For a single-identifier name (the only form the parser used to
- * accept) this is exactly `name.toLowerCase()`, so swapping it in for existing
- * diagrams is byte-identical. A quoted multi-word name (`tag "Trust Zone" as tz`)
- * slugs to a hyphenated identifier (`trust-zone`) so it never produces an
- * invalid DOM attribute name; the original `name` is kept for the legend label.
- */
-declare function tagAttrKey(name: string): string;
-/**
- * The categorical name cycle used to auto-assign colors to bare tag values,
- * in deterministic order. Aliased to the shared {@link CATEGORICAL_COLOR_ORDER}
- * (RGB-seeded, max-contrast, neutrals excluded) so tag swatches and data-chart
- * series colors share one canonical rotation. If a group has more colorless
- * entries than free categorical names, the cycle wraps.
- */
-declare const autoTagColorCycle: readonly string[];
+import { T as TagGroup, D as DgmoError, P as PaletteConfig } from './registry-CaSw0PSH.js';
 
 /** A POI / route-stop position: gazetteer name (+ optional ISO scope) or coords. */
 type PoiPos = {
@@ -638,173 +458,6 @@ interface ResolvedMap {
     readonly error: string | null;
 }
 
-/**
- * Compact view state schema (ADR-6).
- * All fields optional. Only non-default values are encoded.
- * `tag: null` means "user chose none"; absent `tag` means "use DSL default" (ADR-5).
- */
-interface CompactViewState {
-    tag?: string | null;
-    cs?: number[];
-    cg?: string[];
-    swim?: string | null;
-    cl?: string[];
-    cc?: string[];
-    rm?: string;
-    htv?: Record<string, string[]>;
-    ha?: string[];
-    sem?: boolean;
-    cm?: boolean;
-    c4l?: string;
-    c4s?: string;
-    c4c?: string;
-    rps?: number;
-    spd?: number;
-    io?: Record<string, number>;
-    hd?: boolean;
-    cbd?: boolean;
-    rq?: string;
-    an?: boolean;
-    fl?: boolean;
-}
-interface DecodedDiagramUrl {
-    dsl: string;
-    viewState: CompactViewState;
-    palette?: string;
-    theme?: 'light' | 'dark';
-    filename?: string;
-}
-interface EncodeDiagramUrlOptions {
-    baseUrl?: string;
-    viewState?: CompactViewState;
-    palette?: string;
-    theme?: 'light' | 'dark';
-    filename?: string;
-}
-type EncodeDiagramUrlResult = {
-    url: string;
-    error?: undefined;
-} | {
-    url?: undefined;
-    error: 'too-large';
-    compressedSize: number;
-    limit: number;
-};
-/**
- * Encode a CompactViewState to a compressed string for URL embedding.
- * Returns empty string if state has no keys (ADR-4).
- */
-declare function encodeViewState(state: CompactViewState): string;
-/**
- * Decode a compressed view state string back to CompactViewState.
- * Returns empty object on failure (no crash).
- */
-declare function decodeViewState(encoded: string): CompactViewState;
-/**
- * Compress a DGMO DSL string into a shareable URL.
- * Returns `{ url }` on success, or `{ error: 'too-large', compressedSize, limit }` if the
- * compressed payload exceeds the 8 KB limit.
- */
-declare function encodeDiagramUrl(dsl: string, options?: EncodeDiagramUrlOptions): EncodeDiagramUrlResult;
-/**
- * Decode a DGMO DSL string and view state from a URL query string or hash.
- * Accepts any of:
- *   - `?dgmo=<payload>&vs=<state>`
- *   - `#dgmo=<payload>&vs=<state>` (backwards compat)
- *   - `dgmo=<payload>`
- *   - `<bare payload>`
- *
- * Returns `{ dsl, viewState }`. The DSL is empty string on invalid input.
- */
-declare function decodeDiagramUrl(hash: string): DecodedDiagramUrl;
-
-interface ChartTypeMeta {
-    readonly id: string;
-    readonly description: string;
-    readonly fallback?: true;
-}
-declare const chartTypes: readonly ChartTypeMeta[];
-
-/** User-visible rendering category for dispatch and routing. */
-type RenderCategory = 'data-chart' | 'visualization' | 'diagram';
-
-/**
- * Extracts the chart type from raw file content.
- * First tries the first non-empty, non-comment line as a bare chart type name
- * (e.g., `gantt Product Launch`).
- * Falls back to inference when no explicit chart type is found.
- */
-declare function parseDgmoChartType(content: string): string | null;
-
-/**
- * Returns the render category for a given chart type, or `null` if unknown.
- * Use this instead of the internal framework map for dispatch in consumers.
- */
-declare function getRenderCategory(chartType: string): RenderCategory | null;
-/**
- * Returns true if the chart type is an extended chart type
- * handled by parseExtendedChart (scatter, sankey, function, heatmap, funnel).
- * Returns false for standard chart types and all other types.
- */
-declare function isExtendedChartType(chartType: string): boolean;
-/**
- * Returns all supported chart type identifiers in canonical (tier) order,
- * derived from `chartTypes`. Consumers that need alphabetical order should
- * call `.sort()` explicitly.
- */
-declare function getAllChartTypes(): string[];
-/**
- * Canonical descriptions for every supported chart type. Derived from
- * `chartTypes` so there is exactly one place to update when adding a new
- * type. Consumed by the CLI `dgmo types` command, the editor autocomplete
- * popup, and the MCP `list_chart_types` tool.
- */
-declare const CHART_TYPE_DESCRIPTIONS: Record<string, string>;
-type ParseResult = {
-    diagnostics: readonly DgmoError[];
-};
-type ParseFn = (content: string) => ParseResult;
-/**
- * Maps every chart-type id to the parser that handles it, DERIVED from
- * `CHART_TYPE_REGISTRY` (src/chart-type-registry.ts). Adding a new chart type
- * means adding ONE descriptor there plus its `chartTypes` metadata entry; the
- * `chart-type-registry.test.ts` cross-check asserts the registry, `chartTypes`,
- * the render-category sites, and the export handlers all stay in sync.
- */
-declare const chartTypeParsers: ReadonlyArray<readonly [string, ParseFn]>;
-/** Ids in the same order as `chartTypeParsers`; used for cross-checks. */
-declare const knownChartTypeIds: readonly string[];
-/**
- * Parse DGMO content and return diagnostics without rendering.
- * Useful for the CLI and editor to surface all errors before attempting render.
- */
-declare function parseDgmo(content: string): {
-    diagnostics: DgmoError[];
-    chartType: string | null;
-};
-
-/** Validate that a hex string is well-formed (#RGB or #RRGGBB). */
-declare function isValidHex(value: string): boolean;
-/**
- * Register a palette. Called at module initialization.
- * Validates that all 19 color fields per mode are present and valid hex.
- * Throws on malformed palettes to catch errors at startup, not at render time.
- */
-declare function registerPalette(palette: PaletteConfig): void;
-/** Get palette by id. Silently returns the default palette if id is unrecognized. */
-declare function getPalette(id: string): PaletteConfig;
-/**
- * Resolve a palette by id, falling back to the default palette when the id is
- * unregistered. If a `warn` callback is supplied, it is invoked once with a
- * human-readable fallback message on a miss — the single place the "resolve,
- * fall back, warn" policy lives, so each host can surface it its own way
- * (console.warn, Obsidian Notice, MCP response). Silent when the id resolves or
- * when no callback is passed.
- */
-declare function resolvePaletteOrFallback(id: string, warn?: (message: string) => void): PaletteConfig;
-/** List all registered palettes alphabetically (for the selector UI). */
-declare function getAvailablePalettes(): PaletteConfig[];
-
 /**
  * All built-in palettes, keyed by camelCase id. Use directly with render():
  *
@@ -940,4 +593,4 @@ declare const themes: {
     readonly transparent: "transparent";
 };
 
-export { getRenderCategory as $, type AirportData as A, type BoundaryTopology as B, type CompactViewState as C, type DgmoError as D, type EncodeDiagramUrlOptions as E, type ResolvedPoi as F, type GeoExtent as G, type ResolvedRegion as H, type ResolvedRoute as I, type Theme as J, autoTagColorCycle as K, chartTypeParsers as L, type MapData as M, chartTypes as N, completeMapPlaces as O, type PaletteColors as P, completeMapRegions as Q, type ResolvedMap as R, decodeDiagramUrl as S, type TagGroup as T, decodeViewState as U, encodeDiagramUrl as V, encodeViewState as W, formatDgmoError as X, getAllChartTypes as Y, getAvailablePalettes as Z, getPalette as _, type PaletteConfig as a, isExtendedChartType as a0, isValidHex as a1, knownChartTypeIds as a2, makeDgmoError as a3, palettes as a4, parseDgmo as a5, parseDgmoChartType as a6, registerPalette as a7, searchMapLocations as a8, tagAttrKey as a9, themes as aa, type DiagnosticSpec as ab, type DiagnosticParams as ac, type EmitOptions as ad, emit as ae, resolvePaletteOrFallback as af, type TagEntry as b, type ParsedMap as c, type MapLayoutLegend as d, CHART_TYPE_DESCRIPTIONS as e, type ChartTypeMeta as f, type DecodedDiagramUrl as g, type DgmoSeverity as h, type EncodeDiagramUrlResult as i, type Gazetteer as j, type GazetteerEntry as k, type MapCompletionOptions as l, type MapDirectives as m, type MapEdge as n, type MapLocationMatch as o, type MapPlaceCompletion as p, type MapPoi as q, type MapRegion as r, type MapRegionCompletion as s, type MapRoute as t, type PoiPos as u, type ProjectionFamily as v, type RegionName as w, type RegionNames as x, type RenderCategory as y, type ResolvedEdge as z };
+export { type AirportData as A, type BoundaryTopology as B, type Gazetteer as G, type MapCompletionOptions as M, type ParsedMap as P, type RegionName as R, type Theme as T, type GazetteerEntry as a, type MapData as b, type MapLocationMatch as c, type MapPlaceCompletion as d, type MapRegionCompletion as e, type RegionNames as f, completeMapPlaces as g, completeMapRegions as h, type ResolvedMap as i, type MapLayoutLegend as j, type GeoExtent as k, type MapDirectives as l, type MapEdge as m, type MapPoi as n, type MapRegion as o, palettes as p, type MapRoute as q, type PoiPos as r, searchMapLocations as s, themes as t, type ProjectionFamily as u, type ResolvedEdge as v, type ResolvedPoi as w, type ResolvedRegion as x, type ResolvedRoute as y };

package/docs/ai-integration.md

@@ -68,7 +68,7 @@ _Generated from `language-reference.md` — the anti-patterns and 50-type index
 LLMs default to Mermaid / PlantUML habits; DGMO differs. These rules prevent the most common parse errors:
 
 - **No colons in declarations, directives, tags, or data rows.** `bar Revenue` (not `bar: Revenue`); `series Cloud blue, Legacy red` (not `series: ...`); `North 850` (not `North: 850`); `tag Team as t` (not `tag: Team`). A colon binds a value only in metadata (`key: value`), class/function type separators, and a few scoped spots — see §26.
-- **No Mermaid arrow-labels.** Put the label *between* the dashes: `A -Login-> B`, never `A -> B: Login`. Sequence: `->` sync, `~>` async; left-to-right only — no `<-` / `<~`.
+- **No Mermaid arrow-labels.** Put the label _between_ the dashes: `A -Login-> B`, never `A -> B: Login`. Sequence: `->` sync, `~>` async; left-to-right only — no `<-` / `<~`.
 - **No indented edges on a map.** Every map connection is ONE full line — `JFK ~daily~> LAX`; for a hub repeat the origin per spoke (`JFK ~daily~> LHR`, …). A bare source with indented `-> dest` legs errors as `Malformed edge`; indented legs are valid ONLY inside a `route` block (an ordered stop→stop voyage). Edge endpoints auto-create their POIs — don't add separate `poi` lines for places already in an edge.
 - **No `|` metadata delimiter** (removed 0.18.0 → `E_PIPE_OPERATOR_REMOVED`). Use same-line `Name key: value, k2: v2` or indented `key: value`. (`|` survives only in wireframe `{A | B}` dropdowns, in-arrow label text, and quoted names.)
 - **No removed participant keywords.** Do not write `X is a service` / `external` / `frontend` / `networking` / `gateway` — these were removed and error. A bare name renders the default shape; for a typed glyph use `is a person` / `is a database` / `is a queue`.
@@ -80,7 +80,7 @@ LLMs default to Mermaid / PlantUML habits; DGMO differs. These rules prevent the
 - **Declare before reference.** An edge target must be declared on a prior line; put metadata and edges on/under one declaration to avoid `Duplicate node` warnings.
 - **No reference scaffolding in output.** Emit only DGMO source. This doc is organized with HTML-comment anchors (the `TYPE`, `TIPS`, and `AI-CORE` markers, each wrapped in comment delimiters); never copy any such `<!-- … -->` comment into a diagram. They mark sections of the docs, not DGMO syntax; the parser flags a stray HTML comment as an `Unexpected line` warning. (DGMO's only comment form is `//`.)
 
-Two traps in the *other* direction (DGMO wants a colon / a space where you might not expect):
+Two traps in the _other_ direction (DGMO wants a colon / a space where you might not expect):
 
 - **Infra node properties REQUIRE the colon** — `cache-hit: 80%`, `instances: 3`, `max-rps: 8000`, `latency-ms: 45`. But top-level infra **options** are space-separated (`default-rps 100`). Don't conflate them.
 - **ER columns are space-separated** — `id int pk`, `email varchar` (the one SQL-DDL carve-out; everything else indented-typed uses a colon).
@@ -106,10 +106,11 @@ Billing t: Product
 Valid markup is the floor, not the goal. A good diagram reads at a glance. Apply these unless the prompt says otherwise:
 
 <!-- TITLE start -->
+
 - **Always title it.** Every diagram gets a short title on the type-declaration line (`flowchart Checkout Flow`, `sequence Checkout`, `boxes-and-lines Service Map`) so it is self-describing — never leave the bare type keyword alone. Infer a fitting title from the request when the user gives none.
-<!-- TITLE end -->
-<!-- CATEGORIZE start -->
-- **Categorize and color — by default, not only when obvious.** Before drawing, find the axis that sorts the items into kinds and color by it: layer (frontend / backend / data), role (client / service / datastore), trust zone (internal / external / third-party), status (done / active / blocked), owner/team, or read-path vs write-path. Almost every diagram has such an axis — actively look for one rather than leaving everything monochrome. Express it with a **tag group**, never ad-hoc per-node colors: declare `tag <Axis> as t` (the name is a single word — `tag TrustZone as tz` — or quote a multi-word name: `tag "Trust Zone" as tz`), indent the category values (a trailing color is optional — bare values auto-pick a palette color), set `active-tag <Axis>`, then assign each item `Node t: <Category>` (see the tag-group syntax in the per-type section below). Only the 11 named palette colors exist, and they re-resolve per palette/theme. Color the grouping so the categories — and the boundaries between them — read at a glance. **Buckets, not name tags — never 1:1.** A tag group must have *fewer* values than it has members: each color should bucket two or more items so the palette compresses the diagram into a few meaningful kinds (aim for ~2–4 categories, and keep distinct colors well under half the item count). If you find yourself giving nearly every item its own value, you've enumerated, not categorized — merge the singletons up a level until each color groups at least two (a `cache` and a `database` are both `datastore`; a caller and a gateway are both `client`; two microservices are both `service`). One color per item is the same visual noise as random colors — the grouping only earns its place when a color means "these belong together." Leave items uncolored only when they genuinely form a single undifferentiated kind, or the user asked for no color.
+  <!-- TITLE end -->
+  <!-- CATEGORIZE start -->
+- **Categorize and color — by default, not only when obvious.** Before drawing, find the axis that sorts the items into kinds and color by it: layer (frontend / backend / data), role (client / service / datastore), trust zone (internal / external / third-party), status (done / active / blocked), owner/team, or read-path vs write-path. Almost every diagram has such an axis — actively look for one rather than leaving everything monochrome. Express it with a **tag group**, never ad-hoc per-node colors: declare `tag <Axis> as t` (the name is a single word — `tag TrustZone as tz` — or quote a multi-word name: `tag "Trust Zone" as tz`), indent the category values (a trailing color is optional — bare values auto-pick a palette color), set `active-tag <Axis>`, then assign each item `Node t: <Category>` (see the tag-group syntax in the per-type section below). Only the 11 named palette colors exist, and they re-resolve per palette/theme. Color the grouping so the categories — and the boundaries between them — read at a glance. **Buckets, not name tags — never 1:1.** A tag group must have _fewer_ values than it has members: each color should bucket two or more items so the palette compresses the diagram into a few meaningful kinds (aim for ~2–4 categories, and keep distinct colors well under half the item count). If you find yourself giving nearly every item its own value, you've enumerated, not categorized — merge the singletons up a level until each color groups at least two (a `cache` and a `database` are both `datastore`; a caller and a gateway are both `client`; two microservices are both `service`). One color per item is the same visual noise as random colors — the grouping only earns its place when a color means "these belong together." Leave items uncolored only when they genuinely form a single undifferentiated kind, or the user asked for no color.
 <!-- CATEGORIZE end -->
 - **Keep labels short.** A few words per node. Move detail into notes or metadata, never a full sentence inside a label.
 - **Let the defaults show.** Don't add `no-*` opt-outs unless the user asked to hide or disable something — they strip helpful labels, values, and color.
@@ -117,58 +118,58 @@ Valid markup is the floor, not the goal. A good diagram reads at a glance. Apply
 
 ### Chart-type index (45) — pick the type, then fetch its section
 
-| id | when to use |
-| -- | ----------- |
-| `sequence` | message / interaction flows over time |
-| `flowchart` | decision trees and process flows |
-| `state` | state-machine / lifecycle transitions |
-| `class` | UML class hierarchies |
-| `er` | database schemas and relationships |
-| `c4` | system architecture (context / container / component / deployment) |
-| `infra` | infrastructure traffic flow with RPS computation |
-| `boxes-and-lines` | general-purpose node-edge diagrams with groups and tags |
-| `sitemap` | site / app navigation structure |
-| `mindmap` | radial hierarchy of ideas from a central topic |
-| `org` | reporting hierarchy |
-| `family` | family tree / genealogy: unions (couples), children, remarriage, adoption, GEDCOM-style metadata |
-| `bracket` | single-elimination tournament bracket: winners auto-advance; seed the field for a day-0 skeleton or list results casually; two sides mirror to a championship |
-| `kanban` | task-board columns |
-| `gantt` | project scheduling with task dependencies and milestones |
-| `pert` | project network with three-point estimates and critical path |
-| `swimlane` | cross-functional process flow with lanes, phases and gateways (BPMN-style) |
-| `version-control` | git / version-control branch-and-merge graph: commits, branches, merges, rebase, HEAD and remote-tracking (gitGraph-style) |
-| `timeline` | events, eras, and date ranges |
-| `event-line` | annotated narrative timeline — events on a line with descriptions, optionally not to scale (NOT the date-scaled `timeline`) |
-| `body` | human anatomy figure annotated by muscle name — for medical, exercise, and educational diagrams |
-| `journey-map` | UX flow with emotion scores, phases, annotations |
-| `cycle` | cyclical process (PDCA, OODA, DevOps loops) |
-| `raci` | tasks × roles responsibility matrix; variant (RACI / RASCI / DACI) is inferred from the markers used |
-| `tech-radar` | technology adoption quadrants (adopt / trial / assess / hold) |
-| `quadrant` | 2×2 positioning matrix |
-| `pyramid` | stacked hierarchy of layers (Maslow, DIKW) |
-| `ring` | concentric rings of nested categories |
-| `treemap` | nested rectangles sized by value (budgets, disk usage, portfolios) |
-| `block` | author-controlled grid of nested, collapsible blocks (system / architecture layouts) |
-| `sketch` | GUI-first free-placement canvas: uniform shapes on a snap grid, arrows, tags (markup is app-generated) |
-| `goal` | single progress-toward-a-target value (`now` vs `target`) as a progress bar, thermometer, or gauge — KPIs, fundraising, quotas |
-| `countdown` | live "N days until X" that ticks every second and is accurate on every load — trip dates, launches, deadlines; the only dynamic chart type |
-| `clock` | live world-clock board: current time for people/places across time zones, ticking every second, with optional working-hours status and sundown line |
-| `map` | geographic concept map: regions, points, routes |
-| `wireframe` | low-fidelity UI layout with panels and controls |
-| `bar` | categorical comparisons (multi-series via `stack` / `group`) |
-| `line` | trends over time (multiple series via a `series` block; filled via `fill`; dual y-axes via `y-label` / `y-right-label`) |
-| `pie` | part-to-whole proportions (ring/doughnut via `hole`) |
-| `radar` | multi-dimensional metrics |
-| `polar-area` | radial bar chart |
-| `scatter` | 2D points or bubble chart |
-| `heatmap` | matrix intensity |
-| `funnel` | conversion pipeline |
-| `sankey` | flow / allocation |
-| `arc` | network relationships (linear, or circular via `layout chord`) |
-| `slope` | change between two periods |
-| `venn` | set overlaps |
-| `wordcloud` | term-frequency |
-| `function` | mathematical expressions (colon required: `f(x): x^2`) |
+| id                | when to use                                                                                                                                                   |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `sequence`        | message / interaction flows over time                                                                                                                         |
+| `flowchart`       | decision trees and process flows                                                                                                                              |
+| `state`           | state-machine / lifecycle transitions                                                                                                                         |
+| `class`           | UML class hierarchies                                                                                                                                         |
+| `er`              | database schemas and relationships                                                                                                                            |
+| `c4`              | system architecture (context / container / component / deployment)                                                                                            |
+| `infra`           | infrastructure traffic flow with RPS computation                                                                                                              |
+| `boxes-and-lines` | general-purpose node-edge diagrams with groups and tags                                                                                                       |
+| `sitemap`         | site / app navigation structure                                                                                                                               |
+| `mindmap`         | radial hierarchy of ideas from a central topic                                                                                                                |
+| `org`             | reporting hierarchy                                                                                                                                           |
+| `family`          | family tree / genealogy: unions (couples), children, remarriage, adoption, GEDCOM-style metadata                                                              |
+| `bracket`         | single-elimination tournament bracket: winners auto-advance; seed the field for a day-0 skeleton or list results casually; two sides mirror to a championship |
+| `kanban`          | task-board columns                                                                                                                                            |
+| `gantt`           | project scheduling with task dependencies and milestones                                                                                                      |
+| `pert`            | project network with three-point estimates and critical path                                                                                                  |
+| `swimlane`        | cross-functional process flow with lanes, phases and gateways (BPMN-style)                                                                                    |
+| `version-control` | git / version-control branch-and-merge graph: commits, branches, merges, rebase, HEAD and remote-tracking (gitGraph-style)                                    |
+| `timeline`        | events, eras, and date ranges                                                                                                                                 |
+| `event-line`      | annotated narrative timeline — events on a line with descriptions, optionally not to scale (NOT the date-scaled `timeline`)                                   |
+| `body`            | human anatomy figure annotated by muscle name — for medical, exercise, and educational diagrams                                                               |
+| `journey-map`     | UX flow with emotion scores, phases, annotations                                                                                                              |
+| `cycle`           | cyclical process (PDCA, OODA, DevOps loops)                                                                                                                   |
+| `raci`            | tasks × roles responsibility matrix; variant (RACI / RASCI / DACI) is inferred from the markers used                                                          |
+| `tech-radar`      | technology adoption quadrants (adopt / trial / assess / hold)                                                                                                 |
+| `quadrant`        | 2×2 positioning matrix                                                                                                                                        |
+| `pyramid`         | stacked hierarchy of layers (Maslow, DIKW)                                                                                                                    |
+| `ring`            | concentric rings of nested categories                                                                                                                         |
+| `treemap`         | nested rectangles sized by value (budgets, disk usage, portfolios)                                                                                            |
+| `block`           | author-controlled grid of nested, collapsible blocks (system / architecture layouts)                                                                          |
+| `sketch`          | GUI-first free-placement canvas: uniform shapes on a snap grid, arrows, tags (markup is app-generated)                                                        |
+| `goal`            | single progress-toward-a-target value (`now` vs `target`) as a progress bar, thermometer, or gauge — KPIs, fundraising, quotas                                |
+| `countdown`       | live "N days until X" that ticks every second and is accurate on every load — trip dates, launches, deadlines; the only dynamic chart type                    |
+| `clock`           | live world-clock board: current time for people/places across time zones, ticking every second, with optional working-hours status and sundown line           |
+| `map`             | geographic concept map: regions, points, routes                                                                                                               |
+| `wireframe`       | low-fidelity UI layout with panels and controls                                                                                                               |
+| `bar`             | categorical comparisons (multi-series via `stack` / `group`)                                                                                                  |
+| `line`            | trends over time (multiple series via a `series` block; filled via `fill`; dual y-axes via `y-label` / `y-right-label`)                                       |
+| `pie`             | part-to-whole proportions (ring/doughnut via `hole`)                                                                                                          |
+| `radar`           | multi-dimensional metrics                                                                                                                                     |
+| `polar-area`      | radial bar chart                                                                                                                                              |
+| `scatter`         | 2D points or bubble chart                                                                                                                                     |
+| `heatmap`         | matrix intensity                                                                                                                                              |
+| `funnel`          | conversion pipeline                                                                                                                                           |
+| `sankey`          | flow / allocation                                                                                                                                             |
+| `arc`             | network relationships (linear, or circular via `layout chord`)                                                                                                |
+| `slope`           | change between two periods                                                                                                                                    |
+| `venn`            | set overlaps                                                                                                                                                  |
+| `wordcloud`       | term-frequency                                                                                                                                                |
+| `function`        | mathematical expressions (colon required: `f(x): x^2`)                                                                                                        |
 
 **Need more than the index gives you?** Fetch the per-type section: MCP `get_language_reference(type)` / `get_examples(type)`, or read that type's section below. The `suggest_chart_type` tool returns the chosen type's section automatically.
 
@@ -182,7 +183,6 @@ _The most common types, inline so you can generate them without a fetch. For the
 
 ```dgmo
 journey-map A Cabin Boy's First Voyage
-solid-fill
 
 persona Squidlips Sam color: blue
   Greenhorn cabin boy, first time at sea
@@ -212,7 +212,6 @@ persona Squidlips Sam color: blue
 
 ```dgmo
 c4 Pirate Treasure Map System
-solid-fill
 
 tag Scope as sc
   Crew blue
@@ -288,8 +287,6 @@ ports
 ```dgmo
 class Ship Class Hierarchy
 
-solid-fill 
-
 interface Vessel
   + sail(): void
   + anchor(): void
@@ -360,18 +357,25 @@ else
 
 ```dgmo
 state Ship Battle Lifecycle
-solid-fill
 
 [*] -> Sailing
 
 Sailing
   -enemy spotted-> BattleStations
 
-BattleStations
-  -in range-> Engaging
-  -enemy retreats-> Sailing
+[Losses] gray
+  Captured -> [*]
+  Sinking -> [*]
+
+[Aftermath] teal
+  Victorious
+    -loot taken-> Sailing
+
+  Retreating
+    -escaped-> Sailing
+    -caught-> Captured
 
-[Combat]
+[Combat] red
   Engaging
     -alongside-> Boarding
     -hull breach-> Sinking
@@ -381,16 +385,9 @@ BattleStations
     -crew wins-> Victorious
     -crew loses-> Captured
 
-[Aftermath]
-  Victorious
-    -loot taken-> Sailing
-
-  Retreating
-    -escaped-> Sailing
-    -caught-> Captured
-
-Captured -> [*]
-Sinking -> [*]
+BattleStations
+  -in range-> Engaging
+  -enemy retreats-> Sailing
 ```
 #### infra
 
@@ -453,7 +450,7 @@ RumRunner f: Bonny
 ```dgmo
 gantt Blackbeard's Blockade — 1718
 
-start 1718-05-01
+start-date 1718-05-01
 today-marker 1718-05-15
 
 tag Role as r