@prisma-next/cli 0.12.0-dev.6 → 0.12.0-dev.61

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

@@ -12,17 +12,24 @@ export type StructuralCell =
       readonly arcTee?: boolean;
       readonly arcLand?: boolean;
     }
-  | { readonly kind: 'vertical-pass' }
-  | { readonly kind: 'horizontal-pass' }
-  | { readonly kind: 'branch-tee' }
-  | { readonly kind: 'branch-corner' }
-  | { readonly kind: 'merge-tee' }
-  | { readonly kind: 'merge-corner' }
-  | { readonly kind: 'arc-branch-corner' }
-  | { readonly kind: 'arc-branch-tee' }
-  | { readonly kind: 'arc-land-corner' }
-  | { readonly kind: 'arc-crossing' }
-  | { readonly kind: 'arc-land-bridge' }
+  | { readonly kind: 'vertical-pass'; readonly migrationHash?: string }
+  | { readonly kind: 'horizontal-pass'; readonly migrationHash?: string }
+  | { readonly kind: 'branch-tee'; readonly migrationHash?: string }
+  | { readonly kind: 'branch-corner'; readonly migrationHash?: string }
+  | { readonly kind: 'merge-tee'; readonly migrationHash?: string }
+  | { readonly kind: 'merge-corner'; readonly migrationHash?: string }
+  | { readonly kind: 'arc-branch-corner'; readonly migrationHash?: string }
+  | { readonly kind: 'arc-branch-tee'; readonly migrationHash?: string }
+  | { readonly kind: 'arc-land-corner'; readonly migrationHash?: string }
+  | { readonly kind: 'arc-land-tee'; readonly migrationHash?: string }
+  | {
+      readonly kind: 'arc-crossing';
+      /** Hash of the edge whose vertical lane passes through this cell. */
+      readonly migrationHash?: string;
+      /** Hash of the arc edge that crosses over the vertical lane. */
+      readonly arcMigrationHash?: string;
+    }
+  | { readonly kind: 'arc-land-bridge'; readonly migrationHash?: string }
   | {
       readonly kind: 'edge-lane';
       readonly migrationHash: string;
@@ -336,6 +343,15 @@ function refineAdjacency(
             row.convergenceProducer ?? false,
             divergenceBranchEdge,
           );
+    // Reconstruct lane owners from the existing cells so the refined row
+    // preserves per-cell identity on its pass-through vertical-pass cells.
+    const existingLaneEdge = new Map<number, string>();
+    for (const lane of row.passThroughLanes ?? []) {
+      const cell = row.cells[lane];
+      if (cell !== undefined && 'migrationHash' in cell && cell.migrationHash !== undefined) {
+        existingLaneEdge.set(lane, cell.migrationHash);
+      }
+    }
     return {
       ...row,
       cells: buildEdgeCells(
@@ -344,6 +360,7 @@ function refineAdjacency(
         row.passThroughLanes ?? [],
         adjacency,
         row.cells.length,
+        existingLaneEdge,
       ),
     };
   });
@@ -376,24 +393,51 @@ function emptyCells(width: number): StructuralCell[] {
   return Array.from({ length: width }, () => ({ kind: 'empty' as const }));
 }
 
+/** Returns `{ migrationHash: hash }` when hash is defined, otherwise `{}`. */
+function hashProp(hash: string | undefined): { readonly migrationHash: string } | object {
+  return hash !== undefined ? { migrationHash: hash } : {};
+}
+
+/** Returns `{ arcMigrationHash: hash }` when hash is defined, otherwise `{}`. */
+function arcHashProp(hash: string | undefined): { readonly arcMigrationHash: string } | object {
+  return hash !== undefined ? { arcMigrationHash: hash } : {};
+}
+
 function buildBranchConnectorCells(
   startLane: number,
   endLane: number,
+  fanTargetLanes: ReadonlySet<number>,
   activeLanes: ReadonlySet<number>,
   gridWidth: number,
+  /** Hash of the edge whose lane is at startLane (the source/trunk edge). */
+  trunkEdgeHash: string | undefined,
+  /** Hash of the fan edge for each fan-target lane. */
+  fanEdgeHashByLane: ReadonlyMap<number, string>,
+  /** Hash of the edge occupying each active pass-through lane. */
+  laneEdgeByIndex: ReadonlyMap<number, string>,
 ): StructuralCell[] {
   const cells = emptyCells(gridWidth);
   for (let lane = 0; lane < gridWidth; lane++) {
     if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
-      cells[lane] = { kind: 'vertical-pass' };
+      cells[lane] = { kind: 'vertical-pass', ...hashProp(laneEdgeByIndex.get(lane)) };
       continue;
     }
     if (lane === startLane) {
-      cells[lane] = { kind: 'branch-tee' };
+      cells[lane] = { kind: 'branch-tee', ...hashProp(trunkEdgeHash) };
     } else if (lane === endLane) {
-      cells[lane] = { kind: 'branch-corner' };
+      cells[lane] = { kind: 'branch-corner', ...hashProp(fanEdgeHashByLane.get(lane)) };
     } else if (lane > startLane && lane < endLane) {
-      cells[lane] = { kind: 'branch-tee' };
+      if (fanTargetLanes.has(lane)) {
+        cells[lane] = { kind: 'branch-tee', ...hashProp(fanEdgeHashByLane.get(lane)) };
+      } else if (activeLanes.has(lane)) {
+        cells[lane] = {
+          kind: 'arc-crossing',
+          ...hashProp(laneEdgeByIndex.get(lane)),
+          ...arcHashProp(fanEdgeHashByLane.get(endLane)),
+        };
+      } else {
+        cells[lane] = { kind: 'branch-tee', ...hashProp(fanEdgeHashByLane.get(lane)) };
+      }
     }
   }
   return cells;
@@ -402,21 +446,34 @@ function buildBranchConnectorCells(
 function buildMergeConnectorCells(
   startLane: number,
   endLane: number,
+  fanTargetLanes: ReadonlySet<number>,
   activeLanes: ReadonlySet<number>,
   gridWidth: number,
+  /** Hash of the edge occupying each active lane (fan lanes + pass-throughs). */
+  laneEdgeByIndex: ReadonlyMap<number, string>,
 ): StructuralCell[] {
   const cells = emptyCells(gridWidth);
   for (let lane = 0; lane < gridWidth; lane++) {
     if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
-      cells[lane] = { kind: 'vertical-pass' };
+      cells[lane] = { kind: 'vertical-pass', ...hashProp(laneEdgeByIndex.get(lane)) };
       continue;
     }
     if (lane === startLane) {
-      cells[lane] = { kind: 'merge-tee' };
+      cells[lane] = { kind: 'merge-tee', ...hashProp(laneEdgeByIndex.get(lane)) };
     } else if (lane === endLane) {
-      cells[lane] = { kind: 'merge-corner' };
+      cells[lane] = { kind: 'merge-corner', ...hashProp(laneEdgeByIndex.get(lane)) };
     } 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', ...hashProp(laneEdgeByIndex.get(lane)) };
+      } else if (activeLanes.has(lane)) {
+        cells[lane] = {
+          kind: 'arc-crossing',
+          ...hashProp(laneEdgeByIndex.get(lane)),
+          ...arcHashProp(laneEdgeByIndex.get(endLane)),
+        };
+      } else {
+        cells[lane] = { kind: 'horizontal-pass', ...hashProp(laneEdgeByIndex.get(startLane)) };
+      }
     }
   }
   return cells;
@@ -427,11 +484,13 @@ function buildNodeCells(
   nodeColumn: number,
   activeLanes: readonly number[],
   gridWidth: number,
+  /** Hash of the edge occupying each active pass-through lane. */
+  laneEdgeByIndex: ReadonlyMap<number, string>,
 ): StructuralCell[] {
   const cells = emptyCells(gridWidth);
   for (const lane of activeLanes) {
     if (lane !== nodeColumn && lane < gridWidth) {
-      cells[lane] = { kind: 'vertical-pass' };
+      cells[lane] = { kind: 'vertical-pass', ...hashProp(laneEdgeByIndex.get(lane)) };
     }
   }
   if (nodeColumn < gridWidth) {
@@ -446,10 +505,14 @@ function buildEdgeCells(
   passThroughLanes: readonly number[],
   adjacency: EdgeAdjacency,
   gridWidth: number,
+  /** Hash of the edge occupying each active pass-through lane. */
+  laneEdgeByIndex: ReadonlyMap<number, string>,
 ): StructuralCell[] {
   const cells = emptyCells(gridWidth);
   for (const lane of passThroughLanes) {
-    if (lane < gridWidth) cells[lane] = { kind: 'vertical-pass' };
+    if (lane < gridWidth) {
+      cells[lane] = { kind: 'vertical-pass', ...hashProp(laneEdgeByIndex.get(lane)) };
+    }
   }
   if (laneIndex < gridWidth) {
     cells[laneIndex] = {
@@ -689,6 +752,17 @@ 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 { migrationHash: arcHash } = edge;
+
     const sourceRow = result[sourceRowIndex];
     if (sourceRow !== undefined) {
       const cells = sourceRow.cells;
@@ -697,7 +771,12 @@ function applySkipRollbackRouting(
       cells[nodeCol] = { kind: 'node', contractHash, arcTee: true };
       for (let lane = nodeCol + 1; lane < backLane; lane += 1) {
         if (coSourcedLanes.includes(lane)) {
-          cells[lane] = { kind: 'arc-branch-tee' };
+          // A co-sourced arc tees off at this lane; tag it with that arc's hash.
+          const coSourcedArc = routes.find((r) => r.backLane === lane && r.edge.from === edge.from);
+          cells[lane] = {
+            kind: 'arc-branch-tee',
+            ...hashProp(coSourcedArc?.edge.migrationHash),
+          };
           continue;
         }
         const existing = cells[lane];
@@ -710,14 +789,30 @@ function applySkipRollbackRouting(
           occupied ||
           routes.some(
             (other) =>
-              other.edge.migrationHash !== edge.migrationHash &&
+              other.edge.migrationHash !== arcHash &&
               other.backLane === lane &&
               routeCrossesRow(other, sourceRowIndex, result),
           );
-        cells[lane] = crossed ? { kind: 'arc-crossing' } : { kind: 'horizontal-pass' };
+        if (crossed) {
+          // The vertical lane was already occupied; tag the crossing with the
+          // existing vertical owner's hash and the arc that crosses over it.
+          const verticalHash =
+            existing !== undefined && 'migrationHash' in existing
+              ? existing.migrationHash
+              : undefined;
+          cells[lane] = {
+            kind: 'arc-crossing',
+            ...hashProp(verticalHash),
+            arcMigrationHash: arcHash,
+          };
+        } else {
+          cells[lane] = { kind: 'horizontal-pass', migrationHash: arcHash };
+        }
       }
       cells[backLane] =
-        backLane < maxCoSourcedLane ? { kind: 'arc-branch-tee' } : { kind: 'arc-branch-corner' };
+        backLane < maxCoSourcedLane
+          ? { kind: 'arc-branch-tee', migrationHash: arcHash }
+          : { kind: 'arc-branch-corner', migrationHash: arcHash };
     }
 
     const edgeRow = result[edgeRowIndex];
@@ -726,10 +821,17 @@ function applySkipRollbackRouting(
       // lane may already cross this row, and rebuilding would clobber it.
       const cells = edgeRow.cells;
       ensureCellWidth(cells, backLane + 1);
-      cells[nodeCol] = { kind: 'vertical-pass' };
+      // The forward lane at nodeCol is now interrupted by this rollback; tag the
+      // vertical-pass with the edge that owns that forward lane.
+      const forwardLaneCell = cells[nodeCol];
+      const forwardLaneHash =
+        forwardLaneCell !== undefined && 'migrationHash' in forwardLaneCell
+          ? forwardLaneCell.migrationHash
+          : undefined;
+      cells[nodeCol] = { kind: 'vertical-pass', ...hashProp(forwardLaneHash) };
       cells[backLane] = {
         kind: 'edge-lane',
-        migrationHash: edge.migrationHash,
+        migrationHash: arcHash,
         edgeKind: edge.kind,
         ownsLabel: true,
         adjacency: 'node-skipping-rollback',
@@ -750,12 +852,13 @@ 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' &&
         existing?.kind !== 'arc-crossing'
       ) {
-        cells[backLane] = { kind: 'vertical-pass' };
+        cells[backLane] = { kind: 'vertical-pass', migrationHash: arcHash };
       }
     }
 
@@ -766,6 +869,14 @@ 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)) {
+          // Tag the landing tee with the inner arc that closes here.
+          const innerArc = routes.find((r) => r.backLane === lane && r.edge.to === edge.to);
+          cells[lane] = { kind: 'arc-land-tee', ...hashProp(innerArc?.edge.migrationHash) };
+          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,18 +885,36 @@ 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(
             (other) =>
-              other.edge.migrationHash !== edge.migrationHash &&
+              other.edge.migrationHash !== arcHash &&
               other.backLane === lane &&
               routeCrossesRow(other, targetRowIndex, result),
           );
-        cells[lane] = crossed ? { kind: 'arc-crossing' } : { kind: 'arc-land-bridge' };
+        if (crossed) {
+          const verticalHash =
+            existing !== undefined && 'migrationHash' in existing
+              ? existing.migrationHash
+              : undefined;
+          cells[lane] = {
+            kind: 'arc-crossing',
+            ...hashProp(verticalHash),
+            arcMigrationHash: arcHash,
+          };
+        } else {
+          cells[lane] = { kind: 'arc-land-bridge', migrationHash: arcHash };
+        }
       }
-      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', migrationHash: arcHash }
+          : { kind: 'arc-land-corner', migrationHash: arcHash };
       for (const other of routes) {
         if (other.backLane <= backLane) continue;
         if (!routeCrossesRow(other, targetRowIndex, result)) continue;
@@ -793,10 +922,16 @@ 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'
         ) {
-          cells[other.backLane] = { kind: 'vertical-pass' };
+          // This is a pass-through from another arc still in flight; tag with
+          // that arc's hash.
+          cells[other.backLane] = {
+            kind: 'vertical-pass',
+            migrationHash: other.edge.migrationHash,
+          };
         }
       }
     }
@@ -878,6 +1013,9 @@ function layoutComponent(
   const nodeColumn = new Map<string, number>();
   const edgeColumn = new Map<string, number>();
   const producerLaneByHash = new Map<string, number>();
+  // Tracks which edge's migrationHash last occupied each lane, so pass-through
+  // cells on node/edge/connector rows can carry per-cell identity.
+  const laneEdgeByIndex = new Map<number, string>();
   let gridWidth = 1;
 
   function ensureGridWidth(minWidth: number): void {
@@ -922,13 +1060,21 @@ 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,
+        laneEdgeByIndex,
+      ),
     });
     for (const index of laneIndices) {
       if (index !== startLane) setLane(index, null);
@@ -941,16 +1087,32 @@ function layoutComponent(
     startLane: number,
     endLane: number,
     branchCount: number,
+    fanTargetLanes: readonly number[],
+    /** Hash of the first/representative edge for each fan lane (keyed by lane index). */
+    fanEdgeHashByLane: ReadonlyMap<number, string>,
   ): void {
     ensureGridWidth(endLane + 1);
     const activeLanes = new Set(activeLaneIndices());
+    // Prefer the fanEdgeHashByLane entry for startLane (the downward fanout edge
+    // leaving this node) over laneEdgeByIndex, which may still hold the hash of
+    // the last skip-rollback emitted into that lane before the branch-connector.
+    const trunkEdgeHash = fanEdgeHashByLane.get(startLane) ?? laneEdgeByIndex.get(startLane);
     rows.push({
       kind: 'branch-connector',
       contractHash,
       startLane,
       endLane,
       branchCount,
-      cells: buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth),
+      cells: buildBranchConnectorCells(
+        startLane,
+        endLane,
+        new Set(fanTargetLanes),
+        activeLanes,
+        gridWidth,
+        trunkEdgeHash,
+        fanEdgeHashByLane,
+        laneEdgeByIndex,
+      ),
     });
   }
 
@@ -963,11 +1125,14 @@ function layoutComponent(
       edge,
       laneIndex: lane,
       passThroughLanes: passThrough,
-      cells: buildEdgeCells(edge, lane, passThrough, adjacency, gridWidth),
+      cells: buildEdgeCells(edge, lane, passThrough, adjacency, gridWidth, laneEdgeByIndex),
     };
     rows.push(convergenceProducer ? { ...row, convergenceProducer: true } : row);
     edgeColumn.set(edge.migrationHash, lane);
     if (convergenceProducer) producerLaneByHash.set(edge.migrationHash, lane);
+    // Record this edge as the current occupant of its lane so subsequent rows
+    // can tag their pass-through cells with the correct owner.
+    laneEdgeByIndex.set(lane, edge.migrationHash);
   }
 
   function emitNodeRow(contractHash: string, column: number): void {
@@ -976,7 +1141,7 @@ function layoutComponent(
     rows.push({
       kind: 'node',
       contractHash,
-      cells: buildNodeCells(contractHash, column, passThrough, gridWidth),
+      cells: buildNodeCells(contractHash, column, passThrough, gridWidth, laneEdgeByIndex),
     });
     nodeColumn.set(contractHash, column);
   }
@@ -1046,7 +1211,31 @@ function layoutComponent(
 
     if (groups.length >= 2) {
       const endLane = Math.max(...laneForGroup);
-      emitBranchConnector(node, column, endLane, groups.length);
+      // Map each fan lane to the representative edge (first in the group) so
+      // the branch-connector cells can carry per-cell identity.
+      const fanEdgeHashByLane = new Map<number, string>();
+      for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+        const group = groups[groupIndex];
+        const lane = laneForGroup[groupIndex];
+        if (group === undefined || lane === undefined) continue;
+        const firstEdge = group.edges[0];
+        if (firstEdge !== undefined) fanEdgeHashByLane.set(lane, firstEdge.migrationHash);
+      }
+      emitBranchConnector(node, column, endLane, groups.length, laneForGroup, fanEdgeHashByLane);
+
+      // Pre-populate laneEdgeByIndex for every fan lane (including lane 0 / trunk) with the
+      // representative edge hash BEFORE emitting any edge rows. Without this, when groupIndex=0's
+      // edge rows are emitted first, the pass-through cells for groupIndex≥1 lanes carry no hash
+      // (laneEdgeByIndex has no entry yet for those lanes) and fall through to whatever annotation
+      // the row's default override is — often the wrong colour.
+      for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+        const fanLane = laneForGroup[groupIndex];
+        if (fanLane === undefined) continue;
+        const fanHash = fanEdgeHashByLane.get(fanLane);
+        if (fanHash !== undefined) {
+          laneEdgeByIndex.set(fanLane, fanHash);
+        }
+      }
     }
 
     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,
+  };
 }