@draftably/editor 0.0.0-stage → 0.1.0

package/dist/types/src/import/mermaid-facade.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Tested against mermaid 12.2.0. Uses its internal DB behind a narrow, checked boundary.
+ * This file parses only; it neither renders Mermaid nor attaches interaction callbacks.
+ * Call in an isolated Node worker with a DOM, or in a dedicated browser Mermaid instance.
+ */
+export declare const MERMAID_VERSION: "12.2.0";
+export type ParserDiagnostic = {
+    code: string;
+    severity: 'warning' | 'error';
+    message: string;
+    line?: number;
+    column?: number;
+    locationKind?: 'source' | 'parser-relative';
+};
+export type FlowVertex = {
+    id: string;
+    text: string;
+    type?: string;
+    labelType: string;
+    classes: string[];
+    styles: string[];
+    link?: string;
+    icon?: string;
+    img?: string;
+    props?: Record<string, unknown>;
+};
+export type FlowEdge = {
+    start: string;
+    end: string;
+    text: string;
+    type?: string;
+    stroke?: string;
+    id?: string;
+    isUserDefinedId: boolean;
+    labelType: string;
+    classes: string[];
+    style: string[];
+    length?: number;
+    interpolate?: string;
+    animate?: boolean;
+    animation?: string;
+};
+export type FlowGroup = {
+    id: string;
+    title: string;
+    nodes: string[];
+    dir?: string;
+    labelType: string;
+    classes: string[];
+    metadata?: Record<string, unknown>;
+};
+export type FlowClass = {
+    id: string;
+    styles: string[];
+    textStyles: string[];
+};
+export type FlowSnapshot = {
+    format: 'mermaid';
+    family: 'flowchart';
+    parserVersion: typeof MERMAID_VERSION;
+    direction: string;
+    vertices: FlowVertex[];
+    edges: FlowEdge[];
+    groups: FlowGroup[];
+    classes: FlowClass[];
+    defaultEdgeStyle: string[];
+    defaultEdgeInterpolate?: string;
+};
+/** One entry of Mermaid's ordered sequence log; `kind` is its LINETYPE name. */
+export type SequenceEvent = {
+    kind: string;
+    from?: string;
+    to?: string;
+    text: string;
+    placement?: 'left' | 'right' | 'over';
+    central: boolean;
+};
+export type SequenceActor = {
+    id: string;
+    name: string;
+    type: string;
+    box?: number;
+    links: string[];
+};
+export type SequenceBox = {
+    name?: string;
+    fill?: string;
+};
+export type SequenceSnapshot = {
+    format: 'mermaid';
+    family: 'sequence';
+    parserVersion: typeof MERMAID_VERSION;
+    title?: string;
+    actors: SequenceActor[];
+    boxes: SequenceBox[];
+    events: SequenceEvent[];
+    created: string[];
+    destroyed: string[];
+};
+export type ParseFlowResult = {
+    ok: true;
+    snapshot: FlowSnapshot | SequenceSnapshot;
+    diagnostics: ParserDiagnostic[];
+} | {
+    ok: false;
+    diagnostics: ParserDiagnostic[];
+};
+type MermaidApi = Pick<(typeof import('mermaid'))['default'], 'initialize' | 'mermaidAPI'>;
+/** DB strings contain Mermaid entity sentinels; preserve entity spelling for text decoding. */
+export declare function restoreEntitySpelling(value: string): string;
+/**
+ * Use an unattached HTML template only. Its content is inert and is never adopted into the page.
+ * Caller supplies the browser document or the dedicated worker's JSDOM document.
+ * Markdown markers deliberately remain visible; native Markdown rendering is not assumed.
+ */
+export declare function makePlainLabel(document: Document): (value: string) => string;
+export declare function preflightMermaidFlow(source: string): ParserDiagnostic[];
+/** Each factory owns a serialized queue because Mermaid maintains parser/configuration state. */
+export declare function createMermaidFlowParser(load: () => Promise<MermaidApi>): (source: string) => Promise<ParseFlowResult>;
+export {};

package/dist/types/src/import/mermaid-importer.d.ts

@@ -0,0 +1,4 @@
+import { type ImportResult } from './import-core';
+import { type ParseFlowResult } from './mermaid-facade';
+/** Convert a checked Mermaid snapshot into valid native source. */
+export declare function importMermaidFlow(parsed: ParseFlowResult, plainText: (value: string) => string, title?: string): ImportResult;

package/dist/types/src/import/mermaid-sequence.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mermaid `sequenceDiagram` -> native source. Participants become nodes and messages become edges
+ * in file order. Native sequences have no fragments, so each top-level branch of a block becomes
+ * a phase band, and the warning says that the branch logic is gone.
+ */
+import { type Diagnostic, type ImportResult } from './import-core';
+import type { SequenceSnapshot } from './mermaid-facade';
+export declare function mapMermaidSequence(snapshot: SequenceSnapshot, plainText: (value: string) => string, title: string, diagnostics: Diagnostic[]): ImportResult;

package/dist/types/src/import/scratch.d.ts

@@ -0,0 +1,3 @@
+/** Keep the imported native source before navigating away from the current diagram. */
+export declare function keepImportedSource(source: string): string;
+export declare function readImportedSource(id: string): string | null;

package/dist/types/src/lib/engine-tasks.d.ts

@@ -0,0 +1,88 @@
+import { type CandidateResult, type CandidateSpec, type ComparisonConfig } from '../engines/explorer-engine.js';
+import { type LayoutOptions, type LayoutResult } from '../engines/layout-engine.js';
+import { type Timeline } from '../engines/sculpt-engine.js';
+import { type RouteInput, type RoutingOptions, type RoutingResult } from '../engines/routing-engine.js';
+import { type Scene } from '../dsl/compile';
+import { type ViewState } from '../dsl/project';
+import type { Diagram } from '../model/types';
+export type EngineTask = {
+    kind: 'layout';
+    doc: Diagram;
+    options: LayoutOptions;
+} | {
+    kind: 'candidate';
+    baseline: Diagram;
+    spec: CandidateSpec;
+    config: ComparisonConfig;
+} | {
+    kind: 'timeline';
+    doc: Diagram;
+    options: LayoutOptions;
+}
+/** A diagram file variant, compiled exactly as the file would be. */
+ | {
+    kind: 'source';
+    source: string;
+    spec: CandidateSpec;
+}
+/** Full-quality routes for a drawing shown meanwhile with quick routes. */
+ | {
+    kind: 'route';
+    input: RouteInput;
+    options: RoutingOptions;
+}
+/** A diagram file compiled: laid out, not routed. */
+ | {
+    kind: 'compile';
+    source: string;
+}
+/** A diagram file compiled, projected with the editor's view and routed, as the viewer shows it. */
+ | {
+    kind: 'scene';
+    source: string;
+    view: ViewState;
+};
+/** A compiled file and its routes, keyed by the projected document they were drawn for. */
+export interface SceneResult {
+    scene: Scene;
+    fingerprint: string;
+    routing: RoutingResult;
+}
+export type EngineResult<T extends EngineTask> = T extends {
+    kind: 'layout';
+} ? LayoutResult : T extends {
+    kind: 'candidate' | 'source';
+} ? CandidateResult : T extends {
+    kind: 'route';
+} ? RoutingResult : T extends {
+    kind: 'scene';
+} ? SceneResult : T extends {
+    kind: 'compile';
+} ? Scene : Timeline;
+export declare function runEngineTask(task: EngineTask): Promise<LayoutResult | CandidateResult | Timeline | RoutingResult | SceneResult | Scene>;
+/**
+ * Run a short task in one worker that stays up, so frequent work such as recompiling a file after
+ * each edit pays no start-up cost. Without workers the task runs on the main thread.
+ */
+export declare function runShared<T extends EngineTask>(input: T): Promise<EngineResult<T>>;
+export declare class CancelledError extends Error {
+    constructor();
+}
+export interface RunningTask<T> {
+    promise: Promise<T>;
+    /** Stop the computation. The promise rejects with `CancelledError`. */
+    cancel(): void;
+    /** `worker`, or `main thread` when workers are unavailable. */
+    thread: () => string;
+}
+/** Computations to run at once: one core stays with the page. */
+export declare const poolSize: () => number;
+/** Call `work` for each index up to `count`, with at most `poolSize()` calls going at once. */
+export declare function inPool(count: number, work: (index: number) => Promise<void>): Promise<void>;
+/**
+ * Run an engine computation in a worker. If the browser blocks workers, the same computation
+ * runs on the main thread instead.
+ */
+export declare function startEngineTask<T extends EngineTask>(input: T, { timeout }?: {
+    timeout?: number;
+}): RunningTask<EngineResult<T>>;

package/dist/types/src/lib/font-data.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The bundled diagram fonts as data URLs, for SVG exports that must render without the app.
+ * The browser loads this module only when exporting; the CLI bundles it.
+ */
+import type { ResolvedAppearance } from '../model/appearance';
+/** `@font-face` rules for the faces an appearance draws with. */
+export declare function fontFaceCss(look: ResolvedAppearance): string;
+/** Make the bundled faces available to the page, so the canvas draws with measured fonts. */
+export declare function registerFonts(): void;

package/dist/types/src/lib/saved-diagram.d.ts

@@ -0,0 +1,4 @@
+/** Where the editor keeps the browser's diagram. The site reads it too: same origin. */
+export declare const STORAGE_KEY = "diagram-studio-v5";
+/** The title of the diagram kept in this browser, if there is one. */
+export declare function savedTitle(): string;

package/dist/types/src/lib/scene-cache.d.ts

@@ -0,0 +1,4 @@
+/** The compiled file stored for `source` by this build, if any. */
+export declare function cachedScene<T>(source: string): Promise<T | undefined>;
+/** Store the compiled file for `source`, keeping the most recently stored few. */
+export declare function cacheScene(source: string, value: unknown): Promise<void>;

package/dist/types/src/lib/source-hash.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Source in a URL hash, deflated and base64url-encoded: `#s=<data>`. The hash never reaches a
+ * server, so a shared link carries the diagram and nothing else.
+ */
+export declare function encodeSource(source: string): Promise<string>;
+/** The source in a `#s=` hash, or null when there is none or it does not decode. */
+export declare function decodeSource(hash: string): Promise<string | null>;

package/dist/types/src/lib/svg-export.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Deep-copy an SVG subtree with computed styles inlined and editor-only parts removed. An object
+ * with a link (`data-href`) is wrapped in `<a>`, its target written by `href`. The source element
+ * must be attached to the document.
+ */
+export declare function materializeSvg<T extends SVGElement>(original: T, href?: (href: string) => string): T;
+export declare const serializeSvg: (node: Node) => string;
+export declare function createSvgElement<K extends keyof SVGElementTagNameMap>(tag: K, attrs?: Record<string, string | number>): SVGElementTagNameMap[K];
+export declare const escapeXml: (value: unknown) => string;
+export declare function downloadBlob(blob: Blob, name: string): void;
+/** A download name from the diagram's title: `My plan` → `my-plan.svg`. */
+export declare function fileName(title: string, extension: string): string;
+export declare const downloadText: (text: string, name: string, type: string) => void;
+/** Rasterize an SVG string at `scale` (2× unless given), within browser canvas limits. */
+export declare function svgToPng(svg: string, scale?: number): Promise<Blob>;

package/dist/types/src/model/appearance.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Diagram appearance: five preset themes, color families with numeric shades, and the overrides a
+ * file can set. `resolveAppearance` turns a saved appearance into the concrete colors, spacing and
+ * type that sizing, the canvas and both SVG exports read, so all of them agree.
+ *
+ * Diagram appearance is separate from the editor's light or dark mode.
+ */
+import type { Footnote } from './footnote';
+import type { Note } from './note';
+import { type FontRole, type TypeProfile } from './fonts';
+import type { FileConfig } from './link';
+export type ThemeId = 'drafting' | 'fieldnotes' | 'signal' | 'ink' | 'blueprint';
+export declare const THEME_IDS: ThemeId[];
+export declare const DEFAULT_THEME: ThemeId;
+/** Shade stops. Lower numbers are lighter and higher numbers darker, in every theme. */
+export declare const SHADES: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+export type Shade = (typeof SHADES)[number];
+export declare const isShade: (n: unknown) => n is Shade;
+/** Shade of a node that names a color without a shade. */
+export declare const NODE_SHADE: Shade;
+/**
+ * Shade of a group that names a color without a shade. Groups are quiet surfaces behind nodes, so
+ * this is a pale shade in light themes and a deep one in dark themes; the scale itself never flips.
+ */
+export declare const groupShadeFor: (theme: ThemeId) => Shade;
+/** Built-in color families, available in every theme. `primary` and `secondary` follow the theme. */
+export declare const BUILT_IN_FAMILIES: readonly ["primary", "secondary", "slate", "stone", "blue", "sky", "teal", "mint", "green", "amber", "orange", "red", "rose", "violet"];
+export declare const isBuiltInFamily: (name: string) => boolean;
+export interface Swatch {
+    fill: string;
+    stroke: string;
+    ink: string;
+}
+/** A file's color declaration: one shade of a family. Built-in shades may set some fields only. */
+export interface ColorDefinition {
+    family: string;
+    shade: Shade;
+    fill?: string;
+    stroke?: string;
+    ink?: string;
+}
+export interface AppearanceOverrides {
+    paddingX?: number;
+    paddingY?: number;
+    radius?: number;
+    titleFont?: FontRole;
+    annotationFont?: FontRole;
+    canvas?: string;
+    text?: string;
+    connection?: string;
+}
+export interface DiagramAppearance {
+    theme: ThemeId;
+    overrides: AppearanceOverrides;
+    colors: ColorDefinition[];
+    /** What the colors mean, from `legend` statements, drawn as a key beside the diagram. */
+    legend?: LegendEntry[];
+    /** Title and subtitle drawn above exported images, from `diagram` and `subtitle` statements. */
+    heading?: Heading;
+    /** Sentences drawn on the diagram without moving it, from `note` statements. */
+    notes?: Note[];
+    /** Entries of the block between the drawing and the key, from `footnote` statements. */
+    footnotes?: Footnote[];
+    /** Panel labels from a `compare` statement: draw the old and new versions side by side. */
+    compare?: {
+        /** Set by `draftably compare`: the changes the older panel draws in their new version. */
+        undrawn?: string;
+        before: string;
+        after: string;
+        /** `right` sets the panels side by side, `down` stacks them; chosen by `aspect` when unset. */
+        direction?: 'right' | 'down';
+        /** Width over height the whole image should come closest to; 1.6 when unset. */
+        aspect?: number;
+    };
+    /** File settings from `config` statements. */
+    config?: FileConfig;
+    /** Named emphasis states from `state` statements, in file order. */
+    states?: EmphasisState[];
+}
+/** One way to draw the diagram: these objects and connections in focus, the rest faded or plain. */
+export interface EmphasisState {
+    id: string;
+    label: string;
+    /** Objects (a group brings its members) and connections in focus. */
+    ids: string[];
+    /** How everything else draws: faded like a context line, or as usual. */
+    rest: 'dim' | 'plain';
+}
+export interface Heading {
+    title?: string;
+    subtitle?: string;
+    /** Width of the frame round the drawing, from `diagram width=`; never narrower than its content. */
+    width?: number;
+}
+/** The connection styles a `legend line` row can explain. */
+export declare const LEGEND_LINES: readonly ["dashed", "solid"];
+export type LegendLine = (typeof LEGEND_LINES)[number];
+/** One row of the key: a color swatch (`family`), or a short connection (`line`). */
+export interface LegendEntry {
+    family?: string;
+    line?: LegendLine;
+    /** Shade of the swatch; nodes' default when omitted. */
+    shade?: Shade;
+    label: string;
+}
+export declare const defaultAppearance: () => DiagramAppearance;
+/** Limits for numeric overrides, shared by the file parser and JSON validation. */
+export declare const OVERRIDE_LIMITS: {
+    readonly paddingX: {
+        readonly min: 4;
+        readonly max: 48;
+    };
+    readonly paddingY: {
+        readonly min: 4;
+        readonly max: 48;
+    };
+    readonly radius: {
+        readonly min: 0;
+        readonly max: 24;
+    };
+};
+export declare const HEX_COLOR: RegExp;
+interface Preset {
+    label: string;
+    description: string;
+    dark: boolean;
+    canvas: string;
+    text: string;
+    muted: string;
+    connection: string;
+    node: Swatch;
+    group: Swatch;
+    paddingX: number;
+    paddingY: number;
+    radius: number;
+    shadow: boolean;
+    titleFont: FontRole;
+    annotationFont: FontRole;
+    titleSize: number;
+    titleLine: number;
+    annotationSize: number;
+    /** Chroma multiplier for the built-in families: how saturated this theme's colors are. */
+    chroma: number;
+    /** Anchor colors for `primary` and `secondary`, at the shade they appear as. */
+    primary: [string, Shade];
+    secondary: [string, Shade];
+    /** Hue and chroma for built-in families this theme draws in its own way. */
+    hues?: Partial<Record<string, [number, number]>>;
+}
+export declare const PRESETS: Record<ThemeId, Preset>;
+export declare function contrast(a: string, b: string): number;
+/** Contrast targets (WCAG ratios) every generated color meets. */
+export declare const CONTRAST: {
+    /** Dark title text on a pale fill. */
+    readonly paleInk: 7;
+    /** White title text on a dark fill. */
+    readonly darkInk: 4.5;
+    /** A shape's outline against the canvas when its fill alone does not separate it. */
+    readonly outline: 3;
+    /** Connection lines and connection label text against the canvas. */
+    readonly connection: 4.5;
+    /** A group's frame against the canvas. */
+    readonly frame: 2;
+};
+/**
+ * Move a color's lightness away from `against` until it reaches `min` contrast with it. Colors
+ * that already meet the target are returned unchanged.
+ */
+export declare function ensureContrast(color: string, against: string, min: number): string;
+/** The built-in families of a preset on a canvas color, generated once. */
+export declare function builtInFamilies(theme: ThemeId, canvas?: string): Map<string, Map<Shade, Swatch>>;
+export interface ResolvedAppearance {
+    theme: ThemeId;
+    dark: boolean;
+    canvas: string;
+    text: string;
+    muted: string;
+    connection: string;
+    /** Default node and group colors when nothing names a family. */
+    node: Swatch;
+    group: Swatch;
+    paddingX: number;
+    paddingY: number;
+    radius: number;
+    shadow: boolean;
+    title: TypeProfile;
+    groupTitle: TypeProfile;
+    annotation: TypeProfile;
+    /** Space above a group's content; the group title sits in it. */
+    groupHeader: number;
+    /** Every family and the shades it defines: built-in ones plus the file's own. */
+    families: Map<string, Map<Shade, Swatch>>;
+    custom: Set<string>;
+    /** Strike a removed object's title through (`config strike-removed=on`). */
+    strikeRemoved: boolean;
+}
+/** Height of a group's title band, derived from the title's line height. */
+export declare const groupHeaderFor: (lineHeight: number) => number;
+/** Preset values, then file overrides. Omitted fields inherit from the preset. */
+export declare function resolveAppearance(appearance?: DiagramAppearance): ResolvedAppearance;
+/**
+ * Colors for an object. `family` is a family name, or `auto` for the theme's default surface; an
+ * omitted shade is 500 for nodes and 100 for groups. Unknown families or shades fall back to the
+ * default surface; the file parser reports them before they get here.
+ */
+export declare function swatchFor(r: ResolvedAppearance, family: string | undefined, shade: Shade | undefined, kind?: 'node' | 'group'): Swatch;
+/** Shades a family defines, in numeric order. */
+export declare const shadesOf: (r: ResolvedAppearance, family: string) => Shade[];
+export {};

package/dist/types/src/model/bounds.d.ts

@@ -0,0 +1,19 @@
+import type { VisibleGraph } from './graph';
+import type { Diagram, Point, Rect } from './types';
+/** How far a connection's ink reaches past its points: half the stroke plus the arrowhead's wings. */
+export declare const ROUTE_INK = 4;
+export interface BoundedRoute {
+    id?: string;
+    points: readonly Point[];
+    label: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+}
+/**
+ * Bounds of everything drawn: shapes with their labels, containers, every route point with its
+ * stroke and arrowhead, and every connection label box. `pad` adds a margin on each side.
+ */
+export declare function drawingBounds(doc: Diagram, vg: VisibleGraph, rects: ReadonlyMap<string, Rect>, routes: readonly BoundedRoute[], pad?: number): Rect;

package/dist/types/src/model/camera.d.ts

@@ -0,0 +1,21 @@
+import type { Rect } from './types';
+/** A camera described by the world point at the viewport center and a zoom factor. */
+export interface ViewCamera {
+    cx: number;
+    cy: number;
+    k: number;
+}
+/** Camera that fits `bounds` inside `viewport` with padding, or null for a hidden viewport. */
+export declare function fitCamera(bounds: Rect, viewport: {
+    width: number;
+    height: number;
+} | undefined, padding?: number): ViewCamera | null;
+/**
+ * The zoom factor for one wheel event. A mouse notch (about 100px) zooms by about 18%; a pinch,
+ * which arrives as small Ctrl + wheel deltas, keeps its faster rate. `unit` converts line and
+ * page deltas to pixels.
+ */
+export declare function wheelZoomFactor(e: {
+    deltaY: number;
+    ctrlKey: boolean;
+}, unit?: number): number;

package/dist/types/src/model/candidates.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Compare's reading of its candidates: what each one measures, which ones are the same drawing,
+ * which few are worth showing, and how each differs from the current drawing.
+ */
+import type { RoutingResult } from '../engines/routing-engine.js';
+import type { StaticScene } from './static-scene';
+export interface Measure {
+    crossings: number;
+    blocked: number;
+    overlaps: number;
+    labels: number;
+    bends: number;
+    length: number;
+    area: number;
+    aspect: number;
+}
+export declare function measure(scene: StaticScene, routing: RoutingResult): Measure;
+/** Two drawings match when every box and line agrees within a couple of pixels. */
+export declare function sameDrawing(a: StaticScene, b: StaticScene): boolean;
+export interface Reading {
+    /** Hard defects this candidate has that the current drawing does not. */
+    defects: string[];
+    gains: string[];
+    costs: string[];
+}
+export declare const count: (n: number, noun: string) => string;
+/** How a candidate differs from the current drawing, from its measures alone. */
+export declare function readDifference(m: Measure, base: Measure): Reading;
+/** The measures of the drawing the others are read against. */
+export declare const describeMeasure: (m: Measure) => string;
+export interface Candidate {
+    index: number;
+    measure: Measure;
+    scene: StaticScene;
+}
+/**
+ * The sheet's slots after a change: each card in `keep` stays where it was, so a card never moves
+ * under the pointer, and `fill` takes the free slots in order.
+ */
+export declare function holdSlots(before: number[], keep: number[], fill: number[], limit: number): number[];
+/**
+ * The candidates worth showing beside the current drawing, best first. Repeats of the current
+ * drawing or of each other are dropped. A candidate with more hard defects than the current
+ * drawing comes last, whatever its other measures, and the fewer it has the sooner it comes. A
+ * candidate that beats the current drawing on something comes before one that does not: first the
+ * best for hard defects, crossings, area and line length, then the ones with the fewest hard
+ * defects and least like those already chosen.
+ */
+export declare function pickCandidates(current: Candidate, candidates: Candidate[], limit: number): {
+    shown: number[];
+    others: number[];
+    alike: number;
+};

package/dist/types/src/model/colors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The colors an object is drawn in. A file names a family and maybe a shade; drawing adds one
+ * rule on top, so nesting stays readable without the author doing shade arithmetic:
+ *
+ * - A container inside a container of the same family steps one shade toward emphasis per level
+ *   (lighter frames underneath, smaller and stronger ones on top), instead of repeating the fill.
+ * - A shape whose shade is within two steps of its container's, in the same family, moves three
+ *   steps past the container, so a member never melts into its frame.
+ *
+ * The canvas, the CLI's SVG and exports all draw through `drawnSwatch`.
+ */
+import { type ResolvedAppearance, type Shade, type Swatch } from './appearance';
+import type { Diagram } from './types';
+/** The shade an object is drawn at, or undefined for the theme's neutral surface. */
+export declare function drawnShade(doc: Diagram, look: ResolvedAppearance, id: string): Shade | undefined;
+/** The swatch an object is drawn with. */
+export declare function drawnSwatch(doc: Diagram, look: ResolvedAppearance, id: string, kind: 'node' | 'group'): Swatch;
+/**
+ * A sequence participant's accent: the fill its color would have, drawn as a thin stripe along
+ * its top. Undefined for anything else, and for a participant with no color of its own.
+ */
+export declare function participantAccent(doc: Diagram, look: ResolvedAppearance, id: string): string | undefined;

package/dist/types/src/model/document.d.ts

@@ -0,0 +1,24 @@
+import { type DiagramAppearance } from './appearance';
+import type { Diagram, DiagramSettings } from './types';
+export declare const MAX_NODES = 500;
+export declare const MAX_EDGES = 1200;
+export declare function uid(prefix?: string): string;
+export declare const DEFAULT_SETTINGS: DiagramSettings;
+export declare function emptyDiagram(title?: string): Diagram;
+type Raw = any;
+export declare const isLegacyDiagram: (input: Raw) => boolean;
+/**
+ * Validate a diagram from any source and return a complete, canonical copy.
+ * Throws a readable error for anything that cannot be repaired.
+ */
+export declare function normalize(input: unknown): Diagram;
+/** Validate a saved appearance. A missing appearance is the default theme. */
+export declare function normalizeAppearance(input: Raw): DiagramAppearance;
+/** The meaning of a document, ignoring where the camera happens to be. */
+export declare function documentIdentity(doc: Diagram): string;
+/**
+ * Inputs that affect connection routing. The editor store keeps the key order of the document it
+ * replaced, so the worker's freshly projected copy of the same document lists its keys differently.
+ */
+export declare function routingFingerprint(doc: Diagram): string;
+export {};