@dxos/diagram 0.11.1 → 0.13.0

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

@@ -0,0 +1,12 @@
+import type * as DecisionModel from 'effect/ai/DecisionModel';
+import * as Architecture from './architecture.ts';
+import type * as Score from './score.ts';
+export declare const RULES: readonly Architecture.Rule[];
+/** {@link RULES} for a judge shown the page as an image (`Architecture.Subject.images`) instead of `layout`. */
+export declare const IMAGE_RULES: readonly Architecture.Rule[];
+/**
+ * Every aesthetic rule as a score from one `DecisionModel` call. Without `layout` or an image of the
+ * page there is nothing to judge, so each rule reports an error rather than a guess.
+ */
+export declare const judge: (rules?: readonly Architecture.Rule[]) => Score.Batch<Architecture.Subject, DecisionModel.DecisionModel>;
+//# sourceMappingURL=aesthetics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aesthetics.d.ts","sourceRoot":"","sources":["../../../src/aesthetics.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,aAAa,MAAM,yBAAyB,CAAC;AAG9D,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAmBzC,eAAO,MAAM,KAAK,EAAE,SAAS,YAAY,CAAC,IAAI,EA0F7C,CAAC;AAEF,gHAAgH;AAChH,eAAO,MAAM,WAAW,EAAE,SAAS,YAAY,CAAC,IAAI,EAGjD,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,KAAK,WACT,SAAS,YAAY,CAAC,IAAI,EAAE,KAClC,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,aAAa,CAS/D,CAAC"}

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

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

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

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

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

@@ -0,0 +1,55 @@
+import type * as DecisionModel from 'effect/ai/DecisionModel';
+import * as Architecture from './architecture.ts';
+import * as Diagnostics from './diagnostics.ts';
+import * as Objective from './objective.ts';
+import * as Rules from './rules.ts';
+import type * as Scene from './scene.ts';
+import type * as Score from './score.ts';
+import * as View from './view.ts';
+type Point = Scene.Point;
+/** Everything an evaluator reads: the scene, its geometry and its defect report, computed once. */
+export type Subject = {
+    readonly objects: readonly Scene.WorldObject[];
+    readonly drawing: View.Drawing;
+    readonly report: Diagnostics.Report;
+    /** Connectors as a reader traces them (a bus once per spoke), each with the boxes at its ends. */
+    readonly edges: readonly Edge[];
+};
+export type Edge = {
+    readonly points: readonly Point[];
+    readonly bends: number;
+    readonly from?: View.Box;
+    readonly to?: View.Box;
+    readonly style?: View.Path['style'];
+};
+export type Measure = {
+    readonly score: number;
+    readonly detail: string;
+};
+export type Evaluator = (subject: Subject) => Measure;
+/** Code evaluators, keyed by rule id; every `code` and `both` rule in the library has one. */
+export declare const EVALUATORS: Readonly<Record<string, Evaluator>>;
+/** Measures every code-evaluated rule of a scene. */
+export declare const measure: (objects: readonly Scene.WorldObject[], rules?: readonly Rules.DiagramRule[]) => (Rules.DiagramRule & Measure)[];
+/** The weighted mean of rule scores: one number for comparing drawings of the same diagram. */
+export declare const overall: (scores: readonly {
+    weight: number;
+    score: number;
+}[]) => number;
+/** The library's `vision` and `both` rules as questions for a judge shown the rendered page. */
+export declare const visionRules: (rules?: readonly Rules.DiagramRule[]) => readonly Architecture.Rule[];
+/** The vision rules as one batched judge over the rendered page; a failed call scores every rule as an error. */
+export declare const judge: (rules?: readonly Rules.DiagramRule[]) => Score.Batch<Architecture.Subject, DecisionModel.DecisionModel>;
+/** The code-evaluated rules as scorers over a scene, for `Score.evaluate` beside the judge. */
+export declare const scorers: (rules?: readonly Rules.DiagramRule[]) => Score.Scorer<readonly Scene.WorldObject[]>[];
+/**
+ * A layout objective that adds the library's appeal to `base`: its hard constraints and costs stay, and
+ * every point of appeal a candidate lacks costs `weight` (a crossing costs 3), so the engine prefers the
+ * candidate a reader would. Appeal is measured over the code-evaluated rules only.
+ */
+export declare const objective: (base?: Objective.Objective, { weight, rules }?: {
+    weight?: number;
+    rules?: readonly Rules.DiagramRule[];
+}) => Objective.Objective;
+export {};
+//# sourceMappingURL=appeal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"appeal.d.ts","sourceRoot":"","sources":["../../../src/appeal.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,aAAa,MAAM,yBAAyB,CAAC;AAG9D,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAEhD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,KAAK,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;AAGzB,mGAAmG;AACnG,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,OAAO,EAAE,SAAS,KAAK,CAAC,WAAW,EAAE,CAAC;IAC/C,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;IACpC,kGAAkG;IAClG,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1E,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;AAoJtD,8FAA8F;AAC9F,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CA2S1D,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,OAAO,YACT,SAAS,KAAK,CAAC,WAAW,EAAE,UAC9B,SAAS,KAAK,CAAC,WAAW,EAAE,KAClC,CAAC,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,EAY/B,CAAC;AAEF,+FAA+F;AAC/F,eAAO,MAAM,OAAO,WAAY,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,KAAG,MAG9E,CAAC;AAOF,gGAAgG;AAChG,eAAO,MAAM,WAAW,WAAW,SAAS,KAAK,CAAC,WAAW,EAAE,KAAiB,SAAS,YAAY,CAAC,IAAI,EAavG,CAAC;AAEJ,iHAAiH;AACjH,eAAO,MAAM,KAAK,WACT,SAAS,KAAK,CAAC,WAAW,EAAE,KAClC,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,aAAa,CAAqD,CAAC;AAEtH,+FAA+F;AAC/F,eAAO,MAAM,OAAO,WACX,SAAS,KAAK,CAAC,WAAW,EAAE,KAClC,KAAK,CAAC,MAAM,CAAC,SAAS,KAAK,CAAC,WAAW,EAAE,CAAC,EAgB1C,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,SAAS,UACd,SAAS,CAAC,SAAS,sBACa;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,KAAK,CAAC,WAAW,EAAE,CAAA;CAAE,KAC9F,SAAS,CAAC,SAWX,CAAC"}

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

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

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

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

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

@@ -0,0 +1,86 @@
+import * as Decision from 'effect/ai/Decision';
+import * as DecisionModel from 'effect/ai/DecisionModel';
+import * as Schema from 'effect/Schema';
+import type * as Mermaid from './mermaid.ts';
+import type * as Score from './score.ts';
+/** What a diagram says, plus optionally how it is drawn: the input every rule is judged against. */
+export declare const Content: Schema.Struct<{
+    readonly title: Schema.optional<Schema.String>;
+    readonly layout: Schema.optional<Schema.String>;
+    readonly groups: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+    }>>;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly group: Schema.optional<Schema.String>;
+    }>>;
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly from: Schema.String;
+        readonly to: Schema.String;
+        readonly label: Schema.optional<Schema.String>;
+        readonly kind: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export type Content = Schema.Schema.Type<typeof Content>;
+/** The content of a parsed mermaid graph, with an optional caption and text rendering of its layout. */
+export declare const contentOf: (graph: Mermaid.MermaidGraph, { title, layout }?: {
+    title?: string;
+    layout?: string;
+}) => Content;
+export type Rule = {
+    /** Kebab-case, as the review rule it adapts is named. */
+    id: string;
+    /** Decision key: System One names questions by identifier. */
+    key: string;
+    description: string;
+    /** The question, phrased so `true` means the diagram follows the rule. */
+    instructions: string;
+    criteria: {
+        false: string;
+        true: string;
+    };
+};
+/**
+ * The first batch of `architecture-rules`' recommended rules that a diagram can show, plus the
+ * bounded-state pair `non-negotiables.mdl` already enforces on code.
+ */
+export declare const RULES: readonly Rule[];
+/** The decision definition for a set of rules: one probability per rule, answered in one call. */
+export declare const definition: (rules?: readonly Rule[]) => Decision.Definition<Schema.Struct<{
+    readonly title: Schema.optional<Schema.String>;
+    readonly layout: Schema.optional<Schema.String>;
+    readonly groups: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+    }>>;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly group: Schema.optional<Schema.String>;
+    }>>;
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly from: Schema.String;
+        readonly to: Schema.String;
+        readonly label: Schema.optional<Schema.String>;
+        readonly kind: Schema.optional<Schema.String>;
+    }>>;
+}>, {
+    [k: string]: Decision.Probability;
+}>;
+/**
+ * What a judge is shown: the diagram's content, and optionally the rendered page as images for a
+ * model that reads them (one that does not fails the call, which scores every rule as an error).
+ */
+export type Subject = {
+    readonly content: Content;
+    readonly images?: readonly DecisionModel.Image[];
+};
+/**
+ * Every rule as a score, from one `DecisionModel` call: the probability that the diagram follows the
+ * rule. A failed call scores every rule as an error rather than as 0, so an outage never reads as a
+ * bad diagram. `kind` labels the scores, so another rule set (e.g. `Aesthetics`) can share the judge.
+ */
+export declare const judge: (rules?: readonly Rule[], kind?: Score.Kind) => Score.Batch<Subject, DecisionModel.DecisionModel>;
+//# sourceMappingURL=architecture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"architecture.d.ts","sourceRoot":"","sources":["../../../src/architecture.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,aAAa,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC,oGAAoG;AACpG,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;EAqBlB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAC;AAEzD,wGAAwG;AACxG,eAAO,MAAM,SAAS,UACb,OAAO,CAAC,YAAY,sBACR;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,KACrD,OAWD,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG;IACjB,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAC;IACX,8DAA8D;IAC9D,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C,CAAC;AAgBF;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,SAAS,IAAI,EAgFhC,CAAC;AAEF,kGAAkG;AAClG,eAAO,MAAM,UAAU,WAAW,SAAS,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;EAM7C,CAAC;AAEL;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,aAAa,CAAC,KAAK,EAAE,CAAA;CAAE,CAAC;AAEtG;;;;GAIG;AACH,eAAO,MAAM,KAAK,WACT,SAAS,IAAI,EAAE,SAChB,KAAK,CAAC,IAAI,KACf,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,aAAa,CAAC,aAAa,CAmBlD,CAAC"}

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

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

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

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

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

@@ -0,0 +1,39 @@
+import type * as Scene from './scene.ts';
+export type Geometry = {
+    /** Box size, shared by every node. */
+    cell: {
+        w: number;
+        h: number;
+    };
+    /** Lattice pitch; every move is a whole number of pitches. */
+    pitch: {
+        x: number;
+        y: number;
+    };
+    /** Inset of a frame around its members, and the label band above them. */
+    framePad: number;
+    frameLabel: number;
+    /** Clear space a frame keeps from other frames and from boxes outside it. */
+    frameGap: number;
+};
+export type Graph = {
+    nodes: readonly string[];
+    groups: readonly {
+        id: string;
+        children: readonly string[];
+    }[];
+    edges: readonly {
+        from: string;
+        to: string;
+    }[];
+};
+type Points = Map<string, Scene.Point>;
+/**
+ * Compacts a lattice placement. Units are every package (moved rigidly) and every box (moved
+ * within or outside its package); a move is kept only when it lowers the cost — connector length
+ * plus bends plus the drawing's width and height, all in lattice units — and introduces no
+ * violation of the placement's invariants.
+ */
+export declare const compact: (graph: Graph, positions: ReadonlyMap<string, Scene.Point>, geometry: Geometry) => Points;
+export {};
+//# sourceMappingURL=compact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../src/compact.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAC;AAGzC,MAAM,MAAM,QAAQ,GAAG;IACrB,sCAAsC;IACtC,IAAI,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,8DAA8D;IAC9D,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,MAAM,EAAE,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IAC/D,KAAK,EAAE,SAAS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAChD,CAAC;AAWF,KAAK,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;AAgBvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,UAAW,KAAK,aAAa,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,YAAY,QAAQ,KAAG,MAyJvG,CAAC"}

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

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

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

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

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

@@ -1,5 +1,5 @@
 import * as Schema from 'effect/Schema';
-import type * as Scene from './scene.ts';
+import * as Scene from './scene.ts';
 export declare const Severity: Schema.Literals<readonly ["error", "warning"]>;
 export type Severity = Schema.Schema.Type<typeof Severity>;
 /**
@@ -7,12 +7,12 @@ export type Severity = Schema.Schema.Type<typeof Severity>;
  * `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 declare const Code: Schema.Literals<readonly ["node-overlap", "route-through-node", "label-overflow", "edge-crossing", "excessive-bends", "text-overlap", "edge-overlap"]>;
 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 code: Schema.Literals<readonly ["node-overlap", "route-through-node", "label-overflow", "edge-crossing", "excessive-bends", "text-overlap", "edge-overlap"]>;
     readonly severity: Schema.Literals<readonly ["error", "warning"]>;
     readonly message: Schema.String;
     readonly refs: Schema.$Array<Schema.String>;
@@ -21,10 +21,15 @@ 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 as a reader traces them, source to target: a bus counts once per spoke. */
     connectors: number;
     overlaps: number;
     routesThroughNodes: number;
     labelOverflows: number;
+    /** Free text (edge and frame labels) overlapping another label or a box it does not belong to. */
+    textOverlaps: number;
+    /** Connector pairs that run along the same line for part of their length, so a reader cannot tell them apart. */
+    edgeOverlaps: number;
     crossings: number;
     bends: number;
     /** Total connector length in scene units; long edges are hard to follow. */
@@ -46,6 +51,67 @@ export type Options = {
     /** Bends per connector above which `excessive-bends` is reported (default 3). */
     maxBends?: number;
 };
+type Point = Scene.Point;
+type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export type Label = {
+    ref: string;
+    rect: Rect;
+};
+/**
+ * Absolute extents of free text elements, estimated from the font metrics as the renderers draw it:
+ * `x, y` is the top-left, one line per `\n`.
+ */
+export declare const labels: (objects: readonly Scene.WorldObject[]) => Label[];
+/** Absolute rects of every shape an arrow can bind to, keyed `objectId/elementId` as `Scene.resolveRef` spells them. */
+export declare const bindTargets: (objects: readonly Scene.WorldObject[]) => Map<string, Rect>;
+/**
+ * The polyline drawn for an arrow, in absolute coordinates: a bound end sits where the line between the
+ * two centres leaves its shape, and an arrow bound to one shape at both ends loops off its top-right
+ * corner. Undefined when an end resolves to nothing. Renderers draw through this so the picture and the
+ * measurement cannot disagree.
+ */
+export declare const arrowPoints: (object: Scene.WorldObject, arrow: Scene.Arrow, targets: ReadonlyMap<string, Rect>) => Point[] | undefined;
+/** A connector as a reader traces it, from one shape to another; `ref` names the piece at its far end. */
+export type Route = {
+    ref: string;
+    points: Point[];
+    /** Turns a reader follows; a turn where pieces of a bus meet is the bus's shape, not a bend. */
+    bends: number;
+};
+/** Every connector's routes, as a reader traces them; a bus contributes one per spoke. */
+export declare const routes: (objects: readonly Scene.WorldObject[]) => Route[];
+/** Box label type as the SVG renderer sets it, per weight: font size and line advance in scene units. */
+export declare const LABEL_TYPE: Record<Scene.Weight, {
+    size: number;
+    lineH: number;
+}>;
+/** Average glyph advance over font size for a UI sans, for wrap estimates. */
+export declare const CHAR_EM = 0.6;
+/** Room kept between a box label and the box's sides, and its top and bottom. */
+export declare const LABEL_INSET: {
+    x: number;
+    y: number;
+};
+export type LabelLayout = {
+    lines: string[];
+    size: number;
+    lineH: number;
+    /** The label does not show whole: it was ellipsized, or even one line is taller than the box. */
+    overflow: boolean;
+};
+/**
+ * How the SVG renderer sets a box label: wrapped to the box width, shrunk a little if it still does not
+ * fit the height, and ellipsized at the smallest size, so text never spills out of its box.
+ */
+export declare const layoutLabel: (text: string, weight: Scene.Weight, { w, h }: {
+    w: number;
+    h: number;
+}) => LabelLayout;
 /**
  * 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.
@@ -53,4 +119,5 @@ export type Options = {
 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[];
+export {};
 //# sourceMappingURL=diagnostics.d.ts.map

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

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

package/dist/types/src/dsl/cli.d.ts

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

package/dist/types/src/dsl/cli.d.ts.map

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

package/dist/types/src/dsl/compile.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from 'effect/Effect';
+import * as SemanticEngine from '../semantic-engine.ts';
+import { type ParseResult } from './parse.ts';
+/** Options for {@link compile}. */
+export type CompileOptions = Pick<SemanticEngine.SolveOptions, 'emitCandidate'>;
+/**
+ * Reads a document and lays out its semantic statements with the full search, which also tries the
+ * mermaid engine's placements when nothing was hinted. Asynchronous only because that engine's ELK
+ * is; a document of scene statements alone reads exactly as {@link parse} reads it.
+ */
+export declare const compile: (text: string, options?: CompileOptions) => Effect.Effect<ParseResult>;
+//# sourceMappingURL=compile.d.ts.map

package/dist/types/src/dsl/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../../src/dsl/compile.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,cAAc,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,KAAK,WAAW,EAAoB,MAAM,YAAY,CAAC;AAEhE,mCAAmC;AACnC,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,CAU1F,CAAC"}

package/dist/types/src/dsl/convert.d.ts

@@ -0,0 +1,45 @@
+import * as Effect from 'effect/Effect';
+import type * as Scene from '../scene.ts';
+/** A source language that can be turned into DSL text. */
+export type Source = {
+    id: string;
+    description: string;
+    /** True when a source string looks like this language, for `convert` to pick without being told. */
+    detect: (source: string) => boolean;
+    compile: (source: string) => Effect.Effect<readonly Scene.Command[]>;
+};
+/** Mermaid `classDiagram`, laid out synchronously by the UML engine. */
+export declare const umlSource: Source;
+/**
+ * Mermaid `flowchart`, laid out by the ELK-backed engine. ELK is promise-based, so the platform
+ * boundary sits here rather than leaking a Promise into the rest of the pipeline.
+ */
+export declare const mermaidSource: Source;
+/** Mermaid flowchart without the ELK pass — the simple layered placement in `mermaid.ts`. */
+export declare const mermaidLayeredSource: Source;
+export declare const SOURCES: readonly Source[];
+/** The language a source string is written in, or undefined when nothing claims it. */
+export declare const detect: (source: string) => Source | undefined;
+declare const UnknownSourceError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DiagramUnknownSource";
+} & Readonly<A>;
+/** Tagged so the failure channel stays discriminated rather than collapsing into bare `Error`. */
+export declare class UnknownSourceError extends UnknownSourceError_base<{
+    id: string;
+}> {
+    get message(): string;
+}
+declare const UndetectedSourceError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DiagramUndetectedSource";
+} & Readonly<A>;
+export declare class UndetectedSourceError extends UndetectedSourceError_base<{}> {
+    get message(): string;
+}
+export type ConvertOptions = {
+    /** Force a language instead of detecting one. */
+    source?: string;
+};
+/** Compiles `text` through its dialect and prints the result as DSL text. */
+export declare const convert: (text: string, { source }?: ConvertOptions) => Effect.Effect<string, UnknownSourceError | UndetectedSourceError>;
+export {};
+//# sourceMappingURL=convert.d.ts.map

package/dist/types/src/dsl/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../../../src/dsl/convert.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,KAAK,KAAK,MAAM,aAAa,CAAC;AAI1C,0DAA0D;AAC1D,MAAM,MAAM,MAAM,GAAG;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,oGAAoG;IACpG,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IACpC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;CACtE,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,SAAS,EAAE,MAKvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAK3B,CAAC;AAEF,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,EAAE,MAKlC,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,SAAS,MAAM,EAAqD,CAAC;AAE3F,uFAAuF;AACvF,eAAO,MAAM,MAAM,WAAY,MAAM,KAAG,MAAM,GAAG,SAAyD,CAAC;;;;AAI3G,kGAAkG;AAClG,qBAAa,kBAAmB,SAAQ,wBAAyC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;IAC9F,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,qBAAa,qBAAsB,SAAQ,2BAA4C,EAAE,CAAC;IACxF,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,OAAO,SACZ,MAAM,eACA,cAAc,KACzB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,qBAAqB,CAS/D,CAAC"}

package/dist/types/src/dsl/convert.test.d.ts

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

package/dist/types/src/dsl/convert.test.d.ts.map

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

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

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

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

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

package/dist/types/src/dsl/gen/diagram.d.ts

@@ -0,0 +1,3 @@
+import { LRParser } from "@lezer/lr";
+export declare const parser: LRParser;
+//# sourceMappingURL=diagram.d.ts.map

package/dist/types/src/dsl/gen/diagram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram.d.ts","sourceRoot":"","sources":["../../../../../src/dsl/gen/diagram.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,WAAW,CAAA;AAElC,eAAO,MAAM,MAAM,UAkBjB,CAAA"}

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

@@ -0,0 +1,7 @@
+export { type ConvertOptions, type Source, SOURCES, UndetectedSourceError, UnknownSourceError, convert, detect, } from './convert.ts';
+export { type CompileOptions, compile } from './compile.ts';
+export { type ParseResult, type Problem, type Range, type Reading, parse, parseScene, read, toScene, withLayout, } from './parse.ts';
+export { formatCommand, formatElement, formatId, formatObject, formatString, print, printCommands } from './print.ts';
+export { type AttrSpec, type AttrType, CLAUSE_KEYWORDS, DIAGRAM_ATTRS, EDGE_ATTRS, ELEMENT_ATTRS, ELEMENT_KINDS, type ElementKind, GROUP_ATTRS, NODE_ATTRS, OBJECT_ATTRS, RELATION_WORDS, RESERVED, SEMANTIC_KEYWORDS, STATEMENT_KEYWORDS, } from './vocabulary.ts';
+export { parser } from './gen/diagram.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dsl/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,MAAM,EACX,OAAO,EACP,qBAAqB,EACrB,kBAAkB,EAClB,OAAO,EACP,MAAM,GACP,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,KAAK,cAAc,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,KAAK,EACV,KAAK,OAAO,EACZ,KAAK,EACL,UAAU,EACV,IAAI,EACJ,OAAO,EACP,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACtH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,eAAe,EACf,aAAa,EACb,UAAU,EACV,aAAa,EACb,aAAa,EACb,KAAK,WAAW,EAChB,WAAW,EACX,UAAU,EACV,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/types/src/dsl/parse.d.ts

@@ -0,0 +1,49 @@
+import * as Scene from '../scene.ts';
+import * as SemanticEngine from '../semantic-engine.ts';
+import * as Semantic from '../semantic.ts';
+export type Problem = {
+    severity: 'error' | 'warning';
+    message: string;
+    from: number;
+    to: number;
+};
+export type Range = {
+    from: number;
+    to: number;
+};
+export type ParseResult = {
+    commands: Scene.Command[];
+    problems: Problem[];
+    /**
+     * Source range of each `objectId` and `objectId/elementId` — the two spellings
+     * `Diagnostics.Diagnostic.refs` uses, so a layout report can be shown against the line that
+     * produced it rather than at the top of the document.
+     */
+    ranges: Map<string, Range>;
+};
+/** A document as read, before any semantic statement is laid out. */
+export type Reading = ParseResult & {
+    /** The semantic statements, when the document has any. */
+    diagram?: Semantic.Diagram;
+};
+/**
+ * Reads a document. Syntax errors are reported rather than thrown, and the commands that did parse
+ * are returned alongside them, so an editor can keep rendering the last good shapes while a line
+ * is half-typed. Semantic statements are collected into a diagram but not laid out.
+ */
+export declare const read: (text: string) => Reading;
+/** A reading with its semantic diagram laid out: the layout's commands first, then the scene statements. */
+export declare const withLayout: (reading: Reading, solution?: SemanticEngine.Solution) => ParseResult;
+/**
+ * Reads a document and lays out its semantic statements with the grid search, synchronously, so
+ * an editor can lint and preview it; see {@link compile} for the full search.
+ */
+export declare const parse: (text: string) => ParseResult;
+/** Applies commands in order, the same semantics `Scene.Command` documents. */
+export declare const toScene: (commands: readonly Scene.Command[]) => Scene.Scene;
+/** Convenience for the common case: a scene document, with whatever problems it carried. */
+export declare const parseScene: (text: string) => {
+    scene: Scene.Scene;
+    problems: Problem[];
+};
+//# sourceMappingURL=parse.d.ts.map

package/dist/types/src/dsl/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/dsl/parse.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,cAAc,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAe3C,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB;;;;OAIG;IACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC5B,CAAC;AA0CF,qEAAqE;AACrE,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG;IAClC,0DAA0D;IAC1D,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC;CAC5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,IAAI,SAAU,MAAM,KAAG,OAi2BnC,CAAC;AAEF,4GAA4G;AAC5G,eAAO,MAAM,UAAU,YAAa,OAAO,aAAa,cAAc,CAAC,QAAQ,KAAG,WAIhF,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,KAAK,SAAU,MAAM,KAAG,WAGpC,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,OAAO,aAAc,SAAS,KAAK,CAAC,OAAO,EAAE,KAAG,KAAK,CAAC,KA8DlE,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,UAAU,SAAU,MAAM,KAAG;IAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;CAGlF,CAAC"}

package/dist/types/src/dsl/print.d.ts

@@ -0,0 +1,19 @@
+import type * as Scene from '../scene.ts';
+/**
+ * Shortest form that reads back: integers keep no trailing zeros, negatives keep their sign, and
+ * the exponent notation `String` switches to outside ~1e-7..1e21 is spelled as-is, which the
+ * grammar accepts. `NaN` and `Infinity` have no readable form at all, so they are refused here
+ * rather than silently producing a document that cannot be parsed.
+ */
+export declare const formatNumber: (value: number) => string;
+export declare const formatString: (value: string) => string;
+/** Bare where the grammar allows it, quoted where a word would be read as a keyword or fail to lex. */
+export declare const formatId: (id: string) => string;
+export declare const formatElement: (element: Scene.Element) => string;
+export declare const formatObject: (object: Scene.WorldObject) => string;
+export declare const formatCommand: (command: Scene.Command) => string;
+/** A whole document: statements separated by a blank line, newline-terminated. */
+export declare const printCommands: (commands: readonly Scene.Command[]) => string;
+/** A scene document — every statement an `object`, which is what a drawing serializes to. */
+export declare const print: (scene: Scene.Scene) => string;
+//# sourceMappingURL=print.d.ts.map

package/dist/types/src/dsl/print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../../../src/dsl/print.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,KAAK,KAAK,MAAM,aAAa,CAAC;AAK1C;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,MAK5C,CAAC;AAEF,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,MACyC,CAAC;AAEvF,uGAAuG;AACvG,eAAO,MAAM,QAAQ,OAAQ,MAAM,KAAG,MAAyE,CAAC;AAoChH,eAAO,MAAM,aAAa,YAAa,KAAK,CAAC,OAAO,KAAG,MAsFtD,CAAC;AAKF,eAAO,MAAM,YAAY,WAAY,KAAK,CAAC,WAAW,KAAG,MAetD,CAAC;AAEJ,eAAO,MAAM,aAAa,YAAa,KAAK,CAAC,OAAO,KAAG,MAatD,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,aAAa,aAAc,SAAS,KAAK,CAAC,OAAO,EAAE,KAAG,MACW,CAAC;AAE/E,6FAA6F;AAC7F,eAAO,MAAM,KAAK,UAAW,KAAK,CAAC,KAAK,KAAG,MAC+C,CAAC"}

package/dist/types/src/dsl/semantic.test.d.ts

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

package/dist/types/src/dsl/semantic.test.d.ts.map

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