@draftably/markdown 0.2.0 → 0.2.1

package/dist/mermaid.js

@@ -61,7 +61,7 @@ async function S() {
   globalThis.fetch = async () => {
     throw Error("Mermaid resource loading is disabled.");
   };
-  const { JSDOM: i } = await import("jsdom"), { createMermaidFlowParser: s, makePlainLabel: e } = await import("./chunks/mermaid-facade-BoLWBerE.js"), { importMermaidFlow: t } = await import("./chunks/mermaid-importer-IVovOQE9.js"), r = new i("<!doctype html><html><body></body></html>", {
+  const { JSDOM: i } = await import("jsdom"), { createMermaidFlowParser: s, makePlainLabel: e } = await import("./chunks/mermaid-facade-BoLWBerE.js"), { importMermaidFlow: t } = await import("./chunks/mermaid-importer-D9i_Vfxl.js"), r = new i("<!doctype html><html><body></body></html>", {
     url: "https://import.invalid/"
   });
   Object.assign(globalThis, {

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

@@ -1,5 +1,6 @@
 import { type ResolvedAppearance } from '../model/appearance';
 import type { CellsChrome, Lane, SequenceLayout } from '../model/types';
+import { type Planned } from './corridors';
 import { GROUP_HEADER, GROUP_INSET, contentOrigin } from './frame';
 import { type Model, type ModelEdge, type ModelLayout, type ModelObject } from './syntax';
 /** The single render context. Browser window size changes the camera, never the layout. */
@@ -44,6 +45,8 @@ export interface Diagnostic {
 /** A connection as the file declares it, plus the lane a fold's wrap edge returns along. */
 export interface SceneEdge extends ModelEdge {
     lane?: Lane;
+    /** A forward line's route, planned from its scope's ranks and corridors (`planRoutes`). */
+    plan?: Planned;
     /** A sequence message: the height of its row; it is drawn straight between lifelines there. */
     row?: number;
 }
@@ -149,6 +152,16 @@ export declare function crossings(paths: Array<Array<{
 }>>): number;
 /** The order of up to six items that scores fewest crossings; the first such, from `items`. */
 export declare function fewestCrossings<T>(items: T[], score: (order: T[]) => number): T[];
+/**
+ * The corridors a `flow` scope keeps for lines that skip ranks: the ranks with their stand-ins,
+ * each line's stand-ins by its index in the scope's pairs, and each stand-in's place across the
+ * run, in the scope's coordinates.
+ */
+export interface Corridors {
+    order: string[][];
+    chains: Map<number, string[]>;
+    across: Map<string, number>;
+}
 /**
  * Lay out a model. `arranged` holds world positions from layout engines; scopes that an engine
  * governs take their children's relative placement from it instead of their built-in recipe.

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

@@ -0,0 +1,38 @@
+/**
+ * Routes for a `flow` scope's forward lines, planned from its ranks as a layered layout routes its
+ * edges: out of the source's trailing side, along a track in each gap the line turns in, down a
+ * corridor through each rank it skips, and into the target's leading side. The ranks' order already
+ * keeps crossings few, so the plan only has to place ports and order each gap's tracks. The router
+ * takes a planned route as it is when it clears every box.
+ */
+import type { Point, Rect } from '../model/types';
+export interface PlanLine {
+    id: string;
+    /** Source, the stand-ins of the ranks it skips, target. */
+    chain: string[];
+}
+export interface Planned {
+    points: Point[];
+    fromOffset: number;
+    toOffset: number;
+}
+/**
+ * Space between ports on one side and between neighbouring tracks in a gap, as the router keeps
+ * them: ports `max(portGap, edgeGap)` apart and tracks `edgeGap` apart.
+ */
+export interface Spacing {
+    port: number;
+    track: number;
+}
+/**
+ * Plans each line of `lines`. `order` is the ranks with stand-ins, `box` each real member's drawn
+ * box and `across` each stand-in's place across the run, all in drawing coordinates. Lines that
+ * cannot be planned (a member without a box) are left out.
+ */
+export declare function planRoutes(axis: 'down' | 'right', order: string[][], lines: PlanLine[], box: (id: string) => Rect | undefined, across: (id: string) => number | undefined, spacing?: Spacing): Map<string, Planned>;
+/**
+ * The room each gap between ranks needs for the tracks `planRoutes` lays in it: a standoff from
+ * the boxes either side and a pitch between tracks, by gap index; a gap with no track is absent.
+ * `box` may be a member's slot: only its place across the run counts.
+ */
+export declare function trackRoom(axis: 'down' | 'right', order: string[][], lines: PlanLine[], box: (id: string) => Rect | undefined, across: (id: string) => number | undefined, spacing?: Spacing): number[];

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

@@ -93,6 +93,15 @@ export interface EdgeLayout {
     toOffset?: number;
     /** A sequence message: drawn straight between the two lifelines at this height, not routed. */
     row?: number;
+    /**
+     * Set by the compiler for a forward line in a `flow` scope: its route planned from the ranks.
+     * The quick router takes it as it is when it clears every box.
+     */
+    plan?: {
+        points: Point[];
+        fromOffset: number;
+        toOffset: number;
+    };
 }
 /**
  * A channel between two bands of a fold: a level line at `y`, or an upright one at `x`. With

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@draftably/markdown",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Build static SVG diagram assets from Markdown draft fences.",
   "license": "MIT",
   "type": "module",
@@ -35,7 +35,7 @@
   "dependencies": {
     "jsdom": "26.1.0",
     "mermaid": "12.2.0",
-    "@draftably/runtime": "0.2.0"
+    "@draftably/runtime": "0.3.0"
   },
   "engines": {
     "node": ">=22.21.0"