@the-package-labs/idocs-core 0.3.1 → 0.5.0

package/dist/index.js

@@ -1,6 +1,12 @@
+import {
+  attachNested,
+  linkDiagrams,
+  nestedDiagrams
+} from "./chunk-P2X2XSBM.js";
 import {
   BUILTIN_EDGE_KINDS,
   BUILTIN_KINDS,
+  DEFAULT_ENTITY_WIDTH,
   DEFAULT_NODE_WIDTH,
   STEP_KIND_COLORS,
   dist,
@@ -8,7 +14,7 @@ import {
   pointAt,
   polylineLength,
   roundedPath
-} from "./chunk-FRVCGXIG.js";
+} from "./chunk-ZYFFV7Y7.js";
 
 // src/layout.ts
 import ELK from "elkjs/lib/elk.bundled.js";
@@ -951,6 +957,312 @@ function overlap(a, b, pad) {
   return a.x < b.x + b.w + pad && a.x + a.w + pad > b.x && a.y < b.y + b.h + pad && a.y + a.h + pad > b.y;
 }
 
+// src/nested-layout.ts
+var INLINE_PAD = { top: 40, left: 4, right: 4, bottom: 4 };
+function openingView(diagram, ref) {
+  const has = (id) => diagram.views.some((v) => v.id === id);
+  const of = (scenario) => diagram.scenarios.find((s) => s.id === scenario)?.view;
+  return [ref.view, of(ref.scenario), of(diagram.defaults?.scenario), diagram.defaults?.view].find(
+    has
+  ) ?? diagram.views[0].id;
+}
+var canExpand = (ref, diagrams) => !!ref && ref.mode !== "open" && !!diagrams[ref.name];
+var canOpen = (ref, diagrams) => !!ref && ref.mode !== "expand" && !!diagrams[ref.name];
+var pathJoin = (prefix, id) => `${prefix}${id}`;
+function defaultExpanded(diagram, diagrams, prefix = "", seen = []) {
+  const out = [];
+  for (const node of Object.values(diagram.nodes)) {
+    const ref = node.diagram;
+    const child = ref && diagrams[ref.name];
+    if (!ref || !child || seen.includes(ref.name) || !ref.expanded || !canExpand(ref, diagrams))
+      continue;
+    const path = pathJoin(prefix, node.id);
+    out.push(path, ...defaultExpanded(child, diagrams, `${path}/`, [...seen, diagram.name]));
+  }
+  return out;
+}
+function measurable(diagram, viewId, expanded, diagrams, prefix = "") {
+  const view = diagram.views.find((v) => v.id === viewId);
+  if (!view) return [];
+  const out = [];
+  for (const id of view.nodeIds) {
+    const node = diagram.nodes[id];
+    const path = pathJoin(prefix, id);
+    out.push({ key: path, node });
+    const ref = node.diagram;
+    const child = ref && expanded.has(path) && canExpand(ref, diagrams) ? diagrams[ref.name] : void 0;
+    if (ref && child) {
+      out.push(...measurable(child, openingView(child, ref), expanded, diagrams, `${path}/`));
+    }
+  }
+  return out;
+}
+async function layoutNested(diagram, viewId, { sizes = {}, expanded, diagrams = {}, prefix = "" } = {}) {
+  const view = diagram.views.find((v) => v.id === viewId);
+  if (!view) throw new Error(`Unknown view "${viewId}"`);
+  const own = {};
+  for (const id of view.nodeIds) {
+    const size = sizes[pathJoin(prefix, id)];
+    if (size) own[id] = size;
+  }
+  const inner = {};
+  await Promise.all(
+    view.nodeIds.map(async (id) => {
+      const ref = diagram.nodes[id].diagram;
+      const path = pathJoin(prefix, id);
+      const child = ref && expanded?.has(path) && canExpand(ref, diagrams) ? diagrams[ref.name] : void 0;
+      if (!ref || !child) return;
+      const childView = openingView(child, ref);
+      const layout = await layoutNested(child, childView, {
+        sizes,
+        expanded,
+        diagrams,
+        prefix: `${path}/`
+      });
+      inner[id] = {
+        name: ref.name,
+        viewId: childView,
+        offset: { x: INLINE_PAD.left, y: INLINE_PAD.top },
+        layout
+      };
+      own[id] = {
+        w: layout.layout.width + INLINE_PAD.left + INLINE_PAD.right,
+        h: layout.layout.height + INLINE_PAD.top + INLINE_PAD.bottom
+      };
+    })
+  );
+  return { layout: await layoutView(diagram, viewId, own), inner };
+}
+function rectOfPath(nested, path) {
+  let level = nested;
+  let at = { x: 0, y: 0 };
+  const ids = path.split("/");
+  for (const [i, id] of ids.entries()) {
+    const r = level?.layout.nodes[id];
+    if (!level || !r) return void 0;
+    if (i === ids.length - 1) return { x: at.x + r.x, y: at.y + r.y, w: r.w, h: r.h };
+    const inner = level.inner[id];
+    if (!inner) return void 0;
+    at = { x: at.x + r.x + inner.offset.x, y: at.y + r.y + inner.offset.y };
+    level = inner.layout;
+  }
+  return void 0;
+}
+
+// src/outline.ts
+function buildOutline(diagram, view, { diagrams = {}, expanded = /* @__PURE__ */ new Set(), prefix = "", seen = [] } = {}) {
+  const inView = new Set(view.nodeIds);
+  const groups = new Set(view.groupIds);
+  const drawn = view.edgeIds.map((id) => diagram.edges[id]).filter((e) => !e.hidden);
+  const connectionsOf = (id) => {
+    const out = [];
+    for (const e of drawn) {
+      const sends = e.from === id;
+      const gets = e.to === id;
+      if (!sends && !gets) continue;
+      const other = sends ? e.to : e.from;
+      out.push({
+        edge: e.id,
+        dir: e.both ? "both" : sends ? "out" : "in",
+        other,
+        otherTitle: diagram.nodes[other]?.title ?? other,
+        label: e.label,
+        kind: e.kind,
+        status: e.status
+      });
+    }
+    const rank = { out: 0, both: 1, in: 2 };
+    return out.sort((a, b) => rank[a.dir] - rank[b.dir]);
+  };
+  const nodeItem = (id) => {
+    const node = diagram.nodes[id];
+    const path = pathJoin(prefix, id);
+    const item = {
+      type: "node",
+      path,
+      id,
+      title: node.title,
+      sub: node.sub,
+      icon: node.icon,
+      status: node.status,
+      connections: connectionsOf(id)
+    };
+    const ref = node.diagram;
+    const child = ref && diagrams[ref.name];
+    if (ref && child && !seen.includes(ref.name) && (canExpand(ref, diagrams) || canOpen(ref, diagrams))) {
+      const shown = canExpand(ref, diagrams) && expanded.has(path);
+      const childView = child.views.find((v) => v.id === openingView(child, ref));
+      item.inside = {
+        title: child.title,
+        expand: canExpand(ref, diagrams),
+        open: canOpen(ref, diagrams),
+        expanded: shown,
+        items: shown && childView ? buildOutline(child, childView, {
+          diagrams,
+          expanded,
+          prefix: `${path}/`,
+          seen: [...seen, diagram.name]
+        }) : []
+      };
+    }
+    return item;
+  };
+  const childGroups = /* @__PURE__ */ new Map();
+  for (const gid of view.groupIds) {
+    const parent = diagram.groups[gid]?.parent;
+    const key = parent && groups.has(parent) ? parent : "";
+    childGroups.set(key, [...childGroups.get(key) ?? [], gid]);
+  }
+  const childNodes = /* @__PURE__ */ new Map();
+  for (const id of view.nodeIds) {
+    if (!inView.has(id)) continue;
+    const group = diagram.nodes[id].group;
+    const key = group && groups.has(group) ? group : "";
+    childNodes.set(key, [...childNodes.get(key) ?? [], id]);
+  }
+  const position = new Map(view.nodeIds.map((id, i) => [id, i]));
+  const firstNode = (gid) => Math.min(
+    ...(childNodes.get(gid) ?? []).map((n) => position.get(n)),
+    ...(childGroups.get(gid) ?? []).map(firstNode)
+  );
+  const groupItem = (gid) => {
+    const g = diagram.groups[gid];
+    const items = fill(gid);
+    return {
+      type: "group",
+      path: pathJoin(prefix, `#${gid}`),
+      id: gid,
+      title: g.label,
+      caption: g.caption,
+      icon: g.icon,
+      status: g.status,
+      items,
+      count: items.reduce((n, i) => n + (i.type === "group" ? i.count : 1), 0)
+    };
+  };
+  function fill(key) {
+    const ranked = [
+      ...(childGroups.get(key) ?? []).map((gid) => ({
+        at: firstNode(gid),
+        make: () => groupItem(gid)
+      })),
+      ...(childNodes.get(key) ?? []).map((id) => ({
+        at: position.get(id),
+        make: () => nodeItem(id)
+      }))
+    ];
+    return ranked.sort((a, b) => a.at - b.at).map((r) => r.make());
+  }
+  return fill("");
+}
+function outlineNodes(items) {
+  const out = [];
+  for (const item of items) {
+    if (item.type === "group") out.push(...outlineNodes(item.items));
+    else out.push(item, ...outlineNodes(item.inside?.items ?? []));
+  }
+  return out;
+}
+
+// src/phases.ts
+var hasPhases = (scenario) => scenario.phases.some((p) => p.title);
+function phaseSpans(scenario) {
+  const out = [];
+  scenario.steps.forEach((step, i) => {
+    const last = out[out.length - 1];
+    if (last && last.index === step.phase) {
+      last.to = i;
+      last.count++;
+      return;
+    }
+    const phase = scenario.phases[step.phase];
+    out.push({
+      index: step.phase,
+      title: phase?.title ?? "",
+      caption: phase?.caption,
+      from: i,
+      to: i,
+      count: 1
+    });
+  });
+  return out;
+}
+
+// src/scrubber.ts
+function buildScrubber(tl) {
+  const steps = tl.scenario.steps;
+  const slots = [];
+  let i = 0;
+  while (i < steps.length) {
+    let j = i + 1;
+    const par = steps[i].par;
+    if (par !== void 0) while (j < steps.length && steps[j].par === par) j++;
+    const run = tl.steps.slice(i, j);
+    slots.push({ from: i, to: j - 1, t0: Math.min(...run.map((s) => s.start)), t1: 0 });
+    i = j;
+  }
+  slots.forEach((slot, k) => {
+    slot.t1 = slots[k + 1]?.t0 ?? tl.duration;
+  });
+  if (slots[0]) slots[0].t0 = 0;
+  const slotOf = (step) => slots.findIndex((s) => s.from <= step && step <= s.to);
+  const sections = phaseSpans(tl.scenario).map((span) => ({
+    phase: span.index,
+    title: span.title,
+    caption: span.caption,
+    from: slotOf(span.from),
+    to: slotOf(span.to)
+  }));
+  return { slots, sections, duration: tl.duration };
+}
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+function positionAt(s, t) {
+  const n = s.slots.length;
+  if (!n) return 0;
+  let k = 0;
+  s.slots.forEach((slot2, i) => {
+    if (slot2.t0 <= t) k = i;
+  });
+  const slot = s.slots[k];
+  const length = slot.t1 - slot.t0;
+  return (k + (length > 0 ? clamp01((t - slot.t0) / length) : 0)) / n;
+}
+function timeAt(s, position) {
+  const n = s.slots.length;
+  if (!n) return 0;
+  const x = clamp01(position) * n;
+  const k = Math.min(n - 1, Math.floor(x));
+  const slot = s.slots[k];
+  return slot.t0 + (x - k) * (slot.t1 - slot.t0);
+}
+function slotAt(s, position) {
+  const n = s.slots.length;
+  return n ? Math.min(n - 1, Math.floor(clamp01(position) * n)) : -1;
+}
+function slotOfStep(s, index) {
+  return s.slots.findIndex((slot) => slot.from <= index && index <= slot.to);
+}
+
+// src/start.ts
+var defaultMode = (diagram) => diagram.defaults?.mode ?? "flow";
+function startOf(diagram, want = {}) {
+  const d = diagram.defaults ?? {};
+  const scenarioById = (id) => diagram.scenarios.find((s) => s.id === id);
+  const hasView = (id) => diagram.views.some((v) => v.id === id);
+  const first = diagram.views[0].id;
+  let view;
+  let scenario;
+  if (want.view !== void 0 || want.scenario !== void 0) {
+    view = [want.view, scenarioById(want.scenario)?.view].find(hasView) ?? first;
+    scenario = scenarioById(want.scenario)?.id ?? (scenarioById(d.scenario)?.view === view ? d.scenario ?? null : null);
+  } else {
+    scenario = scenarioById(d.scenario)?.id ?? null;
+    view = [scenarioById(scenario ?? void 0)?.view, d.view].find(hasView) ?? first;
+  }
+  const mode = want.mode ?? scenarioById(scenario ?? void 0)?.mode ?? defaultMode(diagram);
+  return { view, scenario, mode };
+}
+
 // src/story.ts
 function buildStory(diagram, scenario) {
   const steps = scenario.steps;
@@ -1249,23 +1561,47 @@ function runBounds(tl, index) {
 export {
   BUILTIN_EDGE_KINDS,
   BUILTIN_KINDS,
+  DEFAULT_ENTITY_WIDTH,
   DEFAULT_NODE_WIDTH,
+  INLINE_PAD,
   STEP_KIND_COLORS,
+  attachNested,
+  buildOutline,
+  buildScrubber,
   buildStory,
   buildTimeline,
+  canExpand,
+  canOpen,
+  defaultExpanded,
+  defaultMode,
   dist,
   frameAt,
+  hasPhases,
   labelWidth,
+  layoutNested,
   layoutView,
   letterKey,
+  linkDiagrams,
+  measurable,
+  nestedDiagrams,
+  openingView,
+  outlineNodes,
   packGrid,
+  pathJoin,
+  phaseSpans,
   pointAt,
   polylineLength,
+  positionAt,
+  rectOfPath,
   roundedPath,
   routeEdges,
   runBounds,
   scopeSvgIds,
+  slotAt,
+  slotOfStep,
+  startOf,
   stepAt,
   stepEnd,
-  stepStart
+  stepStart,
+  timeAt
 };

package/dist/nested-layout.d.ts

@@ -0,0 +1,69 @@
+import { type NodeSize } from './layout';
+import type { CompiledDiagram, CompiledNode, Layout, NodeDiagram, Pt, Rect } from './types';
+/**
+ * What an expanded node adds around the inner diagram: the header that names it, and a margin.
+ * The inner layout already keeps a margin of its own, so the sides stay thin.
+ */
+export declare const INLINE_PAD: {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};
+/** A diagram laid out together with the diagrams expanded inside it, at any depth. */
+export interface NestedLayout {
+    layout: Layout;
+    /** By node id: the layout of the diagram that node shows in place. */
+    inner: Record<string, InnerLayout>;
+}
+export interface InnerLayout {
+    /** Name of the diagram shown. */
+    name: string;
+    viewId: string;
+    /** Where the inner diagram's origin sits inside the expanded node's rectangle. */
+    offset: Pt;
+    layout: NestedLayout;
+}
+export type Diagrams = Record<string, CompiledDiagram | undefined>;
+/**
+ * The view a node's diagram shows when opened: the one the node names, its scenario's, the one the
+ * diagram opens on by itself, or the first.
+ */
+export declare function openingView(diagram: CompiledDiagram, ref: NodeDiagram): string;
+/** Whether a reader may show this node's diagram in place: it is at hand and not limited to `open`. */
+export declare const canExpand: (ref: NodeDiagram | undefined, diagrams: Diagrams) => boolean;
+/** Whether a reader may move into this node's diagram: it is at hand and not limited to `expand`. */
+export declare const canOpen: (ref: NodeDiagram | undefined, diagrams: Diagrams) => boolean;
+/** Paths are node ids joined with `/` (ids cannot contain it): `orders`, `orders/stock`. */
+export declare const pathJoin: (prefix: string, id: string) => string;
+/**
+ * The paths the author asked to start expanded (`expanded: true`), at every depth. A node counts
+ * wherever it sits in its diagram, in whichever view, so switching views loses nothing.
+ */
+export declare function defaultExpanded(diagram: CompiledDiagram, diagrams: Diagrams, prefix?: string, seen?: readonly string[]): string[];
+/**
+ * Every node whose card has to be measured to lay `viewId` out with these paths expanded: the
+ * view's own, and those of each diagram shown in place. `key` is the path, which is what the
+ * layout reads sizes by.
+ */
+export declare function measurable(diagram: CompiledDiagram, viewId: string, expanded: ReadonlySet<string>, diagrams: Diagrams, prefix?: string): {
+    key: string;
+    node: CompiledNode;
+}[];
+export interface NestedOptions {
+    /** Measured card sizes by path. A plain node id for the diagram itself, `orders/api` inside. */
+    sizes?: Record<string, Partial<NodeSize>>;
+    /** Paths shown in place. */
+    expanded?: ReadonlySet<string>;
+    /** Where the diagrams a node opens are found, by name. */
+    diagrams?: Diagrams;
+    prefix?: string;
+}
+/** Lay out `viewId` with the nodes in `expanded` shown in place, each as a group around its diagram. */
+export declare function layoutNested(diagram: CompiledDiagram, viewId: string, { sizes, expanded, diagrams, prefix }?: NestedOptions): Promise<NestedLayout>;
+/**
+ * Where a node sits in the world of the diagram laid out first, however deep it is: the rectangle
+ * of `orders/stock` is `stock`'s inside `orders`, moved to where `orders` is. Undefined when a
+ * step of the path is not laid out (it is not expanded, or not in the view).
+ */
+export declare function rectOfPath(nested: NestedLayout, path: string): Rect | undefined;

package/dist/nesting.d.ts

@@ -0,0 +1,24 @@
+import type { Diagnostic, Where } from './compiler';
+import type { CompiledDiagram } from './types';
+/** What the linker needs to know about one diagram folder. `diagram` is missing when it failed to compile. */
+export interface LinkEntry {
+    diagram?: CompiledDiagram;
+    where?: Where;
+}
+/**
+ * Every diagram that `name` can reach by opening nodes, directly or through other diagrams, but
+ * not `name` itself.
+ */
+export declare function nestedDiagrams(all: Record<string, CompiledDiagram>, name: string): Record<string, CompiledDiagram>;
+/**
+ * Give every diagram that opens others the diagrams it can reach, as `nested`, so wherever a
+ * compiled diagram goes its insides go with it and the viewer is told nothing. Diagrams that open
+ * nothing are returned as they are. Safe to call twice.
+ */
+export declare function attachNested(all: Record<string, CompiledDiagram>): Record<string, CompiledDiagram>;
+/**
+ * Check what no single diagram can: that a node opens a diagram which exists, that the view and
+ * scenario it asks for exist there, and that diagrams do not open each other in a circle (a node
+ * cannot contain itself).
+ */
+export declare function linkDiagrams(entries: Record<string, LinkEntry>): Diagnostic[];

package/dist/node.d.ts

@@ -3,6 +3,7 @@ import type { CompiledDiagram } from './types';
 export * from './compile';
 export { loadIconSets, resolveIcon, searchIcons } from './icons';
 export { renderMarkdown } from './markdown';
+export { attachNested, type LinkEntry, linkDiagrams, nestedDiagrams } from './nesting';
 export { authoringJsonSchema, FamilySchema, KNOWN_KEYS, RootSchema } from './schema';
 export interface LoadedProject {
     diagrams: Record<string, CompiledDiagram>;

package/dist/node.js

@@ -1,3 +1,8 @@
+import {
+  attachNested,
+  linkDiagrams,
+  nestedDiagrams
+} from "./chunk-P2X2XSBM.js";
 import {
   FamilySchema,
   KNOWN_KEYS,
@@ -6,8 +11,8 @@ import {
   compileDiagram,
   createIconResolver,
   renderMarkdown
-} from "./chunk-5BMICZRC.js";
-import "./chunk-FRVCGXIG.js";
+} from "./chunk-Q2NHZ6TV.js";
+import "./chunk-ZYFFV7Y7.js";
 
 // src/node.ts
 import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
@@ -48,6 +53,7 @@ function loadProject(root, dir = "diagrams") {
   const base = diagramsDir(root, dir);
   const result = { diagrams: {}, diagnostics: [], watch: [base] };
   if (!existsSync(base)) return result;
+  const entries = {};
   for (const name of readdirSync(base).sort()) {
     const folder = join(base, name);
     if (!statSync(folder).isDirectory()) continue;
@@ -59,7 +65,7 @@ function loadProject(root, dir = "diagrams") {
       file: join(scenarioDir, f),
       text: readFileSync2(join(scenarioDir, f), "utf8")
     })) : [];
-    const { diagram, diagnostics } = compileDiagram2({
+    const { diagram, diagnostics, where } = compileDiagram2({
       name,
       file: relative(root, file),
       text: readFileSync2(file, "utf8"),
@@ -68,8 +74,11 @@ function loadProject(root, dir = "diagrams") {
     });
     result.diagnostics.push(...diagnostics);
     if (diagram) result.diagrams[name] = diagram;
+    entries[name] = { diagram, where };
     result.watch.push(folder);
   }
+  result.diagnostics.push(...linkDiagrams(entries));
+  result.diagrams = attachNested(result.diagrams);
   return result;
 }
 function readInside(folder, rel) {
@@ -91,12 +100,15 @@ export {
   FamilySchema,
   KNOWN_KEYS,
   RootSchema,
+  attachNested,
   authoringJsonSchema,
   compileDiagram2 as compileDiagram,
   diagramsDir,
   formatDiagnostic,
+  linkDiagrams,
   loadIconSets,
   loadProject,
+  nestedDiagrams,
   renderMarkdown,
   resolveIcon,
   searchIcons

package/dist/outline.d.ts

@@ -0,0 +1,63 @@
+import { type Diagrams } from './nested-layout';
+import type { CompiledDiagram, CompiledView, IconData, Status } from './types';
+/** One edge of a node, seen from that node. */
+export interface OutlineConnection {
+    edge: string;
+    /** `out`: this node sends to `other`; `in`: it receives from `other`; `both`: edge goes either way. */
+    dir: 'out' | 'in' | 'both';
+    /** Id of the node at the other end, in the same diagram. */
+    other: string;
+    /** Its title, so a row needs nothing else to be read. */
+    otherTitle: string;
+    label?: string;
+    kind: string;
+    status: Status;
+}
+export interface OutlineNode {
+    type: 'node';
+    /** The node id, or ids joined with `/` for a node inside one shown in place (`orders/stock`). */
+    path: string;
+    id: string;
+    title: string;
+    sub?: string;
+    icon?: IconData;
+    status: Status;
+    connections: OutlineConnection[];
+    /** Present when the node holds a diagram the reader can reach. */
+    inside?: {
+        title: string;
+        /** The reader may show it in place, and may move into it. */
+        expand: boolean;
+        open: boolean;
+        /** Shown in place right now; `items` are then the nodes of that diagram. */
+        expanded: boolean;
+        items: OutlineItem[];
+    };
+}
+export interface OutlineGroup {
+    type: 'group';
+    /** Group id, prefixed like a node path so it is unique across the levels shown in place. */
+    path: string;
+    id: string;
+    title: string;
+    caption?: string;
+    icon?: IconData;
+    status: Status;
+    items: OutlineItem[];
+    /** How many nodes it holds, however deep. */
+    count: number;
+}
+export type OutlineItem = OutlineNode | OutlineGroup;
+export interface OutlineOptions {
+    /** Where the diagrams a node holds are found, by name. */
+    diagrams?: Diagrams;
+    /** Paths shown in place. */
+    expanded?: ReadonlySet<string>;
+    prefix?: string;
+    /** Diagrams already on the way down, so a loop cannot run forever. */
+    seen?: readonly string[];
+}
+/** The nodes and groups of `view` as a tree, in the order the author wrote them. */
+export declare function buildOutline(diagram: CompiledDiagram, view: CompiledView, { diagrams, expanded, prefix, seen }?: OutlineOptions): OutlineItem[];
+/** Every node of an outline, in reading order, at any depth. */
+export declare function outlineNodes(items: readonly OutlineItem[]): OutlineNode[];

package/dist/phases.d.ts

@@ -0,0 +1,16 @@
+import type { CompiledScenario } from './types';
+export interface PhaseSpan {
+    /** Index in `scenario.phases`. */
+    index: number;
+    title: string;
+    caption?: string;
+    /** Index of its first and last step in `scenario.steps`. */
+    from: number;
+    to: number;
+    /** How many steps it holds. */
+    count: number;
+}
+/** Whether the author named the phases. A scenario written as plain `steps` has one nameless phase. */
+export declare const hasPhases: (scenario: CompiledScenario) => boolean;
+/** The phases that hold steps, in order. Steps follow their phase, so each phase is one run. */
+export declare function phaseSpans(scenario: CompiledScenario): PhaseSpan[];