diagram-contracts 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1002 @@
+import { z } from 'zod';
+
+/**
+ * diagram-contracts Schema — SSoT Catalogs
+ *
+ * Faithfully transcribed from docs/diagram-vocabulary.md.
+ * TOKEN_CATALOG, PROPERTY_CATALOG, ELEMENT_CATALOG are the single
+ * source of truth for validation, documentation, and code generation.
+ */
+declare const TOKEN_CATALOG: {
+    readonly widthSize: readonly ["wrap", "fill"];
+    readonly heightSize: readonly ["wrap", "fill"];
+    readonly align: readonly ["start", "center", "end", "stretch"];
+    readonly justify: readonly ["start", "center", "end", "spaceBetween", "spaceAround", "spaceEvenly"];
+    readonly contentAlign: readonly ["topStart", "top", "topEnd", "start", "center", "end", "bottomStart", "bottom", "bottomEnd"];
+    readonly axis: readonly ["vertical", "horizontal"];
+    readonly shape: readonly ["rect", "roundedRect", "circle", "ellipse", "diamond", "parallelogram", "capsule", "cylinder", "hexagon", "triangle"];
+    readonly anchorPosition: readonly ["topLeft", "top", "topRight", "left", "center", "right", "bottomLeft", "bottom", "bottomRight", "auto"];
+    readonly routeStyle: readonly ["orthogonal", "straight", "curved"];
+    readonly arrowHead: readonly ["none", "arrow", "filledArrow", "diamond", "filledDiamond", "circle", "filledCircle"];
+    readonly strokeStyle: readonly ["solid", "dashed", "dotted"];
+    readonly constraintStrength: readonly ["required", "strong", "normal", "weak"];
+    readonly textPosition: readonly ["inside", "above", "below", "start", "end"];
+    readonly textOverflow: readonly ["clip", "ellipsis"];
+    readonly fontWeight: readonly ["regular", "medium", "bold"];
+    readonly imageFit: readonly ["contain", "cover", "fill", "none"];
+    readonly cellHAlign: readonly ["left", "center", "right"];
+    readonly cellVAlign: readonly ["top", "center", "bottom"];
+    readonly geometryRole: readonly ["layout", "align", "connect", "hit", "measure"];
+    readonly geometryTarget: readonly ["self", "icon"];
+};
+type Shape = (typeof TOKEN_CATALOG.shape)[number];
+type AnchorPosition = (typeof TOKEN_CATALOG.anchorPosition)[number];
+type RouteStyle = (typeof TOKEN_CATALOG.routeStyle)[number];
+type ArrowHead = (typeof TOKEN_CATALOG.arrowHead)[number];
+type StrokeStyle = (typeof TOKEN_CATALOG.strokeStyle)[number];
+type ConstraintStrength = (typeof TOKEN_CATALOG.constraintStrength)[number];
+type TextPosition = (typeof TOKEN_CATALOG.textPosition)[number];
+type TextOverflow = (typeof TOKEN_CATALOG.textOverflow)[number];
+type FontWeight = (typeof TOKEN_CATALOG.fontWeight)[number];
+type ImageFit = (typeof TOKEN_CATALOG.imageFit)[number];
+type Align = (typeof TOKEN_CATALOG.align)[number];
+type Justify = (typeof TOKEN_CATALOG.justify)[number];
+type ContentAlign = (typeof TOKEN_CATALOG.contentAlign)[number];
+type Axis = (typeof TOKEN_CATALOG.axis)[number];
+type GeometryRole = (typeof TOKEN_CATALOG.geometryRole)[number];
+type GeometryTarget = (typeof TOKEN_CATALOG.geometryTarget)[number];
+interface PropertyDef {
+    readonly type: string;
+    readonly category: string;
+    readonly lowering?: string;
+    readonly enum?: string;
+    readonly description?: string;
+    readonly notes?: string;
+}
+declare const PROPERTY_CATALOG: {
+    readonly id: {
+        readonly type: "string";
+        readonly category: "identity";
+        readonly description: "Stable identifier for node/group. Used by constraints, diff, diagnostics";
+    };
+    readonly width: {
+        readonly type: "string | number";
+        readonly category: "size";
+        readonly description: "wrap / fill / fixed value";
+    };
+    readonly height: {
+        readonly type: "string | number";
+        readonly category: "size";
+        readonly description: "wrap / fill / fixed value";
+    };
+    readonly minWidth: {
+        readonly type: "number";
+        readonly category: "size";
+    };
+    readonly maxWidth: {
+        readonly type: "number | string";
+        readonly category: "size";
+        readonly notes: "fill allowed";
+    };
+    readonly minHeight: {
+        readonly type: "number";
+        readonly category: "size";
+    };
+    readonly maxHeight: {
+        readonly type: "number | string";
+        readonly category: "size";
+        readonly notes: "fill allowed";
+    };
+    readonly aspectRatio: {
+        readonly type: "number";
+        readonly category: "size";
+        readonly description: "width / height ratio";
+    };
+    readonly weight: {
+        readonly type: "number";
+        readonly category: "size";
+        readonly description: "Flex ratio in HStack / VStack";
+    };
+    readonly padding: {
+        readonly type: "string | number";
+        readonly category: "spacing";
+        readonly description: "Inner padding. Token or per-side";
+    };
+    readonly gap: {
+        readonly type: "string | number";
+        readonly category: "spacing";
+        readonly description: "Gap between children";
+    };
+    readonly align: {
+        readonly type: "string";
+        readonly category: "alignment";
+        readonly enum: "align";
+        readonly description: "Cross-axis alignment";
+    };
+    readonly justify: {
+        readonly type: "string";
+        readonly category: "alignment";
+        readonly enum: "justify";
+        readonly description: "Main-axis alignment";
+    };
+    readonly selfAlign: {
+        readonly type: "string";
+        readonly category: "alignment";
+        readonly enum: "align";
+        readonly description: "Self alignment override";
+    };
+    readonly contentAlign: {
+        readonly type: "string";
+        readonly category: "alignment";
+        readonly enum: "contentAlign";
+        readonly description: "Child content alignment (Box / Overlay)";
+    };
+    readonly axis: {
+        readonly type: "string";
+        readonly category: "alignment";
+        readonly enum: "axis";
+        readonly description: "Orientation axis";
+    };
+    readonly background: {
+        readonly type: "string";
+        readonly category: "visual";
+        readonly description: "Container background color token";
+    };
+    readonly foreground: {
+        readonly type: "string";
+        readonly category: "visual";
+        readonly description: "Foreground color token (text / icon propagation)";
+    };
+    readonly opacity: {
+        readonly type: "number";
+        readonly category: "visual";
+        readonly description: "Opacity 0..1";
+    };
+    readonly variant: {
+        readonly type: "string";
+        readonly category: "visual";
+        readonly description: "Theme variant";
+    };
+    readonly visible: {
+        readonly type: "boolean";
+        readonly category: "visual";
+        readonly description: "Visibility";
+    };
+    readonly shape: {
+        readonly type: "string";
+        readonly category: "shape-visual";
+        readonly lowering: "attribute";
+        readonly enum: "shape";
+        readonly description: "Visual shape. Layout always uses bounding rect";
+    };
+    readonly radius: {
+        readonly type: "string | number";
+        readonly category: "shape-visual";
+        readonly description: "Corner radius. Effective with shape: rect / roundedRect";
+    };
+    readonly fill: {
+        readonly type: "string";
+        readonly category: "shape-visual";
+        readonly lowering: "attribute";
+        readonly notes: "color token";
+    };
+    readonly stroke: {
+        readonly type: "string";
+        readonly category: "shape-visual";
+        readonly lowering: "attribute";
+        readonly notes: "color token";
+    };
+    readonly strokeWidth: {
+        readonly type: "number";
+        readonly category: "shape-visual";
+        readonly lowering: "attribute";
+    };
+    readonly strokeStyle: {
+        readonly type: "string";
+        readonly category: "shape-visual";
+        readonly lowering: "attribute";
+        readonly enum: "strokeStyle";
+    };
+    readonly shadow: {
+        readonly type: "string";
+        readonly category: "shape-visual";
+        readonly description: "Shadow token";
+    };
+    readonly text: {
+        readonly type: "string";
+        readonly category: "text";
+        readonly description: "Text content (normalized from child text nodes in IR)";
+    };
+    readonly textStyle: {
+        readonly type: "string";
+        readonly category: "text";
+        readonly description: "Typography token";
+    };
+    readonly textAlign: {
+        readonly type: "string";
+        readonly category: "text";
+        readonly description: "Text alignment (start / center / end)";
+    };
+    readonly fontSize: {
+        readonly type: "string | number";
+        readonly category: "text";
+        readonly description: "Font size";
+    };
+    readonly fontWeight: {
+        readonly type: "string";
+        readonly category: "text";
+        readonly enum: "fontWeight";
+    };
+    readonly lineLimit: {
+        readonly type: "number | string";
+        readonly category: "text";
+        readonly description: "Max lines. 'none' for unlimited";
+    };
+    readonly textOverflow: {
+        readonly type: "string";
+        readonly category: "text";
+        readonly enum: "textOverflow";
+    };
+    readonly textPosition: {
+        readonly type: "string";
+        readonly category: "text";
+        readonly lowering: "attribute";
+        readonly enum: "textPosition";
+        readonly description: "Label position on connector";
+    };
+    readonly geometry: {
+        readonly type: "object";
+        readonly category: "geometry";
+        readonly description: "Geometry role mapping: { layout, align, connect, hit, measure } → target (self | icon | child id)";
+    };
+    readonly anchor: {
+        readonly type: "string";
+        readonly category: "constraint";
+        readonly lowering: "none";
+        readonly description: "Reference target for alignment; other targets become movers";
+    };
+    readonly from: {
+        readonly type: "string";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly description: "Source node id or nodeId:role reference";
+    };
+    readonly to: {
+        readonly type: "string";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly description: "Target node id or nodeId:role reference";
+    };
+    readonly fromAnchor: {
+        readonly type: "string";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly enum: "anchorPosition";
+    };
+    readonly toAnchor: {
+        readonly type: "string";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly enum: "anchorPosition";
+    };
+    readonly route: {
+        readonly type: "string";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly enum: "routeStyle";
+    };
+    readonly cornerRadius: {
+        readonly type: "number";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly description: "Corner rounding for orthogonal routing";
+    };
+    readonly curvature: {
+        readonly type: "number";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly description: "Control point distance ratio for curved routing (0.1..1.0, default 0.33)";
+    };
+    readonly startArrow: {
+        readonly type: "string";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly enum: "arrowHead";
+    };
+    readonly endArrow: {
+        readonly type: "string";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly enum: "arrowHead";
+    };
+    readonly arrowSize: {
+        readonly type: "number";
+        readonly category: "connector";
+        readonly lowering: "attribute";
+        readonly description: "Arrow marker scale factor (default 1)";
+    };
+    readonly strokeDasharray: {
+        readonly type: "string";
+        readonly category: "shape-visual";
+        readonly lowering: "attribute";
+        readonly description: "Custom SVG stroke-dasharray. Overrides strokeStyle";
+    };
+    readonly targets: {
+        readonly type: "array";
+        readonly category: "constraint";
+        readonly lowering: "none";
+        readonly notes: "array<string>. Supports nodeId:role syntax for geometry role references";
+    };
+    readonly mover: {
+        readonly type: "string";
+        readonly category: "constraint";
+        readonly lowering: "none";
+    };
+    readonly strength: {
+        readonly type: "string";
+        readonly category: "constraint";
+        readonly lowering: "none";
+        readonly enum: "constraintStrength";
+    };
+    readonly strategy: {
+        readonly type: "string";
+        readonly category: "constraint";
+        readonly lowering: "none";
+        readonly description: "Size equalization strategy: max | min | first";
+    };
+    readonly colAlign: {
+        readonly type: "string";
+        readonly category: "alignment";
+        readonly enum: "cellHAlign";
+        readonly description: "Cell horizontal alignment (left / center / right)";
+    };
+    readonly rowAlign: {
+        readonly type: "string";
+        readonly category: "alignment";
+        readonly enum: "cellVAlign";
+        readonly description: "Cell vertical alignment (top / center / bottom)";
+    };
+    readonly headerRows: {
+        readonly type: "number";
+        readonly category: "structure";
+        readonly description: "Number of header rows (visual distinction)";
+    };
+    readonly src: {
+        readonly type: "string";
+        readonly category: "asset";
+        readonly description: "Image / SVG source reference";
+    };
+    readonly fit: {
+        readonly type: "string";
+        readonly category: "asset";
+        readonly enum: "imageFit";
+        readonly description: "Fit method";
+    };
+    readonly name: {
+        readonly type: "string";
+        readonly category: "asset";
+        readonly lowering: "attribute";
+        readonly description: "Icon token or asset name";
+    };
+};
+type PropertyName = keyof typeof PROPERTY_CATALOG;
+interface ElementDef {
+    readonly tier: "core" | "optional" | "extension";
+    readonly category: string;
+    readonly properties: readonly string[];
+    readonly children: {
+        readonly kind: "list";
+        readonly items: readonly string[];
+    } | {
+        readonly kind: "any";
+    } | {
+        readonly kind: "none";
+    } | {
+        readonly kind: "text";
+    };
+    readonly notes?: string;
+}
+declare const ELEMENT_CATALOG: {
+    readonly document: {
+        readonly tier: "core";
+        readonly category: "structure";
+        readonly properties: readonly ["id", "width", "height", "padding", "background", "variant"];
+        readonly children: {
+            readonly kind: "list";
+            readonly items: readonly ["hstack", "vstack", "overlay", "grid", "flow", "absolute", "box", "group", "table", "connector", "alignConstraint", "equalizeWidth", "equalizeHeight", "minGap", "keepInsideConstraint", "orderConstraint"];
+        };
+    };
+    readonly group: {
+        readonly tier: "core";
+        readonly category: "structure";
+        readonly properties: readonly ["id", "visible", "padding", "gap", "background", "opacity", "geometry", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+    };
+    readonly box: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "width", "height", "minWidth", "maxWidth", "minHeight", "maxHeight", "padding", "gap", "contentAlign", "foreground", "fill", "stroke", "strokeWidth", "strokeStyle", "radius", "shadow", "opacity", "shape", "selfAlign", "geometry", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+    };
+    readonly hstack: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "gap", "align", "justify", "padding", "width", "height", "minWidth", "maxWidth", "minHeight", "maxHeight", "geometry", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+    };
+    readonly vstack: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "gap", "align", "justify", "padding", "width", "height", "minWidth", "maxWidth", "minHeight", "maxHeight", "geometry", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+    };
+    readonly overlay: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "gap", "contentAlign", "padding", "width", "height", "background", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+    };
+    readonly grid: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "gap", "align", "justify", "padding", "width", "height", "minWidth", "maxWidth", "minHeight", "maxHeight", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+        readonly notes: "Track definitions normalized as graph fragments. v1 starts with even tracks";
+    };
+    readonly flow: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "gap", "padding", "width", "height", "minWidth", "maxWidth", "align", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+    };
+    readonly absolute: {
+        readonly tier: "optional";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "padding", "width", "height", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+    };
+    readonly spacer: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "width", "height", "weight"];
+        readonly children: {
+            readonly kind: "none";
+        };
+    };
+    readonly divider: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "axis", "stroke", "strokeWidth", "strokeStyle"];
+        readonly children: {
+            readonly kind: "none";
+        };
+    };
+    readonly text: {
+        readonly tier: "core";
+        readonly category: "text";
+        readonly properties: readonly ["id", "text", "visible", "textStyle", "textAlign", "fontSize", "fontWeight", "lineLimit", "textOverflow", "foreground", "background", "opacity", "padding", "variant"];
+        readonly children: {
+            readonly kind: "text";
+        };
+    };
+    readonly label: {
+        readonly tier: "core";
+        readonly category: "text";
+        readonly properties: readonly ["id", "text", "visible", "textStyle", "textAlign", "fontSize", "fontWeight", "textPosition", "foreground", "background", "opacity", "padding", "radius", "variant"];
+        readonly children: {
+            readonly kind: "text";
+        };
+    };
+    readonly image: {
+        readonly tier: "core";
+        readonly category: "media";
+        readonly properties: readonly ["id", "visible", "src", "fit", "width", "height", "aspectRatio", "radius", "opacity", "variant"];
+        readonly children: {
+            readonly kind: "none";
+        };
+    };
+    readonly icon: {
+        readonly tier: "core";
+        readonly category: "media";
+        readonly properties: readonly ["id", "visible", "name", "foreground", "opacity", "variant"];
+        readonly children: {
+            readonly kind: "none";
+        };
+    };
+    readonly svgAsset: {
+        readonly tier: "core";
+        readonly category: "media";
+        readonly properties: readonly ["id", "visible", "src", "width", "height", "opacity", "variant"];
+        readonly children: {
+            readonly kind: "none";
+        };
+    };
+    readonly table: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "width", "height", "padding", "gap", "headerRows", "fill", "stroke", "strokeWidth", "variant"];
+        readonly children: {
+            readonly kind: "list";
+            readonly items: readonly ["row"];
+        };
+        readonly notes: "Table layout. Column widths equalized via columnWidthResolve (max of cell intrinsic widths). Row heights equalized via rowHeightResolve. No special table algorithm.";
+    };
+    readonly row: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "fill", "variant"];
+        readonly children: {
+            readonly kind: "list";
+            readonly items: readonly ["cell"];
+        };
+    };
+    readonly cell: {
+        readonly tier: "core";
+        readonly category: "layout";
+        readonly properties: readonly ["id", "visible", "width", "height", "padding", "colAlign", "rowAlign", "fill", "stroke", "strokeWidth", "foreground", "variant"];
+        readonly children: {
+            readonly kind: "any";
+        };
+        readonly notes: "Table cell. colAlign (left/center/right) and rowAlign (top/center/bottom) control content positioning within the cell";
+    };
+    readonly connector: {
+        readonly tier: "core";
+        readonly category: "connector";
+        readonly properties: readonly ["id", "visible", "from", "to", "fromAnchor", "toAnchor", "route", "cornerRadius", "curvature", "startArrow", "endArrow", "arrowSize", "stroke", "strokeWidth", "strokeStyle", "strokeDasharray", "opacity", "variant"];
+        readonly children: {
+            readonly kind: "list";
+            readonly items: readonly ["label"];
+        };
+        readonly notes: "Child Labels are annotation text on the connector. Label.textPosition specifies position";
+    };
+    readonly alignConstraint: {
+        readonly tier: "core";
+        readonly category: "constraint";
+        readonly properties: readonly ["id", "targets", "axis", "align", "anchor", "mover", "strength"];
+        readonly children: {
+            readonly kind: "none";
+        };
+        readonly notes: "axis: vertical + align: center = centerX alignment. axis: horizontal + align: center = centerY alignment";
+    };
+    readonly equalizeWidth: {
+        readonly tier: "core";
+        readonly category: "constraint";
+        readonly properties: readonly ["id", "targets", "strategy", "strength"];
+        readonly children: {
+            readonly kind: "none";
+        };
+        readonly notes: "Equalize widths of all targets. strategy: max (default) | min | first";
+    };
+    readonly equalizeHeight: {
+        readonly tier: "core";
+        readonly category: "constraint";
+        readonly properties: readonly ["id", "targets", "strategy", "strength"];
+        readonly children: {
+            readonly kind: "none";
+        };
+        readonly notes: "Equalize heights of all targets. strategy: max (default) | min | first";
+    };
+    readonly minGap: {
+        readonly tier: "optional";
+        readonly category: "constraint";
+        readonly properties: readonly ["id", "targets", "gap", "axis", "strength"];
+        readonly children: {
+            readonly kind: "none";
+        };
+    };
+    readonly keepInsideConstraint: {
+        readonly tier: "optional";
+        readonly category: "constraint";
+        readonly properties: readonly ["id", "targets", "strength"];
+        readonly children: {
+            readonly kind: "none";
+        };
+    };
+    readonly orderConstraint: {
+        readonly tier: "core";
+        readonly category: "constraint";
+        readonly properties: readonly ["id", "targets", "axis", "strength"];
+        readonly children: {
+            readonly kind: "none";
+        };
+        readonly notes: "targets array order is source order. axis: vertical = top-to-bottom, horizontal = left-to-right";
+    };
+};
+type IrKind = keyof typeof ELEMENT_CATALOG;
+
+/**
+ * Layout IR — Intermediate Representation types and parser
+ *
+ * Layout IR is the JSON-based intermediate representation that all input
+ * formats (Draw Text, Draw TSX, direct JSON) converge to. See docs/diagram-contracts.md §4.2.
+ */
+
+interface IrNode {
+    kind: IrKind;
+    id?: string;
+    props: Record<string, unknown>;
+    children?: IrNode[];
+}
+declare const IrNodeSchema: z.ZodType<any>;
+declare function parseIr(json: unknown): IrNode;
+
+/**
+ * Theme / Token Parser
+ *
+ * Parses tokens.yaml and theme.yaml into typed IR structures.
+ * See docs/diagram-vocabulary.md §Theme & Token Configuration.
+ */
+interface TokenEntry {
+    $type: "color" | "dimension" | "fontFamily" | "fontWeight" | "number" | "shadow" | "string";
+    $value: string;
+}
+type TokenIR = {
+    [key: string]: TokenEntry | TokenIR;
+};
+interface ThemeIR {
+    defaults: Record<string, Record<string, unknown>>;
+    variants: Record<string, Record<string, Record<string, unknown>>>;
+}
+declare function parseTokens(yaml: string): TokenIR;
+declare function parseTheme(yaml: string): ThemeIR;
+declare function resolveTokenRef(ref: string, tokens: TokenIR): string;
+
+/**
+ * IR Normalizer — Phase 2
+ *
+ * Takes raw Layout IR + ThemeIR + TokenIR and produces a normalized IR
+ * ready for the constraint graph. See docs/diagram-contracts.md §4.3.
+ */
+
+interface NormalizeOptions {
+    tokens: TokenIR;
+    theme: ThemeIR;
+}
+type GeometryRoleMap = Record<string, string>;
+interface NormalizeResult {
+    ir: IrNode;
+    diagnostics: Diagnostic[];
+    geometryRegistry: Map<string, GeometryRoleMap>;
+}
+interface Diagnostic {
+    level: "error" | "warning";
+    message: string;
+    path: string;
+}
+declare function kindToPascal(kind: string): string;
+declare function normalize(ir: IrNode, options: NormalizeOptions): NormalizeResult;
+
+/**
+ * Draw Text Parser — converts tokenized Draw Text into Layout IR (IrNode tree).
+ *
+ * Handles direction declarations, node definitions, edges (visible + invisible),
+ * subgraph nesting, chain edges, classDef, and @ directives.
+ */
+
+interface ParseResult {
+    ir: IrNode;
+    diagnostics: Diagnostic[];
+}
+declare function parseDrawText(source: string): ParseResult;
+
+/**
+ * Draw TSX Compiler
+ *
+ * Statically analyses `.draw.tsx` source using the TypeScript compiler API
+ * and produces Layout IR (IrNode). No JSX runtime is involved.
+ *
+ * Supports component definitions (exported functions returning JSX) that are
+ * expanded at compile time into primitive IR nodes.
+ */
+
+interface CompileResult {
+    ir: IrNode;
+    diagnostics: Diagnostic[];
+}
+interface CompileOptions {
+    /** Resolve an import specifier to source code string. fromFile is the importing file's specifier for nested resolution. */
+    resolveImport?: (specifier: string, fromFile?: string) => string | undefined;
+    /** Pre-registered component definitions. */
+    components?: Map<string, ComponentDef>;
+}
+interface ComponentDef {
+    name: string;
+    paramNames: Set<string>;
+    template: IrNode;
+}
+declare function compileDrawTsx(source: string, options?: CompileOptions): CompileResult;
+
+/**
+ * Default Tokens & Theme — bundled as embedded YAML strings
+ *
+ * Provides default values so that CLI and convenience functions
+ * produce styled output even without explicit --tokens/--theme flags.
+ */
+
+declare function defaultTokens(): TokenIR;
+declare function defaultTheme(): ThemeIR;
+
+/**
+ * Resolved Layout Artifact Types
+ *
+ * Output of the layout engine after graph evaluation.
+ * See docs/diagram-contracts.md §12.1.
+ */
+
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface ResolvedNode {
+    id: string;
+    kind: IrKind;
+    rect: Rect;
+    worldRect: Rect;
+    styles: Record<string, string | number>;
+    textLines?: string[];
+    textBaseline?: number;
+    textX?: number;
+    textAnchor?: "start" | "middle" | "end";
+    connectorPath?: string;
+    children?: ResolvedNode[];
+}
+interface ResolvedArtifact {
+    viewBox: Rect;
+    nodes: ResolvedNode[];
+    background?: string;
+    fontFamily?: string;
+}
+
+/**
+ * Shape Renderers — SVG element generation for each shape enum value
+ *
+ * All shapes fit within the given bounding Rect.
+ * See docs/diagram-vocabulary.md §shape enum reference.
+ */
+
+/**
+ * Render an SVG shape element fitting within the given Rect.
+ * Falls back to `rect` for unknown shape values.
+ */
+declare function renderShape(shape: string, rect: Rect, styles: Record<string, string | number>): string;
+
+/**
+ * Connector Path Renderer — SVG path/line for connectors + arrow markers
+ *
+ * See docs/diagram-vocabulary.md §connector / §arrowHead.
+ */
+
+/**
+ * Generate empty `<defs>` block (markers are now created dynamically per color).
+ */
+declare function renderArrowMarkers(): string;
+/**
+ * Render a connector as an SVG `<path>` with optional marker references.
+ */
+declare function renderConnector(node: ResolvedNode): string;
+
+/**
+ * Text Renderer — SVG `<text>` with `<tspan>` per line
+ *
+ * Reads fully resolved text layout from the artifact.
+ */
+
+/**
+ * Render text lines as an SVG `<text>` element with `<tspan>` children.
+ */
+declare function renderText(node: ResolvedNode): string;
+
+/**
+ * Icon Registry types — provider-based icon resolution.
+ */
+interface IconPack {
+    readonly provider: string;
+    resolve(name: string): string | undefined;
+    list(): string[];
+}
+interface IconRegistry {
+    register(pack: IconPack): void;
+    resolve(provider: string, name: string): string | undefined;
+    resolveQualified(qualifiedName: string): string | undefined;
+}
+
+/**
+ * SvgComposer — main SVG renderer
+ *
+ * Composes ResolvedArtifact into a complete SVG string.
+ * Pure string generation — no DOM dependency.
+ * See docs/diagram-contracts.md §12.
+ */
+
+interface RenderOptions {
+    iconRegistry?: IconRegistry;
+}
+/**
+ * Render a ResolvedArtifact to a complete SVG string.
+ */
+declare function renderSvg(artifact: ResolvedArtifact, options?: RenderOptions): string;
+
+/**
+ * IconRegistry — provider-based icon resolution.
+ *
+ * Resolves qualified names like "aws:lambda" by splitting on ":"
+ * and delegating to the registered IconPack for that provider.
+ */
+
+declare function createIconRegistry(): IconRegistry;
+
+/**
+ * AWS Icon Pack — resolves AWS service short names to SVG content
+ * using the `aws-icons` npm package.
+ *
+ * `aws-icons` is an optional peer dependency. If not installed,
+ * resolve() returns undefined (graceful degradation).
+ */
+
+declare function createAwsIconPack(): IconPack;
+
+/**
+ * Graph Primitives — Constraint Dependency Graph types
+ *
+ * See docs/diagram-contracts.md §5.
+ */
+type SlotKind = "intrinsicWidth" | "intrinsicHeight" | "availableWidth" | "availableHeight" | "resolvedWidth" | "resolvedHeight" | "localX" | "localY" | "baseLocalX" | "baseLocalY" | "worldX" | "worldY" | "contentWidth" | "contentHeight" | "anchorX" | "anchorY" | "textBaseline" | "textX" | "textAnchor" | "connectorPath";
+interface ValueSlot {
+    id: string;
+    value?: number;
+    nodeId: string;
+    slotKind: SlotKind;
+}
+type OpKind = "sum" | "max" | "clamp" | "resolveSize" | "measureText" | "stackPosition" | "stackCompose" | "suffixShiftDelta" | "alignDelta" | "anchorPoint" | "connectorPath" | "identity" | "subtract" | "add" | "constant" | "copy" | "crossAlign" | "columnWidthResolve" | "columnFill" | "rowHeightResolve";
+interface OperationNode {
+    id: string;
+    op: OpKind;
+    inputs: string[];
+    outputs: string[];
+    compute: (inputs: number[]) => number[];
+}
+type Priority = "required" | "strong" | "normal" | "weak";
+interface CandidateEdge {
+    targetSlotId: string;
+    value?: number;
+    source: string;
+    priority: Priority;
+    operationId?: string;
+}
+type ResolverPolicy = "requiredAllEqual" | "highestPriority" | "max" | "sum";
+interface SlotResolverNode {
+    slotId: string;
+    policy: ResolverPolicy;
+}
+interface DependencyEdge {
+    fromSlotId: string;
+    toOperationId: string;
+}
+
+/**
+ * Graph Evaluator — builds and evaluates the constraint dependency graph
+ *
+ * See docs/diagram-contracts.md §10.
+ */
+
+interface LayoutGraph {
+    slots: Map<string, ValueSlot>;
+    operations: Map<string, OperationNode>;
+    candidates: CandidateEdge[];
+    candidatesBySlot: Map<string, CandidateEdge[]>;
+    candidatesByOperation: Map<string, CandidateEdge[]>;
+    resolvers: Map<string, SlotResolverNode>;
+    dependencies: DependencyEdge[];
+    parentMap: Map<string, string>;
+    nodeKindMap: Map<string, string>;
+    childrenOrderMap: Map<string, string[]>;
+    diagnostics: {
+        level: "error" | "warning";
+        message: string;
+        path: string;
+    }[];
+}
+interface EvaluateResult {
+    artifact: ResolvedArtifact;
+    diagnostics: Diagnostic[];
+}
+declare function createGraph(): LayoutGraph;
+declare function evaluate(graph: LayoutGraph, ir: IrNode): EvaluateResult;
+
+/**
+ * Slot Resolver — resolves multiple candidate values for a single slot
+ *
+ * See docs/diagram-contracts.md §5.5.
+ */
+
+/**
+ * Resolve a set of candidates for a slot according to the given policy.
+ * Returns undefined if no candidates are present.
+ */
+declare function resolveSlot(candidates: CandidateEdge[], policy: ResolverPolicy): number | undefined;
+
+/**
+ * Fragment Factories — IR kind → Graph fragment mapping
+ *
+ * Delegates to rule-engine.ts for all fragment generation.
+ * See docs/diagram-contracts.md §6.
+ */
+
+type FragmentFactory = (node: IrNode, graph: LayoutGraph, parentId?: string) => void;
+
+declare const FRAGMENT_MAP: Record<string, FragmentFactory>;
+
+/**
+ * Pure Operation Functions
+ *
+ * Stateless numeric computations used by OperationNodes.
+ * See docs/diagram-contracts.md §5.3.
+ */
+declare function opSum(inputs: number[]): number[];
+declare function opMax(inputs: number[]): number[];
+declare function opClamp(value: number, min: number, max: number): number;
+declare function opConstant(value: number): () => number[];
+interface TextMeasurer {
+    measure(text: string, fontSize: number, maxWidth?: number, fontWeight?: string | number): {
+        width: number;
+        height: number;
+        lines: string[];
+    };
+}
+/**
+ * SimpleTextMeasurer — approximation-based text measurement (fallback).
+ */
+declare class SimpleTextMeasurer implements TextMeasurer {
+    measure(text: string, fontSize: number, maxWidth?: number): {
+        width: number;
+        height: number;
+        lines: string[];
+    };
+}
+
+/**
+ * diagram-contracts — Public API barrel
+ */
+
+/**
+ * Full layout pipeline: normalize → build graph from fragments → evaluate.
+ */
+declare function layout(ir: IrNode, options: NormalizeOptions): EvaluateResult;
+/**
+ * Full end-to-end pipeline: IR → layout → SVG string.
+ */
+declare function renderToSvg(ir: IrNode, options: NormalizeOptions & {
+    iconRegistry?: IconRegistry;
+}): string;
+/**
+ * Full end-to-end pipeline: Draw Text source → SVG string.
+ */
+declare function renderDrawTextToSvg(source: string, options?: Partial<NormalizeOptions> & {
+    iconRegistry?: IconRegistry;
+}): string;
+/**
+ * Full end-to-end pipeline: Draw TSX source → SVG string.
+ */
+declare function renderDrawTsxToSvg(source: string, options?: Partial<NormalizeOptions> & CompileOptions & {
+    iconRegistry?: IconRegistry;
+}): string;
+
+export { type Align, type AnchorPosition, type ArrowHead, type Axis, type CandidateEdge, type CompileOptions, type CompileResult, type ComponentDef, type ConstraintStrength, type ContentAlign, type DependencyEdge, type Diagnostic, ELEMENT_CATALOG, type ElementDef, type EvaluateResult, FRAGMENT_MAP, type FontWeight, type FragmentFactory, type GeometryRole, type GeometryRoleMap, type GeometryTarget, type IconPack, type IconRegistry, type ImageFit, type IrKind, type IrNode, IrNodeSchema, type Justify, type LayoutGraph, type NormalizeOptions, type NormalizeResult, type OpKind, type OperationNode, PROPERTY_CATALOG, type ParseResult, type Priority, type PropertyDef, type PropertyName, type Rect, type RenderOptions, type ResolvedArtifact, type ResolvedNode, type ResolverPolicy, type RouteStyle, type Shape, SimpleTextMeasurer, type SlotKind, type SlotResolverNode, type StrokeStyle, TOKEN_CATALOG, type TextMeasurer, type TextOverflow, type TextPosition, type ThemeIR, type TokenEntry, type TokenIR, type ValueSlot, compileDrawTsx, createAwsIconPack, createGraph, createIconRegistry, defaultTheme, defaultTokens, evaluate, kindToPascal, layout, normalize, opClamp, opConstant, opMax, opSum, parseDrawText, parseIr, parseTheme, parseTokens, renderArrowMarkers, renderConnector, renderDrawTextToSvg, renderDrawTsxToSvg, renderShape, renderSvg, renderText, renderToSvg, resolveSlot, resolveTokenRef };