@dxos/diagram 0.11.1

package/dist/lib/testing.mjs

@@ -0,0 +1,68 @@
+//#region src/testing.ts
+/**
+* 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.
+*/
+var BASIC = `
+flowchart TB
+  subgraph pkgA [Package A]
+    A[A]
+    B[B]
+    C[C]
+  end
+  subgraph pkgX [Package X]
+    X[X]
+    Y[Y]
+    Z[Z]
+  end
+  subgraph pkgP [Package P]
+    P[P]
+    Q[Q]
+    R[R]
+  end
+  B --|> A
+  C --|> A
+  X --{ Y
+  Y --> Z
+  P --> Q
+  R --> Q
+  Y --> A
+  Q --> X
+`;
+/** Exercises class blocks, a stereotype, generics, cardinalities, and every relation kind. */
+var CLASS_DIAGRAM = `
+classDiagram
+    direction TB
+
+    class Animal {
+        <<abstract>>
+        +name: string
+        +move() void
+    }
+
+    class Dog {
+        +breed: string
+        +bark() void
+    }
+
+    class Serializable {
+        <<interface>>
+        +serialize() string
+    }
+
+    class Leg
+    class Owner
+
+    Animal <|-- Dog
+    Serializable <|.. Dog
+    Dog *-- Leg
+    Owner "1" o-- "*" Dog : owns
+    Dog ..> Bone : chews
+`;
+//#endregion
+export { BASIC, CLASS_DIAGRAM };
+
+//# sourceMappingURL=testing.mjs.map

package/dist/lib/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../../src/testing.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n/**\n * Minimal layout discussion piece: three packages with three types each — an inheritance fan-in\n * (B, C extend A), a chain with a has-many (X ⇒ Y → Z), and a fan-in (P, R → Q), plus two\n * cross-package references (Y → A, Q → X) so routes must leave and enter frames. Small enough to\n * reason about every placement and route by eye. Relationship kinds are carried by the edge\n * tokens (UML end markers), not labels.\n */\nexport 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`;\n\n/** Exercises class blocks, a stereotype, generics, cardinalities, and every relation kind. */\nexport 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`;\n"],"mappings":";;;;;;;;AAWA,IAAa,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BrB,IAAa,gBAAgB"}

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

@@ -0,0 +1,60 @@
+import type * as Scene from './scene.ts';
+/** Opaque map of record id → renderer record. */
+export type ContentMap = Record<string, any>;
+/** DSL identity stamped onto a managed record. */
+export type Identity = {
+    object: string;
+    element: string;
+    /** Set on companion records that belong to an element rather than being one (e.g. arrow labels). */
+    part?: string;
+};
+/** Where an object sits on the canvas: `canvas = origin + local * scale`. */
+export type Placement = {
+    origin: Scene.Point;
+    scale: number;
+};
+/** An object as accepted by the renderer's compiler; `upsert-elements` supplies only a subset. */
+export type ObjectInput = Scene.WorldObject | {
+    id: string;
+    elements: readonly Scene.Element[];
+};
+/** A world object as derived from the canvas: placement is always resolved. */
+export type ReadWorldObject = Scene.WorldObject & Placement;
+export type ReadResult = {
+    scene: {
+        objects: ReadWorldObject[];
+    };
+    /** Records on the canvas not managed by the DSL (drawn by hand). */
+    unmanaged: number;
+};
+export type ApplyResult = {
+    /** Object ids created or modified. */
+    upserted: string[];
+    /** Records removed. */
+    removed: number;
+};
+/**
+ * The renderer-specific half of command application: how records carry identity, how objects
+ * compile to records, and any bookkeeping the renderer's store requires.
+ */
+export type ContentHandler = {
+    /** DSL identity for a record, or undefined when the record isn't managed by the DSL. */
+    identify: (record: any) => Identity | undefined;
+    /** Compile an object's elements into records keyed by record id. */
+    render: (object: ObjectInput, placement: Placement, content: ContentMap) => ContentMap;
+    /** Derive the scene from the content map. */
+    read: (content: ContentMap) => ReadResult;
+    /** Translate an object move into a per-record mutation. */
+    translate: (record: any, delta: Scene.Point) => void;
+    /** Create any scaffolding the renderer needs before its first record (e.g. a page). */
+    scaffold?: (content: ContentMap) => void;
+    /** Merge compiled records into the content map; defaults to a plain assign. */
+    merge?: (content: ContentMap, records: ContentMap) => void;
+    /** Clean up after deletions (e.g. drop bindings left dangling). */
+    prune?: (content: ContentMap) => void;
+};
+/** Apply a batch of edit commands to the canvas content (mutates `content`). */
+export declare const applyCommands: (content: ContentMap, commands: readonly Scene.Command[], handler: ContentHandler) => ApplyResult;
+/** Seed a fractional-index counter past any existing `a<n>` indexes. */
+export declare const nextIndex: (content: ContentMap, isCounted?: (record: any) => boolean) => number;
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/content.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC,iDAAiD;AACjD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE7C,kDAAkD;AAClD,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,oGAAoG;IACpG,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,6EAA6E;AAC7E,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,kGAAkG;AAClG,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,SAAS,KAAK,CAAC,OAAO,EAAE,CAAA;CAAE,CAAC;AAEjG,+EAA+E;AAC/E,MAAM,MAAM,eAAe,GAAG,KAAK,CAAC,WAAW,GAAG,SAAS,CAAC;AAE5D,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE;QAAE,OAAO,EAAE,eAAe,EAAE,CAAA;KAAE,CAAC;IACtC,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,wFAAwF;IACxF,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,QAAQ,GAAG,SAAS,CAAC;IAChD,oEAAoE;IACpE,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,KAAK,UAAU,CAAC;IACvF,6CAA6C;IAC7C,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,UAAU,CAAC;IAC1C,2DAA2D;IAC3D,SAAS,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC;IACrD,uFAAuF;IACvF,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC;IACzC,+EAA+E;IAC/E,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC;IAC3D,mEAAmE;IACnE,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,aAAa,YACf,UAAU,YACT,SAAS,KAAK,CAAC,OAAO,EAAE,WACzB,cAAc,KACtB,WAqFF,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,SAAS,YAAa,UAAU,cAAa,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,KAAgB,MAcjG,CAAC"}

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

@@ -0,0 +1,56 @@
+import * as Schema from 'effect/Schema';
+import type * as Scene from './scene.ts';
+export declare const Severity: Schema.Literals<readonly ["error", "warning"]>;
+export type Severity = Schema.Schema.Type<typeof Severity>;
+/**
+ * `error` codes are objective defects — the picture is wrong, not merely busy — and gate CI.
+ * `warning` codes are quality metrics that trend rather than pass/fail; they are golden-filed so
+ * a layout change reads as a reviewable diff instead of a threshold argument.
+ */
+export declare const Code: Schema.Literals<readonly ["node-overlap", "route-through-node", "label-overflow", "edge-crossing", "excessive-bends"]>;
+export type Code = Schema.Schema.Type<typeof Code>;
+export declare const SEVERITY: Record<Code, Severity>;
+/** A schema so operations can return diagnostics to the agent — the repair loop. */
+export declare const Diagnostic: Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["node-overlap", "route-through-node", "label-overflow", "edge-crossing", "excessive-bends"]>;
+    readonly severity: Schema.Literals<readonly ["error", "warning"]>;
+    readonly message: Schema.String;
+    readonly refs: Schema.$Array<Schema.String>;
+}>;
+export type Diagnostic = Schema.Schema.Type<typeof Diagnostic>;
+/** Aggregate counts; the soft ones are the score a layout change is reviewed against. */
+export type Metrics = {
+    nodes: number;
+    connectors: number;
+    overlaps: number;
+    routesThroughNodes: number;
+    labelOverflows: number;
+    crossings: number;
+    bends: number;
+    /** Total connector length in scene units; long edges are hard to follow. */
+    length: number;
+    width: number;
+    height: number;
+    /** Boxes that enclose another object's box (subgraph / group frames). */
+    containers: number;
+    /** Smallest gap from a container to its nearest container (Infinity with fewer than two). */
+    frameGapMin: number;
+    /** Spread (max − min) of each container's nearest-neighbour gap; 0 when gutters are uniform. */
+    frameGapSpread: number;
+};
+export type Report = {
+    diagnostics: readonly Diagnostic[];
+    metrics: Metrics;
+};
+export type Options = {
+    /** Bends per connector above which `excessive-bends` is reported (default 3). */
+    maxBends?: number;
+};
+/**
+ * Analyzes an emitted scene for layout defects and quality metrics. Pure: the same scene always
+ * yields the same report, so the soft metrics can be golden-filed and the hard codes asserted.
+ */
+export declare const analyze: (objects: readonly Scene.WorldObject[], { maxBends }?: Options) => Report;
+/** Errors only — the set that gates CI and that an agent must fix before the diagram is usable. */
+export declare const errors: (report: Report) => readonly Diagnostic[];
+//# sourceMappingURL=diagnostics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/diagnostics.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,QAAQ,gDAAwC,CAAC;AAC9D,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE3D;;;;GAIG;AACH,eAAO,MAAM,IAAI,wHAMf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,QAAQ,CAM3C,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,UAAU;;;;;EAOrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,yFAAyF;AACzF,MAAM,MAAM,OAAO,GAAG;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,6FAA6F;IAC7F,WAAW,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,iFAAiF;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAyKF;;;GAGG;AACH,eAAO,MAAM,OAAO,YAAa,SAAS,KAAK,CAAC,WAAW,EAAE,iBAAoB,OAAO,KAAQ,MAsI/F,CAAC;AAEF,mGAAmG;AACnG,eAAO,MAAM,MAAM,WAAY,MAAM,KAAG,SAAS,UAAU,EACQ,CAAC"}

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

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

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

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

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

@@ -0,0 +1,19 @@
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import * as Scene from './scene.ts';
+export type Dialect<Input = any> = {
+    id: string;
+    description: string;
+    input: Schema.Codec<Input, any>;
+    compile: (input: Input) => Effect.Effect<readonly Scene.Command[]>;
+};
+/** The core dialect: input is already scene edit commands (identity compile). */
+export declare const sceneDialect: Dialect<readonly Scene.Command[]>;
+export declare class DialectRegistry {
+    #private;
+    constructor(dialects?: Dialect[]);
+    register(dialect: Dialect): void;
+    get(id: string): Dialect | undefined;
+    list(): Dialect[];
+}
+//# sourceMappingURL=dialect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../../src/dialect.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AAEpC,MAAM,MAAM,OAAO,CAAC,KAAK,GAAG,GAAG,IAAI;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAChC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;CACpE,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,SAAS,KAAK,CAAC,OAAO,EAAE,CAK1D,CAAC;AAEF,qBAAa,eAAe;;IAG1B,YAAY,QAAQ,GAAE,OAAO,EAAmB,EAE/C;IAED,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAG/B;IAED,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAEnC;IAED,IAAI,IAAI,OAAO,EAAE,CAEhB;CACF"}

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

@@ -0,0 +1,16 @@
+export * from './content.ts';
+export * from './dialect.ts';
+export * as Diagnostics from './diagnostics.ts';
+export * as Layout from './layout.ts';
+export * as Mermaid from './mermaid.ts';
+export * as MermaidEngine from './mermaid-engine.ts';
+export * as Objective from './objective.ts';
+export * as Scene from './scene.ts';
+export * from './svg-handler.ts';
+export * as Ui from './ui.ts';
+export * as Uml from './uml.ts';
+export * as UmlEngine from './uml-engine.ts';
+export * as UmlGrid from './uml-grid.ts';
+export * as UmlRules from './uml-rules.ts';
+export * as UmlSearch from './uml-search.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,aAAa,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,SAAS,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,SAAS,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,26 @@
+import type * as Scene from './scene.ts';
+export type LayoutEdge = {
+    from: string;
+    to: string;
+};
+export type FontMetrics = {
+    /** Average glyph advance, in scene units at scale 1. */
+    charW: number;
+    /** Line height, in scene units at scale 1. */
+    lineH: number;
+};
+/**
+ * Empirical text metrics per scene weight, calibrated to tldraw's draw font (`size` s/m/l/xl runs
+ * ~18/25/38/48 px): charW ≈ 0.6–0.67 em, lineH ≈ 1.35 em. Dialects size boxes from these so text
+ * fits without the renderer growing shapes over their neighbours.
+ */
+export declare const FONT_METRICS: Record<Scene.Weight, FontMetrics>;
+/**
+ * Edges that close a cycle, found by DFS: an edge into a node still on the stack points backwards.
+ * Ranking ignores them, so `C --> Y --> C` ranks C by its forward predecessors alone instead of
+ * chasing the loop.
+ */
+export declare const backEdges: <Edge extends LayoutEdge>(nodeIds: readonly string[], edges: readonly Edge[]) => Set<Edge>;
+/** Assign each node a rank one past its deepest forward predecessor. */
+export declare const rank: (nodeIds: readonly string[], edges: readonly LayoutEdge[]) => Map<string, number>;
+//# sourceMappingURL=layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/layout.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,WAAW,CAK1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,IAAI,SAAS,UAAU,WAAW,SAAS,MAAM,EAAE,SAAS,SAAS,IAAI,EAAE,KAAG,GAAG,CAAC,IAAI,CAoC/G,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,IAAI,YAAa,SAAS,MAAM,EAAE,SAAS,SAAS,UAAU,EAAE,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAkBjG,CAAC"}

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

@@ -0,0 +1,83 @@
+import * as Objective from './objective.ts';
+import type * as Scene from './scene.ts';
+import { type Router } from './uml-grid.ts';
+/** How ELK orders siblings within a layer. */
+export type Order = 'model' | 'free';
+/**
+ * How groups relate: `layered` lays the whole hierarchy out in one flow (groups stack along it);
+ * `columns` lays each group out in the flow direction and arranges the groups side by side
+ * across it, so cross-package edges run sideways instead of stacking packages.
+ */
+export type Arrangement = 'layered' | 'columns';
+/**
+ * How a plain reference ranks its ends. Inheritance always ranks the base above, has-many and
+ * containment the owner above; a reference has no such convention, so it is a candidate axis:
+ * `down` — the referenced sits below, ELK's reading of an arrow; `up` — the referenced sits above,
+ * as the abstraction does, so a node many others point at heads its package; `free` — a reference
+ * ranks nothing and its ends may share a row. Between packages a reference always orders the packages.
+ */
+export type Layering = 'down' | 'up' | 'free';
+/**
+ * How packages sit along the flow in `columns`: `none` keeps ELK's placement; `edges` shifts each
+ * package by whole rows to where its cross-package edges meet their partners' rows, so those edges
+ * run straight instead of jogging between a short package and a tall one.
+ */
+export type Alignment = 'none' | 'edges';
+export type CompileOptions = {
+    /** Canvas position of the diagram's top-left, in canvas px. */
+    origin?: Scene.Point;
+    /** Canvas px per scene unit. */
+    scale?: number;
+    /**
+     * Pitch of the placement lattice as a multiple of the cell size. Node origins snap to lattice
+     * points, so nodes that ELK placed roughly in line share an axis exactly and their connectors
+     * run straight; the gutter between neighbours is `(lattice − 1) × cell`. A list names the
+     * candidates the objective chooses among (default `[1.5, 2]`); a number fixes it.
+     */
+    lattice?: number | readonly number[];
+    /** ELK sibling ordering candidates (default both): declaration order, or free to minimize crossings. */
+    order?: readonly Order[];
+    /** Group arrangement candidates (default both when the graph has two or more groups). */
+    arrangement?: readonly Arrangement[];
+    /** How references rank their ends (default all three candidates). */
+    layering?: readonly Layering[];
+    /** Package alignment candidates along the flow, in `columns` (default both). */
+    alignment?: readonly Alignment[];
+    /**
+     * Inheritance bus candidates (default both): with `true`, subtypes on one row that share a base
+     * connect through one horizontal bus and a single triangle-headed trunk instead of parallel arrows.
+     */
+    bus?: readonly boolean[];
+    /** Objective that picks among candidates (default `Objective.DEFAULT`). */
+    objective?: Objective.Objective;
+    /** Maximum cell width, in scene units (default GRID × 6); longer labels wrap. */
+    maxWidth?: number;
+    /** Connector router (default: obstacle-avoiding A* with the Z-router as fallback). */
+    route?: Router;
+};
+/** One generated layout with the objective's verdict on it. */
+export type Candidate = {
+    lattice: number;
+    order: Order;
+    arrangement: Arrangement;
+    layering: Layering;
+    alignment: Alignment;
+    bus: boolean;
+    commands: Scene.Command[];
+    layout: Objective.Layout;
+};
+export type Result = {
+    commands: Scene.Command[];
+    chosen: Objective.Ranked<Candidate>;
+    /** Every candidate, best first. */
+    ranked: readonly Objective.Ranked<Candidate>[];
+};
+/**
+ * Lay out a mermaid flowchart: place once per lattice × ordering, emit with and without the
+ * inheritance bus, analyze every candidate, and let the objective choose. All candidates come back
+ * ranked so a bench can show what lost and why. Async because ELK is.
+ */
+export declare const layout: (source: string, options?: CompileOptions) => Promise<Result>;
+/** The chosen layout's scene commands; see {@link layout} for the candidates and verdicts. */
+export declare const compile: (source: string, options?: CompileOptions) => Promise<Scene.Command[]>;
+//# sourceMappingURL=mermaid-engine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid-engine.d.ts","sourceRoot":"","sources":["../../../src/mermaid-engine.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AACzC,OAAO,EAAmB,KAAK,MAAM,EAAW,MAAM,eAAe,CAAC;AAsBtE,8CAA8C;AAC9C,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;AAErC;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAWzC,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;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IACrC,wGAAwG;IACxG,KAAK,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IACzB,yFAAyF;IACzF,WAAW,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IACrC,qEAAqE;IACrE,QAAQ,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC/B,gFAAgF;IAChF,SAAS,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACjC;;;OAGG;IACH,GAAG,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACzB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC;IAChC,iFAAiF;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,+DAA+D;AAC/D,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,GAAG,EAAE,OAAO,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAC1B,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAC1B,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACpC,mCAAmC;IACnC,MAAM,EAAE,SAAS,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;CAChD,CAAC;AAmpBF;;;;GAIG;AACH,eAAO,MAAM,MAAM,WAAkB,MAAM,YAAW,cAAc,KAAQ,OAAO,CAAC,MAAM,CAiEzF,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,OAAO,WAAkB,MAAM,YAAW,cAAc,KAAQ,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,CAC1D,CAAC"}

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

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

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

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

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

@@ -0,0 +1,56 @@
+import type * as Scene from './scene.ts';
+export type Direction = 'TB' | 'BT' | 'LR' | 'RL';
+export type MermaidNode = {
+    id: string;
+    label: string;
+    /** Enclosing subgraph id, when declared inside one. */
+    group?: string;
+    /** What the node depicts (DXN or URI), from a `%% ref <id> <target>` directive. */
+    ref?: string;
+};
+export type MermaidGroup = {
+    id: string;
+    label: string;
+    children: string[];
+};
+/** Relationship kind, from the edge token; drawn with the UML end markers in `markers`. */
+export type RelationKind = 'reference' | 'inheritance' | 'hasMany' | 'contains';
+export type MermaidEdge = {
+    from: string;
+    to: string;
+    kind: RelationKind;
+    label?: string;
+};
+/**
+ * Rewrite the UML edge tokens into mermaid-legal labelled arrows, for rendering the source with
+ * mermaid.js itself (as a reference beside our layout). Lossy by design: mermaid flowcharts have no
+ * triangle or crow's foot, so the kind becomes the label unless the edge already has one; `%% ref`
+ * lines are already comments.
+ */
+export declare const toStandard: (source: string) => string;
+/** Scene arrow markers for a relationship kind. */
+export declare const markers: (kind: RelationKind) => Pick<Scene.Arrow, 'head' | 'tail'>;
+export type MermaidGraph = {
+    direction: Direction;
+    nodes: MermaidNode[];
+    groups: MermaidGroup[];
+    edges: MermaidEdge[];
+};
+/** Parse a mermaid flowchart into a neutral graph. Unrecognised lines are ignored. */
+export declare const parse: (source: string) => MermaidGraph;
+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 60). */
+    gapMain?: number;
+    /** Gap between nodes within a rank, in scene units (default 40). */
+    gapCross?: number;
+};
+/**
+ * Compile a mermaid flowchart into scene commands: one world object per node (element `box`),
+ * one per subgraph frame, and an `edges` object holding the connectors as bound arrows.
+ */
+export declare const compile: (source: string, options?: CompileOptions) => Scene.Command[];
+//# sourceMappingURL=mermaid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid.d.ts","sourceRoot":"","sources":["../../../src/mermaid.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAElD,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mFAAmF;IACnF,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,UAAU,CAAC;AAEhF,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;CAChB,CAAC;AAqBF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,WAAY,MAAM,KAAG,MAO7B,CAAC;AAEhB,mDAAmD;AACnD,eAAO,MAAM,OAAO,SAAU,YAAY,KAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAW7E,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB,CAAC;AAeF,sFAAsF;AACtF,eAAO,MAAM,KAAK,WAAY,MAAM,KAAG,YAwFtC,CAAC;AAgBF,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,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,WAAY,MAAM,YAAW,cAAc,KAAQ,KAAK,CAAC,OAAO,EAiGnF,CAAC"}

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

@@ -0,0 +1,3 @@
+/** Exercises node declarations, a labelled-blank subgraph, fan-out, and a `C <-> Y` cycle. */
+export declare const FLOWCHART = "\nflowchart TB\n    X[X]\n\n    subgraph CORE[\" \"]\n        A[A]\n        B[B]\n        C[C]\n\n        A --> B\n        A --> C\n    end\n\n    Y[Y]\n\n    X --> A\n    X --> B\n    X --> C\n    C --> Y\n    Y --> C\n";
+//# sourceMappingURL=mermaid.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid.test.d.ts","sourceRoot":"","sources":["../../../src/mermaid.test.ts"],"names":[],"mappings":"AASA,8FAA8F;AAC9F,eAAO,MAAM,SAAS,iOAoBrB,CAAC"}

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

@@ -0,0 +1,75 @@
+import type * as Diagnostics from './diagnostics.ts';
+import type * as Scene from './scene.ts';
+/** A candidate layout: the scene plus its analysis. */
+export type Layout = {
+    objects: readonly Scene.WorldObject[];
+    report: Diagnostics.Report;
+};
+/** Hard requirement; `violations` names each way the layout breaks it, empty when it holds. */
+export type Constraint = {
+    id: string;
+    description: string;
+    violations: (layout: Layout) => readonly string[];
+};
+/** Soft preference; `measure` is in the term's natural unit and `weight` converts it to cost. */
+export type CostTerm = {
+    id: string;
+    description: string;
+    weight: number;
+    measure: (layout: Layout) => number;
+};
+export type Objective = {
+    constraints: readonly Constraint[];
+    costs: readonly CostTerm[];
+};
+export type Evaluation = {
+    violations: readonly {
+        constraint: string;
+        message: string;
+    }[];
+    /** Weighted sum of the cost terms. */
+    cost: number;
+    terms: readonly {
+        id: string;
+        value: number;
+        weighted: number;
+    }[];
+};
+export declare const evaluate: (objective: Objective, layout: Layout) => Evaluation;
+export type Ranked<T> = {
+    candidate: T;
+    evaluation: Evaluation;
+};
+/**
+ * Picks the best candidate: fewest constraint violations first (so an infeasible set still yields
+ * the least-bad layout rather than nothing), then lowest cost. Stable on ties, so the generator's
+ * own order breaks them.
+ */
+export declare const select: <T extends {
+    layout: Layout;
+}>(objective: Objective, candidates: readonly T[]) => {
+    chosen: Ranked<T>;
+    ranked: readonly Ranked<T>[];
+};
+/** Every `error` diagnostic is a violation: overlaps, routes through nodes, labels that do not fit. */
+export declare const noHardDefects: Constraint;
+/** Containers keep at least `gap` between them, so packages read as separate. */
+export declare const framesApart: (gap?: number) => Constraint;
+export declare const crossings: CostTerm;
+export declare const bends: CostTerm;
+/**
+ * Uneven gutters between frames, in grid units. Weighted so a whole cell of unevenness costs about
+ * half a crossing: on the pipeline corpus diagram a weight of 2 made the objective accept three
+ * crossings to even out a 7-unit spread, which no reader would.
+ */
+export declare const unevenFrameGaps: CostTerm;
+/**
+ * Total connector length in grid units: a long edge is hard to follow even when it is straight.
+ * Weighted so ~100 grid units of extra connector cost one crossing — at 0.1 the objective traded
+ * crossings for shorter edges on the compute and edge corpus diagrams.
+ */
+export declare const connectorLength: CostTerm;
+/** Bounding perimeter in grid units; a light preference for the tighter of otherwise-equal layouts. */
+export declare const compactness: CostTerm;
+export declare const DEFAULT: Objective;
+//# sourceMappingURL=objective.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objective.d.ts","sourceRoot":"","sources":["../../../src/objective.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,KAAK,WAAW,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAGzC,uDAAuD;AACvD,MAAM,MAAM,MAAM,GAAG;IACnB,OAAO,EAAE,SAAS,KAAK,CAAC,WAAW,EAAE,CAAC;IACtC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;CAC5B,CAAC;AAEF,+FAA+F;AAC/F,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,CAAC;CACnD,CAAC;AAEF,iGAAiG;AACjG,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,SAAS;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC/D,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnE,CAAC;AAEF,eAAO,MAAM,QAAQ,cAAe,SAAS,UAAU,MAAM,KAAG,UAS/D,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IAAE,SAAS,EAAE,CAAC,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,aACtC,SAAS,cACR,SAAS,CAAC,EAAE,KACvB;IAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,MAAM,CAAC,CAAC,CAAC,EAAE,CAAA;CAUnD,CAAC;AAOF,uGAAuG;AACvG,eAAO,MAAM,aAAa,EAAE,UAK3B,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,WAAW,SAAS,MAAM,KAAU,UAO/C,CAAC;AAEH,eAAO,MAAM,SAAS,EAAE,QAKvB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,QAKnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,QAK7B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,QAK7B,CAAC;AAEF,uGAAuG;AACvG,eAAO,MAAM,WAAW,EAAE,QAKzB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,SAGrB,CAAC"}

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

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

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

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

package/dist/types/src/ortho-router.d.ts

@@ -0,0 +1,13 @@
+import type { Rect, Router } from './uml-grid.ts';
+export type AvoidingRouterOptions = {
+    /** Search-cell size (scene px): a fraction of the layout grid, so routes can hug node borders. */
+    step: number;
+};
+/**
+ * Creates a router that avoids the given node rects. Stateful across edges: earlier routes
+ * penalize (not block) the cells they occupy, spreading parallel runs apart. `fallback` handles
+ * the (fenced-in) edges the search cannot reach. The step is passed in rather than derived from
+ * `uml-grid`'s `GRID`, which keeps this module free of a value import cycle with the dialects.
+ */
+export declare const makeAvoidingRouter: (obstacles: Rect[], fallback: Router, { step: STEP }: AvoidingRouterOptions) => Router;
+//# sourceMappingURL=ortho-router.d.ts.map

package/dist/types/src/ortho-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ortho-router.d.ts","sourceRoot":"","sources":["../../../src/ortho-router.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,EAAE,MAAM,eAAe,CAAC;AAiBlE,MAAM,MAAM,qBAAqB,GAAG;IAClC,kGAAkG;IAClG,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,cAClB,IAAI,EAAE,YACP,MAAM,kBACA,qBAAqB,KACpC,MAuUF,CAAC"}