@prisma-next/cli 0.12.0-dev.5 → 0.12.0-dev.51

package/src/utils/formatters/migration-graph-lane-colors.ts

@@ -0,0 +1,194 @@
+import { createColors } from 'colorette';
+import type { StructuralCell } from './migration-graph-layout';
+
+export type LaneColorizer = (text: string) => string;
+
+const { magenta, cyan, green, yellow, blueBright, red } = createColors({ useColor: true });
+
+export const LANE_COLOR_CYCLE: readonly LaneColorizer[] = [
+  magenta,
+  cyan,
+  green,
+  yellow,
+  blueBright,
+  red,
+];
+
+/**
+ * The leftmost lane (column 0) renders neutral — no palette hue. Columns ≥ 1
+ * rotate through {@link LANE_COLOR_CYCLE}.
+ */
+export const NEUTRAL_LANE_COLUMN = 0;
+
+/**
+ * The hue for a gutter column. The leftmost lane (column 0) is **neutral** — it
+ * has nothing to be told apart from in the common single-lane linear case, so
+ * the renderer dims it rather than tinting it; the rotating palette is reserved
+ * for columns ≥ 1 (where a second lane exists to distinguish). Callers must dim
+ * column 0 themselves; this returns identity for it as a guard. A lane freed and
+ * reused by a later branch keeps its column's hue — coloring is by position, not
+ * branch identity, exactly like `git log --graph`.
+ */
+export function laneColorForColumn(column: number): LaneColorizer {
+  if (column <= NEUTRAL_LANE_COLUMN) {
+    return (text) => text;
+  }
+  const colorizer = LANE_COLOR_CYCLE[(column - 1) % LANE_COLOR_CYCLE.length];
+  return colorizer ?? ((text) => text);
+}
+
+/**
+ * Style a structural glyph by its resolved colour column. Column 0 and the
+ * neutral sentinel render dim (`dimLane`); columns ≥ 1 take a palette hue.
+ */
+export function stylerForLaneColumn(
+  colorColumn: number,
+  colorize: boolean,
+  dimLane: (text: string) => string,
+): LaneColorizer {
+  if (!colorize || colorColumn <= NEUTRAL_LANE_COLUMN) {
+    return dimLane;
+  }
+  return laneColorForColumn(colorColumn);
+}
+
+/**
+ * The colour-source column for each cell of a row, resolved together because a
+ * routed back-arc spans columns and must read as **one hue** rather than a
+ * per-column "rainbow".
+ */
+export interface RowArcLaneColors {
+  /** Colour column for a cell's structural glyph (lane / spine / arc body). */
+  readonly lane: readonly number[];
+  /** Colour column for a node arc-pair's connector half (`◂` / `─`). */
+  readonly connector: readonly number[];
+  /**
+   * Colour column for the trailing `─` of a landing tee (`┴─`). The junction
+   * (`lane`) keeps its own column; the dash leads into the next converging arc.
+   */
+  readonly dash: readonly number[];
+}
+
+/**
+ * Resolve per-cell colour columns for a node/arc row. Scanning right-to-left
+ * lets each arc segment inherit the hue of the arc it leads into.
+ */
+export function resolveRowArcLaneColors(cells: readonly StructuralCell[]): RowArcLaneColors {
+  const lane = new Array<number>(cells.length);
+  const connector = new Array<number>(cells.length);
+  const dash = new Array<number>(cells.length);
+  let arcCorner = NEUTRAL_LANE_COLUMN;
+  let landingAnchor = NEUTRAL_LANE_COLUMN;
+  for (let column = cells.length - 1; column >= 0; column--) {
+    const cell = cells[column];
+    connector[column] = landingAnchor !== NEUTRAL_LANE_COLUMN ? landingAnchor : arcCorner;
+    switch (cell?.kind) {
+      case 'arc-branch-corner':
+        arcCorner = column;
+        lane[column] = column;
+        dash[column] = column;
+        break;
+      case 'arc-land-corner':
+        arcCorner = column;
+        landingAnchor = column;
+        lane[column] = column;
+        dash[column] = column;
+        break;
+      case 'arc-branch-tee':
+        lane[column] = column;
+        dash[column] = column;
+        break;
+      case 'arc-land-tee':
+        lane[column] = column;
+        dash[column] = landingAnchor === NEUTRAL_LANE_COLUMN ? column : landingAnchor;
+        landingAnchor = column;
+        break;
+      case 'arc-crossing':
+      case 'arc-land-bridge': {
+        const served = landingAnchor !== NEUTRAL_LANE_COLUMN ? landingAnchor : arcCorner;
+        lane[column] = served;
+        dash[column] = served;
+        break;
+      }
+      case 'horizontal-pass':
+        lane[column] = arcCorner === NEUTRAL_LANE_COLUMN ? column : arcCorner;
+        dash[column] = lane[column] ?? column;
+        break;
+      case 'node':
+        lane[column] = column;
+        dash[column] = column;
+        arcCorner = NEUTRAL_LANE_COLUMN;
+        landingAnchor = NEUTRAL_LANE_COLUMN;
+        break;
+      default:
+        lane[column] = column;
+        dash[column] = column;
+        arcCorner = NEUTRAL_LANE_COLUMN;
+        landingAnchor = NEUTRAL_LANE_COLUMN;
+    }
+  }
+  return { lane, connector, dash };
+}
+
+/**
+ * Per-cell colour for a forward branch/merge connector row, split into the
+ * cell's junction `glyph` and its trailing `dash`.
+ */
+export interface ConnectorLaneColors {
+  /** Colour column for a cell's junction glyph (`├` / `┬` / `┴` / `╮` / `╯`). */
+  readonly glyph: readonly number[];
+  /** Colour column for a tee's trailing `─` — the branch it leads into. */
+  readonly dash: readonly number[];
+}
+
+/**
+ * Resolve per-cell connector colours. Scanning right-to-left, a corner or an
+ * intermediate tee anchors its own lane, but a tee's trailing dash leads into
+ * the branch on its right.
+ */
+export function resolveConnectorLaneColors(
+  cells: readonly StructuralCell[],
+  startLane: number,
+): ConnectorLaneColors {
+  const glyph = new Array<number>(cells.length);
+  const dash = new Array<number>(cells.length);
+  let owner = NEUTRAL_LANE_COLUMN;
+  for (let column = cells.length - 1; column >= 0; column--) {
+    const cell = cells[column];
+    switch (cell?.kind) {
+      case 'branch-corner':
+      case 'merge-corner':
+        owner = column;
+        glyph[column] = column;
+        dash[column] = column;
+        break;
+      case 'branch-tee':
+      case 'merge-tee':
+        if (column === startLane) {
+          const served = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+          glyph[column] = column;
+          dash[column] = served;
+        } else {
+          dash[column] = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+          glyph[column] = column;
+          owner = column;
+        }
+        break;
+      case 'arc-crossing':
+        glyph[column] = column;
+        dash[column] = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+        owner = column;
+        break;
+      case 'horizontal-pass': {
+        const served = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+        glyph[column] = served;
+        dash[column] = served;
+        break;
+      }
+      default:
+        glyph[column] = column;
+        dash[column] = column;
+    }
+  }
+  return { glyph, dash };
+}

package/src/utils/formatters/migration-graph-layout.ts

@@ -21,6 +21,7 @@ export type StructuralCell =
   | { readonly kind: 'arc-branch-corner' }
   | { readonly kind: 'arc-branch-tee' }
   | { readonly kind: 'arc-land-corner' }
+  | { readonly kind: 'arc-land-tee' }
   | { readonly kind: 'arc-crossing' }
   | { readonly kind: 'arc-land-bridge' }
   | {
@@ -379,6 +380,7 @@ function emptyCells(width: number): StructuralCell[] {
 function buildBranchConnectorCells(
   startLane: number,
   endLane: number,
+  fanTargetLanes: ReadonlySet<number>,
   activeLanes: ReadonlySet<number>,
   gridWidth: number,
 ): StructuralCell[] {
@@ -393,7 +395,13 @@ function buildBranchConnectorCells(
     } else if (lane === endLane) {
       cells[lane] = { kind: 'branch-corner' };
     } else if (lane > startLane && lane < endLane) {
-      cells[lane] = { kind: 'branch-tee' };
+      if (fanTargetLanes.has(lane)) {
+        cells[lane] = { kind: 'branch-tee' };
+      } else if (activeLanes.has(lane)) {
+        cells[lane] = { kind: 'arc-crossing' };
+      } else {
+        cells[lane] = { kind: 'branch-tee' };
+      }
     }
   }
   return cells;
@@ -402,6 +410,7 @@ function buildBranchConnectorCells(
 function buildMergeConnectorCells(
   startLane: number,
   endLane: number,
+  fanTargetLanes: ReadonlySet<number>,
   activeLanes: ReadonlySet<number>,
   gridWidth: number,
 ): StructuralCell[] {
@@ -416,7 +425,13 @@ function buildMergeConnectorCells(
     } else if (lane === endLane) {
       cells[lane] = { kind: 'merge-corner' };
     } else if (lane > startLane && lane < endLane) {
-      cells[lane] = activeLanes.has(lane) ? { kind: 'merge-tee' } : { kind: 'horizontal-pass' };
+      if (fanTargetLanes.has(lane)) {
+        cells[lane] = { kind: 'merge-tee' };
+      } else if (activeLanes.has(lane)) {
+        cells[lane] = { kind: 'arc-crossing' };
+      } else {
+        cells[lane] = { kind: 'horizontal-pass' };
+      }
     }
   }
   return cells;
@@ -689,6 +704,15 @@ function applySkipRollbackRouting(
       .map((other) => other.backLane);
     const maxCoSourcedLane = Math.max(...coSourcedLanes);
 
+    // Back-lanes of arcs that converge on this same target node. They share the
+    // node's landing row, so each inner lane reads as a `┴` junction (the outer
+    // arcs' horizontal bridge passes through it on the way to the node) and only
+    // the outermost closes the corner with `╯`.
+    const coLandingLanes = routes
+      .filter((other) => other.edge.to === edge.to)
+      .map((other) => other.backLane);
+    const maxCoLandingLane = Math.max(...coLandingLanes);
+
     const sourceRow = result[sourceRowIndex];
     if (sourceRow !== undefined) {
       const cells = sourceRow.cells;
@@ -750,6 +774,7 @@ function applySkipRollbackRouting(
       const existing = cells[backLane];
       if (
         existing?.kind !== 'arc-land-corner' &&
+        existing?.kind !== 'arc-land-tee' &&
         existing?.kind !== 'arc-land-bridge' &&
         existing?.kind !== 'arc-branch-corner' &&
         existing?.kind !== 'arc-branch-tee' &&
@@ -766,6 +791,12 @@ function applySkipRollbackRouting(
       const contractHash = targetRow.contractHash ?? EMPTY_CONTRACT_HASH;
       cells[targetCol] = { kind: 'node', contractHash, arcLand: true };
       for (let lane = targetCol + 1; lane < backLane; lane += 1) {
+        // An inner converging arc's own landing junction: the outer arcs' bridge
+        // passes through it (`┴`) while its own vertical run closes here.
+        if (coLandingLanes.includes(lane)) {
+          cells[lane] = { kind: 'arc-land-tee' };
+          continue;
+        }
         // A bridged lane that carries another arc OR a forward vertical still
         // active at this row must cross over it (`┼`) rather than overwrite it
         // with a bare bridge (`──`).
@@ -774,7 +805,8 @@ function applySkipRollbackRouting(
           existing !== undefined &&
           existing.kind !== 'empty' &&
           existing.kind !== 'horizontal-pass' &&
-          existing.kind !== 'arc-land-bridge';
+          existing.kind !== 'arc-land-bridge' &&
+          existing.kind !== 'arc-land-tee';
         const crossed =
           occupied ||
           routes.some(
@@ -785,7 +817,10 @@ function applySkipRollbackRouting(
           );
         cells[lane] = crossed ? { kind: 'arc-crossing' } : { kind: 'arc-land-bridge' };
       }
-      cells[backLane] = { kind: 'arc-land-corner' };
+      // Inner converging arcs close as a landing tee so the outermost arc's
+      // bridge reads through to the node; only the outermost arc draws `╯`.
+      cells[backLane] =
+        backLane < maxCoLandingLane ? { kind: 'arc-land-tee' } : { kind: 'arc-land-corner' };
       for (const other of routes) {
         if (other.backLane <= backLane) continue;
         if (!routeCrossesRow(other, targetRowIndex, result)) continue;
@@ -793,6 +828,7 @@ function applySkipRollbackRouting(
         const existing = cells[other.backLane];
         if (
           existing?.kind !== 'arc-land-corner' &&
+          existing?.kind !== 'arc-land-tee' &&
           existing?.kind !== 'arc-land-bridge' &&
           existing?.kind !== 'node'
         ) {
@@ -922,13 +958,14 @@ function layoutComponent(
     const endLane = Math.max(...laneIndices);
     ensureGridWidth(endLane + 1);
     const activeLanes = new Set(activeLaneIndices());
+    const fanTargetLanes = new Set(laneIndices);
     rows.push({
       kind: 'merge-connector',
       contractHash,
       startLane,
       endLane,
       branchCount: laneIndices.length,
-      cells: buildMergeConnectorCells(startLane, endLane, activeLanes, gridWidth),
+      cells: buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth),
     });
     for (const index of laneIndices) {
       if (index !== startLane) setLane(index, null);
@@ -941,6 +978,7 @@ function layoutComponent(
     startLane: number,
     endLane: number,
     branchCount: number,
+    fanTargetLanes: readonly number[],
   ): void {
     ensureGridWidth(endLane + 1);
     const activeLanes = new Set(activeLaneIndices());
@@ -950,7 +988,13 @@ function layoutComponent(
       startLane,
       endLane,
       branchCount,
-      cells: buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth),
+      cells: buildBranchConnectorCells(
+        startLane,
+        endLane,
+        new Set(fanTargetLanes),
+        activeLanes,
+        gridWidth,
+      ),
     });
   }
 
@@ -1046,7 +1090,7 @@ function layoutComponent(
 
     if (groups.length >= 2) {
       const endLane = Math.max(...laneForGroup);
-      emitBranchConnector(node, column, endLane, groups.length);
+      emitBranchConnector(node, column, endLane, groups.length, laneForGroup);
     }
 
     for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {

package/src/utils/formatters/migration-graph-rows.ts

@@ -173,10 +173,19 @@ function compareNodesTipsFirst(a: string, b: string, rank: ReadonlyMap<string, n
  * at the same rank — stable across edge-insertion order and correct under
  * diamonds, cross-links, and rollbacks.
  */
+function maxRank(rank: ReadonlyMap<string, number>): number {
+  let max = 0;
+  for (const value of rank.values()) {
+    if (value > max) max = value;
+  }
+  return max;
+}
+
 function layerNodesByLongestForwardPath(
   componentNodes: ReadonlySet<string>,
   topology: MigrationListGraphTopology,
   graph: MigrationGraph,
+  contractHash: string | undefined,
 ): readonly string[] {
   const forwardOut = new Map<string, string[]>();
 
@@ -224,6 +233,15 @@ function layerNodesByLongestForwardPath(
     }
   }
 
+  if (
+    contractHash !== undefined &&
+    contractHash !== EMPTY_CONTRACT_HASH &&
+    componentNodes.has(contractHash) &&
+    (forwardOut.get(contractHash) ?? []).length === 0
+  ) {
+    rank.set(contractHash, maxRank(rank) + 1);
+  }
+
   return [...componentNodes].sort((a, b) => compareNodesTipsFirst(a, b, rank));
 }
 
@@ -262,6 +280,99 @@ function detachedContractHash(
     : undefined;
 }
 
+function isForwardLeaf(node: string, edges: readonly ClassifiedEdge[]): boolean {
+  return !edges.some((e) => e.kind === 'forward' && e.from === node && e.from !== e.to);
+}
+
+function forwardReachableFrom(
+  start: string,
+  forwardTo: ReadonlyMap<string, readonly string[]>,
+): ReadonlySet<string> {
+  const reachable = new Set<string>([start]);
+  const queue = [start];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (node === undefined) continue;
+    for (const next of forwardTo.get(node) ?? []) {
+      if (!reachable.has(next)) {
+        reachable.add(next);
+        queue.push(next);
+      }
+    }
+  }
+  return reachable;
+}
+
+function buildForwardToMap(edges: readonly ClassifiedEdge[]): Map<string, string[]> {
+  const forwardTo = new Map<string, string[]>();
+  for (const edge of edges) {
+    if (edge.kind !== 'forward' || edge.from === edge.to) continue;
+    const bucket = forwardTo.get(edge.from);
+    if (bucket) bucket.push(edge.to);
+    else forwardTo.set(edge.from, [edge.to]);
+  }
+  return forwardTo;
+}
+
+function sortEdgesForContractHashTrunk(
+  edges: ClassifiedEdge[],
+  contractHash: string | undefined,
+): ClassifiedEdge[] {
+  if (
+    contractHash === undefined ||
+    contractHash === EMPTY_CONTRACT_HASH ||
+    !isForwardLeaf(contractHash, edges)
+  ) {
+    return edges;
+  }
+
+  const preferredLeaf = contractHash;
+  const forwardTo = buildForwardToMap(edges);
+  const reachability = new Map<string, ReadonlySet<string>>();
+  function canReachContractHash(from: string): boolean {
+    let cached = reachability.get(from);
+    if (cached === undefined) {
+      cached = forwardReachableFrom(from, forwardTo);
+      reachability.set(from, cached);
+    }
+    return cached.has(preferredLeaf);
+  }
+
+  function trunkBias(edge: ClassifiedEdge): number {
+    if (edge.kind !== 'forward' || edge.from === edge.to) return 0;
+    if (edge.to === preferredLeaf) return 2;
+    if (canReachContractHash(edge.to)) return 1;
+    return 0;
+  }
+
+  return edges
+    .map((edge, index) => ({ edge, index, bias: trunkBias(edge) }))
+    .sort((a, b) => {
+      if (a.edge.from !== b.edge.from) return a.index - b.index;
+      if (a.bias !== b.bias) return b.bias - a.bias;
+      return a.index - b.index;
+    })
+    .map(({ edge }) => edge);
+}
+
+function rebuildEdgeLookupMaps(edges: readonly ClassifiedEdge[]): {
+  edgesByFrom: Map<string, ClassifiedEdge[]>;
+  edgesByTo: Map<string, ClassifiedEdge[]>;
+} {
+  const edgesByFrom = new Map<string, ClassifiedEdge[]>();
+  const edgesByTo = new Map<string, ClassifiedEdge[]>();
+  for (const classified of edges) {
+    const fromBucket = edgesByFrom.get(classified.from);
+    if (fromBucket) fromBucket.push(classified);
+    else edgesByFrom.set(classified.from, [classified]);
+
+    const toBucket = edgesByTo.get(classified.to);
+    if (toBucket) toBucket.push(classified);
+    else edgesByTo.set(classified.to, [classified]);
+  }
+  return { edgesByFrom, edgesByTo };
+}
+
 export function buildMigrationGraphRows(
   graph: MigrationGraph,
   options: BuildMigrationGraphRowsOptions = {},
@@ -284,31 +395,23 @@ export function buildMigrationGraphRows(
 
   // 2. Build classified edge list
   const edges: ClassifiedEdge[] = [];
-  const edgesByFrom = new Map<string, ClassifiedEdge[]>();
-  const edgesByTo = new Map<string, ClassifiedEdge[]>();
 
   for (const edgeList of graph.forwardChain.values()) {
     for (const edge of edgeList) {
       const kind = topology.kindByMigrationHash.get(edge.migrationHash) ?? 'forward';
-      const classified: ClassifiedEdge = {
+      edges.push({
         migrationHash: edge.migrationHash,
         from: edge.from,
         to: edge.to,
         dirName: edge.dirName,
         kind,
-      };
-      edges.push(classified);
-
-      const fromBucket = edgesByFrom.get(edge.from);
-      if (fromBucket) fromBucket.push(classified);
-      else edgesByFrom.set(edge.from, [classified]);
-
-      const toBucket = edgesByTo.get(edge.to);
-      if (toBucket) toBucket.push(classified);
-      else edgesByTo.set(edge.to, [classified]);
+      });
     }
   }
 
+  const sortedEdges = sortEdgesForContractHashTrunk(edges, options.contractHash);
+  const { edgesByFrom, edgesByTo } = rebuildEdgeLookupMaps(sortedEdges);
+
   // 3. Find weakly-connected components (ordered: EMPTY first, then lex)
   const components = weaklyConnectedComponents(graph);
 
@@ -318,7 +421,12 @@ export function buildMigrationGraphRows(
     if (i > 0) nodes.push(null);
     const component = components[i];
     if (component === undefined) continue;
-    const ordered = layerNodesByLongestForwardPath(component, topology, graph);
+    const ordered = layerNodesByLongestForwardPath(
+      component,
+      topology,
+      graph,
+      options.contractHash,
+    );
     for (const node of ordered) {
       nodes.push(node);
     }
@@ -332,5 +440,10 @@ export function buildMigrationGraphRows(
     nodes.unshift(detached);
   }
 
-  return { nodes, edges, edgesByFrom, edgesByTo };
+  return {
+    nodes,
+    edges: sortedEdges,
+    edgesByFrom,
+    edgesByTo,
+  };
 }

package/src/utils/formatters/migration-graph-space-render.ts

@@ -0,0 +1,138 @@
+import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
+import type { GlyphMode } from '../glyph-mode';
+import { buildMigrationGraphLayout } from './migration-graph-layout';
+import { buildMigrationGraphRows } from './migration-graph-rows';
+import {
+  computeMaxDirNameLengthForLayout,
+  computeMaxEdgeTreePrefixWidthForLayout,
+  type MigrationEdgeAnnotation,
+  renderMigrationGraphTree,
+} from './migration-graph-tree-render';
+import {
+  buildEdgeAnnotationsByHashFromListEntries,
+  buildRefsByHashFromListEntries,
+  type MigrationListStyler,
+} from './migration-list-render';
+import type { MigrationListEntry } from './migration-list-types';
+
+export { buildEdgeAnnotationsByHashFromListEntries } from './migration-list-render';
+
+export function mergeMigrationEdgeAnnotations(
+  listOverlay: ReadonlyMap<string, MigrationEdgeAnnotation>,
+  statusOverlay: ReadonlyMap<string, MigrationEdgeAnnotation>,
+): ReadonlyMap<string, MigrationEdgeAnnotation> {
+  const merged = new Map<string, MigrationEdgeAnnotation>();
+  for (const [migrationHash, listAnnotation] of listOverlay) {
+    const statusAnnotation = statusOverlay.get(migrationHash);
+    merged.set(migrationHash, {
+      ...listAnnotation,
+      ...(statusAnnotation?.status !== undefined ? { status: statusAnnotation.status } : {}),
+    });
+  }
+  return merged;
+}
+
+export interface RenderMigrationGraphSpaceTreeInput {
+  readonly graph: MigrationGraph;
+  readonly migrations: readonly MigrationListEntry[];
+  readonly liveContractHash: string;
+  readonly glyphMode: GlyphMode;
+  readonly colorize: boolean;
+  readonly refsByHash?: ReadonlyMap<string, readonly string[]>;
+  readonly statusOverlayByHash?: ReadonlyMap<string, MigrationEdgeAnnotation>;
+  readonly dbHash?: string;
+  readonly styler?: MigrationListStyler;
+  readonly globalMaxEdgeTreePrefixWidth?: number;
+  readonly globalMaxDirNameWidth?: number;
+}
+
+export interface ComputeGlobalMaxEdgeTreePrefixWidthInput {
+  readonly graph: MigrationGraph;
+  readonly liveContractHash: string;
+}
+
+export function computeGlobalMaxEdgeTreePrefixWidth(
+  inputs: readonly ComputeGlobalMaxEdgeTreePrefixWidthInput[],
+): number {
+  let globalMax = 0;
+  for (const input of inputs) {
+    const rowModel = buildMigrationGraphRows(input.graph, {
+      contractHash: input.liveContractHash,
+    });
+    const layout = buildMigrationGraphLayout(rowModel);
+    globalMax = Math.max(globalMax, computeMaxEdgeTreePrefixWidthForLayout(layout));
+  }
+  return globalMax;
+}
+
+export function computeGlobalMaxDirNameWidth(
+  inputs: readonly ComputeGlobalMaxEdgeTreePrefixWidthInput[],
+): number {
+  let globalMax = 0;
+  for (const input of inputs) {
+    const rowModel = buildMigrationGraphRows(input.graph, {
+      contractHash: input.liveContractHash,
+    });
+    const layout = buildMigrationGraphLayout(rowModel);
+    globalMax = Math.max(globalMax, computeMaxDirNameLengthForLayout(layout));
+  }
+  return globalMax;
+}
+
+function renderMigrationGraphSpaceTreeInternal(input: RenderMigrationGraphSpaceTreeInput): string {
+  const rowModel = buildMigrationGraphRows(input.graph, {
+    contractHash: input.liveContractHash,
+  });
+  const layout = buildMigrationGraphLayout(rowModel);
+  const listOverlay = buildEdgeAnnotationsByHashFromListEntries(input.migrations);
+  const edgeAnnotationsByHash =
+    input.statusOverlayByHash === undefined
+      ? listOverlay
+      : mergeMigrationEdgeAnnotations(listOverlay, input.statusOverlayByHash);
+  return renderMigrationGraphTree(layout, {
+    refsByHash: input.refsByHash ?? buildRefsByHashFromListEntries(input.migrations),
+    contractHash: input.liveContractHash,
+    edgeAnnotationsByHash,
+    colorize: input.colorize,
+    glyphMode: input.glyphMode,
+    ...(input.dbHash !== undefined ? { dbHash: input.dbHash } : {}),
+    ...(input.styler !== undefined ? { styler: input.styler } : {}),
+    ...(input.globalMaxEdgeTreePrefixWidth !== undefined
+      ? { globalMaxEdgeTreePrefixWidth: input.globalMaxEdgeTreePrefixWidth }
+      : {}),
+    ...(input.globalMaxDirNameWidth !== undefined
+      ? { globalMaxDirNameWidth: input.globalMaxDirNameWidth }
+      : {}),
+  });
+}
+
+export function renderMigrationGraphSpaceTree(input: RenderMigrationGraphSpaceTreeInput): string {
+  return renderMigrationGraphSpaceTreeInternal(input);
+}
+
+export function renderMigrationGraphSpaceTrees(
+  inputs: readonly RenderMigrationGraphSpaceTreeInput[],
+): readonly string[] {
+  const globalMaxTreePrefix =
+    inputs.length > 1 ? computeGlobalMaxEdgeTreePrefixWidth(inputs) : undefined;
+  const globalMaxDirName = inputs.length > 1 ? computeGlobalMaxDirNameWidth(inputs) : undefined;
+  return inputs.map((input) =>
+    renderMigrationGraphSpaceTreeInternal({
+      ...input,
+      ...(globalMaxTreePrefix !== undefined
+        ? { globalMaxEdgeTreePrefixWidth: globalMaxTreePrefix }
+        : {}),
+      ...(globalMaxDirName !== undefined ? { globalMaxDirNameWidth: globalMaxDirName } : {}),
+    }),
+  );
+}
+
+export function indentMigrationGraphTreeBlock(treeOutput: string, indent: string): string {
+  if (treeOutput.length === 0) {
+    return treeOutput;
+  }
+  return treeOutput
+    .split('\n')
+    .map((line) => (line.length === 0 ? line : `${indent}${line}`))
+    .join('\n');
+}