@dxos/diagram 0.11.1

package/dist/types/src/scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../src/scene.ts"],"names":[],"mappings":"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"}

package/dist/types/src/scene.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scene.test.d.ts.map

package/dist/types/src/scene.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.test.d.ts","sourceRoot":"","sources":["../../../src/scene.test.ts"],"names":[],"mappings":""}

package/dist/types/src/svg-handler.d.ts

@@ -0,0 +1,5 @@
+import { type ContentHandler } from './content.ts';
+/** Discriminates the base `Drawing.Canvas` as SVG-rendered scene content. */
+export declare const SVG_SCHEMA = "dxos.org/svg/1";
+export declare const SvgHandler: ContentHandler;
+//# sourceMappingURL=svg-handler.d.ts.map

package/dist/types/src/svg-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg-handler.d.ts","sourceRoot":"","sources":["../../../src/svg-handler.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,cAAc,EAAyC,MAAM,cAAc,CAAC;AAG1F,6EAA6E;AAC7E,eAAO,MAAM,UAAU,mBAAmB,CAAC;AAgC3C,eAAO,MAAM,UAAU,EAAE,cAuExB,CAAC"}

package/dist/types/src/svg-handler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=svg-handler.test.d.ts.map

package/dist/types/src/svg-handler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg-handler.test.d.ts","sourceRoot":"","sources":["../../../src/svg-handler.test.ts"],"names":[],"mappings":""}

package/dist/types/src/testing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Minimal layout discussion piece: three packages with three types each — an inheritance fan-in
+ * (B, C extend A), a chain with a has-many (X ⇒ Y → Z), and a fan-in (P, R → Q), plus two
+ * cross-package references (Y → A, Q → X) so routes must leave and enter frames. Small enough to
+ * reason about every placement and route by eye. Relationship kinds are carried by the edge
+ * tokens (UML end markers), not labels.
+ */
+export declare const BASIC = "\nflowchart TB\n  subgraph pkgA [Package A]\n    A[A]\n    B[B]\n    C[C]\n  end\n  subgraph pkgX [Package X]\n    X[X]\n    Y[Y]\n    Z[Z]\n  end\n  subgraph pkgP [Package P]\n    P[P]\n    Q[Q]\n    R[R]\n  end\n  B --|> A\n  C --|> A\n  X --{ Y\n  Y --> Z\n  P --> Q\n  R --> Q\n  Y --> A\n  Q --> X\n";
+/** Exercises class blocks, a stereotype, generics, cardinalities, and every relation kind. */
+export declare const CLASS_DIAGRAM = "\nclassDiagram\n    direction TB\n\n    class Animal {\n        <<abstract>>\n        +name: string\n        +move() void\n    }\n\n    class Dog {\n        +breed: string\n        +bark() void\n    }\n\n    class Serializable {\n        <<interface>>\n        +serialize() string\n    }\n\n    class Leg\n    class Owner\n\n    Animal <|-- Dog\n    Serializable <|.. Dog\n    Dog *-- Leg\n    Owner \"1\" o-- \"*\" Dog : owns\n    Dog ..> Bone : chews\n";
+//# sourceMappingURL=testing.d.ts.map

package/dist/types/src/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../src/testing.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,qTAyBjB,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,aAAa,2cA4BzB,CAAC"}

package/dist/types/src/ui.d.ts

@@ -0,0 +1,67 @@
+import type * as Schema from 'effect/Schema';
+import type * as Scene from './scene.ts';
+export type ControlKind = 'input' | 'switch' | 'checkbox' | 'select';
+export type Control = {
+    kind: 'control';
+    control: ControlKind;
+    label: string;
+    /** Dotted schema path; doubles as the element id so drawn controls stay addressable. */
+    path: string;
+};
+/** Nested object: a labeled group of fields. */
+export type Group = {
+    kind: 'group';
+    label: string;
+    path: string;
+    children: FormChild[];
+};
+/** Array: a labeled repetition of one item template. */
+export type ArrayGroup = {
+    kind: 'array';
+    label: string;
+    path: string;
+    /** The element template, rendered once with a trailing "+" affordance. */
+    item: FormChild;
+};
+export type FormChild = Control | Group | ArrayGroup;
+/** A form has no title of its own — the schema title belongs to the enclosing container. */
+export type Form = {
+    kind: 'form';
+    children: FormChild[];
+};
+export type Panel = {
+    kind: 'panel';
+    label?: string;
+    child: Form;
+};
+export type Plank = {
+    kind: 'plank';
+    label?: string;
+    child: Panel;
+};
+export type Deck = {
+    kind: 'deck';
+    planks: Plank[];
+};
+export type UiNode = Deck | Plank | Panel | Form | FormChild;
+export type FromSchemaOptions = {
+    /** Recursion guard for self-referential schemas. */
+    maxDepth?: number;
+};
+/** Convert a schema into a form drawing: the phase-1 slice of the app model. */
+export declare const fromSchema: (schema: Schema.Top, options?: FromSchemaOptions) => Form;
+/** The schema's title annotation — container chrome, not form content. */
+export declare const schemaTitle: (schema: Schema.Top) => string | undefined;
+/** Wrap a form in the app-ontology containers for a full schematic. */
+export declare const deckOf: (form: Form, title?: string) => Deck;
+export type CompileOptions = {
+    /** Canvas position of the schematic's top-left, in canvas px. */
+    origin?: Scene.Point;
+    /** Canvas px per scene unit. */
+    scale?: number;
+};
+/** Compile a UI drawing into scene commands (frames first, controls above them). */
+export declare const compile: (node: UiNode, options?: CompileOptions) => Scene.Command[];
+/** Render a UI drawing as ASCII art. */
+export declare const renderAscii: (node: UiNode) => string;
+//# sourceMappingURL=ui.d.ts.map

package/dist/types/src/ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["../../../src/ui.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAOzC,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;AAErE,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,EAAE,CAAC;CACvB,CAAC;AAEF,wDAAwD;AACxD,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,CAAC;AAErD,4FAA4F;AAC5F,MAAM,MAAM,IAAI,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;AAC3D,MAAM,MAAM,KAAK,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC;AACnE,MAAM,MAAM,KAAK,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AACpE,MAAM,MAAM,IAAI,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,CAAC;AAErD,MAAM,MAAM,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC;AAQ7D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAiEF,gFAAgF;AAChF,eAAO,MAAM,UAAU,WAAY,MAAM,CAAC,GAAG,YAAW,iBAAiB,KAAQ,IAMhF,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,WAAW,WAAY,MAAM,CAAC,GAAG,KAAG,MAAM,GAAG,SAAgC,CAAC;AAE3F,uEAAuE;AACvE,eAAO,MAAM,MAAM,SAAU,IAAI,UAAU,MAAM,KAAG,IAGlD,CAAC;AA0KH,MAAM,MAAM,cAAc,GAAG;IAC3B,iEAAiE;IACjE,MAAM,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;IACrB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,OAAO,SAAU,MAAM,YAAW,cAAc,KAAQ,KAAK,CAAC,OAAO,EAmBjF,CAAC;AA+CF,wCAAwC;AACxC,eAAO,MAAM,WAAW,SAAU,MAAM,KAAG,MAAqC,CAAC"}

package/dist/types/src/ui.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ui.test.d.ts.map

package/dist/types/src/ui.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.test.d.ts","sourceRoot":"","sources":["../../../src/ui.test.ts"],"names":[],"mappings":""}

package/dist/types/src/uml-engine.d.ts

@@ -0,0 +1,14 @@
+import type * as Scene from './scene.ts';
+import { type CompileOptions as GridCompileOptions } from './uml-grid.ts';
+export type Engine = 'dagre' | 'elk';
+export type CompileOptions = Omit<GridCompileOptions, 'route'> & {
+    /** Placement engine (default 'elk'). */
+    engine?: Engine;
+};
+/**
+ * Compile a mermaid class diagram with engine-backed placement; identical output structure to
+ * `UmlGrid.compile` (equal-size grid cells, orthogonal Z-routed connectors), but node positions
+ * come from dagre/ELK. Async because ELK is.
+ */
+export declare const compile: (source: string, options?: CompileOptions) => Promise<Scene.Command[]>;
+//# sourceMappingURL=uml-engine.d.ts.map

package/dist/types/src/uml-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-engine.d.ts","sourceRoot":"","sources":["../../../src/uml-engine.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AACzC,OAAO,EAGL,KAAK,cAAc,IAAI,kBAAkB,EAI1C,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAErC,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,EAAE,OAAO,CAAC,GAAG;IAC/D,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAkGF;;;;GAIG;AACH,eAAO,MAAM,OAAO,WAAkB,MAAM,YAAW,cAAc,KAAQ,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,CAYnG,CAAC"}

package/dist/types/src/uml-engine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uml-engine.test.d.ts.map

package/dist/types/src/uml-engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-engine.test.d.ts","sourceRoot":"","sources":["../../../src/uml-engine.test.ts"],"names":[],"mappings":""}

package/dist/types/src/uml-grid.d.ts

@@ -0,0 +1,99 @@
+import * as Layout from './layout.ts';
+import type * as Scene from './scene.ts';
+import { type UmlModel } from './uml.ts';
+/**
+ * Snap unit for cells, gaps, and positions, chosen so node edges land on the grid lines tldraw
+ * renders at working zoom (it draws lines at power-of-two multiples of its document gridSize).
+ */
+export declare const GRID = 32;
+/** Node rect in scene units. */
+export type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export type RoutedRelation = {
+    /** The edge being routed; routers read only its endpoints, so any dialect's edge type fits. */
+    relation: Layout.LayoutEdge;
+    from: Rect;
+    to: Rect;
+    /** True when the diagram flows LR/RL, so ranks stack along x. */
+    horizontal: boolean;
+    /** Channel slot among relations sharing a gutter, centered on it (shift = offset × GRID_FINE). */
+    offset: number;
+    /** Terminal cross-axis coordinates (port positions); node-edge centers when omitted. */
+    ports?: {
+        start?: number;
+        end?: number;
+    };
+};
+/**
+ * Produces the connector waypoints for one relation, in scene units. The returned polyline is
+ * rendered verbatim (last segment carries the arrowhead), so a router fully controls the path.
+ */
+export type Router = (edge: RoutedRelation) => Scene.Point[];
+/**
+ * Default router: an orthogonal Z along the flow axis — rank-crossing edges route through the
+ * inter-rank gutter (channel shifted per parallel edge); same-rank edges route out the side.
+ */
+export declare const zRouter: Router;
+/** Fixed cell size, in scene units; omitted dimensions are measured from content. */
+export type CellSize = {
+    w?: number;
+    h?: number;
+};
+export type Cell = {
+    w: number;
+    h: number;
+    titleH: number;
+};
+export type MeasureOptions = {
+    maxWidth: number;
+    cell?: CellSize;
+    titleHeight?: number;
+};
+/** One cell fits the largest class: widest line (wrapped at maxWidth) and tallest member list. */
+export declare const measureCell: (model: UmlModel, { maxWidth, cell: override, titleHeight }: MeasureOptions) => Cell;
+export type CompileOptions = {
+    /** Canvas position of the diagram's top-left, in canvas px. */
+    origin?: Scene.Point;
+    /** Canvas px per scene unit. */
+    scale?: number;
+    /** Gap between ranks along the flow direction, in scene units (default GRID × 4, snapped). */
+    gapMain?: number;
+    /** Gap between classes within a rank, in scene units (default GRID × 4, snapped). */
+    gapCross?: number;
+    /** Maximum cell width, in scene units (default GRID × 6); longer lines wrap. */
+    maxWidth?: number;
+    /** Fixed cell size (snapped to GRID); overrides measurement per dimension. */
+    cell?: CellSize;
+    /** Fixed header height, in scene units (snapped to the fine grid); measured when unset. */
+    titleHeight?: number;
+    /** Connector routing (default `zRouter`). */
+    route?: Router;
+};
+/** A placed diagram: the parsed model plus per-class node rects (scene units). */
+export type Placement = {
+    model: UmlModel;
+    cell: Cell;
+    rects: Map<string, Rect>;
+    ranks: Map<string, number>;
+};
+export type EmitOptions = {
+    origin?: Scene.Point;
+    scale?: number;
+    route?: Router;
+};
+/**
+ * Compile a mermaid class diagram into scene commands with equal-size grid-aligned nodes: per
+ * class a `title` bar plus a `body` compartment filling the cell, and an `edges` object holding
+ * orthogonal connector paths (polyline waypoints, an arrowhead segment, and a floating label).
+ */
+export declare const compile: (source: string, options?: CompileOptions) => Scene.Command[];
+/**
+ * Emit scene commands from a placed model — the shared back half of `compile`, also used by the
+ * engine-backed dialects (`uml-engine.ts`) which supply their own placement.
+ */
+export declare const emit: ({ model, cell, rects, ranks }: Placement, { origin, scale, route }?: EmitOptions) => Scene.Command[];
+//# sourceMappingURL=uml-grid.d.ts.map

package/dist/types/src/uml-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-grid.d.ts","sourceRoot":"","sources":["../../../src/uml-grid.ts"],"names":[],"mappings":"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"}

package/dist/types/src/uml-grid.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uml-grid.test.d.ts.map

package/dist/types/src/uml-grid.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-grid.test.d.ts","sourceRoot":"","sources":["../../../src/uml-grid.test.ts"],"names":[],"mappings":""}

package/dist/types/src/uml-rules.d.ts

@@ -0,0 +1,56 @@
+import type * as Scene from './scene.ts';
+import { type Cell, type CompileOptions as GridCompileOptions, type Rect } from './uml-grid.ts';
+import { type UmlModel } from './uml.ts';
+/** A laid-out group: member rects in group-local coordinates plus the packed bounds. */
+export type Group = {
+    id: string;
+    /** Rule that claimed the group (frame label; singletons carry none). */
+    rule?: string;
+    rects: Map<string, Rect>;
+    w: number;
+    h: number;
+};
+/**
+ * A layout rule: claims disjoint groups from the still-unclaimed nodes and lays each out
+ * internally. Rules run in priority order; unclaimed nodes fall through to singleton groups.
+ */
+export type GroupRule = {
+    id: string;
+    apply: (model: UmlModel, unclaimed: Set<string>, cell: Cell) => Group[];
+};
+/**
+ * Inheritance trees: each supertype with claimable subtypes forms a group — the hierarchy stacks
+ * vertically (root on top, arrows up) and peers share a horizontal axis, packed as a tidy tree
+ * (each parent centered over its subtree).
+ */
+export declare const inheritanceTreeRule: GroupRule;
+/**
+ * Longest linear chain: the longest path through the still-unclaimed up-oriented relation graph
+ * renders left to right (each target directly right of its source).
+ */
+export declare const linearChainRule: GroupRule;
+export type CompileOptions = Omit<GridCompileOptions, 'route'> & {
+    /** Grouping rules, highest priority first. */
+    rules?: GroupRule[];
+};
+/** Run the rules over the model; leftovers become singleton groups. */
+export declare const buildGroups: (model: UmlModel, cell: Cell, rules: GroupRule[]) => Group[];
+/**
+ * Pack groups as super-nodes: rank by up-oriented cross-group edges (target group above), then
+ * lay ranks out as rows, bottom rank last — mirroring the node-level convention.
+ */
+export declare const packGroups: (model: UmlModel, groups: Group[]) => Map<string, Scene.Point>;
+/** Absolute node rects for a (possibly partial) group placement. */
+export declare const resolveRects: (groups: Group[], origins: Map<string, Scene.Point>) => Map<string, Rect>;
+/** Dashed frames behind multi-node groups. */
+export declare const frameCommands: (groups: Group[], origins: Map<string, Scene.Point>, { origin, scale }?: {
+    origin?: Scene.Point;
+    scale?: number;
+}) => Scene.Command[];
+/**
+ * Compile with rule-based grouping: rules claim groups, leftovers become singletons, groups pack
+ * as super-nodes ranked by their cross-group edges (lanes advance vertically; no borders overlap
+ * by construction), and multi-node groups render a dashed frame behind their members.
+ */
+export declare const compile: (source: string, options?: CompileOptions) => Scene.Command[];
+//# sourceMappingURL=uml-rules.d.ts.map

package/dist/types/src/uml-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-rules.d.ts","sourceRoot":"","sources":["../../../src/uml-rules.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AACzC,OAAO,EACL,KAAK,IAAI,EAET,KAAK,cAAc,IAAI,kBAAkB,EACzC,KAAK,IAAI,EAGV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,QAAQ,EAAwB,MAAM,UAAU,CAAC;AAQ/D,wFAAwF;AACxF,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,KAAK,KAAK,EAAE,CAAC;CACzE,CAAC;AAUF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAuEjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,SAmD7B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,EAAE,OAAO,CAAC,GAAG;IAC/D,8CAA8C;IAC9C,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;CACrB,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,WAAW,UAAW,QAAQ,QAAQ,IAAI,SAAS,SAAS,EAAE,KAAG,KAAK,EAelF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,UAAW,QAAQ,UAAU,KAAK,EAAE,KAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAiCpF,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,YAAY,WAAY,KAAK,EAAE,WAAW,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,KAAG,GAAG,CAAC,MAAM,EAAE,IAAI,CAYjG,CAAC;AAEF,8CAA8C;AAC9C,eAAO,MAAM,aAAa,WAChB,KAAK,EAAE,WACN,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,sBACO;IAAE,MAAM,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KAC/E,KAAK,CAAC,OAAO,EAyBV,CAAC;AAEP;;;;GAIG;AACH,eAAO,MAAM,OAAO,WAAY,MAAM,YAAW,cAAc,KAAQ,KAAK,CAAC,OAAO,EAYnF,CAAC"}

package/dist/types/src/uml-rules.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uml-rules.test.d.ts.map

package/dist/types/src/uml-rules.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-rules.test.d.ts","sourceRoot":"","sources":["../../../src/uml-rules.test.ts"],"names":[],"mappings":""}

package/dist/types/src/uml-search.d.ts

@@ -0,0 +1,26 @@
+import type * as Scene from './scene.ts';
+import { type CompileOptions as GridCompileOptions, type Rect } from './uml-grid.ts';
+import { type Group, type GroupRule } from './uml-rules.ts';
+import { type UmlModel } from './uml.ts';
+/**
+ * Layout score over the placed subset: +1 per straight or single-bend (L) route, −1 per crossing
+ * pair. Routes come from the cheap Z-router — the score ranks candidates, the A* router draws
+ * the final picture.
+ */
+export declare const scoreLayout: (model: UmlModel, rects: Map<string, Rect>) => number;
+/**
+ * Greedy tree search: place the chain (or largest) group first, then repeatedly place the
+ * unplaced group connected to the earliest-placed node, trying axis-aligned candidates around
+ * the anchor (below and above preferred, then right/left, sliding off collisions) and keeping
+ * the best-scoring one.
+ */
+export declare const searchPlacement: (model: UmlModel, groups: Group[]) => Map<string, Scene.Point>;
+export type CompileOptions = Omit<GridCompileOptions, 'route'> & {
+    rules?: GroupRule[];
+};
+/**
+ * Compile via the scored search, falling back to whichever of {search, rank packing} scores
+ * higher — the search is greedy, so the packing occasionally beats it.
+ */
+export declare const compile: (source: string, options?: CompileOptions) => Scene.Command[];
+//# sourceMappingURL=uml-search.d.ts.map

package/dist/types/src/uml-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-search.d.ts","sourceRoot":"","sources":["../../../src/uml-search.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AACzC,OAAO,EAAQ,KAAK,cAAc,IAAI,kBAAkB,EAAE,KAAK,IAAI,EAA8B,MAAM,eAAe,CAAC;AACvH,OAAO,EACL,KAAK,KAAK,EACV,KAAK,SAAS,EAOf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,QAAQ,EAAwB,MAAM,UAAU,CAAC;AA+C/D;;;;GAIG;AACH,eAAO,MAAM,WAAW,UAAW,QAAQ,SAAS,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,KAAG,MA6BvE,CAAC;AAKF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,UAAW,QAAQ,UAAU,KAAK,EAAE,KAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAkHzF,CAAC;AAMF,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,EAAE,OAAO,CAAC,GAAG;IAC/D,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;CACrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,WAAY,MAAM,YAAW,cAAc,KAAQ,KAAK,CAAC,OAAO,EAkBnF,CAAC"}

package/dist/types/src/uml-search.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uml-search.test.d.ts.map

package/dist/types/src/uml-search.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml-search.test.d.ts","sourceRoot":"","sources":["../../../src/uml-search.test.ts"],"names":[],"mappings":""}

package/dist/types/src/uml.d.ts

@@ -0,0 +1,60 @@
+import type * as Scene from './scene.ts';
+export type Direction = 'TB' | 'BT' | 'LR' | 'RL';
+export type UmlClass = {
+    id: string;
+    label: string;
+    /** e.g. "interface", "abstract", "enumeration". */
+    stereotype?: string;
+    attributes: string[];
+    methods: string[];
+};
+export type RelationKind = 'inheritance' | 'realization' | 'composition' | 'aggregation' | 'association' | 'dependency';
+/** Rendered arrow direction: subtype → supertype, whole → part, source → target. */
+export type UmlRelation = {
+    from: string;
+    to: string;
+    kind: RelationKind;
+    label?: string;
+    fromCardinality?: string;
+    toCardinality?: string;
+};
+export type UmlModel = {
+    direction: Direction;
+    classes: UmlClass[];
+    relations: UmlRelation[];
+};
+/** Parse a mermaid class diagram into a neutral model. Unrecognised lines are ignored. */
+export declare const parse: (source: string) => UmlModel;
+/** Arrow styling per relation kind; dependency and realization render dashed, as in UML. */
+export declare const relationStyle: (kind: RelationKind) => {
+    stroke?: Scene.Stroke;
+};
+/** Mid-arrow label: cardinalities and the diamond glyph UML puts at the whole end. */
+export declare const relationText: (relation: UmlRelation) => string | undefined;
+/**
+ * Rank so arrows read upward where UML convention points at abstractions — inheritance,
+ * realization, and dependency targets sit above their sources; containment and association
+ * flow downward (whole/source above part/target).
+ */
+export declare const relationRanks: (model: UmlModel) => Map<string, number>;
+export type CompileOptions = {
+    /** Canvas position of the diagram's top-left, in canvas px. */
+    origin?: Scene.Point;
+    /** Canvas px per scene unit. */
+    scale?: number;
+    /** Gap between ranks along the flow direction, in scene units (default 90). */
+    gapMain?: number;
+    /** Gap between classes within a rank, in scene units (default 60). */
+    gapCross?: number;
+    /** Maximum class-box width, in scene units (default 400); longer lines wrap. */
+    maxWidth?: number;
+};
+/**
+ * Compile a mermaid class diagram into scene commands: one world object per class (compartment
+ * rects `title`/`attributes`/`methods`) and an `edges` object holding the relations as bound
+ * arrows. Supertypes rank above subtypes, so inheritance reads downward.
+ */
+export declare const compile: (source: string, options?: CompileOptions) => Scene.Command[];
+/** True when the mermaid source declares a class diagram rather than a flowchart. */
+export declare const isClassDiagram: (source: string) => boolean;
+//# sourceMappingURL=uml.d.ts.map

package/dist/types/src/uml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml.d.ts","sourceRoot":"","sources":["../../../src/uml.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAElD,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,aAAa,GAAG,aAAa,GAAG,aAAa,GAAG,aAAa,GAAG,YAAY,CAAC;AAExH,oFAAoF;AACpF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,SAAS,EAAE,WAAW,EAAE,CAAC;CAC1B,CAAC;AAyCF,0FAA0F;AAC1F,eAAO,MAAM,KAAK,WAAY,MAAM,KAAG,QA4FtC,CAAC;AA6CF,4FAA4F;AAC5F,eAAO,MAAM,aAAa,SAAU,YAAY,KAAG;IAAE,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAA;CACG,CAAC;AAE9E,sFAAsF;AACtF,eAAO,MAAM,YAAY,aAAc,WAAW,KAAG,MAAM,GAAG,SAI7D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,UAAW,QAAQ,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAQ/D,CAAC;AAEJ,MAAM,MAAM,cAAc,GAAG;IAC3B,+DAA+D;IAC/D,MAAM,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;IACrB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,WAAY,MAAM,YAAW,cAAc,KAAQ,KAAK,CAAC,OAAO,EA0HnF,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,cAAc,WAAY,MAAM,KAAG,OAAmD,CAAC"}

package/dist/types/src/uml.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uml.test.d.ts.map

package/dist/types/src/uml.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uml.test.d.ts","sourceRoot":"","sources":["../../../src/uml.test.ts"],"names":[],"mappings":""}