@prisma-next/cli 0.12.0 → 0.13.0-dev.2

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

@@ -0,0 +1,258 @@
+/**
+ * Occlusion renderer for the line/plane/occlusion migration-graph.
+ *
+ * Per cell: pick the topmost-plane line (lowest plane number = drawn on top),
+ * look up its glyph, apply colour from the line's lane or role. Lower-plane
+ * lines are occluded (not drawn).
+ *
+ * Colour is forced via createColors({ useColor: true }) regardless of NO_COLOR.
+ */
+
+import { createColors } from 'colorette';
+import {
+  type Cell,
+  type CellLine,
+  DEFAULT_COLS_PER_LANE,
+  type Direction,
+  type Grid,
+  type PathRole,
+} from './migration-graph-model';
+
+// ---------------------------------------------------------------------------
+// Force-colour seam — always emits ANSI regardless of NO_COLOR.
+// Same technique as gallery-cells.ts.
+// ---------------------------------------------------------------------------
+const palette = createColors({ useColor: true });
+
+// Lane colour palette: lane N → colour N+1 (lane0=white, lane1=cyan, …).
+// No red (reads as an error). The on-path highlight uses greenBright (SGR 92),
+// distinct from flat-lane green (SGR 32).
+type Colorizer = (text: string) => string;
+
+const LANE_COLORIZERS: Colorizer[] = [
+  palette.white,
+  palette.cyan,
+  palette.yellow,
+  palette.blueBright,
+  palette.magenta,
+  palette.green,
+];
+
+function laneColor(lane: number): Colorizer {
+  return LANE_COLORIZERS[lane % LANE_COLORIZERS.length] ?? ((t) => t);
+}
+
+/**
+ * The colourizer for a lane's hue (lane0 = white, lane1 = cyan, …). Exported
+ * so the per-row LABEL renderer can tint a migration name in its lane's colour,
+ * matching the node `○`, the edges, and the arrows drawn in the gutter — one
+ * colour per lane across glyph and text.
+ */
+export function laneColorizer(lane: number): (text: string) => string {
+  return laneColor(lane);
+}
+
+// ---------------------------------------------------------------------------
+// Focus colour: on-path → green, off-path → dim. Read straight off the line's
+// role; a defined role always overrides the lane rotation.
+// ---------------------------------------------------------------------------
+function roleColor(role: PathRole): Colorizer {
+  return role === 'on-path' ? palette.greenBright : palette.dim;
+}
+
+// ---------------------------------------------------------------------------
+// Glyph alphabet — unicode and ASCII variants.
+// ---------------------------------------------------------------------------
+export type GraphGlyphMode = 'unicode' | 'ascii';
+
+interface GraphGlyphAlphabet {
+  readonly vertical: string;
+  readonly horizontal: string;
+  readonly cornerUpRight: string;
+  readonly cornerDownRight: string;
+  readonly cornerUpLeft: string;
+  readonly cornerDownLeft: string;
+  readonly arrowUp: string;
+  readonly arrowDown: string;
+  readonly node: string;
+  readonly selfLoop: string;
+  readonly landingArrow: string;
+  readonly fallback: string;
+}
+
+const UNICODE_ALPHABET: GraphGlyphAlphabet = {
+  vertical: '│',
+  horizontal: '─',
+  cornerUpRight: '╰',
+  cornerDownRight: '╭',
+  cornerUpLeft: '╯',
+  cornerDownLeft: '╮',
+  arrowUp: '↑',
+  arrowDown: '↓',
+  node: '○',
+  selfLoop: '⟲',
+  landingArrow: '◂',
+  fallback: '?',
+};
+
+const ASCII_ALPHABET: GraphGlyphAlphabet = {
+  vertical: '|',
+  horizontal: '-',
+  cornerUpRight: '\\',
+  cornerDownRight: '/',
+  cornerUpLeft: '/',
+  cornerDownLeft: '\\',
+  arrowUp: '^',
+  arrowDown: 'v',
+  node: '*',
+  selfLoop: '@',
+  landingArrow: '<',
+  fallback: '?',
+};
+
+function alphabetFor(mode: GraphGlyphMode): GraphGlyphAlphabet {
+  return mode === 'ascii' ? ASCII_ALPHABET : UNICODE_ALPHABET;
+}
+
+function glyphFor(dirs: ReadonlySet<Direction>, alphabet: GraphGlyphAlphabet): string {
+  const has = (d: Direction) => dirs.has(d);
+
+  if (has('up') && has('down') && !has('left') && !has('right')) return alphabet.vertical;
+  if (has('left') && has('right') && !has('up') && !has('down')) return alphabet.horizontal;
+  if (has('up') && has('right') && !has('down') && !has('left')) return alphabet.cornerUpRight;
+  if (has('down') && has('right') && !has('up') && !has('left')) return alphabet.cornerDownRight;
+  if (has('up') && has('left') && !has('down') && !has('right')) return alphabet.cornerUpLeft;
+  if (has('down') && has('left') && !has('up') && !has('right')) return alphabet.cornerDownLeft;
+  if (has('up') && !has('down') && !has('left') && !has('right')) return alphabet.arrowUp;
+  if (has('down') && !has('up') && !has('left') && !has('right')) return alphabet.arrowDown;
+
+  // Fallback: shouldn't happen in well-formed grids
+  return alphabet.fallback;
+}
+
+// ---------------------------------------------------------------------------
+// renderCell — project one cell to a coloured string fragment.
+// ---------------------------------------------------------------------------
+
+const NO_COLOR: Colorizer = (t) => t;
+
+function renderCell(cell: Cell, colorEnabled: boolean, alphabet: GraphGlyphAlphabet): string {
+  // Node marker overrides everything
+  if (cell.node !== undefined) {
+    // Every node uses ○ — the ∅ identifier is only used as the label, not as a
+    // glyph, per the golden colour model. Colour by role (focus) or lane (flat).
+    const colorize = !colorEnabled
+      ? NO_COLOR
+      : cell.node.role !== undefined
+        ? roleColor(cell.node.role)
+        : laneColor(cell.node.lane);
+    return colorize(alphabet.node);
+  }
+
+  if (cell.lines.length === 0) {
+    return ' ';
+  }
+
+  // Pick the drawn line by occlusion: lowest plane number wins (drawn on top).
+  // At an equal plane, on-path beats off-path explicitly — never rely on array
+  // order to break the tie (the single-owner invariant should already prevent
+  // a same-plane on/off-path collision, but the priority is made explicit here).
+  const topLine = cell.lines.reduce<CellLine>((best, current) => {
+    if (current.plane < best.plane) return current;
+    if (current.plane > best.plane) return best;
+    if (current.line.role === 'on-path' && best.line.role !== 'on-path') return current;
+    return best;
+  }, cell.lines[0]!);
+
+  const glyph =
+    topLine.selfLoop === true
+      ? alphabet.selfLoop
+      : topLine.landingArrow === true
+        ? alphabet.landingArrow
+        : glyphFor(topLine.directions, alphabet);
+  const colorize = !colorEnabled
+    ? NO_COLOR
+    : topLine.line.role !== undefined
+      ? roleColor(topLine.line.role)
+      : laneColor(topLine.line.lane);
+  return colorize(glyph);
+}
+
+// ---------------------------------------------------------------------------
+// RenderGridOptions
+// ---------------------------------------------------------------------------
+
+export interface RenderGridOptions {
+  readonly colorize?: boolean;
+  readonly colsPerLane?: number;
+  readonly glyphMode?: GraphGlyphMode;
+}
+
+// ---------------------------------------------------------------------------
+// renderGrid — the main render function.
+//
+// Produces the final string: one line per grid row, each cell rendered to
+// a coloured character. Trailing empty cells are trimmed, but we always
+// include up to the last non-empty cell's connector column
+// (the full 2-col-per-lane width for the active lane count).
+// ---------------------------------------------------------------------------
+
+/**
+ * Render a single grid row to a coloured string. A completely empty row returns
+ * the empty string (the row is NOT dropped) so callers that pair grid rows with
+ * an external per-row label list keep a 1:1 index correspondence. `renderGrid`
+ * itself drops empty rows for its standalone output (but preserves separator rows).
+ */
+export function renderGridRow(
+  row: readonly (Cell | undefined)[],
+  opts: RenderGridOptions = {},
+): string {
+  // Inter-component separator row — always renders as an empty line.
+  if (row[0]?.separator === true) {
+    return '';
+  }
+
+  // Find the last non-empty cell index
+  let lastNonEmpty = -1;
+  for (let i = row.length - 1; i >= 0; i--) {
+    const cell = row[i];
+    if (cell !== undefined && (cell.lines.length > 0 || cell.node !== undefined)) {
+      lastNonEmpty = i;
+      break;
+    }
+  }
+
+  if (lastNonEmpty < 0) {
+    return '';
+  }
+
+  // Extend to the next even column boundary (connector col of the current lane)
+  // so that connector columns are always present for active lane ranges.
+  const colsPerLane = opts.colsPerLane ?? DEFAULT_COLS_PER_LANE;
+  const colorEnabled = opts.colorize ?? true;
+  const alphabet = alphabetFor(opts.glyphMode ?? 'unicode');
+  const lastLane = Math.floor(lastNonEmpty / colsPerLane);
+  const lastConnectorCol = lastLane * colsPerLane + (colsPerLane - 1);
+  const renderThrough = Math.max(lastNonEmpty, lastConnectorCol);
+
+  let line = '';
+  for (let col = 0; col <= Math.min(renderThrough, row.length - 1); col++) {
+    const cell = row[col];
+    line += cell === undefined ? ' ' : renderCell(cell, colorEnabled, alphabet);
+  }
+  return line;
+}
+
+export function renderGrid(grid: Grid, opts: RenderGridOptions = {}): string {
+  const lines: string[] = [];
+  for (const row of grid) {
+    const isSeparator = row[0]?.separator === true;
+    const rendered = renderGridRow(row, opts);
+    if (rendered === '' && !isSeparator) {
+      // Completely empty non-separator row — skip in standalone output.
+      continue;
+    }
+    lines.push(rendered);
+  }
+  return lines.join('\n');
+}

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,188 @@
+import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
+import type { GlyphMode } from '../glyph-mode';
+import {
+  computeLabelColumn,
+  computeMaxDirNameWidth,
+  renderMigrationGraphCommand,
+} from './migration-graph-command-render';
+import { buildGrid } from './migration-graph-grid-layout';
+import type { MigrationEdgeAnnotation } from './migration-graph-labels';
+import type { Highlight } from './migration-graph-model';
+import { buildMigrationGraphRows } from './migration-graph-rows';
+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;
+}
+
+/**
+ * Translate `migrate --show` per-edge path-highlight annotations into a
+ * {@link Highlight}. With any `pathHighlight` present the result is focus mode
+ * (on-path lifted green, off-path dim); otherwise flat (lane-rotation colour).
+ */
+export function highlightFromEdgeAnnotations(
+  edgeAnnotationsByHash: ReadonlyMap<string, MigrationEdgeAnnotation>,
+): Highlight {
+  const onPath = new Set<string>();
+  let anyPathHighlight = false;
+  for (const [migrationHash, annotation] of edgeAnnotationsByHash) {
+    if (annotation.pathHighlight === undefined) continue;
+    anyPathHighlight = true;
+    if (annotation.pathHighlight === 'on-path') onPath.add(migrationHash);
+  }
+  return anyPathHighlight ? { mode: 'focus', onPath } : { mode: 'flat', onPath: new Set() };
+}
+
+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;
+  /**
+   * Cross-space override for the gutter→label column (the widest gutter across
+   * sibling space sections, plus the label gap). Named for historical
+   * continuity with the previous renderer's prefix-width input.
+   */
+  readonly globalMaxEdgeTreePrefixWidth?: number;
+  readonly globalMaxDirNameWidth?: number;
+  /**
+   * Whether this render is for the app space. When false, `contractHash` is not
+   * forwarded to `buildMigrationGraphRows` (suppressing the floating working-
+   * contract node) and the `@contract` marker is suppressed. Defaults to `true`.
+   */
+  readonly isAppSpace?: boolean;
+}
+
+export interface ComputeGlobalMaxEdgeTreePrefixWidthInput {
+  readonly graph: MigrationGraph;
+  readonly liveContractHash: string;
+}
+
+function buildGridForInput(input: ComputeGlobalMaxEdgeTreePrefixWidthInput): {
+  readonly grid: ReturnType<typeof buildGrid>;
+  readonly rowModel: ReturnType<typeof buildMigrationGraphRows>;
+} {
+  const rowModel = buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash });
+  const grid = buildGrid(rowModel, {}, { mode: 'flat', onPath: new Set() });
+  return { grid, rowModel };
+}
+
+/**
+ * The widest gutter→label column across the given space layouts. Cross-space
+ * callers pass this back in so every section's labels share one column.
+ */
+export function computeGlobalMaxEdgeTreePrefixWidth(
+  inputs: readonly ComputeGlobalMaxEdgeTreePrefixWidthInput[],
+  glyphMode: GlyphMode = 'unicode',
+): number {
+  let globalMax = 0;
+  for (const input of inputs) {
+    const { grid } = buildGridForInput(input);
+    globalMax = Math.max(globalMax, computeLabelColumn(grid, glyphMode));
+  }
+  return globalMax;
+}
+
+export function computeGlobalMaxDirNameWidth(
+  inputs: readonly ComputeGlobalMaxEdgeTreePrefixWidthInput[],
+): number {
+  let globalMax = 0;
+  for (const input of inputs) {
+    const { rowModel } = buildGridForInput(input);
+    globalMax = Math.max(globalMax, computeMaxDirNameWidth(rowModel));
+  }
+  return globalMax;
+}
+
+function renderMigrationGraphSpaceTreeInternal(input: RenderMigrationGraphSpaceTreeInput): string {
+  const appSpace = input.isAppSpace !== false;
+  const rowModel = buildMigrationGraphRows(input.graph, {
+    ...(appSpace ? { contractHash: input.liveContractHash } : {}),
+  });
+  const listOverlay = buildEdgeAnnotationsByHashFromListEntries(input.migrations);
+  const edgeAnnotationsByHash =
+    input.statusOverlayByHash === undefined
+      ? listOverlay
+      : mergeMigrationEdgeAnnotations(listOverlay, input.statusOverlayByHash);
+  const highlight = highlightFromEdgeAnnotations(edgeAnnotationsByHash);
+  const grid = buildGrid(rowModel, {}, highlight);
+
+  return renderMigrationGraphCommand({
+    grid,
+    rowModel,
+    colorize: input.colorize,
+    glyphMode: input.glyphMode,
+    contractHash: input.liveContractHash,
+    isAppSpace: appSpace,
+    edgeAnnotationsByHash,
+    refsByHash: input.refsByHash ?? buildRefsByHashFromListEntries(input.migrations),
+    ...(input.dbHash !== undefined ? { dbHash: input.dbHash } : {}),
+    ...(input.styler !== undefined ? { styler: input.styler } : {}),
+    ...(input.globalMaxEdgeTreePrefixWidth !== undefined
+      ? { globalLabelColumn: 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 globalInputs: ComputeGlobalMaxEdgeTreePrefixWidthInput[] = inputs.map((input) => ({
+    graph: input.graph,
+    liveContractHash: input.liveContractHash,
+  }));
+  const glyphMode = inputs[0]?.glyphMode ?? 'unicode';
+  const globalLabelColumn =
+    inputs.length > 1 ? computeGlobalMaxEdgeTreePrefixWidth(globalInputs, glyphMode) : undefined;
+  const globalMaxDirName =
+    inputs.length > 1 ? computeGlobalMaxDirNameWidth(globalInputs) : undefined;
+  return inputs.map((input) =>
+    renderMigrationGraphSpaceTreeInternal({
+      ...input,
+      ...(globalLabelColumn !== undefined
+        ? { globalMaxEdgeTreePrefixWidth: globalLabelColumn }
+        : {}),
+      ...(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');
+}