@quolu/lattice 0.12.31 → 0.12.33

package/package.json

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

package/src/todo-dashboard-registry.mjs

@@ -272,7 +272,7 @@ export async function writeTodoDashboardDaemonDescriptor({ port, env = process.e
 }
 
 export async function ensureTodoDashboardDaemon({ env = process.env, spawnDaemon = spawn,
-  signalProcess = process.kill, isProcessAlive = processIsAlive, startupTimeoutMs = 4_000,
+  signalProcess = process.kill, isProcessAlive = processIsAlive, startupTimeoutMs = 120_000,
   legacyStopTimeoutMs = 3_000, replacementIsProcessAlive = processIsAlive,
   attestationTimeoutMs = 2_000 } = {}) {
   const refs = paths(env);
@@ -299,11 +299,20 @@ export async function ensureTodoDashboardDaemon({ env = process.env, spawnDaemon
       env: { ...env, LATTICE_DASHBOARD_RUNTIME_DIR: refs.root, LATTICE_DASHBOARD_PORT: String(port) },
     });
     child.unref();
+    // 起動待ちの終わりを固定秒数で決めない。それは機械の速さの見積りになり、遅い側
+    // へ外すとpublish済みのcodeを載せたdaemonへ入れ替われず、公開面が古いまま取り
+    // 残される。daemonはdescriptorを書く前に登録済み全projectのstoreを読むので、
+    // 起動時間はproject数とstore規模に比例する（実測: 8 projectで約51秒）。
+    // 待つのはspawnした子が生きている間だけとし、死んだら即座に諦める。
+    // startupTimeoutMsは無反応な子に対するbackstopであって起動時間の上限ではない。
     const deadline = Date.now() + startupTimeoutMs;
     while (Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, 50));
       const descriptor = await readJson(refs.descriptor, null);
-      if (await daemonHealthy(descriptor) && descriptor.pid !== legacy?.pid) {
+      const healthy = await daemonHealthy(descriptor);
+      if (!healthy && typeof child.pid === 'number'
+        && !await replacementIsProcessAlive(child.pid)) break;
+      if (healthy && descriptor.pid !== legacy?.pid) {
         if (legacy !== null) {
           try {
             await stopAttestedLegacyDaemon(legacy, {

package/src/todo-gantt-layout.mjs

@@ -416,9 +416,15 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
   const layers = orderLayers(nodes, wave, incoming, outgoing);
   // A ToDo with no registered dependency has nothing to line up with. Laying
   // every one of them out in a single row makes the canvas as wide as the plan
-  // is old — real stores have hundreds — so they wrap into a block underneath
-  // the wired ToDos of their stage. Nodes that carry edges keep the top row:
-  // edge routing assumes both endpoints of a stage share one baseline.
+  // is old — real stores have hundreds — so they wrap into a block of rows.
+  //
+  // That block goes ABOVE the wired ToDos of its stage. Below them it used to be
+  // pierced: a wired card's port descends from its own bottom edge to the routing
+  // band under the whole stage, straight through whatever independent card had
+  // wrapped into the same column, and the hidden half of that line read as a
+  // dependency the plan does not have. Independent ToDos carry no edge, so they
+  // have no incoming one either and always land in stage 0, which nothing ever
+  // arrives into — putting them on top leaves no line to cross them.
   const wired = new Set();
   for (const edge of edges) { wired.add(edge.from); wired.add(edge.to); }
   const transversePosition = new Map();
@@ -427,12 +433,15 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
   for (const layer of layers) {
     const connected = layer.filter((key) => wired.has(key));
     const loose = layer.filter((key) => !wired.has(key));
-    connected.forEach((key, index) => { transversePosition.set(key, index); stageRow.set(key, 0); });
     const columns = Math.max(LOOSE_COLUMNS_MINIMUM, connected.length);
-    const firstLooseRow = connected.length === 0 ? 0 : 1;
+    const looseRows = loose.length === 0 ? 0 : Math.ceil(loose.length / columns);
     loose.forEach((key, index) => {
       transversePosition.set(key, index % columns);
-      stageRow.set(key, firstLooseRow + Math.floor(index / columns));
+      stageRow.set(key, Math.floor(index / columns));
+    });
+    connected.forEach((key, index) => {
+      transversePosition.set(key, index);
+      stageRow.set(key, looseRows);
     });
     stageRowCount.push(Math.max(0, ...layer.map((key) => stageRow.get(key))) + 1);
   }