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

package/src/utils/formatters/migration-list-data-column.ts

@@ -1,32 +1,11 @@
+import stringWidth from 'string-width';
 import type { GlyphMode } from '../glyph-mode';
-import type { MigrationEdgeKind } from './migration-list-graph-topology';
-import type { MigrationListStyler } from './migration-list-render';
-import type { MigrationListEntry } from './migration-list-types';
 
 export const MIGRATION_LIST_HASH_WIDTH = 7;
 export const MIGRATION_LIST_EMPTY_SOURCE = '∅';
 export const MIGRATION_LIST_ASCII_EMPTY_SOURCE = '-';
 export const MIGRATION_LIST_FORWARD_EDGE_GLYPH = '→';
 export const MIGRATION_LIST_ASCII_FORWARD_EDGE_GLYPH = '->';
-export const MIGRATION_LIST_DECORATION_PREFIX = '  ';
-
-export const MIGRATION_LIST_UNICODE_KIND_GLYPH: Record<MigrationEdgeKind, string> = {
-  forward: '*',
-  rollback: '↩',
-  self: '⟲',
-};
-
-export const MIGRATION_LIST_ASCII_KIND_GLYPH: Record<MigrationEdgeKind, string> = {
-  forward: '*',
-  rollback: '<',
-  self: '~',
-};
-
-export function migrationListKindGlyph(glyphMode: GlyphMode, edgeKind: MigrationEdgeKind): string {
-  return glyphMode === 'ascii'
-    ? MIGRATION_LIST_ASCII_KIND_GLYPH[edgeKind]
-    : MIGRATION_LIST_UNICODE_KIND_GLYPH[edgeKind];
-}
 
 export function migrationListForwardArrow(glyphMode: GlyphMode): string {
   return glyphMode === 'ascii'
@@ -43,73 +22,7 @@ export function abbreviateContractHash(hash: string): string {
   return stripped.slice(0, MIGRATION_LIST_HASH_WIDTH);
 }
 
-export function computeMigrationDirNameWidth(migrations: readonly MigrationListEntry[]): number {
-  if (migrations.length === 0) return 0;
-  return Math.max(...migrations.map((entry) => entry.dirName.length)) + 2;
-}
-
-function formatSourceColumn(
-  from: string | null,
-  style: MigrationListStyler,
-  emptySource: string,
-): string {
-  if (from === null) {
-    return style.glyph(emptySource) + ' '.repeat(MIGRATION_LIST_HASH_WIDTH - emptySource.length);
-  }
-  return style.sourceHash(abbreviateContractHash(from));
-}
-
-export function formatDecorations(
-  providedInvariants: readonly string[],
-  refs: readonly string[],
-  style: MigrationListStyler,
-): string {
-  const blocks: string[] = [];
-  if (providedInvariants.length > 0) {
-    blocks.push(style.invariants(providedInvariants));
-  }
-  if (refs.length > 0) {
-    blocks.push(style.refs(refs));
-  }
-  if (blocks.length === 0) return '';
-  return `${MIGRATION_LIST_DECORATION_PREFIX}${blocks.join(' ')}`;
-}
-
-export interface MigrationDataColumnOptions {
-  readonly dirNameWidth: number;
-  readonly edgeKind: MigrationEdgeKind;
-  readonly style: MigrationListStyler;
-  readonly forwardArrow?: string;
-  readonly emptySource?: string;
-}
-
-export function formatMigrationDataColumn(
-  migration: MigrationListEntry,
-  options: MigrationDataColumnOptions,
-): string {
-  const {
-    dirNameWidth,
-    edgeKind,
-    style,
-    forwardArrow = MIGRATION_LIST_FORWARD_EDGE_GLYPH,
-    emptySource = MIGRATION_LIST_EMPTY_SOURCE,
-  } = options;
-  const dirNamePadding = ' '.repeat(Math.max(0, dirNameWidth - migration.dirName.length));
-  const dirName = `${style.dirName(migration.dirName)}${dirNamePadding}`;
-  const decorations = formatDecorations(migration.providedInvariants, migration.refs, style);
-
-  if (edgeKind === 'self') {
-    const contractHash = migration.from ?? migration.to;
-    const hash = style.sourceHash(abbreviateContractHash(contractHash));
-    return `${dirName}${hash}${decorations}`;
-  }
-
-  const source = formatSourceColumn(migration.from, style, emptySource);
-  const arrow = style.glyph(forwardArrow);
-  const dest = style.destHash(abbreviateContractHash(migration.to));
-  return `${dirName}${source} ${arrow} ${dest}${decorations}`;
-}
-
-export function formatNodeLineDataColumn(contractHash: string, style: MigrationListStyler): string {
-  return style.sourceHash(abbreviateContractHash(contractHash));
+export function padFromHashColumn(text: string, width: number): string {
+  const padding = Math.max(0, width - stringWidth(text));
+  return `${' '.repeat(padding)}${text}`;
 }

package/src/utils/formatters/migration-list-graph-topology.ts

@@ -11,8 +11,7 @@ export interface MigrationListGraphTopology {
 }
 
 // ---------------------------------------------------------------------------
-// Shared classifier — operates on a normalized edge shape common to both
-// MigrationListEntry (Tier-2) and MigrationEdge / MigrationGraph (Tier-3).
+// Shared classifier — operates on a normalized edge shape for MigrationGraph.
 // ---------------------------------------------------------------------------
 
 interface NormalizedEdge {
@@ -30,10 +29,30 @@ function bumpDegree(map: Map<string, number>, key: string): void {
   map.set(key, (map.get(key) ?? 0) + 1);
 }
 
-function forwardRootsForDepth(
+function compareNodesRootFirst(a: string, b: string): number {
+  if (a === EMPTY_CONTRACT_HASH) return -1;
+  if (b === EMPTY_CONTRACT_HASH) return 1;
+  return a.localeCompare(b);
+}
+
+/**
+ * Shortest-path distance of each node from the forward roots, over the given
+ * candidate edges. Roots are the in-degree-0 nodes (baseline first, then lex);
+ * a rooted component therefore distances every node by how many forward steps
+ * it sits from a root. A component with no root (a pure cycle) is seeded from
+ * its single lexically-smallest node so the cycle still gets a stable layering.
+ *
+ * Crucially this is *shortest* path, not longest: a backward (rollback) edge
+ * `deep → shallow` never offers a shorter route to the already-shallower
+ * target, so it is inert here. Distances are thus stable whether or not the
+ * rollbacks are still in the candidate set — which is what lets the peel below
+ * tell a genuine back-edge (target strictly shallower than source) apart from a
+ * forward edge that merely happens to share the back-edge's cycle.
+ */
+function forwardDistances(
   nodes: ReadonlySet<string>,
   candidates: readonly NormalizedEdge[],
-): readonly string[] {
+): Map<string, number> {
   const inDegree = new Map<string, number>();
   for (const node of nodes) {
     inDegree.set(node, 0);
@@ -42,44 +61,24 @@ function forwardRootsForDepth(
     bumpDegree(inDegree, edge.to);
   }
 
-  const roots: string[] = [];
-  for (const node of nodes) {
-    if ((inDegree.get(node) ?? 0) === 0) {
-      roots.push(node);
-    }
-  }
-  roots.sort((a, b) => {
-    if (a === EMPTY_CONTRACT_HASH) return -1;
-    if (b === EMPTY_CONTRACT_HASH) return 1;
-    return a.localeCompare(b);
-  });
-  if (roots.length > 0) return roots;
+  const roots = [...nodes].filter((node) => (inDegree.get(node) ?? 0) === 0);
+  roots.sort(compareNodesRootFirst);
+  const seeds = roots.length > 0 ? roots : [...nodes].sort(compareNodesRootFirst).slice(0, 1);
 
-  return [...nodes].sort((a, b) => {
-    if (a === EMPTY_CONTRACT_HASH) return -1;
-    if (b === EMPTY_CONTRACT_HASH) return 1;
-    return a.localeCompare(b);
-  });
-}
-
-function longestPathDepths(
-  nodes: ReadonlySet<string>,
-  candidates: readonly NormalizedEdge[],
-): Map<string, number> {
-  const depth = new Map<string, number>();
-  for (const root of forwardRootsForDepth(nodes, candidates)) {
-    depth.set(root, 0);
+  const dist = new Map<string, number>();
+  for (const seed of seeds) {
+    dist.set(seed, 0);
   }
 
   const maxPasses = nodes.size;
   for (let pass = 0; pass < maxPasses; pass++) {
     let changed = false;
     for (const edge of candidates) {
-      const base = depth.get(edge.from);
+      const base = dist.get(edge.from);
       if (base === undefined) continue;
       const next = base + 1;
-      if (next > (depth.get(edge.to) ?? -1)) {
-        depth.set(edge.to, next);
+      if (next < (dist.get(edge.to) ?? Number.POSITIVE_INFINITY)) {
+        dist.set(edge.to, next);
         changed = true;
       }
     }
@@ -87,12 +86,12 @@ function longestPathDepths(
   }
 
   for (const node of nodes) {
-    if (!depth.has(node)) {
-      depth.set(node, 0);
+    if (!dist.has(node)) {
+      dist.set(node, 0);
     }
   }
 
-  return depth;
+  return dist;
 }
 
 function canReachForward(
@@ -126,45 +125,24 @@ function canReachForward(
   return false;
 }
 
-function isMarginalForwardEdge(
-  nodes: ReadonlySet<string>,
-  candidates: readonly NormalizedEdge[],
-  edge: NormalizedEdge,
-): boolean {
-  const without = candidates.filter((candidate) => candidate !== edge);
-  const depthWithout = longestPathDepths(nodes, without);
-  const depthWith = longestPathDepths(nodes, candidates);
-  const fromDepth = depthWithout.get(edge.from) ?? 0;
-  const toWith = depthWith.get(edge.to) ?? 0;
-  return toWith > fromDepth;
-}
-
-// The first branch is the load-bearing one: a forward edge `from → to` is a
-// disguised node-skipping rollback when, after removing it, `to` can still
-// reach `from` and `from` sits strictly deeper than `to + 1` (a longer path
-// already connects them). This branch fires on every cycle-closing edge, and
-// the caller peels exactly one edge (dirName-max) per iteration before
-// recomputing — so cycles are broken deterministically regardless of edge
-// order. `isMarginalForwardEdge` is only a fallback for the residual case and
-// is reached only while the candidate set is still cyclic.
-function shouldPeelForwardEdge(
-  nodes: ReadonlySet<string>,
-  candidates: readonly NormalizedEdge[],
-  edge: NormalizedEdge,
-): boolean {
-  const without = candidates.filter((candidate) => candidate !== edge);
-  const depthWithout = longestPathDepths(nodes, without);
-  const fromDepth = depthWithout.get(edge.from) ?? 0;
-  const toWithout = depthWithout.get(edge.to) ?? 0;
-
-  if (canReachForward(edge.to, edge.from, without) && fromDepth > toWithout + 1) {
-    return true;
-  }
-
-  return !isMarginalForwardEdge(nodes, candidates, edge);
-}
-
-function peelNonMarginalForwardEdges(
+/**
+ * Demote node-skipping rollbacks left forward by the DFS. An edge `from → to`
+ * is a rollback exactly when both hold:
+ *   1. `to` is a forward-ancestor of `from` — `to` can still reach `from` over
+ *      the other forward edges, so the edge closes a cycle; and
+ *   2. `to` is strictly shallower than `from` (smaller forward distance) — the
+ *      edge points back toward the root rather than advancing history.
+ *
+ * Condition 2 is the discriminator: in a cycle created by a rollback every edge
+ * satisfies condition 1, but only the rollback itself runs deep → shallow. The
+ * forward chain edges run shallow → deep and are never peeled, however many
+ * rollbacks converge on the same target. Tight back-edges whose source and
+ * target sit at the same distance (mutual two-node cycles) are already resolved
+ * by the DFS immediate-parent rule, so they never reach this pass. One edge is
+ * peeled per iteration (dirName-descending tie-break) and distances/reachability
+ * are recomputed, making the outcome independent of edge input order.
+ */
+function peelNodeSkippingRollbacks(
   nodes: ReadonlySet<string>,
   kindByMigrationHash: Map<string, MigrationEdgeKind>,
   nonSelf: readonly NormalizedEdge[],
@@ -172,13 +150,18 @@ function peelNonMarginalForwardEdges(
   let candidates = nonSelf.filter((edge) => kindByMigrationHash.get(edge.hash) === 'forward');
 
   while (candidates.length > 0) {
-    const rollbackCandidates = candidates.filter((edge) =>
-      shouldPeelForwardEdge(nodes, candidates, edge),
-    );
-    if (rollbackCandidates.length === 0) break;
-
-    rollbackCandidates.sort(compareDirNameDesc);
-    const rollback = rollbackCandidates[0];
+    const dist = forwardDistances(nodes, candidates);
+    const backEdges = candidates.filter((edge) => {
+      const toDist = dist.get(edge.to) ?? 0;
+      const fromDist = dist.get(edge.from) ?? 0;
+      if (toDist >= fromDist) return false;
+      const without = candidates.filter((candidate) => candidate !== edge);
+      return canReachForward(edge.to, edge.from, without);
+    });
+    if (backEdges.length === 0) break;
+
+    backEdges.sort(compareDirNameDesc);
+    const rollback = backEdges[0];
     if (rollback === undefined) break;
 
     kindByMigrationHash.set(rollback.hash, 'rollback');
@@ -189,8 +172,8 @@ function peelNonMarginalForwardEdges(
 /**
  * DFS with dirName-descending traversal. A GRAY target is a rollback only when it
  * is the immediate DFS parent of the source — cross-links to other GRAY nodes
- * stay forward. A follow-up peel pass drops node-skipping rollbacks (target can
- * reach the source on the forward subgraph and sits more than one rank below).
+ * stay forward. A follow-up peel pass demotes node-skipping rollbacks (target is
+ * a forward-ancestor of the source and sits strictly shallower than it).
  */
 function classifyNormalizedEdges(edges: readonly NormalizedEdge[]): MigrationListGraphTopology {
   const nodes = new Set<string>();
@@ -307,7 +290,7 @@ function classifyNormalizedEdges(edges: readonly NormalizedEdge[]): MigrationLis
     runDfsFrom(root);
   }
 
-  peelNonMarginalForwardEdges(nodes, kindByMigrationHash, nonSelf);
+  peelNodeSkippingRollbacks(nodes, kindByMigrationHash, nonSelf);
 
   const forwardInDegree = new Map<string, number>();
   const forwardOutDegree = new Map<string, number>();
@@ -331,26 +314,21 @@ function canonicalFrom(from: string | null): string {
 
 /**
  * Classify forward/rollback/self for a Tier-2 `MigrationListEntry[]` edge set.
- * Returns the kind of each migration plus the forward in/out degree of each
- * contract node. This is the established Tier-2 surface; its behaviour is
- * unchanged — only its implementation now delegates to the shared classifier.
  */
 export function classifyMigrationListGraphTopology(
   entries: readonly MigrationListEntry[],
 ): MigrationListGraphTopology {
   const normalized: NormalizedEdge[] = entries.map((entry) => ({
-    hash: entry.migrationHash,
-    from: canonicalFrom(entry.from),
-    to: entry.to,
-    dirName: entry.dirName,
+    hash: entry.hash,
+    from: canonicalFrom(entry.fromContract),
+    to: entry.toContract,
+    dirName: entry.name,
   }));
   return classifyNormalizedEdges(normalized);
 }
 
 /**
  * Classify forward/rollback/self for a `MigrationGraph` edge set (Tier-3).
- * Delegates to the same shared classifier as `classifyMigrationListGraphTopology`
- * so both tiers agree on forward/rollback/self without duplicating logic.
  */
 export function classifyMigrationGraphTopology(graph: MigrationGraph): MigrationListGraphTopology {
   const normalized: NormalizedEdge[] = [];

package/src/utils/formatters/migration-list-render.ts

@@ -1,16 +1,13 @@
+import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
+import type { MigrationEdge, MigrationGraph } from '@prisma-next/migration-tools/graph';
 import type { GlyphMode } from '../glyph-mode';
+import type { MigrationEdgeAnnotation } from './migration-graph-labels';
 import {
-  computeMigrationDirNameWidth,
-  formatMigrationDataColumn,
-  migrationListEmptySource,
-  migrationListForwardArrow,
-  migrationListKindGlyph,
-} from './migration-list-data-column';
-import {
-  classifyMigrationListGraphTopology,
-  type MigrationEdgeKind,
-  type MigrationListGraphTopology,
-} from './migration-list-graph-topology';
+  computeGlobalMaxDirNameWidth,
+  computeGlobalMaxEdgeTreePrefixWidth,
+  indentMigrationGraphTreeBlock,
+  renderMigrationGraphSpaceTree,
+} from './migration-graph-space-render';
 import type { MigrationListEntry, MigrationListResult } from './migration-list-types';
 
 export type { GlyphMode } from '../glyph-mode';
@@ -62,42 +59,83 @@ export const IDENTITY_MIGRATION_LIST_STYLER: MigrationListStyler = {
   emptyState: (text) => text,
 };
 
-function resolveEdgeKind(
-  migrationHash: string,
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
-): MigrationEdgeKind {
-  return kindByMigrationHash.get(migrationHash) ?? 'forward';
+function canonicalFrom(from: string | null): string {
+  return from ?? EMPTY_CONTRACT_HASH;
 }
 
-function formatMigrationRow(
-  migration: MigrationListEntry,
-  dirNameWidth: number,
-  edgeKind: MigrationEdgeKind,
-  glyphMode: GlyphMode,
-  style: MigrationListStyler,
-): string {
-  const kindColumn = `${style.kind(migrationListKindGlyph(glyphMode, edgeKind))} `;
-  const data = formatMigrationDataColumn(migration, {
-    dirNameWidth,
-    edgeKind,
-    style,
-    forwardArrow: migrationListForwardArrow(glyphMode),
-    emptySource: migrationListEmptySource(glyphMode),
-  });
-  return `${kindColumn}${data}`;
+export function migrationGraphFromListEntries(
+  entries: readonly MigrationListEntry[],
+): MigrationGraph {
+  const nodes = new Set<string>();
+  const forwardChain = new Map<string, MigrationEdge[]>();
+  const reverseChain = new Map<string, MigrationEdge[]>();
+  const migrationByHash = new Map<string, MigrationEdge>();
+
+  for (const entry of entries) {
+    const from = canonicalFrom(entry.fromContract);
+    const edge: MigrationEdge = {
+      from,
+      to: entry.toContract,
+      migrationHash: entry.hash,
+      dirName: entry.name,
+      createdAt: entry.createdAt,
+      invariants: entry.providedInvariants,
+    };
+    nodes.add(from);
+    nodes.add(entry.toContract);
+    const forward = forwardChain.get(from);
+    if (forward) forward.push(edge);
+    else forwardChain.set(from, [edge]);
+    const reverse = reverseChain.get(entry.toContract);
+    if (reverse) reverse.push(edge);
+    else reverseChain.set(entry.toContract, [edge]);
+    migrationByHash.set(entry.hash, edge);
+  }
+
+  return { nodes, forwardChain, reverseChain, migrationByHash };
+}
+
+export function buildEdgeAnnotationsByHashFromListEntries(
+  entries: readonly MigrationListEntry[],
+): ReadonlyMap<string, MigrationEdgeAnnotation> {
+  const annotations = new Map<string, MigrationEdgeAnnotation>();
+  for (const entry of entries) {
+    annotations.set(entry.hash, {
+      operationCount: entry.operationCount,
+      invariants: entry.providedInvariants,
+    });
+  }
+  return annotations;
+}
+
+export function buildRefsByHashFromListEntries(
+  entries: readonly MigrationListEntry[],
+): ReadonlyMap<string, readonly string[]> {
+  const refsByHash = new Map<string, readonly string[]>();
+  for (const entry of entries) {
+    if (entry.refs.length > 0) {
+      refsByHash.set(entry.toContract, entry.refs);
+    }
+  }
+  return refsByHash;
 }
 
 function formatEmptyStateLine(spaceId: string, style: MigrationListStyler): string {
   return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
 }
 
-function renderSpaceBlock(
+function renderSpaceTreeBlock(
   spaceId: string,
   migrations: readonly MigrationListEntry[],
   multiSpace: boolean,
   glyphMode: GlyphMode,
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
   style: MigrationListStyler,
+  colorize: boolean,
+  liveContractHash: string,
+  graphForSpace: (spaceId: string) => MigrationGraph | undefined,
+  appSpaceId: string | undefined,
+  globalMaxEdgeTreePrefixWidth?: number,
+  globalMaxDirNameWidth?: number,
 ): readonly string[] {
   if (migrations.length === 0) {
     const emptyLine = formatEmptyStateLine(spaceId, style);
@@ -107,50 +145,75 @@ function renderSpaceBlock(
     return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
   }
 
-  const dirNameWidth = computeMigrationDirNameWidth(migrations);
-  const rows = migrations.map((entry) =>
-    formatMigrationRow(
-      entry,
-      dirNameWidth,
-      resolveEdgeKind(entry.migrationHash, kindByMigrationHash),
-      glyphMode,
-      style,
-    ),
-  );
+  const graph = graphForSpace(spaceId) ?? migrationGraphFromListEntries(migrations);
+  const isAppSpace = appSpaceId === undefined ? undefined : spaceId === appSpaceId;
+  const treeOutput = renderMigrationGraphSpaceTree({
+    graph,
+    migrations,
+    liveContractHash,
+    glyphMode,
+    colorize,
+    refsByHash: buildRefsByHashFromListEntries(migrations),
+    styler: style,
+    ...(isAppSpace !== undefined ? { isAppSpace } : {}),
+    ...(globalMaxEdgeTreePrefixWidth !== undefined ? { globalMaxEdgeTreePrefixWidth } : {}),
+    ...(globalMaxDirNameWidth !== undefined ? { globalMaxDirNameWidth } : {}),
+  });
+
   if (!multiSpace) {
-    return rows;
+    return treeOutput.length === 0 ? [] : [treeOutput];
   }
-  return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
+
+  const indented = indentMigrationGraphTreeBlock(treeOutput, '  ');
+  return [style.spaceHeading(`${spaceId}:`), indented];
 }
 
-export function buildMigrationListTopologyBySpace(
-  result: MigrationListResult,
-): ReadonlyMap<string, MigrationListGraphTopology> {
-  const topologyBySpaceId = new Map<string, MigrationListGraphTopology>();
-  for (const space of result.spaces) {
-    topologyBySpaceId.set(space.spaceId, classifyMigrationListGraphTopology(space.migrations));
-  }
-  return topologyBySpaceId;
+export interface RenderMigrationListWithStyleOptions {
+  readonly colorize?: boolean;
+  readonly liveContractHash?: string;
+  readonly graphForSpace?: (spaceId: string) => MigrationGraph | undefined;
+  /**
+   * The space ID that is the app contract space. When provided, `@contract`
+   * and the floating working-contract node are shown only for this space.
+   * When absent, the renderer falls back to the default (`isAppSpace: true`
+   * for every space), which is safe for single-space callers.
+   */
+  readonly appSpaceId?: string;
 }
 
 /**
- * Compose the styled `migration list` output. The renderer is
- * presentation-neutral — every token passes through `style` before
- * landing in the output, so the same composition serves the pure-text
- * path ({@link renderMigrationList} via
- * {@link IDENTITY_MIGRATION_LIST_STYLER}) and the ANSI-styled CLI path
- * (via the ANSI styler the CLI shell wires up).
+ * Compose the styled `migration list` human output via the shared tree
+ * renderer. Each on-disk migration is one edge row with package-fact
+ * annotations; refs decorate destination contract nodes.
+ *
+ * `options.colorize` must match whether `style` emits ANSI (e.g. both true for
+ * `createAnsiMigrationListStyler({ useColor: true })`).
  */
 export function renderMigrationListWithStyle(
   result: MigrationListResult,
   style: MigrationListStyler,
   glyphMode: GlyphMode = 'unicode',
-  topologyBySpaceId: ReadonlyMap<
-    string,
-    MigrationListGraphTopology
-  > = buildMigrationListTopologyBySpace(result),
+  options: RenderMigrationListWithStyleOptions = {},
 ): string {
   const multiSpace = result.spaces.length > 1;
+  const colorize = options.colorize ?? false;
+  const liveContractHash = options.liveContractHash ?? EMPTY_CONTRACT_HASH;
+  const graphForSpace = options.graphForSpace ?? (() => undefined);
+  const appSpaceId = options.appSpaceId;
+  const globalLayoutInputs = multiSpace
+    ? result.spaces
+        .filter((space) => space.migrations.length > 0)
+        .map((space) => ({
+          graph: graphForSpace(space.space) ?? migrationGraphFromListEntries(space.migrations),
+          liveContractHash,
+        }))
+    : [];
+  const globalMaxEdgeTreePrefixWidth =
+    globalLayoutInputs.length > 0
+      ? computeGlobalMaxEdgeTreePrefixWidth(globalLayoutInputs)
+      : undefined;
+  const globalMaxDirNameWidth =
+    globalLayoutInputs.length > 0 ? computeGlobalMaxDirNameWidth(globalLayoutInputs) : undefined;
   const lines: string[] = [];
 
   for (let index = 0; index < result.spaces.length; index++) {
@@ -158,18 +221,19 @@ export function renderMigrationListWithStyle(
     if (index > 0) {
       lines.push('');
     }
-    const topology = topologyBySpaceId.get(space.spaceId);
-    const kindByMigrationHash =
-      topology?.kindByMigrationHash ??
-      classifyMigrationListGraphTopology(space.migrations).kindByMigrationHash;
     lines.push(
-      ...renderSpaceBlock(
-        space.spaceId,
+      ...renderSpaceTreeBlock(
+        space.space,
         space.migrations,
         multiSpace,
         glyphMode,
-        kindByMigrationHash,
         style,
+        colorize,
+        liveContractHash,
+        graphForSpace,
+        appSpaceId,
+        globalMaxEdgeTreePrefixWidth,
+        globalMaxDirNameWidth,
       ),
     );
   }