@a9n-shoji/rvw 0.4.3 → 0.5.0

package/dist/cli.mjs

@@ -20295,7 +20295,7 @@ import path5 from "node:path";
 import { TextDecoder as TextDecoder2 } from "node:util";
 
 // src/shared/constants.ts
-var APP_VERSION = "0.4.3";
+var APP_VERSION = "0.5.0";
 var PROTOCOL_VERSION = 4;
 var VIEWER_ID_HEADER = "x-rvw-viewer-id";
 var VIEWER_OPEN_LEASE_HEADER = "x-rvw-viewer-open-lease";
@@ -43805,6 +43805,691 @@ function createRuntime(options = {}) {
   return { database, git, github, service, close: () => database.close() };
 }
 
+// src/domain/structure-projection.ts
+var STRUCTURE_NODE_WIDTH = 228;
+var STRUCTURE_NODE_HEIGHT = 112;
+function stableCompare(left, right) {
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+function compareLinks([leftA, leftB], [rightA, rightB]) {
+  const first = stableCompare(leftA, rightA);
+  return first === 0 ? stableCompare(leftB, rightB) : first;
+}
+function simpleStructureTopology(structure) {
+  const neighborSets = new Map(structure.nodes.map((node2) => [node2.id, /* @__PURE__ */ new Set()]));
+  const pairNodes = /* @__PURE__ */ new Map();
+  const pairDirections = /* @__PURE__ */ new Map();
+  for (const edge of structure.edges) {
+    if (edge.from === edge.to || !neighborSets.has(edge.from) || !neighborSets.has(edge.to)) {
+      continue;
+    }
+    neighborSets.get(edge.from)?.add(edge.to);
+    neighborSets.get(edge.to)?.add(edge.from);
+    const ordered = [edge.from, edge.to].sort(stableCompare);
+    const pairKey = JSON.stringify(ordered);
+    pairNodes.set(pairKey, ordered);
+    const directions = pairDirections.get(pairKey) ?? {
+      hasUndirected: false,
+      directions: /* @__PURE__ */ new Map()
+    };
+    if (edge.directed) {
+      directions.directions.set(JSON.stringify([edge.from, edge.to]), [edge.from, edge.to]);
+    } else {
+      directions.hasUndirected = true;
+    }
+    pairDirections.set(pairKey, directions);
+  }
+  return {
+    neighbors: new Map(
+      [...neighborSets].map(([nodeId, neighbors]) => [nodeId, [...neighbors].sort(stableCompare)])
+    ),
+    links: [...pairNodes.values()].sort(compareLinks),
+    directionalLinks: [...pairDirections.values()].flatMap(
+      ({ hasUndirected, directions }) => !hasUndirected && directions.size === 1 ? [...directions.values()] : []
+    ).sort(compareLinks)
+  };
+}
+function topologyComponents(topology) {
+  const components = [];
+  const assigned = /* @__PURE__ */ new Set();
+  for (const first of [...topology.neighbors.keys()].sort(stableCompare)) {
+    if (assigned.has(first)) continue;
+    const component = [];
+    const queue = [first];
+    assigned.add(first);
+    for (let index2 = 0; index2 < queue.length; index2 += 1) {
+      const current = queue[index2];
+      component.push(current);
+      for (const neighbor of topology.neighbors.get(current) ?? []) {
+        if (assigned.has(neighbor)) continue;
+        assigned.add(neighbor);
+        queue.push(neighbor);
+      }
+    }
+    component.sort(stableCompare);
+    components.push(component);
+  }
+  return components.sort(
+    (left, right) => right.length - left.length || stableCompare(left[0], right[0])
+  );
+}
+function topologyRoot(nodeIds, topology) {
+  const neighborDegree = (nodeId) => (topology.neighbors.get(nodeId) ?? []).reduce(
+    (total, neighbor) => total + (topology.neighbors.get(neighbor)?.length ?? 0),
+    0
+  );
+  return [...nodeIds].sort(
+    (left, right) => (topology.neighbors.get(right)?.length ?? 0) - (topology.neighbors.get(left)?.length ?? 0) || neighborDegree(right) - neighborDegree(left) || stableCompare(left, right)
+  )[0];
+}
+function countNonForwardLinks(ranks, directionalLinks) {
+  return directionalLinks.reduce((count, [from, to]) => {
+    const fromRank = ranks.get(from);
+    const toRank = ranks.get(to);
+    return count + (fromRank !== void 0 && toRank !== void 0 && fromRank >= toRank ? 1 : 0);
+  }, 0);
+}
+function normalizedRankIndexes(ranks) {
+  return new Map(
+    [...new Set(ranks.values())].sort((left, right) => left - right).map((rank, index2) => [rank, index2])
+  );
+}
+function totalDirectionalSpan(ranks, directionalLinks) {
+  const indexes = normalizedRankIndexes(ranks);
+  return directionalLinks.reduce((total, [from, to]) => {
+    const fromRank = ranks.get(from);
+    const toRank = ranks.get(to);
+    if (fromRank === void 0 || toRank === void 0) return total;
+    return total + Math.abs(indexes.get(fromRank) - indexes.get(toRank));
+  }, 0);
+}
+function compareNumberArrays(left, right) {
+  for (let index2 = 0; index2 < Math.max(left.length, right.length); index2 += 1) {
+    const difference = (left[index2] ?? 0) - (right[index2] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function canonicalTopologyStructuralColors(nodeIds, topology, originNodeId) {
+  const nodeSet = new Set(nodeIds);
+  const incomingNeighbors = new Map(nodeIds.map((nodeId) => [nodeId, /* @__PURE__ */ new Set()]));
+  const outgoingNeighbors = new Map(nodeIds.map((nodeId) => [nodeId, /* @__PURE__ */ new Set()]));
+  for (const [from, to] of topology.directionalLinks) {
+    if (!nodeSet.has(from) || !nodeSet.has(to)) continue;
+    outgoingNeighbors.get(from)?.add(to);
+    incomingNeighbors.get(to)?.add(from);
+  }
+  const ambiguousNeighbors = new Map(
+    nodeIds.map((nodeId) => {
+      const directionalNeighbors = /* @__PURE__ */ new Set([
+        ...incomingNeighbors.get(nodeId),
+        ...outgoingNeighbors.get(nodeId)
+      ]);
+      return [
+        nodeId,
+        new Set(
+          (topology.neighbors.get(nodeId) ?? []).filter(
+            (neighbor) => nodeSet.has(neighbor) && !directionalNeighbors.has(neighbor)
+          )
+        )
+      ];
+    })
+  );
+  const assignColors = (descriptors) => {
+    const colorByDescriptor = new Map(
+      [...new Set(descriptors.values())].sort(stableCompare).map((descriptor, index2) => [descriptor, index2])
+    );
+    return new Map(
+      nodeIds.map((nodeId) => [nodeId, colorByDescriptor.get(descriptors.get(nodeId))])
+    );
+  };
+  let colors = assignColors(
+    new Map(
+      nodeIds.map((nodeId) => [
+        nodeId,
+        JSON.stringify([
+          nodeId === originNodeId ? 1 : 0,
+          incomingNeighbors.get(nodeId).size,
+          outgoingNeighbors.get(nodeId).size,
+          ambiguousNeighbors.get(nodeId).size
+        ])
+      ])
+    )
+  );
+  for (let pass = 0; pass < nodeIds.length; pass += 1) {
+    const next2 = assignColors(
+      new Map(
+        nodeIds.map((nodeId) => [
+          nodeId,
+          JSON.stringify([
+            colors.get(nodeId),
+            [...incomingNeighbors.get(nodeId)].map((neighbor) => colors.get(neighbor)).sort((left, right) => left - right),
+            [...outgoingNeighbors.get(nodeId)].map((neighbor) => colors.get(neighbor)).sort((left, right) => left - right),
+            [...ambiguousNeighbors.get(nodeId)].map((neighbor) => colors.get(neighbor)).sort((left, right) => left - right)
+          ])
+        ])
+      )
+    );
+    if (nodeIds.every((nodeId) => next2.get(nodeId) === colors.get(nodeId))) break;
+    colors = next2;
+  }
+  return colors;
+}
+function chooseRankProposal(nodeId, proposals, ranks, directionalLinks) {
+  const scored = [...proposals].map((rank) => {
+    const candidate = new Map(ranks).set(nodeId, rank);
+    return {
+      rank,
+      nonForward: countNonForwardLinks(candidate, directionalLinks),
+      occupiedColumns: new Set(candidate.values()).size,
+      span: totalDirectionalSpan(candidate, directionalLinks)
+    };
+  });
+  scored.sort(
+    (left, right) => left.nonForward - right.nonForward || left.occupiedColumns - right.occupiedColumns || left.span - right.span || Math.abs(left.rank) - Math.abs(right.rank) || left.rank - right.rank
+  );
+  return scored[0].rank;
+}
+function applyForwardWaves(nodeSet, topology, ranks) {
+  for (let pass = 0; pass < nodeSet.size; pass += 1) {
+    const proposals = /* @__PURE__ */ new Map();
+    for (const [from, to] of topology.directionalLinks) {
+      if (!nodeSet.has(from) || !nodeSet.has(to) || ranks.has(to)) continue;
+      const fromRank = ranks.get(from);
+      if (fromRank === void 0) continue;
+      const targetProposals = proposals.get(to) ?? /* @__PURE__ */ new Set();
+      targetProposals.add(fromRank + 1);
+      proposals.set(to, targetProposals);
+    }
+    if (proposals.size === 0) break;
+    const accepted = [...proposals].map(
+      ([nodeId, nodeProposals]) => [
+        nodeId,
+        chooseRankProposal(nodeId, nodeProposals, ranks, topology.directionalLinks)
+      ]
+    ).sort(([left], [right]) => stableCompare(left, right));
+    for (const [nodeId, rank] of accepted) ranks.set(nodeId, rank);
+  }
+}
+function stronglyConnectedComponents(nodeIds, directionalLinks) {
+  const nodeSet = new Set(nodeIds);
+  const outgoing = new Map(nodeIds.map((nodeId) => [nodeId, /* @__PURE__ */ new Set()]));
+  for (const [from, to] of directionalLinks) {
+    if (nodeSet.has(from) && nodeSet.has(to)) outgoing.get(from)?.add(to);
+  }
+  const indexes = /* @__PURE__ */ new Map();
+  const lowLinks = /* @__PURE__ */ new Map();
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const components = [];
+  let nextIndex = 0;
+  const visit = (nodeId) => {
+    const nodeIndex = nextIndex;
+    nextIndex += 1;
+    indexes.set(nodeId, nodeIndex);
+    lowLinks.set(nodeId, nodeIndex);
+    stack.push(nodeId);
+    onStack.add(nodeId);
+    for (const neighbor of [...outgoing.get(nodeId) ?? []].sort(stableCompare)) {
+      if (!indexes.has(neighbor)) {
+        visit(neighbor);
+        lowLinks.set(nodeId, Math.min(lowLinks.get(nodeId), lowLinks.get(neighbor)));
+      } else if (onStack.has(neighbor)) {
+        lowLinks.set(nodeId, Math.min(lowLinks.get(nodeId), indexes.get(neighbor)));
+      }
+    }
+    if (lowLinks.get(nodeId) !== indexes.get(nodeId)) return;
+    const component = [];
+    for (; ; ) {
+      const member = stack.pop();
+      onStack.delete(member);
+      component.push(member);
+      if (member === nodeId) break;
+    }
+    component.sort(stableCompare);
+    components.push(component);
+  };
+  for (const nodeId of [...nodeIds].sort(stableCompare)) {
+    if (!indexes.has(nodeId)) visit(nodeId);
+  }
+  return components;
+}
+function internalComponentRanks(nodeIds, directionalLinks, structuralColors, preferredAnchor, originIncomingBoundaryNodeIds, incomingBoundaryNodeIds, outgoingBoundaryNodeIds, attachmentBoundaryNodeIds) {
+  if (nodeIds.length === 1) return /* @__PURE__ */ new Map([[nodeIds[0], 0]]);
+  const nodeSet = new Set(nodeIds);
+  const internalLinks = directionalLinks.filter(
+    ([from, to]) => nodeSet.has(from) && nodeSet.has(to)
+  );
+  const neighborSets = new Map(nodeIds.map((nodeId) => [nodeId, /* @__PURE__ */ new Set()]));
+  for (const [from, to] of internalLinks) {
+    neighborSets.get(from)?.add(to);
+    neighborSets.get(to)?.add(from);
+  }
+  const topology = {
+    neighbors: new Map(
+      [...neighborSets].map(([nodeId, neighbors]) => [nodeId, [...neighbors].sort(stableCompare)])
+    ),
+    links: internalLinks,
+    directionalLinks: internalLinks
+  };
+  const ranksFromAnchor = (anchor) => {
+    const rawRanks = /* @__PURE__ */ new Map([[anchor, 0]]);
+    applyForwardWaves(nodeSet, topology, rawRanks);
+    const rankIndexes = normalizedRankIndexes(rawRanks);
+    return new Map(nodeIds.map((nodeId) => [nodeId, rankIndexes.get(rawRanks.get(nodeId)) ?? 0]));
+  };
+  if (preferredAnchor && nodeSet.has(preferredAnchor)) return ranksFromAnchor(preferredAnchor);
+  const candidates = nodeIds.map((anchor) => {
+    const ranks = ranksFromAnchor(anchor);
+    const maxRank = Math.max(...ranks.values());
+    const rankLoadProfile = Array.from(
+      { length: maxRank + 1 },
+      (_, rank) => nodeIds.filter((nodeId) => ranks.get(nodeId) === rank).length
+    );
+    const rankStructuralProfile = rankLoadProfile.flatMap((_, rank) => [
+      -1,
+      ...nodeIds.filter((nodeId) => ranks.get(nodeId) === rank).map((nodeId) => structuralColors.get(nodeId)).sort((left, right) => left - right)
+    ]);
+    return {
+      anchor,
+      ranks,
+      nonForward: countNonForwardLinks(ranks, internalLinks),
+      originIncomingBoundaryRanks: originIncomingBoundaryNodeIds.map((nodeId) => ranks.get(nodeId)).sort((left, right) => right - left),
+      incomingBoundaryRanks: incomingBoundaryNodeIds.map((nodeId) => ranks.get(nodeId)).sort((left, right) => right - left),
+      outgoingBoundaryDistances: outgoingBoundaryNodeIds.map((nodeId) => maxRank - ranks.get(nodeId)).sort((left, right) => right - left),
+      attachmentBoundaryRanks: attachmentBoundaryNodeIds.map((nodeId) => ranks.get(nodeId)).sort((left, right) => right - left),
+      width: new Set(ranks.values()).size,
+      span: totalDirectionalSpan(ranks, internalLinks),
+      rankLoadProfile,
+      rankStructuralProfile,
+      anchorStructuralColor: structuralColors.get(anchor)
+    };
+  });
+  candidates.sort(
+    (left, right) => left.nonForward - right.nonForward || compareNumberArrays(left.originIncomingBoundaryRanks, right.originIncomingBoundaryRanks) || compareNumberArrays(left.incomingBoundaryRanks, right.incomingBoundaryRanks) || compareNumberArrays(left.outgoingBoundaryDistances, right.outgoingBoundaryDistances) || compareNumberArrays(left.attachmentBoundaryRanks, right.attachmentBoundaryRanks) || left.width - right.width || left.span - right.span || compareNumberArrays(left.rankLoadProfile, right.rankLoadProfile) || compareNumberArrays(left.rankStructuralProfile, right.rankStructuralProfile) || left.anchorStructuralColor - right.anchorStructuralColor || stableCompare(left.anchor, right.anchor)
+  );
+  return candidates[0].ranks;
+}
+function directionalCondensationRanks(nodeIds, topology, originNodeId) {
+  const nodeSet = new Set(nodeIds);
+  const directionalLinks = topology.directionalLinks.filter(
+    ([from, to]) => nodeSet.has(from) && nodeSet.has(to)
+  );
+  const structuralColors = canonicalTopologyStructuralColors(nodeIds, topology, originNodeId);
+  const components = stronglyConnectedComponents(nodeIds, directionalLinks);
+  const componentByNodeId = /* @__PURE__ */ new Map();
+  components.forEach((component, componentIndex) => {
+    for (const nodeId of component) componentByNodeId.set(nodeId, componentIndex);
+  });
+  const outgoing = new Map(components.map((_, index2) => [index2, /* @__PURE__ */ new Set()]));
+  const incoming = new Map(components.map((_, index2) => [index2, /* @__PURE__ */ new Set()]));
+  for (const [from, to] of directionalLinks) {
+    const fromComponent = componentByNodeId.get(from);
+    const toComponent = componentByNodeId.get(to);
+    if (fromComponent === toComponent) continue;
+    outgoing.get(fromComponent).add(toComponent);
+    incoming.get(toComponent).add(fromComponent);
+  }
+  const originComponent = componentByNodeId.get(originNodeId);
+  const directionalGroups = [];
+  const directionalGroupByComponent = /* @__PURE__ */ new Map();
+  for (let first = 0; first < components.length; first += 1) {
+    if (directionalGroupByComponent.has(first)) continue;
+    const groupIndex = directionalGroups.length;
+    const group = [];
+    const queue = [first];
+    directionalGroupByComponent.set(first, groupIndex);
+    for (let index2 = 0; index2 < queue.length; index2 += 1) {
+      const current = queue[index2];
+      group.push(current);
+      for (const neighbor of [...outgoing.get(current), ...incoming.get(current)]) {
+        if (directionalGroupByComponent.has(neighbor)) continue;
+        directionalGroupByComponent.set(neighbor, groupIndex);
+        queue.push(neighbor);
+      }
+    }
+    directionalGroups.push(group);
+  }
+  const directionalGroupByNodeId = /* @__PURE__ */ new Map();
+  for (const [nodeId, componentIndex] of componentByNodeId) {
+    directionalGroupByNodeId.set(nodeId, directionalGroupByComponent.get(componentIndex));
+  }
+  const attachmentBoundaryNodeIds = new Map(
+    components.map((_, componentIndex) => [componentIndex, []])
+  );
+  for (const [left, right] of topology.links) {
+    if (directionalGroupByNodeId.get(left) === directionalGroupByNodeId.get(right)) continue;
+    attachmentBoundaryNodeIds.get(componentByNodeId.get(left)).push(left);
+    attachmentBoundaryNodeIds.get(componentByNodeId.get(right)).push(right);
+  }
+  const compareComponents = (left, right) => stableCompare(components[left][0], components[right][0]);
+  const localRanks = /* @__PURE__ */ new Map();
+  const componentWidths = /* @__PURE__ */ new Map();
+  for (let componentIndex = 0; componentIndex < components.length; componentIndex += 1) {
+    const component = components[componentIndex];
+    const ranks2 = internalComponentRanks(
+      component,
+      directionalLinks,
+      structuralColors,
+      component.includes(originNodeId) ? originNodeId : null,
+      directionalLinks.flatMap(
+        ([from, to]) => componentByNodeId.get(from) === originComponent && componentByNodeId.get(to) === componentIndex && componentIndex !== originComponent ? [to] : []
+      ),
+      directionalLinks.flatMap(
+        ([from, to]) => componentByNodeId.get(to) === componentIndex && componentByNodeId.get(from) !== componentIndex ? [to] : []
+      ),
+      directionalLinks.flatMap(
+        ([from, to]) => componentByNodeId.get(from) === componentIndex && componentByNodeId.get(to) !== componentIndex ? [from] : []
+      ),
+      attachmentBoundaryNodeIds.get(componentIndex)
+    );
+    localRanks.set(componentIndex, ranks2);
+    componentWidths.set(componentIndex, Math.max(...ranks2.values()) + 1);
+  }
+  const remainingIncoming = new Map(
+    components.map((_, componentIndex) => [componentIndex, incoming.get(componentIndex).size])
+  );
+  const componentStarts = /* @__PURE__ */ new Map();
+  const ready = components.map((_, componentIndex) => componentIndex).filter((componentIndex) => remainingIncoming.get(componentIndex) === 0).sort(compareComponents);
+  for (const componentIndex of ready) componentStarts.set(componentIndex, 0);
+  while (ready.length > 0) {
+    const current = ready.shift();
+    for (const target of [...outgoing.get(current)].sort(compareComponents)) {
+      componentStarts.set(
+        target,
+        Math.max(
+          componentStarts.get(target) ?? 0,
+          componentStarts.get(current) + componentWidths.get(current)
+        )
+      );
+      const unresolved = remainingIncoming.get(target) - 1;
+      remainingIncoming.set(target, unresolved);
+      if (unresolved === 0) {
+        ready.push(target);
+        ready.sort(compareComponents);
+      }
+    }
+  }
+  const unshiftedRanks = /* @__PURE__ */ new Map();
+  for (let componentIndex = 0; componentIndex < components.length; componentIndex += 1) {
+    for (const [nodeId, localRank] of localRanks.get(componentIndex)) {
+      unshiftedRanks.set(nodeId, componentStarts.get(componentIndex) + localRank);
+    }
+  }
+  const originGroup = directionalGroupByComponent.get(originComponent);
+  const groupOffsets = /* @__PURE__ */ new Map([[originGroup, -unshiftedRanks.get(originNodeId)]]);
+  while (groupOffsets.size < directionalGroups.length) {
+    const proposals = /* @__PURE__ */ new Map();
+    for (const [left, right] of topology.links) {
+      const leftGroup = directionalGroupByNodeId.get(left);
+      const rightGroup = directionalGroupByNodeId.get(right);
+      if (leftGroup === rightGroup) continue;
+      const leftOffset = groupOffsets.get(leftGroup);
+      const rightOffset = groupOffsets.get(rightGroup);
+      if (leftOffset !== void 0 && rightOffset === void 0) {
+        const offsets = proposals.get(rightGroup) ?? /* @__PURE__ */ new Set();
+        offsets.add(unshiftedRanks.get(left) + leftOffset + 1 - unshiftedRanks.get(right));
+        proposals.set(rightGroup, offsets);
+      }
+      if (leftOffset === void 0 && rightOffset !== void 0) {
+        const offsets = proposals.get(leftGroup) ?? /* @__PURE__ */ new Set();
+        offsets.add(unshiftedRanks.get(right) + rightOffset + 1 - unshiftedRanks.get(left));
+        proposals.set(leftGroup, offsets);
+      }
+    }
+    if (proposals.size === 0) break;
+    const knownGroupOffsets = new Map(groupOffsets);
+    const rankedValues = [...unshiftedRanks].flatMap(([nodeId, rank]) => {
+      const offset = knownGroupOffsets.get(directionalGroupByNodeId.get(nodeId));
+      return offset === void 0 ? [] : [rank + offset];
+    });
+    const acceptedOffsets = /* @__PURE__ */ new Map();
+    for (const [groupIndex, proposedOffsets] of proposals) {
+      const candidates = [...proposedOffsets].map((offset) => {
+        const crossGroupSpan = topology.links.reduce((total, [left, right]) => {
+          const leftGroup = directionalGroupByNodeId.get(left);
+          const rightGroup = directionalGroupByNodeId.get(right);
+          const leftOffset = leftGroup === groupIndex ? offset : knownGroupOffsets.get(leftGroup);
+          const rightOffset = rightGroup === groupIndex ? offset : knownGroupOffsets.get(rightGroup);
+          if (leftOffset === void 0 || rightOffset === void 0) return total;
+          return total + Math.abs(
+            unshiftedRanks.get(left) + leftOffset - unshiftedRanks.get(right) - rightOffset
+          );
+        }, 0);
+        const addedRanks = directionalGroups[groupIndex].flatMap(
+          (componentIndex) => components[componentIndex].map((nodeId) => unshiftedRanks.get(nodeId) + offset)
+        );
+        return {
+          offset,
+          crossGroupSpan,
+          occupiedColumns: (/* @__PURE__ */ new Set([...rankedValues, ...addedRanks])).size
+        };
+      });
+      candidates.sort(
+        (left, right) => left.crossGroupSpan - right.crossGroupSpan || left.occupiedColumns - right.occupiedColumns || Math.abs(left.offset) - Math.abs(right.offset) || left.offset - right.offset
+      );
+      acceptedOffsets.set(groupIndex, candidates[0].offset);
+    }
+    for (const [groupIndex, offset] of acceptedOffsets) groupOffsets.set(groupIndex, offset);
+  }
+  const ranks = /* @__PURE__ */ new Map();
+  for (const [nodeId, rank] of unshiftedRanks) {
+    const groupOffset = groupOffsets.get(directionalGroupByNodeId.get(nodeId));
+    ranks.set(nodeId, rank + (groupOffset ?? 0));
+  }
+  return ranks;
+}
+function componentRanks(nodeIds, topology, entrypointId) {
+  const nodeSet = new Set(nodeIds);
+  const entrypoint = entrypointId && nodeSet.has(entrypointId) ? entrypointId : null;
+  if (!entrypoint) {
+    const root3 = topologyRoot(nodeIds, topology);
+    const ranks2 = /* @__PURE__ */ new Map();
+    ranks2.set(root3, 0);
+    const queue = [root3];
+    for (let index2 = 0; index2 < queue.length; index2 += 1) {
+      const current = queue[index2];
+      for (const neighbor of topology.neighbors.get(current) ?? []) {
+        if (!nodeSet.has(neighbor) || ranks2.has(neighbor)) continue;
+        ranks2.set(neighbor, ranks2.get(current) + 1);
+        queue.push(neighbor);
+      }
+    }
+    return ranks2;
+  }
+  const ranks = directionalCondensationRanks(nodeIds, topology, entrypoint);
+  const rankedQueue = [...ranks].sort(
+    ([leftId, leftRank], [rightId, rightRank]) => leftRank - rightRank || stableCompare(leftId, rightId)
+  ).map(([nodeId]) => nodeId);
+  for (let index2 = 0; index2 < rankedQueue.length; index2 += 1) {
+    const current = rankedQueue[index2];
+    for (const neighbor of topology.neighbors.get(current) ?? []) {
+      if (!nodeSet.has(neighbor) || ranks.has(neighbor)) continue;
+      ranks.set(neighbor, ranks.get(current) + 1);
+      rankedQueue.push(neighbor);
+    }
+  }
+  return ranks;
+}
+function orderRankGroups(groups, topology) {
+  const rankValues = [...groups.keys()].sort((left, right) => left - right);
+  const result = new Map(
+    rankValues.map((rank) => [rank, [...groups.get(rank)].sort(stableCompare)])
+  );
+  const sortAgainst = (rank, adjacentRank) => {
+    const nodes = result.get(rank);
+    const adjacent = result.get(adjacentRank);
+    const adjacentOrder = new Map(adjacent.map((nodeId, index2) => [nodeId, index2]));
+    const barycenter = (nodeId) => {
+      const indexes = (topology.neighbors.get(nodeId) ?? []).flatMap((neighbor) => {
+        const index2 = adjacentOrder.get(neighbor);
+        return index2 === void 0 ? [] : [index2];
+      });
+      return indexes.length === 0 ? null : indexes.reduce((total, index2) => total + index2, 0) / indexes.length;
+    };
+    nodes.sort((left, right) => {
+      const leftCenter = barycenter(left);
+      const rightCenter = barycenter(right);
+      if (leftCenter === null && rightCenter === null) return stableCompare(left, right);
+      if (leftCenter === null) return 1;
+      if (rightCenter === null) return -1;
+      return leftCenter - rightCenter || stableCompare(left, right);
+    });
+  };
+  for (let pass = 0; pass < 6; pass += 1) {
+    for (let index2 = 1; index2 < rankValues.length; index2 += 1) {
+      sortAgainst(rankValues[index2], rankValues[index2 - 1]);
+    }
+    for (let index2 = rankValues.length - 2; index2 >= 0; index2 -= 1) {
+      sortAgainst(rankValues[index2], rankValues[index2 + 1]);
+    }
+  }
+  return result;
+}
+function layoutTopologyComponent(nodeIds, topology, entrypointId) {
+  const ranks = componentRanks(nodeIds, topology, entrypointId);
+  const rawGroups = /* @__PURE__ */ new Map();
+  for (const nodeId of nodeIds) {
+    const rank = ranks.get(nodeId) ?? 0;
+    const group = rawGroups.get(rank) ?? [];
+    group.push(nodeId);
+    rawGroups.set(rank, group);
+  }
+  const groups = orderRankGroups(rawGroups, topology);
+  const rankValues = [...groups.keys()].sort((left, right) => left - right);
+  const rankStride = STRUCTURE_NODE_WIDTH + 192;
+  const rowStride = STRUCTURE_NODE_HEIGHT + 72;
+  const maxRows = Math.max(...[...groups.values()].map((nodes) => nodes.length));
+  const centerY = (maxRows - 1) * rowStride / 2;
+  const positions = /* @__PURE__ */ new Map();
+  rankValues.forEach((rank, rankIndex) => {
+    const group = groups.get(rank);
+    const top = centerY - (group.length - 1) * rowStride / 2;
+    group.forEach((nodeId, rowIndex) => {
+      positions.set(nodeId, { x: rankIndex * rankStride, y: top + rowIndex * rowStride });
+    });
+  });
+  return {
+    nodeIds,
+    positions,
+    ranks,
+    width: (rankValues.length - 1) * rankStride + STRUCTURE_NODE_WIDTH,
+    height: (maxRows - 1) * rowStride + STRUCTURE_NODE_HEIGHT
+  };
+}
+function projectStructure(structure) {
+  const topology = simpleStructureTopology(structure);
+  if (structure.nodes.length === 0) {
+    const diagnostics2 = {
+      columnCount: 0,
+      rowsPerColumn: [],
+      maxRows: 0,
+      directionalLinkCount: topology.directionalLinks.length,
+      nonForwardDirectionalLinkCount: 0,
+      nonForwardDirectionalLinkRatio: 0,
+      originOutgoingDirectionalLinkCount: 0
+    };
+    return {
+      positionsByNodeId: /* @__PURE__ */ new Map(),
+      rankByNodeId: /* @__PURE__ */ new Map(),
+      columnIndexByNodeId: /* @__PURE__ */ new Map(),
+      columns: [],
+      directionalLinks: topology.directionalLinks,
+      diagnostics: diagnostics2
+    };
+  }
+  const componentGap = 180;
+  const outerPadding = 64;
+  const components = topologyComponents(topology).map(
+    (nodeIds) => layoutTopologyComponent(
+      nodeIds,
+      topology,
+      nodeIds.includes(structure.originNodeId) ? structure.originNodeId : null
+    )
+  );
+  const totalArea = components.reduce(
+    (sum, component) => sum + (component.width + componentGap) * (component.height + componentGap),
+    0
+  );
+  const targetRowWidth = Math.max(960, Math.sqrt(totalArea) * 1.45);
+  const positions = /* @__PURE__ */ new Map();
+  const ranks = /* @__PURE__ */ new Map();
+  let cursorX = outerPadding;
+  let cursorY = outerPadding;
+  let rowHeight = 0;
+  for (const component of components) {
+    if (cursorX > outerPadding && cursorX + component.width > targetRowWidth) {
+      cursorX = outerPadding;
+      cursorY += rowHeight + componentGap;
+      rowHeight = 0;
+    }
+    for (const nodeId of component.nodeIds) {
+      const point5 = component.positions.get(nodeId);
+      positions.set(nodeId, { x: cursorX + point5.x, y: cursorY + point5.y });
+      ranks.set(nodeId, component.ranks.get(nodeId) ?? 0);
+    }
+    cursorX += component.width + componentGap;
+    rowHeight = Math.max(rowHeight, component.height);
+  }
+  const xValues = [...new Set([...positions.values()].map(({ x }) => x))].sort(
+    (left, right) => left - right
+  );
+  const columnIndexByX = new Map(xValues.map((x, index2) => [x, index2]));
+  const columns = xValues.map(
+    (x) => [...positions].filter(([, point5]) => point5.x === x).sort(([, left], [, right]) => left.y - right.y).map(([nodeId]) => nodeId)
+  );
+  const columnIndexByNodeId = new Map(
+    [...positions].map(([nodeId, point5]) => [nodeId, columnIndexByX.get(point5.x)])
+  );
+  const nonForwardDirectionalLinkCount = topology.directionalLinks.reduce(
+    (count, [from, to]) => count + (columnIndexByNodeId.has(from) && columnIndexByNodeId.has(to) && columnIndexByNodeId.get(from) >= columnIndexByNodeId.get(to) ? 1 : 0),
+    0
+  );
+  const directionalLinkCount = topology.directionalLinks.length;
+  const rowsPerColumn = columns.map((column) => column.length);
+  const diagnostics = {
+    columnCount: columns.length,
+    rowsPerColumn,
+    maxRows: Math.max(0, ...rowsPerColumn),
+    directionalLinkCount,
+    nonForwardDirectionalLinkCount,
+    nonForwardDirectionalLinkRatio: directionalLinkCount === 0 ? 0 : nonForwardDirectionalLinkCount / directionalLinkCount,
+    originOutgoingDirectionalLinkCount: topology.directionalLinks.filter(
+      ([from]) => from === structure.originNodeId
+    ).length
+  };
+  return {
+    positionsByNodeId: positions,
+    rankByNodeId: ranks,
+    columnIndexByNodeId,
+    columns,
+    directionalLinks: topology.directionalLinks,
+    diagnostics
+  };
+}
+function structureAuthoringWarnings(diagnostics) {
+  const warnings = [];
+  if (diagnostics.originOutgoingDirectionalLinkCount === 0) {
+    warnings.push({
+      code: "STRUCTURE_ORIGIN_NO_OUTGOING_DIRECTIONAL_RELATION",
+      message: "origin has no outgoing unambiguous directed relation; verify that it is the factual code entrypoint for this behavior. A terminal or intermediate origin may still be valid. Do not change factual relation direction solely to remove this warning."
+    });
+  }
+  if (diagnostics.maxRows >= 8) {
+    warnings.push({
+      code: "STRUCTURE_LAYOUT_MAX_ROWS_HIGH",
+      message: "the initial projection has a tall column; reconsider the factual origin, node granularity, overlapping or nested claims, whether multiple behaviors are mixed, and the subject boundary."
+    });
+  }
+  if (diagnostics.nonForwardDirectionalLinkRatio >= 0.25) {
+    warnings.push({
+      code: "STRUCTURE_LAYOUT_NON_FORWARD_DIRECTIONAL_LINK_RATIO_HIGH",
+      message: "many unambiguous directed relations are non-forward in the initial projection; reconsider the factual origin, node granularity, behavior boundary, and subject boundary. A factual graph may remain above this threshold. Do not change edge direction solely to improve the score."
+    });
+  }
+  return warnings;
+}
+
 // src/infrastructure/skills/skill-installer.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import {
@@ -50080,6 +50765,10 @@ function writeJson(value) {
   process.stdout.write(`${JSON.stringify(value)}
 `);
 }
+function structureAuthoringFeedback(structure) {
+  const layout = projectStructure(structure).diagnostics;
+  return { layout, warnings: structureAuthoringWarnings(layout) };
+}
 function writeJsonSequence(value) {
   process.stdout.write(`${JSON.stringify(value)}
 `);
@@ -50687,6 +51376,7 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
         "pullRequest.sync",
         "structure.list",
         "structure.read",
+        "structure.preview",
         "structure.publish",
         "structure.update",
         "structure.delete",
@@ -50825,6 +51515,10 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
   });
   const comment3 = program2.command("comment").description("\u4FDD\u5B58\u6E08\u307F\u30B3\u30E1\u30F3\u30C8\u3092\u64CD\u4F5C");
   const structure = program2.command("structure").description("source anchor\u4ED8\u304DStructure\u3092\u7BA1\u7406");
+  structure.command("preview").requiredOption("--stdin", "stdin\u304B\u3089JSON\u3092\u8AAD\u3080").requiredOption("--json", "JSON\u3067\u51FA\u529B").description("Structure content\u3092\u4FDD\u5B58\u305B\u305Acanonical initial layout\u3067\u691C\u67FB").action(async () => {
+    const content3 = structureContentInputSchema.parse(await readStdinJson());
+    writeJson({ ok: true, ...structureAuthoringFeedback(content3) });
+  });
   structure.command("publish").requiredOption("--stdin", "stdin\u304B\u3089JSON\u3092\u8AAD\u3080").requiredOption("--json", "JSON\u3067\u51FA\u529B").description("Structure\u3092\u767B\u9332\uFF08viewer\u306F\u958B\u304B\u305Anavigation\u3082\u5909\u66F4\u3057\u306A\u3044\uFF09").action(async () => {
     const input = structurePublishInputSchema.parse(await readStdinJson());
     const published = await callService(
@@ -50832,7 +51526,8 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
       input,
       async () => await getRuntime().service.publishStructure(input)
     );
-    writeJson({ ok: true, structure: published });
+    const warnings = structureAuthoringFeedback(published).warnings;
+    writeJson({ ok: true, structure: published, ...warnings.length > 0 ? { warnings } : {} });
   });
   structure.command("get").argument("<structure-uri>").requiredOption("--json", "JSON\u3067\u51FA\u529B").description("Structure\u306E\u73FE\u5728\u5185\u5BB9\u3092\u53D6\u5F97").action(async (uri) => {
     const result = await callService(
@@ -50857,7 +51552,8 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
       { uri, content: content3 },
       async () => await getRuntime().service.updateStructure(uri, content3)
     );
-    writeJson({ ok: true, structure: updated });
+    const warnings = structureAuthoringFeedback(updated).warnings;
+    writeJson({ ok: true, structure: updated, ...warnings.length > 0 ? { warnings } : {} });
   });
   structure.command("delete").argument("<structure-uri>").option("--yes", "\u4E0D\u53EF\u9006\u306A\u524A\u9664\u3092\u78BA\u8A8D").option("--expected-updated-at <timestamp>", "preview\u3067\u53D6\u5F97\u3057\u305FupdatedAt").requiredOption("--json", "JSON\u3067\u51FA\u529B").description("Structure\u3092\u524A\u9664").action(
     async (uri, options) => {