@a9n-shoji/rvw 0.4.3 → 0.6.0

package/dist/cli.mjs

@@ -18698,6 +18698,52 @@ function parseStructureUri(uri) {
   return id;
 }
 
+// src/domain/structure-presentation.ts
+function compareStructureIds(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function canonicalStructureBackboneEdgeIds(edgeIds) {
+  return [...edgeIds].sort(compareStructureIds);
+}
+function canonicalStructureRegionNodeIds(nodeIds) {
+  return [...nodeIds].sort(compareStructureIds);
+}
+function canonicalStructurePresentationRegions(regions) {
+  return [...regions].map((region) => ({
+    ...region,
+    nodeIds: canonicalStructureRegionNodeIds(region.nodeIds)
+  })).sort((left, right) => compareStructureIds(left.id, right.id));
+}
+function structureBackboneNodeIds(edges) {
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    nodeIds.add(edge.from);
+    nodeIds.add(edge.to);
+  }
+  return nodeIds;
+}
+function isStructureBackboneWeaklyConnected(edges, startNodeId) {
+  const nodeIds = structureBackboneNodeIds(edges);
+  if (!nodeIds.has(startNodeId)) return false;
+  const neighbors = new Map([...nodeIds].map((nodeId) => [nodeId, /* @__PURE__ */ new Set()]));
+  for (const edge of edges) {
+    if (edge.from === edge.to) continue;
+    neighbors.get(edge.from).add(edge.to);
+    neighbors.get(edge.to).add(edge.from);
+  }
+  const reached = /* @__PURE__ */ new Set([startNodeId]);
+  const queue = [startNodeId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const neighbor of neighbors.get(current) ?? []) {
+      if (reached.has(neighbor)) continue;
+      reached.add(neighbor);
+      queue.push(neighbor);
+    }
+  }
+  return reached.size === nodeIds.size;
+}
+
 // src/domain/walkthrough-uri.ts
 var prefix2 = "rvw://walkthrough/";
 var walkthroughIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -18715,6 +18761,63 @@ function parseWalkthroughUri(uri) {
   return id;
 }
 
+// src/shared/constants.ts
+var APP_VERSION = "0.6.0";
+var PROTOCOL_VERSION = 5;
+var VIEWER_ID_HEADER = "x-rvw-viewer-id";
+var VIEWER_OPEN_LEASE_HEADER = "x-rvw-viewer-open-lease";
+var VIEWER_OPEN_LEASE_QUERY = "viewerLease";
+var DEFAULT_VIEWER_PORT = 43117;
+var GIT_OBJECT_ID_PATTERN = /^[0-9a-f]{40,64}$/i;
+var CONTENT_FINGERPRINT_PATTERN = /^[0-9a-f]{64}$/;
+var MAX_TEXT_DOCUMENT_BYTES = 1024 * 1024;
+var MAX_MARKDOWN_ASSET_BYTES = 5 * 1024 * 1024;
+var MAX_GITHUB_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var MAX_GITHUB_ATTACHMENT_STDERR_BYTES = 64 * 1024;
+var GITHUB_ATTACHMENT_TIMEOUT_MS = 3e4;
+var MAX_COMMENT_BODY_BYTES = 64 * 1024;
+var MAX_AUTHOR_LABEL_CHARACTERS = 100;
+var MAX_IDEMPOTENCY_KEY_CHARACTERS = 200;
+var DEFAULT_PULL_REQUEST_LIST_LIMIT = 50;
+var MAX_PULL_REQUEST_LIST_LIMIT = 100;
+var DEFAULT_COMMENT_LIST_LIMIT = 50;
+var MAX_COMMENT_LIST_LIMIT = 100;
+var DEFAULT_COMMENT_WATCH_LIMIT = 100;
+var MAX_COMMENT_WATCH_LIMIT = 100;
+var DEFAULT_COMMENT_WATCH_INTERVAL_SECONDS = 10;
+var MAX_COMMENT_WATCH_INTERVAL_SECONDS = 300;
+var MAX_COMMENT_LIST_BODY_PREVIEW_BYTES = 512;
+var MAX_CODE_REFERENCES = 200;
+var MAX_CODE_REFERENCE_LABEL_CHARACTERS = 200;
+var MAX_CODE_REFERENCE_PATH_CHARACTERS = 4096;
+var MAX_CODE_REFERENCE_DESCRIPTION_CHARACTERS = 1e3;
+var MAX_WALKTHROUGH_BODY_BYTES = 256 * 1024;
+var MAX_WALKTHROUGH_TITLE_CHARACTERS = 200;
+var MAX_STRUCTURE_PAYLOAD_BYTES = 2 * 1024 * 1024;
+var MAX_STRUCTURE_TITLE_CHARACTERS = 200;
+var MAX_STRUCTURE_SCOPE_CHARACTERS = 4e3;
+var MAX_STRUCTURE_NODES = 50;
+var MAX_STRUCTURE_EDGES = 200;
+var MAX_STRUCTURE_EDGE_ANCHORS = 20;
+var MAX_STRUCTURE_SOURCE_ANCHORS = 400;
+var MAX_STRUCTURE_ID_CHARACTERS = 64;
+var STRUCTURE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+var MAX_STRUCTURE_LABEL_CHARACTERS = 200;
+var MAX_STRUCTURE_DESCRIPTION_CHARACTERS = 2e3;
+var MAX_STRUCTURE_KIND_CHARACTERS = 100;
+var MAX_STRUCTURE_PRESENTATION_THESIS_CHARACTERS = 1e3;
+var MAX_STRUCTURE_PRIMARY_BACKBONE_NODES = 12;
+var MAX_STRUCTURE_PRIMARY_BACKBONE_EDGES = 16;
+var MAX_STRUCTURE_PRESENTATION_REGIONS = 12;
+var MAX_STRUCTURE_PRESENTATION_REGION_LABEL_CHARACTERS = 100;
+var MAX_STRUCTURE_PRESENTATION_REGION_SUMMARY_CHARACTERS = 500;
+var MAX_SEARCH_QUERY_BYTES = 1024;
+var MAX_SEARCH_RESULTS = 500;
+var MAX_SEARCH_STDOUT_BYTES = 8 * 1024 * 1024;
+var DEFAULT_PROCESS_TIMEOUT_MS = 3e4;
+var DEFAULT_PROCESS_STDOUT_BYTES = 16 * 1024 * 1024;
+var DEFAULT_PROCESS_STDERR_BYTES = 2 * 1024 * 1024;
+
 // src/shared/preferences.ts
 var themePreferences = ["light", "dark", "system"];
 function isThemePreference(value) {
@@ -18791,17 +18894,122 @@ function isStructureNode(value) {
 function isStructureEdge(value) {
   return isRecord(value) && typeof value.id === "string" && typeof value.from === "string" && typeof value.to === "string" && typeof value.label === "string" && typeof value.directed === "boolean" && Array.isArray(value.anchors) && value.anchors.every(isSourceAnchor);
 }
+function hasExactKeys(value, keys2) {
+  const actualKeys = Object.keys(value);
+  return actualKeys.length === keys2.length && actualKeys.every((key2) => keys2.includes(key2));
+}
+function isCanonicalPresentationText(value, maximum) {
+  return typeof value === "string" && value === value.trim() && value.length >= 1 && value.length <= maximum;
+}
+function isStructurePresentation(value, nodes, edges) {
+  if (!isRecord(value) || !hasExactKeys(value, ["thesis", "startNodeId", "primaryBackbone", "regions"]) || !isCanonicalPresentationText(value.thesis, MAX_STRUCTURE_PRESENTATION_THESIS_CHARACTERS) || typeof value.startNodeId !== "string" || !Array.isArray(value.regions) || value.regions.length > MAX_STRUCTURE_PRESENTATION_REGIONS) {
+    return false;
+  }
+  const nodeIds = new Set(nodes.map((node2) => node2.id));
+  if (!STRUCTURE_ID_PATTERN.test(value.startNodeId) || !nodeIds.has(value.startNodeId)) {
+    return false;
+  }
+  if (value.primaryBackbone !== null) {
+    if (!isRecord(value.primaryBackbone) || !hasExactKeys(value.primaryBackbone, ["edgeIds"]) || !Array.isArray(value.primaryBackbone.edgeIds) || value.primaryBackbone.edgeIds.length < 1 || value.primaryBackbone.edgeIds.length > MAX_STRUCTURE_PRIMARY_BACKBONE_EDGES) {
+      return false;
+    }
+    const edgeById = new Map(edges.map((edge) => [edge.id, edge]));
+    const selectedEdgeIds = /* @__PURE__ */ new Set();
+    const selectedEdges = [];
+    for (const edgeId of value.primaryBackbone.edgeIds) {
+      if (typeof edgeId !== "string" || !STRUCTURE_ID_PATTERN.test(edgeId) || selectedEdgeIds.has(edgeId)) {
+        return false;
+      }
+      selectedEdgeIds.add(edgeId);
+      const edge = edgeById.get(edgeId);
+      if (edge === void 0) return false;
+      selectedEdges.push(edge);
+    }
+    const primaryBackboneNodeIds = structureBackboneNodeIds(selectedEdges);
+    if (primaryBackboneNodeIds.size < 2 || primaryBackboneNodeIds.size > MAX_STRUCTURE_PRIMARY_BACKBONE_NODES || !primaryBackboneNodeIds.has(value.startNodeId) || !isStructureBackboneWeaklyConnected(selectedEdges, value.startNodeId)) {
+      return false;
+    }
+  }
+  const regionIds = /* @__PURE__ */ new Set();
+  const regionByNodeId = /* @__PURE__ */ new Map();
+  for (const region of value.regions) {
+    if (!isRecord(region) || !hasExactKeys(region, ["id", "label", "summary", "nodeIds"]) || typeof region.id !== "string" || !STRUCTURE_ID_PATTERN.test(region.id) || regionIds.has(region.id) || !isCanonicalPresentationText(
+      region.label,
+      MAX_STRUCTURE_PRESENTATION_REGION_LABEL_CHARACTERS
+    ) || !isCanonicalPresentationText(
+      region.summary,
+      MAX_STRUCTURE_PRESENTATION_REGION_SUMMARY_CHARACTERS
+    ) || !Array.isArray(region.nodeIds) || region.nodeIds.length < 1 || region.nodeIds.length > MAX_STRUCTURE_NODES) {
+      return false;
+    }
+    regionIds.add(region.id);
+    const currentRegionNodeIds = /* @__PURE__ */ new Set();
+    for (const nodeId of region.nodeIds) {
+      if (typeof nodeId !== "string" || !STRUCTURE_ID_PATTERN.test(nodeId) || !nodeIds.has(nodeId) || currentRegionNodeIds.has(nodeId) || regionByNodeId.has(nodeId)) {
+        return false;
+      }
+      currentRegionNodeIds.add(nodeId);
+      regionByNodeId.set(nodeId, region.id);
+    }
+  }
+  return true;
+}
 function structureGraphValue(row) {
   try {
-    const value = JSON.parse(stringValue(row, "graph_json"));
-    const originNodeId = isRecord(value) && typeof value.originNodeId === "string" ? value.originNodeId : null;
-    if (!isRecord(value) || originNodeId === null || !Array.isArray(value.nodes) || !value.nodes.every(isStructureNode) || !Array.isArray(value.edges) || !value.edges.every(isStructureEdge)) {
+    const serializedGraph = stringValue(row, "graph_json");
+    if (Buffer.byteLength(serializedGraph, "utf8") > MAX_STRUCTURE_PAYLOAD_BYTES) {
+      throw new Error("invalid Structure graph size");
+    }
+    const value = JSON.parse(serializedGraph);
+    if (!isRecord(value)) throw new Error("invalid Structure graph");
+    const originNodeId = typeof value.originNodeId === "string" ? value.originNodeId : null;
+    const presentation = value.presentation === void 0 ? null : value.presentation;
+    if (originNodeId === null || !Array.isArray(value.nodes) || !value.nodes.every(isStructureNode) || !Array.isArray(value.edges) || !value.edges.every(isStructureEdge)) {
       throw new Error("invalid Structure graph");
     }
+    const nodes = value.nodes;
+    const edges = value.edges;
+    if (nodes.length < 1 || nodes.length > MAX_STRUCTURE_NODES) {
+      throw new Error("invalid Structure Node count");
+    }
+    const nodeIds = /* @__PURE__ */ new Set();
+    for (const node2 of nodes) {
+      if (!STRUCTURE_ID_PATTERN.test(node2.id) || nodeIds.has(node2.id)) {
+        throw new Error("invalid Structure Node identity");
+      }
+      nodeIds.add(node2.id);
+    }
+    const originNode = nodes.find((node2) => node2.id === originNodeId);
+    if (originNode === void 0 || originNode.anchor === null) {
+      throw new Error("invalid Structure origin");
+    }
+    const edgeIds = /* @__PURE__ */ new Set();
+    for (const edge of edges) {
+      if (!STRUCTURE_ID_PATTERN.test(edge.id) || edgeIds.has(edge.id)) {
+        throw new Error("invalid Structure Edge identity");
+      }
+      edgeIds.add(edge.id);
+      if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to)) {
+        throw new Error("invalid Structure Edge endpoint");
+      }
+    }
+    if (presentation !== null && !isStructurePresentation(presentation, nodes, edges)) {
+      throw new Error("invalid Structure presentation");
+    }
+    const normalizedPresentation = presentation === null ? null : {
+      ...presentation,
+      primaryBackbone: presentation.primaryBackbone === null ? null : {
+        edgeIds: canonicalStructureBackboneEdgeIds(
+          presentation.primaryBackbone.edgeIds
+        )
+      },
+      regions: canonicalStructurePresentationRegions(presentation.regions)
+    };
     return {
       originNodeId,
-      nodes: value.nodes.map((node2) => ({ ...node2, notation: node2.notation ?? "plain" })),
-      edges: value.edges
+      nodes: nodes.map((node2) => ({ ...node2, notation: node2.notation ?? "plain" })),
+      edges,
+      presentation: normalizedPresentation
     };
   } catch (error51) {
     throw new RvwError("DATABASE_ERROR", "Structure graph_json\u304C\u4E0D\u6B63\u3067\u3059\u3002", { cause: error51 });
@@ -19165,6 +19373,163 @@ var RvwDatabase = class {
     if (!row) throw new RvwError("DATABASE_ERROR", "comment watch\u306Edatabase ID\u304C\u3042\u308A\u307E\u305B\u3093\u3002");
     return stringValue(row, "value");
   }
+  activateCommentWatchTask(taskId) {
+    return this.immediateTransaction(() => {
+      const existing = this.database.prepare(
+        `SELECT task_id, generation, superseded_at
+          FROM comment_watch_tasks WHERE task_id = ?`
+      ).get(taskId);
+      if (existing) {
+        const generation2 = numberValue(existing, "generation");
+        if (nullableString(existing, "superseded_at") !== null) {
+          const active = this.database.prepare(
+            `SELECT task_id, generation FROM comment_watch_tasks
+              WHERE superseded_at IS NULL`
+          ).get();
+          throw new RvwError(
+            "WATCH_TASK_SUPERSEDED",
+            "\u3053\u306Ecomment watch task\u306F\u65E2\u306B\u5225\u306Etask\u3078\u5F15\u304D\u7D99\u304C\u308C\u3066\u3044\u307E\u3059\u3002",
+            {
+              details: {
+                taskId,
+                generation: generation2,
+                activeTaskId: active ? stringValue(active, "task_id") : null,
+                activeGeneration: active ? numberValue(active, "generation") : null
+              },
+              suggestions: ["\u73FE\u5728active\u306Awatch task\u3092resume\u3057\u3066\u304F\u3060\u3055\u3044\u3002"]
+            }
+          );
+        }
+        return {
+          databaseId: this.getCommentWatchDatabaseId(),
+          taskId,
+          generation: generation2,
+          status: "existing"
+        };
+      }
+      const latest = this.database.prepare("SELECT COALESCE(MAX(generation), 0) AS generation FROM comment_watch_tasks").get();
+      const generation = numberValue(latest, "generation") + 1;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      this.database.prepare(
+        `UPDATE comment_watch_tasks SET superseded_at = ?
+          WHERE superseded_at IS NULL`
+      ).run(now);
+      this.database.prepare(
+        `INSERT INTO comment_watch_tasks(task_id, generation, activated_at, superseded_at)
+          VALUES (?, ?, ?, NULL)`
+      ).run(taskId, generation, now);
+      return {
+        databaseId: this.getCommentWatchDatabaseId(),
+        taskId,
+        generation,
+        status: "activated"
+      };
+    });
+  }
+  assertCommentWatchTaskAuthority(taskId, generation) {
+    const active = this.database.prepare(
+      `SELECT task_id, generation FROM comment_watch_tasks
+        WHERE superseded_at IS NULL`
+    ).get();
+    if (!active || stringValue(active, "task_id") !== taskId || numberValue(active, "generation") !== generation) {
+      throw new RvwError(
+        "WATCH_TASK_SUPERSEDED",
+        "\u3053\u306Ecomment watch task\u306Factive generation\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002",
+        {
+          details: {
+            taskId,
+            generation,
+            activeTaskId: active ? stringValue(active, "task_id") : null,
+            activeGeneration: active ? numberValue(active, "generation") : null
+          },
+          suggestions: ["\u73FE\u5728active\u306Awatch task\u3092resume\u3057\u3066\u304F\u3060\u3055\u3044\u3002"]
+        }
+      );
+    }
+    return { databaseId: this.getCommentWatchDatabaseId(), taskId, generation };
+  }
+  reserveCommentWatchWriter(taskId, generation, leaseId, writeKey) {
+    if (!/^[^/\s]+\/[^/\s]+$/.test(writeKey)) {
+      throw new RvwError("INVALID_INPUT", "writer reservation key\u306Fowner/repository\u5F62\u5F0F\u3067\u3059\u3002");
+    }
+    const canonicalWriteKey = writeKey.toLowerCase();
+    return this.immediateTransaction(() => {
+      const authority = this.assertCommentWatchTaskAuthority(taskId, generation);
+      const existingLease = this.database.prepare(
+        `SELECT lease_id, write_key, task_id, generation
+          FROM comment_watch_write_reservations WHERE lease_id = ?`
+      ).get(leaseId);
+      if (existingLease) {
+        if (stringValue(existingLease, "write_key") !== canonicalWriteKey || stringValue(existingLease, "task_id") !== taskId || numberValue(existingLease, "generation") !== generation) {
+          throw new RvwError(
+            "WATCH_WRITE_RESERVED",
+            "\u3053\u306Elease\u306F\u5225\u306Ecomment watch writer reservation\u306B\u4F7F\u7528\u3055\u308C\u3066\u3044\u307E\u3059\u3002",
+            { details: { taskId, generation, leaseId, writeKey: canonicalWriteKey } }
+          );
+        }
+        return { ...authority, leaseId, writeKey: canonicalWriteKey, status: "existing" };
+      }
+      const existingWriter = this.database.prepare(
+        `SELECT lease_id, task_id, generation
+          FROM comment_watch_write_reservations WHERE write_key = ?`
+      ).get(canonicalWriteKey);
+      if (existingWriter) {
+        throw new RvwError(
+          "WATCH_WRITE_RESERVED",
+          `repository ${canonicalWriteKey} \u306F\u5225\u306Ewatch worker\u304C\u4F7F\u7528\u4E2D\u3067\u3059\u3002`,
+          {
+            details: {
+              writeKey: canonicalWriteKey,
+              ownerLeaseId: stringValue(existingWriter, "lease_id"),
+              ownerTaskId: stringValue(existingWriter, "task_id"),
+              ownerGeneration: numberValue(existingWriter, "generation")
+            }
+          }
+        );
+      }
+      this.database.prepare(
+        `INSERT INTO comment_watch_write_reservations(
+            lease_id, write_key, task_id, generation, acquired_at
+          ) VALUES (?, ?, ?, ?, ?)`
+      ).run(leaseId, canonicalWriteKey, taskId, generation, (/* @__PURE__ */ new Date()).toISOString());
+      return { ...authority, leaseId, writeKey: canonicalWriteKey, status: "reserved" };
+    });
+  }
+  releaseCommentWatchWriter(taskId, generation, leaseId) {
+    return this.immediateTransaction(() => {
+      const existing = this.database.prepare(
+        `SELECT lease_id, write_key, task_id, generation
+          FROM comment_watch_write_reservations WHERE lease_id = ?`
+      ).get(leaseId);
+      if (!existing) {
+        return {
+          databaseId: this.getCommentWatchDatabaseId(),
+          taskId,
+          generation,
+          leaseId,
+          writeKey: null,
+          status: "absent"
+        };
+      }
+      if (stringValue(existing, "task_id") !== taskId || numberValue(existing, "generation") !== generation) {
+        throw new RvwError(
+          "WATCH_WRITE_RESERVED",
+          "\u5225\u306Ecomment watch task\u304C\u6240\u6709\u3059\u308Bwriter reservation\u306F\u89E3\u653E\u3067\u304D\u307E\u305B\u3093\u3002",
+          { details: { taskId, generation, leaseId } }
+        );
+      }
+      const writeKey = stringValue(existing, "write_key");
+      this.database.prepare("DELETE FROM comment_watch_write_reservations WHERE lease_id = ?").run(leaseId);
+      return {
+        databaseId: this.getCommentWatchDatabaseId(),
+        taskId,
+        generation,
+        leaseId,
+        writeKey,
+        status: "released"
+      };
+    });
+  }
   getLatestCommentPostEventSequence() {
     const row = this.database.prepare("SELECT COALESCE(MAX(sequence), 0) AS sequence FROM comment_post_events").get();
     return numberValue(row, "sequence");
@@ -19551,13 +19916,15 @@ var RvwDatabase = class {
     const graphJson = JSON.stringify({
       originNodeId: input.originNodeId,
       nodes: input.nodes,
-      edges: input.edges
+      edges: input.edges,
+      presentation: input.presentation
     });
     this.immediateTransaction(() => {
       const keyHash = hashIdempotencyKey(input.idempotencyKey);
       const existingRow = this.database.prepare("SELECT * FROM structure_publish_idempotency WHERE key_hash = ?").get(keyHash);
       if (existingRow) {
-        if (stringValue(existingRow, "request_hash") !== input.idempotencyRequestHash) {
+        const existingRequestHash = stringValue(existingRow, "request_hash");
+        if (existingRequestHash !== input.idempotencyRequestHash && (input.presentation !== null || existingRequestHash !== input.legacyNullPresentationIdempotencyRequestHash)) {
           throw new RvwError(
             "IDEMPOTENCY_CONFLICT",
             "\u540C\u3058idempotencyKey\u304C\u5225\u306EStructure publish\u306B\u4F7F\u7528\u3055\u308C\u3066\u3044\u307E\u3059\u3002"
@@ -19590,6 +19957,9 @@ var RvwDatabase = class {
         now,
         now
       );
+      if (!this.getStructure(id)) {
+        throw new RvwError("DATABASE_ERROR", "\u4FDD\u5B58\u3057\u305FStructure\u3092\u8AAD\u307F\u51FA\u305B\u307E\u305B\u3093\u3002");
+      }
       this.database.prepare(
         `INSERT INTO structure_publish_idempotency(
              key_hash, request_hash, structure_id, created_at
@@ -19614,7 +19984,8 @@ var RvwDatabase = class {
     const graphJson = JSON.stringify({
       originNodeId: input.originNodeId,
       nodes: input.nodes,
-      edges: input.edges
+      edges: input.edges,
+      presentation: input.presentation
     });
     this.immediateTransaction(() => {
       const current = this.getStructure(id);
@@ -19637,6 +20008,9 @@ var RvwDatabase = class {
       const retiredEdgeIds = new Set(
         this.database.prepare("SELECT edge_id FROM structure_retired_edge_ids WHERE structure_id = ?").all(id).map((row) => stringValue(row, "edge_id"))
       );
+      const retiredRegionIds = new Set(
+        this.database.prepare("SELECT region_id FROM structure_retired_region_ids WHERE structure_id = ?").all(id).map((row) => stringValue(row, "region_id"))
+      );
       const reusedNode = input.nodes.find((node2) => retiredNodeIds.has(node2.id));
       if (reusedNode) {
         throw new RvwError(
@@ -19651,10 +20025,21 @@ var RvwDatabase = class {
           `\u524A\u9664\u6E08\u307F\u306EStructure Edge ID\u306F\u518D\u5229\u7528\u3067\u304D\u307E\u305B\u3093: ${reusedEdge.id}`
         );
       }
+      const reusedRegion = input.presentation?.regions.find(
+        (region) => retiredRegionIds.has(region.id)
+      );
+      if (reusedRegion) {
+        throw new RvwError(
+          "INVALID_INPUT",
+          `\u524A\u9664\u6E08\u307F\u306EStructure Region ID\u306F\u518D\u5229\u7528\u3067\u304D\u307E\u305B\u3093: ${reusedRegion.id}`
+        );
+      }
       const nextNodeIds = new Set(input.nodes.map((node2) => node2.id));
       const nextEdgeIds = new Set(input.edges.map((edge) => edge.id));
+      const nextRegionIds = new Set(input.presentation?.regions.map((region) => region.id) ?? []);
       const retiredAtThisUpdate = current.nodes.map((node2) => node2.id).filter((nodeId) => !nextNodeIds.has(nodeId));
       const retiredEdgesAtThisUpdate = current.edges.map((edge) => edge.id).filter((edgeId) => !nextEdgeIds.has(edgeId));
+      const retiredRegionsAtThisUpdate = (current.presentation?.regions ?? []).map((region) => region.id).filter((regionId) => !nextRegionIds.has(regionId));
       const result = this.database.prepare(
         `UPDATE structures
            SET source_oid = ?, title = ?, scope = ?, graph_json = ?, updated_at = ?
@@ -19670,6 +20055,9 @@ var RvwDatabase = class {
           }
         );
       }
+      if (!this.getStructure(id)) {
+        throw new RvwError("DATABASE_ERROR", "\u66F4\u65B0\u3057\u305FStructure\u3092\u8AAD\u307F\u51FA\u305B\u307E\u305B\u3093\u3002");
+      }
       const retireNode = this.database.prepare(
         "INSERT OR IGNORE INTO structure_retired_node_ids(structure_id, node_id, retired_at) VALUES (?, ?, ?)"
       );
@@ -19678,6 +20066,10 @@ var RvwDatabase = class {
         "INSERT OR IGNORE INTO structure_retired_edge_ids(structure_id, edge_id, retired_at) VALUES (?, ?, ?)"
       );
       for (const edgeId of retiredEdgesAtThisUpdate) retireEdge.run(id, edgeId, now);
+      const retireRegion = this.database.prepare(
+        "INSERT OR IGNORE INTO structure_retired_region_ids(structure_id, region_id, retired_at) VALUES (?, ?, ?)"
+      );
+      for (const regionId of retiredRegionsAtThisUpdate) retireRegion.run(id, regionId, now);
       this.incrementDomainRevisions(["structures"]);
     });
     const structure = this.getStructure(id);
@@ -20095,10 +20487,20 @@ var RvwDatabase = class {
   insertReply(commentId, input, incrementSequence = true) {
     let result;
     const write = () => {
+      if (input.watchTask) {
+        this.assertCommentWatchTaskAuthority(input.watchTask.taskId, input.watchTask.generation);
+      }
       const comment3 = this.getComment(commentId);
       if (!comment3) {
         throw new RvwError("COMMENT_NOT_FOUND", "\u30B3\u30E1\u30F3\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002");
       }
+      if (input.watchTask && comment3.resolvedAt !== null) {
+        throw new RvwError(
+          "COMMENT_NOT_ACTIONABLE",
+          "\u89E3\u6C7A\u6E08\u307Fcomment\u306B\u306Fwatch acknowledgement\u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3002",
+          { details: { commentRef: comment3.ref } }
+        );
+      }
       const pullRequest = this.getPullRequest(comment3.pullRequestId);
       if (!pullRequest) throw new RvwError("PR_NOT_FOUND", "Pull Request\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002");
       const relatedCommitOid = input.relatedCommitOid ?? null;
@@ -20181,9 +20583,23 @@ var RvwDatabase = class {
     if (!result) throw new RvwError("DATABASE_ERROR", "\u8FD4\u4FE1\u7D50\u679C\u3092\u8AAD\u307F\u51FA\u305B\u307E\u305B\u3093\u3002");
     return result;
   }
-  updateCommentPost(commentId, postId, body3, relatedCommitOid, references, lastModifiedBy) {
+  updateCommentPost(commentId, postId, body3, relatedCommitOid, references, lastModifiedBy, watchTask) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.immediateTransaction(() => {
+      if (watchTask) {
+        this.assertCommentWatchTaskAuthority(watchTask.taskId, watchTask.generation);
+        const comment3 = this.getComment(commentId);
+        if (!comment3) {
+          throw new RvwError("COMMENT_NOT_FOUND", "\u30B3\u30E1\u30F3\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002", { status: 404 });
+        }
+        if (comment3.resolvedAt !== null) {
+          throw new RvwError(
+            "COMMENT_NOT_ACTIONABLE",
+            "\u89E3\u6C7A\u6E08\u307Fcomment\u306Ewatch acknowledgement\u306F\u5FA9\u5143\u3067\u304D\u307E\u305B\u3093\u3002",
+            { details: { commentRef: comment3.ref } }
+          );
+        }
+      }
       const result = this.database.prepare(
         `UPDATE comment_posts
            SET body = ?, related_commit_oid = ?, last_modified_by = ?, updated_at = ?
@@ -20294,56 +20710,6 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import path5 from "node:path";
 import { TextDecoder as TextDecoder2 } from "node:util";
 
-// src/shared/constants.ts
-var APP_VERSION = "0.4.3";
-var PROTOCOL_VERSION = 4;
-var VIEWER_ID_HEADER = "x-rvw-viewer-id";
-var VIEWER_OPEN_LEASE_HEADER = "x-rvw-viewer-open-lease";
-var VIEWER_OPEN_LEASE_QUERY = "viewerLease";
-var GIT_OBJECT_ID_PATTERN = /^[0-9a-f]{40,64}$/i;
-var CONTENT_FINGERPRINT_PATTERN = /^[0-9a-f]{64}$/;
-var MAX_TEXT_DOCUMENT_BYTES = 1024 * 1024;
-var MAX_MARKDOWN_ASSET_BYTES = 5 * 1024 * 1024;
-var MAX_GITHUB_ATTACHMENT_BYTES = 10 * 1024 * 1024;
-var MAX_GITHUB_ATTACHMENT_STDERR_BYTES = 64 * 1024;
-var GITHUB_ATTACHMENT_TIMEOUT_MS = 3e4;
-var MAX_COMMENT_BODY_BYTES = 64 * 1024;
-var MAX_AUTHOR_LABEL_CHARACTERS = 100;
-var MAX_IDEMPOTENCY_KEY_CHARACTERS = 200;
-var DEFAULT_PULL_REQUEST_LIST_LIMIT = 50;
-var MAX_PULL_REQUEST_LIST_LIMIT = 100;
-var DEFAULT_COMMENT_LIST_LIMIT = 50;
-var MAX_COMMENT_LIST_LIMIT = 100;
-var DEFAULT_COMMENT_WATCH_LIMIT = 100;
-var MAX_COMMENT_WATCH_LIMIT = 100;
-var DEFAULT_COMMENT_WATCH_INTERVAL_SECONDS = 10;
-var MAX_COMMENT_WATCH_INTERVAL_SECONDS = 300;
-var MAX_COMMENT_LIST_BODY_PREVIEW_BYTES = 512;
-var MAX_CODE_REFERENCES = 200;
-var MAX_CODE_REFERENCE_LABEL_CHARACTERS = 200;
-var MAX_CODE_REFERENCE_PATH_CHARACTERS = 4096;
-var MAX_CODE_REFERENCE_DESCRIPTION_CHARACTERS = 1e3;
-var MAX_WALKTHROUGH_BODY_BYTES = 256 * 1024;
-var MAX_WALKTHROUGH_TITLE_CHARACTERS = 200;
-var MAX_STRUCTURE_PAYLOAD_BYTES = 2 * 1024 * 1024;
-var MAX_STRUCTURE_TITLE_CHARACTERS = 200;
-var MAX_STRUCTURE_SCOPE_CHARACTERS = 4e3;
-var MAX_STRUCTURE_NODES = 50;
-var MAX_STRUCTURE_EDGES = 200;
-var MAX_STRUCTURE_EDGE_ANCHORS = 20;
-var MAX_STRUCTURE_SOURCE_ANCHORS = 400;
-var MAX_STRUCTURE_ID_CHARACTERS = 64;
-var STRUCTURE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
-var MAX_STRUCTURE_LABEL_CHARACTERS = 200;
-var MAX_STRUCTURE_DESCRIPTION_CHARACTERS = 2e3;
-var MAX_STRUCTURE_KIND_CHARACTERS = 100;
-var MAX_SEARCH_QUERY_BYTES = 1024;
-var MAX_SEARCH_RESULTS = 500;
-var MAX_SEARCH_STDOUT_BYTES = 8 * 1024 * 1024;
-var DEFAULT_PROCESS_TIMEOUT_MS = 3e4;
-var DEFAULT_PROCESS_STDOUT_BYTES = 16 * 1024 * 1024;
-var DEFAULT_PROCESS_STDERR_BYTES = 2 * 1024 * 1024;
-
 // src/domain/search.ts
 var wordCharacter = /[\p{L}\p{N}_]/u;
 function escapeRegularExpression(value) {
@@ -42710,6 +43076,21 @@ var RvwService = class {
       events
     };
   }
+  activateCommentWatchTask(taskId) {
+    return this.database.activateCommentWatchTask(taskId);
+  }
+  verifyCommentWatchTask(taskId, generation) {
+    return {
+      ...this.database.assertCommentWatchTaskAuthority(taskId, generation),
+      status: "active"
+    };
+  }
+  reserveCommentWatchWriter(taskId, generation, leaseId, writeKey) {
+    return this.database.reserveCommentWatchWriter(taskId, generation, leaseId, writeKey);
+  }
+  releaseCommentWatchWriter(taskId, generation, leaseId) {
+    return this.database.releaseCommentWatchWriter(taskId, generation, leaseId);
+  }
   listComments(pullRequestId, resolved) {
     this.getPullRequest(pullRequestId);
     return this.database.listComments(pullRequestId, resolved);
@@ -42852,6 +43233,16 @@ var RvwService = class {
     }
     return normalized;
   }
+  assertStructurePresentationText(value, maximum, subject) {
+    if (typeof value !== "string") {
+      throw new RvwError("INVALID_INPUT", `${subject}\u306F\u6587\u5B57\u5217\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+    }
+    const normalized = value.trim();
+    if (normalized.length < 1 || normalized.length > maximum) {
+      throw new RvwError("INVALID_INPUT", `${subject}\u306Ftrim\u5F8C1\u301C${maximum}\u6587\u5B57\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+    }
+    return normalized;
+  }
   assertStructureId(value, subject) {
     if (!STRUCTURE_ID_PATTERN.test(value)) {
       throw new RvwError(
@@ -43026,7 +43417,172 @@ var RvwService = class {
         `Structure\u306Esource anchor\u306F\u5408\u8A08${MAX_STRUCTURE_SOURCE_ANCHORS}\u4EF6\u4EE5\u4E0B\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
       );
     }
-    const graph = { originNodeId, nodes, edges };
+    if (input.presentation === void 0) {
+      throw new RvwError(
+        "INVALID_INPUT",
+        "Structure presentation\u306Fnull\u307E\u305F\u306Fobject\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      );
+    }
+    let presentation = null;
+    if (input.presentation !== null) {
+      if (typeof input.presentation !== "object" || Array.isArray(input.presentation) || Object.keys(input.presentation).some(
+        (key2) => key2 !== "thesis" && key2 !== "startNodeId" && key2 !== "primaryBackbone" && key2 !== "regions"
+      )) {
+        throw new RvwError("INVALID_INPUT", "Structure presentation\u304C\u4E0D\u6B63\u3067\u3059\u3002");
+      }
+      const thesis = this.assertStructurePresentationText(
+        input.presentation.thesis,
+        MAX_STRUCTURE_PRESENTATION_THESIS_CHARACTERS,
+        "Structure presentation thesis"
+      );
+      const startNodeId = this.assertStructureId(
+        input.presentation.startNodeId,
+        "Structure presentation startNodeId"
+      );
+      if (!nodeIds.has(startNodeId)) {
+        throw new RvwError(
+          "INVALID_INPUT",
+          `Structure presentation startNodeId\u306ENode\u304C\u5B58\u5728\u3057\u307E\u305B\u3093: ${startNodeId}`
+        );
+      }
+      let primaryBackbone = null;
+      if (input.presentation.primaryBackbone !== null) {
+        const rawPrimaryBackbone = input.presentation.primaryBackbone;
+        if (typeof rawPrimaryBackbone !== "object" || Array.isArray(rawPrimaryBackbone) || Object.keys(rawPrimaryBackbone).some((key2) => key2 !== "edgeIds") || !Array.isArray(rawPrimaryBackbone.edgeIds) || rawPrimaryBackbone.edgeIds.length < 1 || rawPrimaryBackbone.edgeIds.length > MAX_STRUCTURE_PRIMARY_BACKBONE_EDGES) {
+          throw new RvwError(
+            "INVALID_INPUT",
+            `Structure presentation primaryBackbone.edgeIds\u306F1\u301C${MAX_STRUCTURE_PRIMARY_BACKBONE_EDGES}\u4EF6\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+          );
+        }
+        const edgeById = new Map(edges.map((edge) => [edge.id, edge]));
+        const selectedEdgeIds = /* @__PURE__ */ new Set();
+        const selectedEdges = rawPrimaryBackbone.edgeIds.map((rawEdgeId) => {
+          const edgeId = this.assertStructureId(
+            rawEdgeId,
+            "Structure presentation primaryBackbone Edge ID"
+          );
+          if (selectedEdgeIds.has(edgeId)) {
+            throw new RvwError(
+              "INVALID_INPUT",
+              `Structure presentation primaryBackbone\u306EEdge ID\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059: ${edgeId}`
+            );
+          }
+          selectedEdgeIds.add(edgeId);
+          const edge = edgeById.get(edgeId);
+          if (edge === void 0) {
+            throw new RvwError(
+              "INVALID_INPUT",
+              `Structure presentation primaryBackbone\u306EEdge\u304C\u5B58\u5728\u3057\u307E\u305B\u3093: ${edgeId}`
+            );
+          }
+          return edge;
+        });
+        const primaryBackboneNodeIds = structureBackboneNodeIds(selectedEdges);
+        if (primaryBackboneNodeIds.size < 2 || primaryBackboneNodeIds.size > MAX_STRUCTURE_PRIMARY_BACKBONE_NODES) {
+          throw new RvwError(
+            "INVALID_INPUT",
+            `Structure presentation primaryBackbone\u306F2\u301C${MAX_STRUCTURE_PRIMARY_BACKBONE_NODES}\u4EF6\u306ENode\u3092\u7D50\u3076\u3088\u3046\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+          );
+        }
+        if (!primaryBackboneNodeIds.has(startNodeId)) {
+          throw new RvwError(
+            "INVALID_INPUT",
+            "Structure presentation startNodeId\u306FprimaryBackbone\u306EEdge endpoint\u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002"
+          );
+        }
+        if (!isStructureBackboneWeaklyConnected(selectedEdges, startNodeId)) {
+          throw new RvwError(
+            "INVALID_INPUT",
+            "Structure presentation primaryBackbone\u306FstartNodeId\u304B\u3089\u8FBF\u308C\u308B\u4E00\u3064\u306Econnected graph\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+          );
+        }
+        primaryBackbone = {
+          edgeIds: canonicalStructureBackboneEdgeIds([...selectedEdgeIds])
+        };
+      }
+      if (!Array.isArray(input.presentation.regions) || input.presentation.regions.length > MAX_STRUCTURE_PRESENTATION_REGIONS) {
+        throw new RvwError(
+          "INVALID_INPUT",
+          `Structure presentation regions\u306F${MAX_STRUCTURE_PRESENTATION_REGIONS}\u4EF6\u4EE5\u4E0B\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+        );
+      }
+      const regionIds = /* @__PURE__ */ new Set();
+      const assignedRegionByNodeId = /* @__PURE__ */ new Map();
+      const regions = input.presentation.regions.map((region, regionIndex) => {
+        if (typeof region !== "object" || region === null || Array.isArray(region) || Object.keys(region).some(
+          (key2) => key2 !== "id" && key2 !== "label" && key2 !== "summary" && key2 !== "nodeIds"
+        )) {
+          throw new RvwError(
+            "INVALID_INPUT",
+            `Structure presentation region ${regionIndex + 1}\u304C\u4E0D\u6B63\u3067\u3059\u3002`
+          );
+        }
+        const id = this.assertStructureId(
+          region.id,
+          `Structure presentation region ${regionIndex + 1} ID`
+        );
+        if (regionIds.has(id)) {
+          throw new RvwError(
+            "INVALID_INPUT",
+            `Structure presentation region ID\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059: ${id}`
+          );
+        }
+        regionIds.add(id);
+        const label = this.assertStructurePresentationText(
+          region.label,
+          MAX_STRUCTURE_PRESENTATION_REGION_LABEL_CHARACTERS,
+          `Structure presentation region ${regionIndex + 1} label`
+        );
+        const summary = this.assertStructurePresentationText(
+          region.summary,
+          MAX_STRUCTURE_PRESENTATION_REGION_SUMMARY_CHARACTERS,
+          `Structure presentation region ${label} summary`
+        );
+        if (!Array.isArray(region.nodeIds) || region.nodeIds.length < 1 || region.nodeIds.length > MAX_STRUCTURE_NODES) {
+          throw new RvwError(
+            "INVALID_INPUT",
+            `Structure presentation region ${label}\u306EnodeIds\u306F1\u301C${MAX_STRUCTURE_NODES}\u4EF6\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+          );
+        }
+        const currentRegionNodeIds = /* @__PURE__ */ new Set();
+        const normalizedNodeIds = region.nodeIds.map((rawNodeId) => {
+          const nodeId = this.assertStructureId(
+            rawNodeId,
+            `Structure presentation region ${label} Node ID`
+          );
+          if (currentRegionNodeIds.has(nodeId)) {
+            throw new RvwError(
+              "INVALID_INPUT",
+              `Structure presentation region ${label}\u306ENode ID\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059: ${nodeId}`
+            );
+          }
+          if (!nodeIds.has(nodeId)) {
+            throw new RvwError(
+              "INVALID_INPUT",
+              `Structure presentation region ${label}\u306ENode\u304C\u5B58\u5728\u3057\u307E\u305B\u3093: ${nodeId}`
+            );
+          }
+          const assignedRegion = assignedRegionByNodeId.get(nodeId);
+          if (assignedRegion !== void 0) {
+            throw new RvwError(
+              "INVALID_INPUT",
+              `Structure presentation Node ${nodeId}\u306F\u8907\u6570region\u306B\u6240\u5C5E\u3067\u304D\u307E\u305B\u3093: ${assignedRegion.label} (${assignedRegion.id}), ${label} (${id})`
+            );
+          }
+          currentRegionNodeIds.add(nodeId);
+          assignedRegionByNodeId.set(nodeId, { id, label });
+          return nodeId;
+        });
+        return { id, label, summary, nodeIds: normalizedNodeIds };
+      });
+      presentation = {
+        thesis,
+        startNodeId,
+        primaryBackbone,
+        regions: canonicalStructurePresentationRegions(regions)
+      };
+    }
+    const graph = { originNodeId, nodes, edges, presentation };
     if (Buffer.byteLength(JSON.stringify(graph), "utf8") > MAX_STRUCTURE_PAYLOAD_BYTES) {
       throw new RvwError(
         "INVALID_INPUT",
@@ -43042,6 +43598,18 @@ var RvwService = class {
     assertIdempotencyKey(input.idempotencyKey);
     const pullRequest = this.resolveStoredPullRequest(input.pullRequest);
     const content3 = await this.validateStructureContent(pullRequest, input);
+    const legacyNullPresentationIdempotencyRequestHash = content3.presentation === null ? idempotencyRequestHash({
+      operation: "structure.publish",
+      pullRequestId: pullRequest.id,
+      content: {
+        sourceOid: content3.sourceOid,
+        title: content3.title,
+        scope: content3.scope,
+        originNodeId: content3.originNodeId,
+        nodes: content3.nodes,
+        edges: content3.edges
+      }
+    }) : void 0;
     return await this.writeWithRetainedCommit(
       pullRequest,
       content3.sourceOid,
@@ -43054,7 +43622,8 @@ var RvwService = class {
           operation: "structure.publish",
           pullRequestId: pullRequest.id,
           content: content3
-        })
+        }),
+        ...legacyNullPresentationIdempotencyRequestHash === void 0 ? {} : { legacyNullPresentationIdempotencyRequestHash }
       })
     );
   }
@@ -43475,7 +44044,8 @@ var RvwService = class {
       body3,
       relatedCommitOid,
       references,
-      input.lastModifiedBy ?? post.lastModifiedBy
+      input.lastModifiedBy ?? post.lastModifiedBy,
+      input.watchTask
     );
     return relatedCommitOid ? await this.writeWithRetainedCommit(pullRequest, relatedCommitOid, "comment", write) : write();
   }
@@ -43805,6 +44375,696 @@ 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;
+}
+var PRESENTATION_ROW_STRIDE = STRUCTURE_NODE_HEIGHT + 72;
+var PRESENTATION_COLUMN_STRIDE = STRUCTURE_NODE_WIDTH + 64;
+var PRESENTATION_TARGET_ASPECT_RATIO = 5 / 3;
+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 projectTopologyStructureWithTopology(structure, topology) {
+  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 projectTopologyStructure(structure) {
+  return projectTopologyStructureWithTopology(structure, simpleStructureTopology(structure));
+}
+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 neutral topology diagnostic 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 neutral topology diagnostic; 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 {
@@ -43824,6 +45084,7 @@ import path7 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var skillNames = [
   "rvw",
+  "rvw-review-compose",
   "rvw-walkthrough",
   "rvw-structure",
   "rvw-watch-comments"
@@ -47648,6 +48909,8 @@ var nullableCommentLine = external_exports.number().int().positive().nullable().
 var idempotencyKey = external_exports.string().min(1).max(MAX_IDEMPOTENCY_KEY_CHARACTERS).optional();
 var requiredIdempotencyKey = external_exports.string().min(1).max(MAX_IDEMPOTENCY_KEY_CHARACTERS);
 var expectedUpdatedAt = external_exports.string().min(1).max(100);
+var commentWatchTaskFenceSchema = external_exports.object({ taskId: external_exports.uuid(), generation: external_exports.number().int().positive() }).strict();
+var commentWatchLeaseSchema = commentWatchTaskFenceSchema.extend({ leaseId: external_exports.uuid() }).strict();
 var commentTargetInputSchema = external_exports.union([
   external_exports.object({ kind: external_exports.literal("pull-request") }).strict(),
   external_exports.object({
@@ -47735,14 +48998,16 @@ var commentReplyInputSchema = external_exports.object({
   authorLabel: external_exports.string().max(MAX_AUTHOR_LABEL_CHARACTERS).nullable().optional(),
   relatedCommitOid: external_exports.string().regex(GIT_OBJECT_ID_PATTERN).nullable().optional(),
   references: optionalCodeReferences,
-  idempotencyKey
+  idempotencyKey,
+  watchTask: commentWatchTaskFenceSchema.optional()
 }).strict().superRefine(requireRelatedCommitForReferences);
 var commentPostEditInputSchema = external_exports.object({
   body: external_exports.string().min(1).refine((value) => Buffer.byteLength(value, "utf8") <= MAX_COMMENT_BODY_BYTES, {
     message: `body\u306FUTF-8\u3067${MAX_COMMENT_BODY_BYTES} bytes\uFF0864 KiB\uFF09\u4EE5\u4E0B\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
   }),
   relatedCommitOid: external_exports.string().regex(GIT_OBJECT_ID_PATTERN).nullable().optional(),
-  references: optionalCodeReferences
+  references: optionalCodeReferences,
+  watchTask: commentWatchTaskFenceSchema.optional()
 }).strict();
 var pullRequestSyncInputSchema = external_exports.object({
   pullRequest: nonEmptyString,
@@ -47802,13 +49067,29 @@ var structureEdgeInputSchema = external_exports.object({
   directed: external_exports.boolean(),
   anchors: external_exports.array(sourceAnchorInputSchema).max(MAX_STRUCTURE_EDGE_ANCHORS).optional().default([])
 }).strict();
+var structurePresentationInputSchema = external_exports.object({
+  thesis: external_exports.string().transform((value) => value.trim()).pipe(external_exports.string().min(1).max(MAX_STRUCTURE_PRESENTATION_THESIS_CHARACTERS)),
+  startNodeId: external_exports.string().max(MAX_STRUCTURE_ID_CHARACTERS).regex(STRUCTURE_ID_PATTERN),
+  primaryBackbone: external_exports.object({
+    edgeIds: external_exports.array(external_exports.string().max(MAX_STRUCTURE_ID_CHARACTERS).regex(STRUCTURE_ID_PATTERN)).min(1).max(MAX_STRUCTURE_PRIMARY_BACKBONE_EDGES).transform(canonicalStructureBackboneEdgeIds)
+  }).strict().nullable(),
+  regions: external_exports.array(
+    external_exports.object({
+      id: external_exports.string().max(MAX_STRUCTURE_ID_CHARACTERS).regex(STRUCTURE_ID_PATTERN),
+      label: external_exports.string().transform((value) => value.trim()).pipe(external_exports.string().min(1).max(MAX_STRUCTURE_PRESENTATION_REGION_LABEL_CHARACTERS)),
+      summary: external_exports.string().transform((value) => value.trim()).pipe(external_exports.string().min(1).max(MAX_STRUCTURE_PRESENTATION_REGION_SUMMARY_CHARACTERS)),
+      nodeIds: external_exports.array(external_exports.string().max(MAX_STRUCTURE_ID_CHARACTERS).regex(STRUCTURE_ID_PATTERN)).min(1).max(MAX_STRUCTURE_NODES).transform(canonicalStructureRegionNodeIds)
+    }).strict()
+  ).max(MAX_STRUCTURE_PRESENTATION_REGIONS).transform(canonicalStructurePresentationRegions)
+}).strict();
 var structureContentShape = {
   sourceOid: external_exports.string().regex(GIT_OBJECT_ID_PATTERN),
   title: external_exports.string().min(1).max(MAX_STRUCTURE_TITLE_CHARACTERS),
   scope: external_exports.string().min(1).max(MAX_STRUCTURE_SCOPE_CHARACTERS),
   originNodeId: external_exports.string().max(MAX_STRUCTURE_ID_CHARACTERS).regex(STRUCTURE_ID_PATTERN),
   nodes: external_exports.array(structureNodeInputSchema).min(1).max(MAX_STRUCTURE_NODES),
-  edges: external_exports.array(structureEdgeInputSchema).max(MAX_STRUCTURE_EDGES)
+  edges: external_exports.array(structureEdgeInputSchema).max(MAX_STRUCTURE_EDGES),
+  presentation: structurePresentationInputSchema.nullable()
 };
 function refineStructureContent(value, context) {
   const nodeIds = /* @__PURE__ */ new Set();
@@ -47887,6 +49168,107 @@ function refineStructureContent(value, context) {
       });
     }
   }
+  if (value.presentation !== null) {
+    if (!nodeIds.has(value.presentation.startNodeId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["presentation", "startNodeId"],
+        message: "startNodeId\u306ENode\u304C\u5B58\u5728\u3057\u307E\u305B\u3093\u3002"
+      });
+    }
+    const primaryBackbone = value.presentation.primaryBackbone;
+    if (primaryBackbone !== null) {
+      const selectedEdgeIds = /* @__PURE__ */ new Set();
+      const edgeById = new Map(value.edges.map((edge) => [edge.id, edge]));
+      const selectedEdges = [];
+      let allEdgeIdsValid = true;
+      for (const [index2, edgeId] of primaryBackbone.edgeIds.entries()) {
+        if (selectedEdgeIds.has(edgeId)) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "primaryBackbone", "edgeIds", index2],
+            message: "primaryBackbone\u306EEdge ID\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059\u3002"
+          });
+          allEdgeIdsValid = false;
+          continue;
+        }
+        selectedEdgeIds.add(edgeId);
+        const edge = edgeById.get(edgeId);
+        if (edge === void 0) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "primaryBackbone", "edgeIds", index2],
+            message: "primaryBackbone\u306EEdge\u304C\u5B58\u5728\u3057\u307E\u305B\u3093\u3002"
+          });
+          allEdgeIdsValid = false;
+          continue;
+        }
+        selectedEdges.push(edge);
+      }
+      if (allEdgeIdsValid) {
+        const backboneNodeIds = structureBackboneNodeIds(selectedEdges);
+        if (backboneNodeIds.size < 2 || backboneNodeIds.size > MAX_STRUCTURE_PRIMARY_BACKBONE_NODES) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "primaryBackbone", "edgeIds"],
+            message: `primaryBackbone\u306F2\u301C${MAX_STRUCTURE_PRIMARY_BACKBONE_NODES}\u4EF6\u306ENode\u3092\u7D50\u3076\u3088\u3046\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+          });
+        }
+        if (!backboneNodeIds.has(value.presentation.startNodeId)) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "startNodeId"],
+            message: "startNodeId\u306FprimaryBackbone\u306EEdge endpoint\u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002"
+          });
+        } else if (!isStructureBackboneWeaklyConnected(selectedEdges, value.presentation.startNodeId)) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "primaryBackbone", "edgeIds"],
+            message: "primaryBackbone\u306FstartNodeId\u304B\u3089\u8FBF\u308C\u308B\u4E00\u3064\u306Econnected graph\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+          });
+        }
+      }
+    }
+    const regionIds = /* @__PURE__ */ new Set();
+    const regionByNodeId = /* @__PURE__ */ new Map();
+    for (const [regionIndex, region] of value.presentation.regions.entries()) {
+      if (regionIds.has(region.id)) {
+        context.addIssue({
+          code: "custom",
+          path: ["presentation", "regions", regionIndex, "id"],
+          message: "region ID\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059\u3002"
+        });
+      }
+      regionIds.add(region.id);
+      const currentRegionNodeIds = /* @__PURE__ */ new Set();
+      for (const [nodeIndex, nodeId] of region.nodeIds.entries()) {
+        if (currentRegionNodeIds.has(nodeId)) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "regions", regionIndex, "nodeIds", nodeIndex],
+            message: "\u540C\u3058region\u5185\u3067Node ID\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059\u3002"
+          });
+        }
+        currentRegionNodeIds.add(nodeId);
+        if (!nodeIds.has(nodeId)) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "regions", regionIndex, "nodeIds", nodeIndex],
+            message: "region\u306ENode\u304C\u5B58\u5728\u3057\u307E\u305B\u3093\u3002"
+          });
+        }
+        const assignedRegionId = regionByNodeId.get(nodeId);
+        if (assignedRegionId !== void 0 && assignedRegionId !== region.id) {
+          context.addIssue({
+            code: "custom",
+            path: ["presentation", "regions", regionIndex, "nodeIds", nodeIndex],
+            message: "\u4E00\u3064\u306ENode\u3092\u8907\u6570region\u3078\u6240\u5C5E\u3055\u305B\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002"
+          });
+        }
+        if (assignedRegionId === void 0) regionByNodeId.set(nodeId, region.id);
+      }
+    }
+  }
   const anchorCount = value.nodes.filter((node2) => node2.anchor !== null).length + value.edges.reduce((count, edge) => count + edge.anchors.length, 0);
   if (anchorCount < 1) {
     context.addIssue({
@@ -47900,7 +49282,12 @@ function refineStructureContent(value, context) {
       message: `Structure\u306Esource anchor\u306F\u5408\u8A08${MAX_STRUCTURE_SOURCE_ANCHORS}\u4EF6\u4EE5\u4E0B\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
     });
   }
-  const graph = { originNodeId: value.originNodeId, nodes: value.nodes, edges: value.edges };
+  const graph = {
+    originNodeId: value.originNodeId,
+    nodes: value.nodes,
+    edges: value.edges,
+    presentation: value.presentation
+  };
   if (Buffer.byteLength(JSON.stringify(graph), "utf8") > MAX_STRUCTURE_PAYLOAD_BYTES) {
     context.addIssue({
       code: "custom",
@@ -47935,6 +49322,10 @@ var agentCommandInputSchemas = {
     cursor: external_exports.string().min(1).max(512).optional(),
     limit: external_exports.number().int().min(1).max(MAX_COMMENT_WATCH_LIMIT)
   }).strict(),
+  "comment.watch.activate": external_exports.object({ taskId: external_exports.uuid() }).strict(),
+  "comment.watch.verify": commentWatchTaskFenceSchema,
+  "comment.watch.reserveWrite": commentWatchLeaseSchema.extend({ writeKey: external_exports.string().regex(/^[^/\s]+\/[^/\s]+$/) }).strict(),
+  "comment.watch.releaseWrite": commentWatchLeaseSchema,
   "comment.create": commentCreateInputSchema,
   "comment.get": external_exports.object({ uri: commentUri, live: external_exports.boolean().default(false) }).strict(),
   "comment.reply": external_exports.object({ uri: commentUri, reply: commentReplyInputSchema }).strict(),
@@ -48790,7 +50181,22 @@ async function startServer(service, options = {}) {
         });
       }
     );
-    server.on("error", reject);
+    server.on("error", (error51) => {
+      if (error51.code !== "EADDRINUSE" || (options.port ?? 0) === 0) {
+        reject(error51);
+        return;
+      }
+      reject(
+        new RvwError("PROCESS_FAILED", `port ${options.port}\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002`, {
+          cause: error51,
+          details: { port: options.port, reason: "address-in-use" },
+          suggestions: [
+            "\u8D77\u52D5\u4E2D\u306Eprocess\u3092\u505C\u6B62\u3059\u308B\u304B\u3001\u5225\u306E--port\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+            "\u4E00\u6642\u7684\u306B\u7A7A\u304Dport\u3092\u81EA\u52D5\u9078\u629E\u3059\u308B\u5834\u5408\u306F--port 0\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+          ]
+        })
+      );
+    });
   });
 }
 
@@ -48811,7 +50217,7 @@ import os4 from "node:os";
 import path9 from "node:path";
 var MAX_CLI_STDIN_BYTES = 40 * 1024 * 1024;
 var MAX_AGENT_MESSAGE_BYTES = MAX_CLI_STDIN_BYTES + 64 * 1024;
-var AGENT_SOCKET_PROTOCOL_VERSION = 4;
+var AGENT_SOCKET_PROTOCOL_VERSION = 5;
 var RUNTIME_VIEWER_OPEN_OPERATION = "viewer.open";
 var AGENT_SOCKET_RESTART_SUGGESTION = "\u8D77\u52D5\u4E2D\u306Ervw viewer\u3092\u505C\u6B62\u3057\u3001\u66F4\u65B0\u5F8C\u306Ervw open\u3067\u518D\u8D77\u52D5\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 var DEFAULT_CONNECT_TIMEOUT_MS = 2e3;
@@ -48976,6 +50382,27 @@ async function dispatchAgentSocketRequest(service, rawRequest) {
       const input = parseOperationInput("comment.watch", request.input);
       return service.listCommentPostEvents(input.cursor, input.limit);
     }
+    case "comment.watch.activate": {
+      const input = parseOperationInput("comment.watch.activate", request.input);
+      return service.activateCommentWatchTask(input.taskId);
+    }
+    case "comment.watch.verify": {
+      const input = parseOperationInput("comment.watch.verify", request.input);
+      return service.verifyCommentWatchTask(input.taskId, input.generation);
+    }
+    case "comment.watch.reserveWrite": {
+      const input = parseOperationInput("comment.watch.reserveWrite", request.input);
+      return service.reserveCommentWatchWriter(
+        input.taskId,
+        input.generation,
+        input.leaseId,
+        input.writeKey
+      );
+    }
+    case "comment.watch.releaseWrite": {
+      const input = parseOperationInput("comment.watch.releaseWrite", request.input);
+      return service.releaseCommentWatchWriter(input.taskId, input.generation, input.leaseId);
+    }
     case "comment.create": {
       const input = parseOperationInput("comment.create", request.input);
       return await service.createCommentForReference(
@@ -48999,6 +50426,7 @@ async function dispatchAgentSocketRequest(service, rawRequest) {
         body: input.edit.body,
         ...input.edit.relatedCommitOid === void 0 ? {} : { relatedCommitOid: input.edit.relatedCommitOid },
         ...input.edit.references === void 0 ? {} : { references: input.edit.references },
+        ...input.edit.watchTask === void 0 ? {} : { watchTask: input.edit.watchTask },
         lastModifiedBy: "agent"
       });
     }
@@ -50080,6 +51508,10 @@ function writeJson(value) {
   process.stdout.write(`${JSON.stringify(value)}
 `);
 }
+function structureAuthoringFeedback(structure) {
+  const layout = projectTopologyStructure(structure).diagnostics;
+  return { layout, warnings: structureAuthoringWarnings(layout) };
+}
 function writeJsonSequence(value) {
   process.stdout.write(`${JSON.stringify(value)}
 `);
@@ -50284,12 +51716,12 @@ function staticDirectory() {
   ];
   return candidates.find((candidate) => existsSync6(candidate)) ?? candidates[0];
 }
-function forkOpenWorker(reference, port) {
+function forkOpenWorker(reference, port, requestedPort) {
   const modulePath = process.argv[1];
   if (!modulePath) {
     throw new RvwError("PROCESS_FAILED", "rvw CLI\u306E\u5B9F\u884Cpath\u3092\u89E3\u6C7A\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002");
   }
-  const args = ["__open-worker", "--port", String(port)];
+  const args = ["__open-worker", "--port", String(port), "--requested-port", String(requestedPort)];
   if (reference !== void 0) args.push("--reference", reference);
   return fork(path10.resolve(modulePath), args, {
     cwd: process.cwd(),
@@ -50299,10 +51731,12 @@ function forkOpenWorker(reference, port) {
   });
 }
 async function startBackgroundOpen(reference, port, dependencies = {}) {
+  const startupPort = port ?? DEFAULT_VIEWER_PORT;
+  const requestedPort = port ?? 0;
   const input = {
     ...reference === void 0 ? {} : { reference },
     cwd: process.cwd(),
-    requestedPort: port
+    requestedPort
   };
   const launchBrowser = dependencies.launchBrowser ?? (async (url2) => await open_default(url2));
   let existing = null;
@@ -50322,7 +51756,7 @@ async function startBackgroundOpen(reference, port, dependencies = {}) {
       { details: existing.details }
     );
   }
-  const child = (dependencies.forkWorker ?? forkOpenWorker)(reference, port);
+  const child = (dependencies.forkWorker ?? forkOpenWorker)(reference, startupPort, requestedPort);
   return await completeBackgroundOpen(child, launchBrowser);
 }
 async function sendOpenWorkerMessage(message) {
@@ -50515,6 +51949,8 @@ async function waitForWorkerParentDisconnect() {
   await new Promise((resolve) => process.once("disconnect", resolve));
 }
 async function runOpenServer(runtimeFactory, reference, port, openAutomatically, useAgentSocket, reuseExisting) {
+  const startupPort = port ?? DEFAULT_VIEWER_PORT;
+  const requestedPort = port ?? 0;
   let activeRuntime;
   let running;
   let agentSocket;
@@ -50523,7 +51959,7 @@ async function runOpenServer(runtimeFactory, reference, port, openAutomatically,
       const databaseFilePath = databasePathConfiguration().filePath;
       if (reuseExisting) {
         const startup = await acquireRuntimeOrReuseExisting(
-          runtimeViewerOpenInput(reference, process.cwd(), port),
+          runtimeViewerOpenInput(reference, process.cwd(), requestedPort),
           databaseFilePath
         );
         if (startup.kind === "reused") {
@@ -50552,7 +51988,7 @@ async function runOpenServer(runtimeFactory, reference, port, openAutomatically,
     activeRuntime = runtimeFactory();
     const opened = await activeRuntime.service.openPullRequest(reference, process.cwd());
     running = await startServer(activeRuntime.service, {
-      port,
+      port: startupPort,
       staticDirectory: staticDirectory(),
       autoCloseWhenNoViewers: openAutomatically
     });
@@ -50570,7 +52006,7 @@ async function runOpenServer(runtimeFactory, reference, port, openAutomatically,
     await closeOwnedRuntime(agentSocket, running, activeRuntime);
   }
 }
-async function runOpenWorker(runtimeFactory, reference, port) {
+async function runOpenWorker(runtimeFactory, reference, port, requestedPort) {
   let activeRuntime;
   let running;
   let agentSocket;
@@ -50580,7 +52016,7 @@ async function runOpenWorker(runtimeFactory, reference, port) {
     }
     const databaseFilePath = databasePathConfiguration().filePath;
     const startup = await acquireRuntimeOrReuseExisting(
-      runtimeViewerOpenInput(reference, process.cwd(), port),
+      runtimeViewerOpenInput(reference, process.cwd(), requestedPort),
       databaseFilePath
     );
     if (startup.kind === "reused") {
@@ -50678,6 +52114,7 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
         "comment.create",
         "comment.list",
         "comment.watch",
+        "comment.watchOwnership",
         "comment.read",
         "comment.reply",
         "comment.edit",
@@ -50687,6 +52124,8 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
         "pullRequest.sync",
         "structure.list",
         "structure.read",
+        "structure.preview",
+        "structure.presentation",
         "structure.publish",
         "structure.update",
         "structure.delete",
@@ -50716,7 +52155,7 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
     writeOutput(options, { ok: ok2, ...status }, formatAgentTransportStatus(status));
     if (!ok2) process.exitCode = 2;
   });
-  program2.command("open").argument("[pull-request]", "PR URL\u307E\u305F\u306F\u756A\u53F7").option("--no-open", "\u30D6\u30E9\u30A6\u30B6\u3092\u958B\u304B\u306A\u3044").option("--foreground", "terminal\u306B\u63A5\u7D9A\u3057\u305F\u307E\u307Eviewer\u3092\u5B9F\u884C").option("--port <port>", "listen port\uFF080\u306F\u81EA\u52D5\uFF09", parsePort, 0).description("Pull Request\u3092\u958B\u3044\u3066\u30ED\u30FC\u30AB\u30EBviewer\u3092\u8D77\u52D5").action(
+  program2.command("open").argument("[pull-request]", "PR URL\u307E\u305F\u306F\u756A\u53F7").option("--no-open", "\u30D6\u30E9\u30A6\u30B6\u3092\u958B\u304B\u306A\u3044").option("--foreground", "terminal\u306B\u63A5\u7D9A\u3057\u305F\u307E\u307Eviewer\u3092\u5B9F\u884C").option("--port <port>", `listen port\uFF08\u65E2\u5B9A${DEFAULT_VIEWER_PORT}\u30010\u306F\u81EA\u52D5\uFF09`, parsePort).description("Pull Request\u3092\u958B\u3044\u3066\u30ED\u30FC\u30AB\u30EBviewer\u3092\u8D77\u52D5").action(
     async (reference, options) => {
       if (options.open && !options.foreground && useAgentSocket) {
         const url2 = await startBackgroundOpen(reference, options.port);
@@ -50734,9 +52173,9 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
       );
     }
   );
-  program2.command("__open-worker", { hidden: true }).option("--reference <pull-request>").requiredOption("--port <port>", "listen port", parsePort).action(async (options) => {
+  program2.command("__open-worker", { hidden: true }).option("--reference <pull-request>").requiredOption("--port <port>", "listen port", parsePort).requiredOption("--requested-port <port>", "requested listen port", parsePort).action(async (options) => {
     try {
-      await runOpenWorker(getRuntime, options.reference, options.port);
+      await runOpenWorker(getRuntime, options.reference, options.port, options.requestedPort);
     } catch (error51) {
       const rvwError = asRvwError(error51);
       const sent = await sendOpenWorkerMessage({
@@ -50825,6 +52264,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 +52275,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 +52301,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) => {
@@ -51018,6 +52463,66 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
       process.off("SIGTERM", stop);
     }
   });
+  const watchTask = comment3.command("watch-task").description("comment watch task\u306Eshared ownership\u3092\u7BA1\u7406");
+  watchTask.command("activate").requiredOption("--task-id <task-id>", "\u65B0\u3057\u3044logical watch task ID").requiredOption("--json", "JSON\u3067\u51FA\u529B").action(async (options) => {
+    const input = { taskId: external_exports.uuid().parse(options.taskId) };
+    const result = await callService(
+      "comment.watch.activate",
+      input,
+      () => getRuntime().service.activateCommentWatchTask(input.taskId)
+    );
+    writeJson({ ok: true, ...result });
+  });
+  watchTask.command("verify").requiredOption("--task-id <task-id>", "logical watch task ID").requiredOption("--generation <generation>", "watch generation").requiredOption("--json", "JSON\u3067\u51FA\u529B").action(async (options) => {
+    const input = {
+      taskId: external_exports.uuid().parse(options.taskId),
+      generation: external_exports.coerce.number().int().positive().parse(options.generation)
+    };
+    const result = await callService(
+      "comment.watch.verify",
+      input,
+      () => getRuntime().service.verifyCommentWatchTask(input.taskId, input.generation)
+    );
+    writeJson({ ok: true, ...result });
+  });
+  watchTask.command("reserve-write").requiredOption("--task-id <task-id>", "logical watch task ID").requiredOption("--generation <generation>", "watch generation").requiredOption("--lease-id <lease-id>", "task-local batch lease ID").requiredOption("--write-key <owner-repository>", "\u5171\u6709\u3059\u308Bowner/repository writer key").requiredOption("--json", "JSON\u3067\u51FA\u529B").action(
+    async (options) => {
+      const input = {
+        taskId: external_exports.uuid().parse(options.taskId),
+        generation: external_exports.coerce.number().int().positive().parse(options.generation),
+        leaseId: external_exports.uuid().parse(options.leaseId),
+        writeKey: external_exports.string().regex(/^[^/\s]+\/[^/\s]+$/).parse(options.writeKey.toLowerCase())
+      };
+      const result = await callService(
+        "comment.watch.reserveWrite",
+        input,
+        () => getRuntime().service.reserveCommentWatchWriter(
+          input.taskId,
+          input.generation,
+          input.leaseId,
+          input.writeKey
+        )
+      );
+      writeJson({ ok: true, ...result });
+    }
+  );
+  watchTask.command("release-write").requiredOption("--task-id <task-id>", "logical watch task ID").requiredOption("--generation <generation>", "watch generation").requiredOption("--lease-id <lease-id>", "task-local batch lease ID").requiredOption("--json", "JSON\u3067\u51FA\u529B").action(async (options) => {
+    const input = {
+      taskId: external_exports.uuid().parse(options.taskId),
+      generation: external_exports.coerce.number().int().positive().parse(options.generation),
+      leaseId: external_exports.uuid().parse(options.leaseId)
+    };
+    const result = await callService(
+      "comment.watch.releaseWrite",
+      input,
+      () => getRuntime().service.releaseCommentWatchWriter(
+        input.taskId,
+        input.generation,
+        input.leaseId
+      )
+    );
+    writeJson({ ok: true, ...result });
+  });
   comment3.command("create").requiredOption("--stdin", "stdin\u304B\u3089JSON\u3092\u8AAD\u3080").requiredOption("--json", "JSON\u3067\u51FA\u529B").description("\u767B\u9332\u6E08\u307FPR\u3078\u672A\u89E3\u6C7A\u30B3\u30E1\u30F3\u30C8\u3092\u4E00\u4EF6\u4F5C\u6210").action(async () => {
     const input = commentCreateInputSchema.parse(await readStdinJson());
     const request = {
@@ -51069,7 +52574,8 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
       ...input.authorLabel === void 0 ? {} : { authorLabel: input.authorLabel },
       ...input.relatedCommitOid === void 0 ? {} : { relatedCommitOid: input.relatedCommitOid },
       ...input.references === void 0 ? {} : { references: input.references },
-      ...input.idempotencyKey === void 0 ? {} : { idempotencyKey: input.idempotencyKey }
+      ...input.idempotencyKey === void 0 ? {} : { idempotencyKey: input.idempotencyKey },
+      ...input.watchTask === void 0 ? {} : { watchTask: input.watchTask }
     };
     const post = await callService(
       "comment.reply",
@@ -51086,7 +52592,8 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
     const edit = {
       body: input.body,
       ...input.relatedCommitOid === void 0 ? {} : { relatedCommitOid: input.relatedCommitOid },
-      ...input.references === void 0 ? {} : { references: input.references }
+      ...input.references === void 0 ? {} : { references: input.references },
+      ...input.watchTask === void 0 ? {} : { watchTask: input.watchTask }
     };
     const post = await callService(
       "comment.edit",