@quolu/lattice 0.12.29 → 0.12.31

package/README.md

@@ -119,7 +119,8 @@ dashboardはmanifestのfile identityが変わらない間のstable store readを
 最近のsession activityが期限切れでも、Lattice storeの`active_set`が非空なprojectは一覧へ残ります。
 長時間の外部処理中にCLI呼出しが途切れても進行中projectを休眠扱いしません。
 LANや外部reverse proxyから閲覧するoptional bridgeは既定で無効です。明示したIPにだけbindする初回設定、
-再設定、停止方法は[bridge setup](docs/bridge-setup.md)を参照してください。
+再設定、停止方法は[bridge setup](docs/bridge-setup.md)を参照してください。reverse proxy hostへsshで
+到達できる場合は、LANへbindせずloopbackだけを逆トンネルで公開する構成も選べます。
 工程図の既定表示は、後続に作業中・未着手が残っていない完了工程を図から除きます。まとめnodeも置かないため、
 完走したplanは図の場所を取りません。除いた工程は凡例の件数、右ペインの「全工程」一覧、各工程の詳細から
 辿れ、詳細の前提・後続は除外前の依存関係を示します。総数・進捗・最長依存鎖は除外前の全工程で数えます。

package/docs/bridge-setup.md

@@ -10,7 +10,7 @@ portを省略するか`auto`にすると、49152–65535から候補を重複な
 実際のexclusive bindとhealth確認に成功したportだけを保存する。
 
 ```bash
-lattice bridge setup --listen 192.168.1.102 --port auto --dashboard --allow-host lattice.kitepon.dev --json
+lattice bridge setup --listen 192.168.1.50 --port auto --dashboard --allow-host lattice.example.com --json
 ```
 
 `--dashboard`は現在のlocal dashboard descriptorをrequestごとに解決するため、dashboard再起動でportが変わっても
@@ -20,7 +20,7 @@ listen IPは常に許可Hostへ入り、reverse proxyで公開するhostnameは`
 
 ```bash
 lattice bridge status --json
-lattice bridge reconfigure --listen 192.168.1.102 --port auto --dashboard --json
+lattice bridge reconfigure --listen 192.168.1.50 --port auto --dashboard --json
 lattice bridge disable --json
 ```
 
@@ -45,6 +45,26 @@ daemonは各reconcileで実効アドレスを解決し直し、同一subnet（IP
 ssh送信元から決めるため、各hostは自分自身しか登録できない。登録の失敗はbridgeを落とさずstderrへ
 typedに報告する。この配線が無いと、Caddy等が持つリテラルはlease変更のたびに黙って陳腐化する。
 
+## reverse proxyへ逆トンネルで繋ぐ（LAN bindを使わない）
+
+reverse proxy hostへsshで到達できるなら、LANへbindせずloopbackだけで公開できる。bridgeが動くhostから
+接続しに行くため、そのhostのLAN addressはreverse proxyのどこにも現れず、追従も自己登録も不要になる。
+
+```bash
+lattice bridge setup --listen 127.0.0.1 --port 53939 --dashboard --allow-host lattice.example.com --json
+ssh -N -o ExitOnForwardFailure=yes -o ServerAliveInterval=30 \
+  -R 172.18.0.1:53939:127.0.0.1:53939 proxy-host
+```
+
+reverse proxyはこの固定endpointだけを見る。転送口のbind先は、reverse proxyが到達できるaddressにする。
+Docker上のreverse proxyでは、containerの`127.0.0.1`はcontainer自身のloopbackでありhostのそれではないため、
+hostのloopbackへ開いた口には届かない。対象networkのgateway（`docker network inspect`の`Gateway`）へbindする。
+
+sshdは既定の`GatewayPorts no`だと`127.0.0.1`にしかbindできない。`clientspecified`にすると、clientが明示した
+addressだけにbindする（`yes`と違い全interfaceへは晒さない）。host firewallがINPUTをDROPしている場合は、
+その1 portだけを許可する。`ExitOnForwardFailure=yes`は、転送口を開けないまま接続だけ生かす状態を防ぐ。
+常駐はprocess supervisorのKeepAliveに任せ、切断時は張り直す。
+
 ## Docker Caddy／Cloudflare Tunnelへ接続する
 
 bridgeを有効化したMacとreverse proxy hostの間で、まず許可Hostを付けたLAN到達を確認する。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.12.29",
+  "version": "0.12.31",
   "description": "Lattice — phase-aware TODO graph compiler and conflict-aware orchestration runtime",
   "type": "module",
   "license": "MIT",

package/src/todo-gantt-layout.mjs

@@ -436,6 +436,8 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     });
     stageRowCount.push(Math.max(0, ...layer.map((key) => stageRow.get(key))) + 1);
   }
+  const maximumLayerWidth = Math.max(1,
+    ...[...transversePosition.values()].map((position) => position + 1));
   const visibleKeys = new Set(nodes.map(({ key }) => key));
   const displayBranches = edges.flatMap((edge, semanticIndex) => {
     const identities = [...edge.joinIdentities.entries()]
@@ -455,14 +457,26 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     if (!portGroups.has(key)) portGroups.set(key, []);
     portGroups.get(key).push(entry);
   };
+  // 隣の段の真下へ繋ぐ辺は、出発と到着が同じ取り付け位置の集合を奪い合う。別々の
+  // 枠を取ると2本の縦線が12pxずれて短い横棒で継がれ、まっすぐ引ける線が段差付きに
+  // 見える。両端の縦線は帯の中で1点で接するだけなので、1枠を共有させて直線にする。
+  const sharedPort = new Set();
   displayBranches.forEach((branch) => {
     const { edge } = branch;
     for (const gap of new Set([wave.get(edge.from), wave.get(edge.to) - 1])) {
       if (!gapGroups.has(gap)) gapGroups.set(gap, []);
       gapGroups.get(gap).push(branch.key);
     }
-    addPort(wave.get(edge.from), transversePosition.get(edge.from), portEntryKey(branch.key, 'departure'));
-    addPort(wave.get(edge.to) - 1, transversePosition.get(edge.to), portEntryKey(branch.key, 'arrival'));
+    const departureGap = wave.get(edge.from);
+    const fromColumn = transversePosition.get(edge.from);
+    const toColumn = transversePosition.get(edge.to);
+    if (departureGap === wave.get(edge.to) - 1 && fromColumn === toColumn) {
+      sharedPort.add(branch.key);
+      addPort(departureGap, fromColumn, portEntryKey(branch.key, 'through'));
+      return;
+    }
+    addPort(departureGap, fromColumn, portEntryKey(branch.key, 'departure'));
+    addPort(wave.get(edge.to) - 1, toColumn, portEntryKey(branch.key, 'arrival'));
   });
   for (const keys of gapGroups.values()) keys.sort(compareText);
   for (const entries of portGroups.values()) entries.sort(compareText);
@@ -477,9 +491,51 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
   const allGapIndexes = new Set([...gapGroups.keys(), ...connectorGroupKeysByGap.keys()]);
   const maximumGapOccupancy = Math.max(0, ...[...allGapIndexes].map((gap) =>
     (gapGroups.get(gap)?.length ?? 0) + (connectorGroupKeysByGap.get(gap)?.size ?? 0)));
+  // An edge that skips a stage has to travel vertically past the stages in
+  // between. It used to do that in a corridor beyond the right edge of the
+  // whole diagram, so a local hop between two neighbouring cards was drawn as a
+  // trip to the far right and back. It now descends through the vertical
+  // channel between two columns of cards, chosen from the boundaries that lie
+  // between its endpoints. Every card sits on the same column grid, so those
+  // gaps are free of cards at every stage: routing inside one is both shorter
+  // to follow and structurally unable to cross a card.
+  const channelLoad = new Map();
+  const channelAssignment = new Map();
+  const channelTraffic = (boundary) => channelLoad.get(boundary) ?? 0;
+  for (const branch of [...displayBranches].sort((left, right) => compareText(left.key, right.key))) {
+    const { edge } = branch;
+    if (wave.get(edge.from) === wave.get(edge.to) - 1) continue;
+    const fromColumn = transversePosition.get(edge.from);
+    const toColumn = transversePosition.get(edge.to);
+    const [first, last] = fromColumn === toColumn
+      ? [toColumn, toColumn + 1]
+      : [Math.min(fromColumn, toColumn) + 1, Math.max(fromColumn, toColumn)];
+    let chosen = first;
+    for (let boundary = first + 1; boundary <= last; boundary += 1) {
+      const closer = Math.abs(boundary - toColumn) < Math.abs(chosen - toColumn);
+      if (channelTraffic(boundary) < channelTraffic(chosen)
+        || (channelTraffic(boundary) === channelTraffic(chosen) && closer)) chosen = boundary;
+    }
+    channelAssignment.set(branch.key, { boundary: chosen, lane: channelTraffic(chosen) });
+    channelLoad.set(chosen, channelTraffic(chosen) + 1);
+  }
+
   const nodeWidth = Math.max(GEOMETRY.node_width,
     GEOMETRY.route_inset * 2 + (maximumPortTraffic + 1) * GEOMETRY.route_spacing);
-  const laneGap = nodeWidth + 24;
+  // Only the boundaries that actually carry channels pay for them. Boundary 0
+  // is the margin left of the first column and only exists when something
+  // routes there, so an untravelled diagram keeps its original left edge.
+  const channelWidth = (boundary) => Math.max(24,
+    (channelTraffic(boundary) + 1) * GEOMETRY.route_spacing);
+  const columnLeft = [GEOMETRY.left + (channelTraffic(0) === 0 ? 0 : channelWidth(0))];
+  for (let column = 1; column < maximumLayerWidth; column += 1) {
+    columnLeft.push(columnLeft[column - 1] + nodeWidth + channelWidth(column));
+  }
+  const channelPosition = (edgeKey) => {
+    const { boundary, lane } = channelAssignment.get(edgeKey);
+    const left = boundary === 0 ? GEOMETRY.left : columnLeft[boundary - 1] + nodeWidth;
+    return left + GEOMETRY.route_spacing * (lane + 1);
+  };
   // Each routing band is sized for the edges that actually cross it. One
   // crowded band used to set the spacing for every stage in the diagram, so a
   // long plan paid the width of its busiest junction on all of its stages.
@@ -496,7 +552,7 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
   const projectedNodes = nodes.map((node) => {
     const visible = visibleKeys.has(node.key);
     const geometry = visible ? {
-      x: GEOMETRY.left + transversePosition.get(node.key) * laneGap,
+      x: columnLeft[transversePosition.get(node.key)],
       y: stageTop[wave.get(node.key)]
         + stageRow.get(node.key) * (GEOMETRY.node_height + GEOMETRY.stage_row_gap),
       width: nodeWidth,
@@ -521,20 +577,18 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     return stageTop[waveIndex] + stageHeight(waveIndex)
       + GEOMETRY.route_spacing * (index + 1);
   };
-  const maximumLayerWidth = Math.max(1,
-    ...[...transversePosition.values()].map((position) => position + 1));
-  const routeRight = GEOMETRY.left + (maximumLayerWidth - 1) * laneGap + nodeWidth + 12;
   const branchCounts = new Map();
   for (const branch of displayBranches) {
     branchCounts.set(branch.semanticIndex, (branchCounts.get(branch.semanticIndex) ?? 0) + 1);
   }
   const portPosition = (edgeKey, direction, gap, row, nodeX) => {
     const entries = portGroups.get(portGroupKey(gap, row));
+    const entry = portEntryKey(edgeKey, sharedPort.has(edgeKey) ? 'through' : direction);
     return nodeX + GEOMETRY.route_inset
-      + GEOMETRY.route_spacing * (entries.indexOf(portEntryKey(edgeKey, direction)) + 1);
+      + GEOMETRY.route_spacing * (entries.indexOf(entry) + 1);
   };
 
-  const projectedEdges = displayBranches.map((branch, index) => {
+  const projectedEdges = displayBranches.map((branch) => {
     const { edge } = branch;
     const onLongestChain = longestEdgeKeys.has(edge.key);
     const from = coordinates.get(edge.from);
@@ -549,11 +603,17 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     const endY = to.y;
     const departureY = gapPosition(branch.key, departureGap);
     const arrivalY = gapPosition(branch.key, arrivalGap);
-    const corridorX = routeRight + GEOMETRY.route_spacing * (index + 1);
-    const route = [[startX, startY], [startX, departureY]];
-    if (arrivalY === departureY) route.push([endX, arrivalY]);
-    else route.push([corridorX, departureY], [corridorX, arrivalY], [endX, arrivalY]);
-    route.push([endX, endY]);
+    const corners = [[startX, startY], [startX, departureY]];
+    if (departureGap === arrivalGap) corners.push([endX, arrivalY]);
+    else {
+      const channelX = channelPosition(branch.key);
+      corners.push([channelX, departureY], [channelX, arrivalY], [endX, arrivalY]);
+    }
+    corners.push([endX, endY]);
+    // 1枠を共有する直線では折れ点が重なる。長さゼロの区間を残すと交差判定にも
+    // 描画にも意味のない点が混ざるので畳む。
+    const route = corners.filter(([x, y], index) =>
+      index === 0 || x !== corners[index - 1][0] || y !== corners[index - 1][1]);
     return {
       id: branchCounts.get(branch.semanticIndex) === 1
         ? `edge-${branch.semanticIndex}` : `edge-${branch.semanticIndex}-join-${branch.branchIndex}`,
@@ -610,7 +670,7 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
   }
   addCrossingBridges([...projectedEdges, ...junctionConnectors], logicalContacts);
   let routeMaximumX = nodes.length === 0 ? 0
-    : GEOMETRY.left + (maximumLayerWidth - 1) * laneGap + nodeWidth;
+    : columnLeft[maximumLayerWidth - 1] + nodeWidth;
   for (const edge of projectedEdges) {
     for (const [x] of edge.route) routeMaximumX = Math.max(routeMaximumX, x);
   }