@diagrammo/dgmo 0.64.1 → 0.66.0

package/dist/dgmo-router-EAW7XiBE.d.ts

@@ -0,0 +1,280 @@
+import { P as PaletteConfig, D as DgmoError } from './tag-groups-NUA2F1I5.js';
+
+/** 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[];
+
+interface ChartTypeMeta {
+    readonly id: string;
+    readonly description: string;
+    readonly fallback?: true;
+    /**
+     * Routable but never OFFERED. The type parses, routes and renders like any
+     * other, but no surface that enumerates types for a human or a model may list
+     * it — nobody hand-authors one, so a picker entry would produce a file the
+     * user cannot complete.
+     *
+     * Honoured at five edges, and deliberately NOT inside `getAllChartTypes()`,
+     * which keeps meaning "everything routable":
+     *   1. `cli.ts` — `dgmo types` (plain and `--json`)
+     *   2. `completion-registry.ts` — the chart-type completion popup
+     *   3. `dgmo-mcp/src/index.ts` — the `list_chart_types` tool
+     *   4. `dgmo-mcp/src/suggest/scoring.ts` — the suggester's candidate pool
+     *   5. `scripts/gen-ai-core.mjs` — the generated AI core every model reads
+     * `tests/internal-chart-types.test.ts` is this flag's specification; without
+     * it the flag is a convention and the next refactor drops an edge silently.
+     */
+    readonly internal?: true;
+}
+declare const chartTypesData: readonly [{
+    readonly id: "journey-map";
+    readonly description: "User experience flow with emotion scores, phases, and annotations";
+}, {
+    readonly id: "c4";
+    readonly description: "System architecture (context, container, component, deployment)";
+}, {
+    readonly id: "er";
+    readonly description: "Database schemas and relationships";
+}, {
+    readonly id: "class";
+    readonly description: "UML class hierarchies";
+}, {
+    readonly id: "sequence";
+    readonly description: "Message request and response interaction flows";
+    readonly fallback: true;
+}, {
+    readonly id: "state";
+    readonly description: "State machine / lifecycle transitions";
+}, {
+    readonly id: "infra";
+    readonly description: "Infrastructure traffic flow with RPS computation";
+}, {
+    readonly id: "gantt";
+    readonly description: "Project scheduling with task dependencies and milestones";
+}, {
+    readonly id: "pert";
+    readonly description: "Project network with three-point estimates, critical path, and uncertainty (Beta-PERT, Monte Carlo)";
+}, {
+    readonly id: "swimlane";
+    readonly description: "Cross-functional process flow with lanes, phases and gateways (BPMN-style)";
+}, {
+    readonly id: "version-control";
+    readonly description: "Git / version-control branch-and-merge graph: commits, branches, merges, rebase, HEAD and remote-tracking (gitGraph-style)";
+}, {
+    readonly id: "timeline";
+    readonly description: "Events, eras, and date ranges";
+}, {
+    readonly id: "event-line";
+    readonly description: "Annotated narrative timeline — events on a horizontal line with descriptions (not the date-scaled timeline)";
+}, {
+    readonly id: "body";
+    readonly description: "Human anatomy figure annotated by muscle/bone/joint name — for medical, exercise, and educational diagrams";
+}, {
+    readonly id: "org";
+    readonly description: "Reporting hierarchy";
+}, {
+    readonly id: "family";
+    readonly description: "Family tree / genealogy: unions (couples), children, remarriage, adoption, and GEDCOM-style metadata";
+}, {
+    readonly id: "sitemap";
+    readonly description: "Site / app navigation structure";
+}, {
+    readonly id: "bracket";
+    readonly description: "Single-elimination tournament bracket: winners auto-advance up a tree; seed the field for a day-0 skeleton or list results for a casual bracket, with two sides mirroring inward to a championship";
+}, {
+    readonly id: "kanban";
+    readonly description: "Task board columns";
+}, {
+    readonly id: "raci";
+    readonly description: "Tasks × roles responsibility matrix with constraint linting";
+}, {
+    readonly id: "tech-radar";
+    readonly description: "Technology adoption quadrants (adopt/trial/assess/hold)";
+}, {
+    readonly id: "mindmap";
+    readonly description: "Radial hierarchy of ideas branching from a central topic";
+}, {
+    readonly id: "wireframe";
+    readonly description: "Low-fidelity UI layout with panels, controls, and annotations";
+}, {
+    readonly id: "cycle";
+    readonly description: "Cyclical process visualization (PDCA, OODA, DevOps loops)";
+}, {
+    readonly id: "pyramid";
+    readonly description: "Stacked hierarchy of layers with descriptions (Maslow, DIKW)";
+}, {
+    readonly id: "ring";
+    readonly description: "Concentric rings showing nested or hierarchical categories (read core-out)";
+}, {
+    readonly id: "treemap";
+    readonly description: "Nested rectangles sized by value — show a hierarchy’s proportions (budgets, disk usage, portfolios) with color by category, value heatmap, or branch";
+}, {
+    readonly id: "block";
+    readonly description: "Block diagram: an author-controlled grid of rectangular blocks with nested, collapsible containers — system/hardware/architecture layouts where the 2-D arrangement is the meaning";
+}, {
+    readonly id: "sketch";
+    readonly description: "GUI-first constrained canvas: uniformly-sized shapes placed freely on a snap grid, arrows between them, meaning through tags — the markup is generated by the canvas editor";
+}, {
+    readonly id: "goal";
+    readonly description: "Single progress-toward-a-target value (now vs target) as a progress bar, thermometer, or gauge — KPIs, fundraising, quotas, completion";
+}, {
+    readonly id: "countdown";
+    readonly description: "Live \"N days until X\" that ticks every second and is accurate on every load — trip dates, launches, deadlines; the only dynamic chart type";
+}, {
+    readonly id: "clock";
+    readonly description: "Live world-clock board: current time for people/places across time zones, ticking every second, with optional working-hours status and sundown line";
+}, {
+    readonly id: "map";
+    readonly description: "Geographic concept map: highlight/score regions, drop points of interest, connect with routes or edges";
+}, {
+    readonly id: "quadrant";
+    readonly description: "2x2 positioning matrix";
+}, {
+    readonly id: "venn";
+    readonly description: "Set overlaps";
+}, {
+    readonly id: "funnel";
+    readonly description: "Conversion pipeline";
+}, {
+    readonly id: "slope";
+    readonly description: "Change between 2 time periods";
+}, {
+    readonly id: "sankey";
+    readonly description: "Flow / allocation visualization";
+}, {
+    readonly id: "arc";
+    readonly description: "Network relationships (linear or circular via `layout`)";
+}, {
+    readonly id: "wordcloud";
+    readonly description: "Term frequency visualization";
+}, {
+    readonly id: "heatmap";
+    readonly description: "Matrix intensity visualization";
+}, {
+    readonly id: "function";
+    readonly description: "Mathematical expressions";
+}, {
+    readonly id: "bar";
+    readonly description: "Categorical comparisons for 3 - 5 figures";
+    readonly fallback: true;
+}, {
+    readonly id: "line";
+    readonly description: "Trends over time";
+    readonly fallback: true;
+}, {
+    readonly id: "pie";
+    readonly description: "Part-to-whole proportions";
+}, {
+    readonly id: "radar";
+    readonly description: "Multi-dimensional metrics";
+}, {
+    readonly id: "polar-area";
+    readonly description: "Radial bar chart";
+}, {
+    readonly id: "scatter";
+    readonly description: "2D data points or bubble chart";
+}, {
+    readonly id: "flowchart";
+    readonly description: "Decision trees and process flows";
+    readonly fallback: true;
+}, {
+    readonly id: "boxes-and-lines";
+    readonly description: "General-purpose node-edge diagrams with groups and tags";
+    readonly fallback: true;
+}, {
+    readonly id: "live-link";
+    readonly description: "A pointer to a diagram published at Diagrammo Cloud";
+    readonly internal: true;
+}];
+/**
+ * Every chart type the router can dispatch — the "routable" set.
+ *
+ * Distinct from the "offered" set (`utils/offered-types.ts`), which drops the
+ * `internal` types nobody hand-authors. A live link is routable but never
+ * offered.
+ *
+ * This union is the reason the id list lives here: `chart-type-registry.ts`
+ * keys its `Record` by it, so a chart type missing from the registry is a
+ * compile error, and `ALL_CHART_TYPES` / the editor's `CHART_TYPES` derive from
+ * the same array rather than restating it.
+ */
+type ChartTypeId = (typeof chartTypesData)[number]['id'];
+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;
+};
+
+export { type ChartTypeId as C, type RenderCategory as R, type ChartTypeMeta as a, CHART_TYPE_DESCRIPTIONS as b, chartTypes as c, chartTypeParsers as d, getAllChartTypes as e, getAvailablePalettes as f, getPalette as g, getRenderCategory as h, isExtendedChartType as i, isValidHex as j, knownChartTypeIds as k, parseDgmoChartType as l, registerPalette as m, parseDgmo as p, resolvePaletteOrFallback as r };

package/dist/{dimensions-ES6O2T4H.js → dimensions-RD3Y7FCF.js}

@@ -1,14 +1,14 @@
 import {
   mapContentAspect,
   mapExportDimensions
-} from "./chunk-JU2VMFYC.js";
-import "./chunk-37EHGTQ2.js";
+} from "./chunk-X26BF4T2.js";
+import "./chunk-R7S5542V.js";
 import "./chunk-4QV26TEG.js";
-import "./chunk-CVVICCSB.js";
+import "./chunk-L65WI4HO.js";
 import "./chunk-A4GOY3PE.js";
-import "./chunk-ES66QH6J.js";
-import "./chunk-SCJ7CAJF.js";
-import "./chunk-4ASYQ347.js";
+import "./chunk-FG24NXKN.js";
+import "./chunk-3HOCNSPD.js";
+import "./chunk-MTGGOCND.js";
 import "./chunk-MDI5FMWO.js";
 import "./chunk-P2PUWV3Y.js";
 import "./chunk-42IT4BG2.js";
@@ -19,4 +19,4 @@ export {
   mapContentAspect,
   mapExportDimensions
 };
-//# sourceMappingURL=dimensions-ES6O2T4H.js.map
+//# sourceMappingURL=dimensions-RD3Y7FCF.js.map

package/dist/{flowchart-renderer-EXMRHFTQ.js → flowchart-renderer-6JKM2FA4.js}

@@ -1,22 +1,22 @@
 import {
   renderFlowchart,
   renderFlowchartForExport
-} from "./chunk-SMCUX42K.js";
+} from "./chunk-4TM7MWU4.js";
 import "./chunk-PDKUANDZ.js";
-import "./chunk-LSFZDBAP.js";
+import "./chunk-IKHV5IJB.js";
 import "./chunk-LP7EC4MI.js";
 import "./chunk-H52HJ26L.js";
 import "./chunk-6EK55ART.js";
-import "./chunk-VJARCVMH.js";
+import "./chunk-MU3CJPJF.js";
 import "./chunk-5DH3KYFH.js";
 import "./chunk-NCT22MOD.js";
 import "./chunk-WGC42WJU.js";
-import "./chunk-3CIOJ5YJ.js";
+import "./chunk-FJ57274M.js";
 import "./chunk-YYVTBZZC.js";
 import "./chunk-RU2HHHYA.js";
 import "./chunk-A4GOY3PE.js";
-import "./chunk-Z5ID35YP.js";
-import "./chunk-4ASYQ347.js";
+import "./chunk-UTCPNJND.js";
+import "./chunk-MTGGOCND.js";
 import "./chunk-CHOKOYSC.js";
 import "./chunk-7TF3QOOD.js";
 import "./chunk-NXMESY4J.js";
@@ -33,4 +33,4 @@ export {
   renderFlowchart,
   renderFlowchartForExport
 };
-//# sourceMappingURL=flowchart-renderer-EXMRHFTQ.js.map
+//# sourceMappingURL=flowchart-renderer-6JKM2FA4.js.map

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+import { b as DiagnosticSpec, P as PaletteConfig, C as CompactViewState, D as DgmoError } from './tag-groups-NUA2F1I5.js';
+export { c as DgmoSeverity, d as DiagnosticParams, E as EmitOptions, a as PaletteColors, e as emit, f as formatDgmoError } from './tag-groups-NUA2F1I5.js';
+export { C as ChartTypeId, a as ChartTypeMeta, c as chartTypes, g as getPalette, r as resolvePaletteOrFallback, p as validate } from './dgmo-router-EAW7XiBE.js';
+import { T as Theme } from './themes-Dem5xalq.js';
+export { M as MapCompletionOptions, a as MapLocationMatch, b as MapPlaceCompletion, c as MapRegionCompletion, d as completeMapPlaces, e as completeMapRegions, p as palettes, s as searchMapLocations, t as themes } from './themes-Dem5xalq.js';
+import { M as MapDataSource } from './d3-Bfhj-XBX.js';
+export { G as Gazetteer, a as GazetteerEntry, b as MapData, R as RegionName, c as RegionNames } from './d3-Bfhj-XBX.js';
+
+/**
+ * Make an SVG produced by `@diagrammo/dgmo`'s static `render()` suitable for
+ * responsive inline embedding in any host (Obsidian, remark/markdown, web
+ * pages):
+ *
+ * - dgmo renders diagrams inside a fixed export canvas (e.g.
+ *   `viewBox="0 0 1200 800"`), with content often occupying only a fraction
+ *   of it. We compute a tight content bounding box from element coordinates
+ *   and set the root `viewBox` to bbox+padding, so the diagram's intrinsic
+ *   aspect ratio matches its CONTENT — no dead space above/below or beside it.
+ * - Ensure the root `<svg>` has a `viewBox` so it scales responsively.
+ * - Strip fixed `width="N"` / `height="N"` so CSS (e.g. `width:100%;
+ *   height:auto`, or an aspect-ratio derived from the tight viewBox) controls
+ *   sizing.
+ * - The root background (the theme's opaque `palette.bg` — both the inline
+ *   `background:` style and the full-canvas `<rect>` some renderers paint) is
+ *   STRIPPED by default so the embed inherits the host page surface and blends
+ *   into Obsidian / doc-site / arbitrary pages instead of showing a mismatched
+ *   rectangle. Pass `{ background: 'opaque' }` to keep it — the embedder
+ *   opt-out, and the automatic default for background-meaningful types like
+ *   `map` (whose bg is the ocean) via `defaultEmbedBackground`. Standalone
+ *   PNG/SVG export does NOT go through here and stays opaque.
+ *
+ * This is intentionally a string transform, not a DOM `getBBox()` step: dgmo
+ * can dual-render light/dark SVGs where one is hidden by color-mode CSS, and
+ * `getBBox()` returns 0 for the hidden copy. Parsing coordinates from the
+ * markup measures both copies reliably and works server-side (Node).
+ */
+interface NormalizeSvgForEmbedOptions {
+    /**
+     * `transparent` (default) strips the theme's opaque root background so the
+     * embed inherits the host page surface. `opaque` preserves it — the embedder
+     * opt-out for diagrams that need their own solid backdrop. Callers that know
+     * the chart type should resolve this via `defaultEmbedBackground`.
+     */
+    background?: 'transparent' | 'opaque';
+}
+declare function normalizeSvgForEmbed(input: string, opts?: NormalizeSvgForEmbedOptions): string;
+/**
+ * The embed background an embedder gets by default for a given chart type:
+ * `transparent` (blend into the host) for everything except
+ * background-meaningful types, which stay `opaque`.
+ */
+declare function defaultEmbedBackground(chartType?: string): 'transparent' | 'opaque';
+/**
+ * Parse the content bounding box of a normalized embed SVG, if one can be
+ * derived. Returns `null` when no usable coordinates are found (e.g. an empty
+ * diagram). Useful for hosts that want to set an explicit `aspect-ratio` from
+ * the tight viewBox.
+ */
+declare function getEmbedSvgViewBox(svg: string): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+
+interface MountD3Opts {
+    theme?: 'light' | 'dark' | 'transparent';
+    palette?: string;
+    /** Forwarded to the interaction adapter: source-line navigation on click. */
+    onNavigate?: (line: number) => void;
+    mutedColor?: string;
+    surface?: string;
+    text?: string;
+}
+interface MountedD3Chart {
+    /** Re-render with new content and/or theme/palette; re-attaches interactions. */
+    update: (content: string, opts?: Partial<MountD3Opts>) => Promise<void>;
+    /** Emphasize the chart element on the given source line (editor cursor sync);
+     *  pass null to clear. */
+    highlight: (line: number | null) => void;
+    /** Tear down listeners + overlays and clear the container. */
+    destroy: () => void;
+}
+declare function mountD3DataChart(container: HTMLElement, content: string, opts?: MountD3Opts): MountedD3Chart;
+
+interface DataChartInteractionOpts {
+    onNavigate?: (line: number) => void;
+    mutedColor?: string;
+    surface?: string;
+    text?: string;
+}
+interface DataChartController {
+    /** Remove all listeners + overlays. */
+    destroy: () => void;
+    /** Emphasize the chart element(s) on the given source line (editor cursor
+     *  sync); pass null to clear. No-op while the pointer is actively hovering. */
+    highlight: (line: number | null) => void;
+}
+declare function attachDataChartInteractions(svg: SVGSVGElement, opts?: DataChartInteractionOpts): DataChartController;
+
+/** All data-chart types the hand-built renderers currently cover. */
+declare const D3_DATA_CHART_TYPES: Set<string>;
+declare function supportsD3DataChart(type: string): boolean;
+
+/**
+ * The full diagnostic catalog, sorted by code. Every coded diagnostic
+ * dgmo can emit — its severity, owning chart type, canonical message,
+ * fix hint, and a triggering example. This is the enumerable source of
+ * truth for the CLI `diagnostics` subcommand, the console error-review
+ * surface, MCP, and the language-spec catalog.
+ */
+declare function listDiagnosticCodes(): DiagnosticSpec[];
+/** Look up a single spec by its code, or `undefined` if not cataloged. */
+declare function getDiagnosticSpec(code: string): DiagnosticSpec | undefined;
+
+interface RenderOptions {
+    theme?: Theme;
+    /**
+     * A `PaletteConfig` (e.g. `palettes.catppuccin`) or a palette id string
+     * (e.g. `'catppuccin'`). Unknown ids fall back to the default palette.
+     */
+    palette?: PaletteConfig | string;
+    /**
+     * How to handle parse errors:
+     *   'svg'    — render an inline error SVG (default)
+     *   'silent' — return empty svg + diagnostics; caller handles UI
+     *   'throw'  — throw an Error with the diagnostics
+     */
+    onError?: 'svg' | 'silent' | 'throw';
+    /**
+     * Pre-applied interactive view state — collapsed sections/columns,
+     * active swimlane tag-group, etc. Used to render a specific view
+     * non-interactively (server-side render, share-link decode).
+     */
+    viewState?: CompactViewState;
+    /**
+     * Canvas to draw onto, in px. Defaults to the 1200x800 export sheet.
+     *
+     * Omit these and nothing changes. Pass them when the result is going into a
+     * box whose shape you already know — fitting the default sheet to a narrow
+     * column inherits its aspect, so a one-line meter arrives as tall as a poster.
+     */
+    width?: number;
+    height?: number;
+    /**
+     * Basemap assets for `map` charts — the data itself, or a loader returning
+     * it. `render()` reads nothing from the filesystem or the network on its own,
+     * so this is the only way a map obtains a basemap, and its presence here is
+     * what tells a caller whether a render can touch the environment.
+     *
+     * - Node / CLI / SSR: pass the `loadMapData` loader from
+     *   `@diagrammo/dgmo/advanced`. It runs only when the content really is a
+     *   map, so a non-map render never pays to read the assets.
+     * - Browser / Worker / Obsidian: pass your bundled `MapData`.
+     *
+     * Omit it and a map renders empty with an `E_MAP_DATA_NOT_SUPPLIED`
+     * diagnostic. Every other chart type ignores this option.
+     */
+    mapData?: MapDataSource;
+}
+
+interface RenderResult {
+    svg: string;
+    diagnostics: DgmoError[];
+}
+/**
+ * Render DGMO source to an SVG string.
+ *
+ * @example
+ * ```ts
+ * import { render, palettes, themes } from '@diagrammo/dgmo';
+ *
+ * const { svg } = await render(text, {
+ *   palette: palettes.catppuccin,
+ *   theme: themes.dark,
+ * });
+ * document.getElementById('chart').innerHTML = svg;
+ * ```
+ */
+declare function render(text: string, options?: RenderOptions): Promise<RenderResult>;
+
+interface EncodeDiagramUrlOptions {
+    baseUrl?: string;
+    palette?: PaletteConfig;
+    theme?: Theme;
+    filename?: string;
+    /**
+     * Initial view state to embed in the URL — re-applied when the link is
+     * decoded so recipients open the diagram in the same configuration.
+     */
+    viewState?: CompactViewState;
+}
+/**
+ * Encode DGMO text into a shareable URL. Returns null if the compressed
+ * payload exceeds the 8 KB URL limit.
+ */
+declare function encodeDiagramUrl(text: string, options?: EncodeDiagramUrlOptions): string | null;
+interface DecodedDiagramUrl {
+    text: string;
+    palette?: PaletteConfig;
+    theme?: Theme;
+    filename?: string;
+}
+/**
+ * Decode a share URL back into DGMO text plus optional palette/theme/filename.
+ * Returns null if the URL contains no valid DGMO payload.
+ */
+declare function decodeDiagramUrl(url: string): DecodedDiagramUrl | null;
+
+export { CompactViewState, D3_DATA_CHART_TYPES, type DataChartInteractionOpts, type DecodedDiagramUrl, DgmoError, DiagnosticSpec, type EncodeDiagramUrlOptions, MapDataSource, type MountD3Opts, type MountedD3Chart, type NormalizeSvgForEmbedOptions, PaletteConfig, type RenderOptions, type RenderResult, Theme, attachDataChartInteractions, decodeDiagramUrl, defaultEmbedBackground, encodeDiagramUrl, getDiagnosticSpec, getEmbedSvgViewBox, listDiagnosticCodes, mountD3DataChart, normalizeSvgForEmbed, render, supportsD3DataChart };

package/dist/index.js

@@ -11,10 +11,10 @@ import {
 } from "./chunk-SQAG3UXH.js";
 import {
   render
-} from "./chunk-VOJOARA6.js";
+} from "./chunk-3OT63FS4.js";
 import {
   renderErrorCard
-} from "./chunk-S5RWWISJ.js";
+} from "./chunk-7L53J53J.js";
 import {
   MAP_DIAGNOSTICS
 } from "./chunk-EOYPX6SF.js";
@@ -22,27 +22,27 @@ import {
   D3_DATA_CHART_TYPES,
   renderDataChartD3,
   supportsD3DataChart
-} from "./chunk-7T3A2UK3.js";
-import "./chunk-CVVICCSB.js";
-import "./chunk-OMTBYLKN.js";
+} from "./chunk-5T7K6QND.js";
+import "./chunk-L65WI4HO.js";
+import "./chunk-TPKNA2U5.js";
 import "./chunk-YRYKTYMQ.js";
 import "./chunk-YYVTBZZC.js";
-import "./chunk-67D4MN2H.js";
-import "./chunk-6VJCURWU.js";
+import "./chunk-LK6LTSLH.js";
+import "./chunk-J2EXBAPZ.js";
 import "./chunk-RU2HHHYA.js";
 import "./chunk-A4GOY3PE.js";
-import "./chunk-RBAW7VUG.js";
-import "./chunk-ES66QH6J.js";
-import "./chunk-Z5ID35YP.js";
-import "./chunk-SCJ7CAJF.js";
-import "./chunk-4ASYQ347.js";
+import "./chunk-2EPV7CLY.js";
+import "./chunk-FG24NXKN.js";
+import "./chunk-UTCPNJND.js";
+import "./chunk-3HOCNSPD.js";
+import "./chunk-MTGGOCND.js";
 import {
   decodeDiagramUrl,
   encodeDiagramUrl
 } from "./chunk-U7VO6JAA.js";
 import {
   parseDgmo
-} from "./chunk-AA4M6F2P.js";
+} from "./chunk-BBY57XAA.js";
 import "./chunk-2CMM36O7.js";
 import "./chunk-A2RUBBVT.js";
 import "./chunk-JWJBWNQL.js";
@@ -84,7 +84,7 @@ import {
   PERT_DIAGNOSTICS
 } from "./chunk-VXBEG3IB.js";
 import "./chunk-3TYUXC7D.js";
-import "./chunk-6BVIZW5N.js";
+import "./chunk-FLFBY5GN.js";
 import {
   EVENT_LINE_DIAGNOSTICS
 } from "./chunk-QMYJO4EL.js";
@@ -107,7 +107,7 @@ import {
 import "./chunk-SR7NGZNM.js";
 import "./chunk-NXMESY4J.js";
 import "./chunk-EK4QX7NQ.js";
-import "./chunk-NKRVFQGO.js";
+import "./chunk-BDI25HWH.js";
 import "./chunk-QE4GTFZS.js";
 import "./chunk-7NK42OIB.js";
 import {

package/dist/{layout-HBWT2G23.js → layout-4LNMXLVK.js}

@@ -2,12 +2,12 @@ import {
   fixEdgeWaypoints,
   layoutInfra,
   separateGroups
-} from "./chunk-43E26CDA.js";
-import "./chunk-4ASYQ347.js";
+} from "./chunk-VS2M72PF.js";
+import "./chunk-MTGGOCND.js";
 import "./chunk-5WRI5ZAA.js";
 export {
   fixEdgeWaypoints,
   layoutInfra,
   separateGroups
 };
-//# sourceMappingURL=layout-HBWT2G23.js.map
+//# sourceMappingURL=layout-4LNMXLVK.js.map

package/dist/{layout-UU4VJTOP.js → layout-62ERBWCM.js}

@@ -1,8 +1,8 @@
 import {
   layoutMindmap
-} from "./chunk-U42ZEK7L.js";
+} from "./chunk-V4BYBIBU.js";
 import "./chunk-YYVTBZZC.js";
-import "./chunk-4ASYQ347.js";
+import "./chunk-MTGGOCND.js";
 import "./chunk-IYULMRBE.js";
 import "./chunk-MDI5FMWO.js";
 import "./chunk-P2PUWV3Y.js";
@@ -12,4 +12,4 @@ import "./chunk-5WRI5ZAA.js";
 export {
   layoutMindmap
 };
-//# sourceMappingURL=layout-UU4VJTOP.js.map
+//# sourceMappingURL=layout-62ERBWCM.js.map

package/dist/{layout-N6X46MWG.js → layout-6SKHNQYO.js}

@@ -1,14 +1,14 @@
 import {
   focusFamily,
   layoutFamily
-} from "./chunk-DJCZWQ2A.js";
+} from "./chunk-RTTZIX34.js";
 import "./chunk-IVKC4GID.js";
-import "./chunk-3CIOJ5YJ.js";
-import "./chunk-4ASYQ347.js";
+import "./chunk-FJ57274M.js";
+import "./chunk-MTGGOCND.js";
 import "./chunk-QQJUTGQH.js";
 import "./chunk-5WRI5ZAA.js";
 export {
   focusFamily,
   layoutFamily
 };
-//# sourceMappingURL=layout-N6X46MWG.js.map
+//# sourceMappingURL=layout-6SKHNQYO.js.map