@quolu/lattice 0.52.2 → 0.52.4

package/src/runtime-seam-treatment.mjs

@@ -1,173 +1,173 @@
-/**
- * 実行時競合を、実際の変換で解消する処置へ変える（請求項8・ADR 0137〜0139）。
- *
- * 実行時の入力は観測である。どのpathでどの2 taskがぶつかったかは`detectCheckpointFindings`が
- * 実際に変更された資源から返すので、ここで影響範囲を探し直さない。
- *
- * 変換の導出はbase状態に対して行う。holdされたTODOは再計画で旧contextを失効させられ、
- * 新plan_ref由来のpacketで再開するため、進行中の編集は設計上そこで捨てられる。
- * `head_sha`が効くのは止めずに継続するcarry-over側であり、held側ではない。
- */
-
-import { createHash } from 'node:crypto';
-
-import { canonicalizeArtifact } from './artifact-contracts.mjs';
-import { selfDigest } from './runtime-contracts.mjs';
-import { seamConflictFromFinding } from './seam-apply.mjs';
-
-const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
-const sha16 = (value) => createHash('sha256').update(value, 'utf8').digest('hex').slice(0, 16);
-
-/** 資源idはidentifier規律なのでpathをそのまま使えない。boundary compilerと同じ合成形にする。 */
-export function pathResourceId(target) {
-  return `own-path-${sha16(target)}`;
-}
-
-function sealed(value, field) {
-  const record = { ...value, [field]: '' };
-  record[field] = selfDigest(record, field);
-  return record;
-}
-
-function canonicalSort(entries) {
-  return [...entries].sort((left, right) => compareText(
-    canonicalizeArtifact(left), canonicalizeArtifact(right),
-  ));
-}
-
-/**
- * 採用された変換から、再計画が読む`lattice.runtime_seam_split.v1`を組む。
- *
- * 所有の差分は「係争資源の所有を降りて、自分の新資源を所有する」である。競合辺は消える——
- * それが変換の目的であり、消えていなければ五条件のoverlap_reducedが通っていない。
- */
-export function buildRuntimeSeamSplit({
-  conflict, candidate, taskMigrationDigest, verifierRefs = [],
-} = {}) {
-  const owned = (candidate?.surfaces ?? []).filter(({ role }) => role === 'task_owned');
-  if (owned.length < 2) return { split: null, reasons: ['owned_surfaces_below_two'] };
-  const sourceResource = pathResourceId(conflict.sourcePath);
-
-  const removed = canonicalSort(conflict.taskIds.map((taskId) => ({
-    resource_id: sourceResource, owner_todo_id: taskId, access_kind: 'own',
-  })));
-  const added = canonicalSort(owned.map((surface) => ({
-    resource_id: pathResourceId(surface.path),
-    owner_todo_id: surface.owner_task_ids[0],
-    access_kind: 'own',
-  })));
-
-  // 競合辺は消える側だけを載せる。変換で新しい競合を作っていないことは
-  // 五条件のoverlap_reduced（plan全体の競合対が増えない）が既に見ている。
-  const removedEdges = [];
-  for (let left = 0; left < conflict.taskIds.length; left += 1) {
-    for (let right = left + 1; right < conflict.taskIds.length; right += 1) {
-      const pair = [conflict.taskIds[left], conflict.taskIds[right]].sort(compareText);
-      removedEdges.push({ from_todo_id: pair[0], to_todo_id: pair[1], kind: 'conflict' });
-    }
-  }
-
-  const split = sealed({
-    schema: 'lattice.runtime_seam_split.v1',
-    finding_digest: conflict.findingDigest,
-    predecessor_task_ids: [...conflict.taskIds].sort(compareText),
-    task_migration_digest: taskMigrationDigest,
-    ownership_diff: sealed({
-      schema: 'lattice.runtime_ownership_diff.v1', added, removed, diff_digest: '',
-    }, 'diff_digest'),
-    edge_diff: sealed({
-      schema: 'lattice.runtime_edge_diff.v1',
-      added: [], removed: canonicalSort(removedEdges), diff_digest: '',
-    }, 'diff_digest'),
-    verifier_refs: [...new Set(verifierRefs)].sort(compareText),
-    split_digest: '',
-  }, 'split_digest');
-  return { split, reasons: [] };
-}
-
-/**
- * 実行時競合の処置を決める。
- *
- * 事前宣言された処置があればそれを使う。無ければ**その場で変換候補を導出して適用を試みる**——
- * ここが請求項8の一手で、従来は事前宣言が無い競合をすべて意図的直列へ倒していた。
- *
- * 変換は五条件を通ったときだけ処置になる。1つでも欠けたら意図的直列へ送り、欠けた条件を残す。
- * 「実行時だから緩める」ことをしない——緩めると、外部挙動を変えうる変更が便益の証明なしに
- * 実行中のrunへ入る。
- */
-export async function resolveRuntimeSeamTreatment(options = {}) {
-  const {
-    finding, witnessSet, pathNames = {}, predeclaredTreatments = [],
-    applyConflict, commitTransform, baseSha, manifestDigest, affectedTests = [],
-    taskMigrationDigest, recordedFindingDigest = null,
-  } = options;
-
-  if (finding?.kind === 'observed_write_conflict' && typeof finding.path === 'string') {
-    for (const treatment of predeclaredTreatments) {
-      if (Array.isArray(treatment.covered_paths) && treatment.covered_paths.includes(finding.path)) {
-        return { lane: 'seam_transform', treatment: structuredClone(treatment), split: null, reasons: [] };
-      }
-    }
-  }
-
-  const { conflict, reasons } = seamConflictFromFinding({
-    finding, witnessSet, pathNames, affectedTests, baseSha, manifestDigest,
-    recordedFindingDigest,
-  });
-  if (conflict === null) {
-    return { lane: 'intentional_serial', treatment: null, split: null, reasons };
-  }
-  if (typeof applyConflict !== 'function') {
-    return {
-      lane: 'intentional_serial', treatment: null, split: null, reasons: ['applier_absent'],
-    };
-  }
-
-  const applied = await applyConflict({ conflict });
-  if (applied?.outcome?.decision === 'accepted' && typeof commitTransform !== 'function') {
-    // 確定する手段が無いまま採用すると、splitは所有を宣言するのに再開先へその成果が無い。
-    // 「変換した」と言いながら再開できない状態を作らない（ADR 0141）。
-    return {
-      lane: 'intentional_serial', treatment: null, split: null, reasons: ['committer_absent'],
-    };
-  }
-  if (applied?.outcome?.decision !== 'accepted') {
-    return {
-      lane: 'intentional_serial',
-      treatment: null,
-      split: null,
-      reasons: [...(applied?.outcome?.reasons ?? ['transform_rejected'])],
-    };
-  }
-
-  const built = buildRuntimeSeamSplit({
-    conflict,
-    candidate: applied.candidate ?? { surfaces: applied.outcome.surfaces ?? [] },
-    taskMigrationDigest,
-    verifierRefs: affectedTests,
-  });
-  if (built.split === null) {
-    return { lane: 'intentional_serial', treatment: null, split: null, reasons: built.reasons };
-  }
-  // 再開先が実在するbaseを要る。branchを動かさずcommitとして確定し、そのshaを後継planへ渡す。
-  const committed = await commitTransform({
-    conflict, files: applied.files ?? {}, candidateId: conflict.candidateId,
-  });
-  if (!/^[0-9a-f]{40}$/u.test(committed?.commitSha ?? '')) {
-    return {
-      lane: 'intentional_serial', treatment: null, split: null, reasons: ['transform_not_committed'],
-    };
-  }
-  return {
-    lane: 'seam_transform',
-    treatment: {
-      covered_paths: [conflict.sourcePath],
-      candidate_digest: applied.outcome.candidate_digest,
-    },
-    split: built.split,
-    files: applied.files ?? null,
-    successor_base_sha: committed.commitSha,
-    successor_base_ref: committed.ref ?? null,
-    reasons: [],
-  };
-}
+/**
+ * 実行時競合を、実際の変換で解消する処置へ変える（請求項8・ADR 0137〜0139）。
+ *
+ * 実行時の入力は観測である。どのpathでどの2 taskがぶつかったかは`detectCheckpointFindings`が
+ * 実際に変更された資源から返すので、ここで影響範囲を探し直さない。
+ *
+ * 変換の導出はbase状態に対して行う。holdされたTODOは再計画で旧contextを失効させられ、
+ * 新plan_ref由来のpacketで再開するため、進行中の編集は設計上そこで捨てられる。
+ * `head_sha`が効くのは止めずに継続するcarry-over側であり、held側ではない。
+ */
+
+import { createHash } from 'node:crypto';
+
+import { canonicalizeArtifact } from './artifact-contracts.mjs';
+import { selfDigest } from './runtime-contracts.mjs';
+import { seamConflictFromFinding } from './seam-apply.mjs';
+
+const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const sha16 = (value) => createHash('sha256').update(value, 'utf8').digest('hex').slice(0, 16);
+
+/** 資源idはidentifier規律なのでpathをそのまま使えない。boundary compilerと同じ合成形にする。 */
+export function pathResourceId(target) {
+  return `own-path-${sha16(target)}`;
+}
+
+function sealed(value, field) {
+  const record = { ...value, [field]: '' };
+  record[field] = selfDigest(record, field);
+  return record;
+}
+
+function canonicalSort(entries) {
+  return [...entries].sort((left, right) => compareText(
+    canonicalizeArtifact(left), canonicalizeArtifact(right),
+  ));
+}
+
+/**
+ * 採用された変換から、再計画が読む`lattice.runtime_seam_split.v1`を組む。
+ *
+ * 所有の差分は「係争資源の所有を降りて、自分の新資源を所有する」である。競合辺は消える——
+ * それが変換の目的であり、消えていなければ五条件のoverlap_reducedが通っていない。
+ */
+export function buildRuntimeSeamSplit({
+  conflict, candidate, taskMigrationDigest, verifierRefs = [],
+} = {}) {
+  const owned = (candidate?.surfaces ?? []).filter(({ role }) => role === 'task_owned');
+  if (owned.length < 2) return { split: null, reasons: ['owned_surfaces_below_two'] };
+  const sourceResource = pathResourceId(conflict.sourcePath);
+
+  const removed = canonicalSort(conflict.taskIds.map((taskId) => ({
+    resource_id: sourceResource, owner_todo_id: taskId, access_kind: 'own',
+  })));
+  const added = canonicalSort(owned.map((surface) => ({
+    resource_id: pathResourceId(surface.path),
+    owner_todo_id: surface.owner_task_ids[0],
+    access_kind: 'own',
+  })));
+
+  // 競合辺は消える側だけを載せる。変換で新しい競合を作っていないことは
+  // 五条件のoverlap_reduced（plan全体の競合対が増えない）が既に見ている。
+  const removedEdges = [];
+  for (let left = 0; left < conflict.taskIds.length; left += 1) {
+    for (let right = left + 1; right < conflict.taskIds.length; right += 1) {
+      const pair = [conflict.taskIds[left], conflict.taskIds[right]].sort(compareText);
+      removedEdges.push({ from_todo_id: pair[0], to_todo_id: pair[1], kind: 'conflict' });
+    }
+  }
+
+  const split = sealed({
+    schema: 'lattice.runtime_seam_split.v1',
+    finding_digest: conflict.findingDigest,
+    predecessor_task_ids: [...conflict.taskIds].sort(compareText),
+    task_migration_digest: taskMigrationDigest,
+    ownership_diff: sealed({
+      schema: 'lattice.runtime_ownership_diff.v1', added, removed, diff_digest: '',
+    }, 'diff_digest'),
+    edge_diff: sealed({
+      schema: 'lattice.runtime_edge_diff.v1',
+      added: [], removed: canonicalSort(removedEdges), diff_digest: '',
+    }, 'diff_digest'),
+    verifier_refs: [...new Set(verifierRefs)].sort(compareText),
+    split_digest: '',
+  }, 'split_digest');
+  return { split, reasons: [] };
+}
+
+/**
+ * 実行時競合の処置を決める。
+ *
+ * 事前宣言された処置があればそれを使う。無ければ**その場で変換候補を導出して適用を試みる**——
+ * ここが請求項8の一手で、従来は事前宣言が無い競合をすべて意図的直列へ倒していた。
+ *
+ * 変換は五条件を通ったときだけ処置になる。1つでも欠けたら意図的直列へ送り、欠けた条件を残す。
+ * 「実行時だから緩める」ことをしない——緩めると、外部挙動を変えうる変更が便益の証明なしに
+ * 実行中のrunへ入る。
+ */
+export async function resolveRuntimeSeamTreatment(options = {}) {
+  const {
+    finding, witnessSet, pathNames = {}, predeclaredTreatments = [],
+    applyConflict, commitTransform, baseSha, manifestDigest, affectedTests = [],
+    taskMigrationDigest, recordedFindingDigest = null,
+  } = options;
+
+  if (finding?.kind === 'observed_write_conflict' && typeof finding.path === 'string') {
+    for (const treatment of predeclaredTreatments) {
+      if (Array.isArray(treatment.covered_paths) && treatment.covered_paths.includes(finding.path)) {
+        return { lane: 'seam_transform', treatment: structuredClone(treatment), split: null, reasons: [] };
+      }
+    }
+  }
+
+  const { conflict, reasons } = seamConflictFromFinding({
+    finding, witnessSet, pathNames, affectedTests, baseSha, manifestDigest,
+    recordedFindingDigest,
+  });
+  if (conflict === null) {
+    return { lane: 'intentional_serial', treatment: null, split: null, reasons };
+  }
+  if (typeof applyConflict !== 'function') {
+    return {
+      lane: 'intentional_serial', treatment: null, split: null, reasons: ['applier_absent'],
+    };
+  }
+
+  const applied = await applyConflict({ conflict });
+  if (applied?.outcome?.decision === 'accepted' && typeof commitTransform !== 'function') {
+    // 確定する手段が無いまま採用すると、splitは所有を宣言するのに再開先へその成果が無い。
+    // 「変換した」と言いながら再開できない状態を作らない（ADR 0141）。
+    return {
+      lane: 'intentional_serial', treatment: null, split: null, reasons: ['committer_absent'],
+    };
+  }
+  if (applied?.outcome?.decision !== 'accepted') {
+    return {
+      lane: 'intentional_serial',
+      treatment: null,
+      split: null,
+      reasons: [...(applied?.outcome?.reasons ?? ['transform_rejected'])],
+    };
+  }
+
+  const built = buildRuntimeSeamSplit({
+    conflict,
+    candidate: applied.candidate ?? { surfaces: applied.outcome.surfaces ?? [] },
+    taskMigrationDigest,
+    verifierRefs: affectedTests,
+  });
+  if (built.split === null) {
+    return { lane: 'intentional_serial', treatment: null, split: null, reasons: built.reasons };
+  }
+  // 再開先が実在するbaseを要る。branchを動かさずcommitとして確定し、そのshaを後継planへ渡す。
+  const committed = await commitTransform({
+    conflict, files: applied.files ?? {}, candidateId: conflict.candidateId,
+  });
+  if (!/^[0-9a-f]{40}$/u.test(committed?.commitSha ?? '')) {
+    return {
+      lane: 'intentional_serial', treatment: null, split: null, reasons: ['transform_not_committed'],
+    };
+  }
+  return {
+    lane: 'seam_transform',
+    treatment: {
+      covered_paths: [conflict.sourcePath],
+      candidate_digest: applied.outcome.candidate_digest,
+    },
+    split: built.split,
+    files: applied.files ?? null,
+    successor_base_sha: committed.commitSha,
+    successor_base_ref: committed.ref ?? null,
+    reasons: [],
+  };
+}

package/src/runtime-socket-owner.mjs

@@ -1,125 +1,125 @@
-/**
- * unix domain socketの所有関係をOS非依存に観測する。
- *
- * 管理runtimeは「そのPIDが本当にそのcontrol socketを持っているか」を確かめてから接続する。
- * この検査は成りすましたsocketへ繋がないための要であり、緩めない。
- *
- * 実装は`/usr/sbin/lsof`をhard-codeしていた。**これはmacOS専用のpathで、Linuxでは管理runtime
- * が丸ごと動かなかった**（CIで実測：実daemonを起動するtestが軒並み`socket owner観測失敗`で
- * 落ちていた）。移植性の欠陥であってtestの都合ではない。
- *
- * Linuxには`/proc`という一次情報があるので、外部commandを介さずに同じことが分かる。
- * `/proc/<pid>/fd/*`のsymlinkが`socket:[inode]`を指し、`/proc/net/unix`がinodeとpathを結ぶ。
- * lsofを持たない最小構成のcontainerでも動くので、Linuxでは`/proc`を優先する。
- *
- * どちらの手段でも観測できない環境では、**観測できたことにしない**。呼び出し側がfail closed
- * するために、例外を投げるか空を返す（「所有していない」ではなく「分からない」を返さない設計に
- * するため、判定は必ず呼び出し側の`some(...)`で行う）。
- */
-
-import { execFile } from 'node:child_process';
-import { readdir, readFile, readlink } from 'node:fs/promises';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFile);
-
-/** lsofの絶対path候補。PATHは引かない——探索経路を広げるとsocket検査の前提が緩む。 */
-const LSOF_PATHS = Object.freeze(['/usr/sbin/lsof', '/usr/bin/lsof', '/bin/lsof']);
-
-const SOCKET_INODE = /^socket:\[(\d+)\]$/u;
-
-async function runLsof(args) {
-  let lastError = new Error('lsof not found');
-  for (const binary of LSOF_PATHS) {
-    try {
-      const { stdout } = await execFileAsync(binary, args, { encoding: 'utf8' });
-      return stdout;
-    } catch (error) {
-      // ENOENTは「その場所に無い」だけなので次の候補へ。
-      if (error?.code === 'ENOENT') { lastError = error; continue; }
-      // lsofは該当が無いとexit 1を返す。これは観測の失敗ではなく「所有者なし」である。
-      // ここを潰すと、誰も掴んでいないstale socketが観測失敗として扱われ、正常な後片付けが
-      // 止まる（元の呼び出し側も同じ区別をしていた）。
-      if (error?.code === 1 && String(error?.stdout ?? '').trim() === '') return '';
-      throw error;
-    }
-  }
-  throw lastError;
-}
-
-/** `/proc/<pid>/fd`からunix socketのinodeを集める。Linux専用。 */
-async function procSocketInodes(pid) {
-  const entries = await readdir(`/proc/${pid}/fd`);
-  const inodes = new Set();
-  for (const entry of entries) {
-    let target;
-    try { target = await readlink(`/proc/${pid}/fd/${entry}`); } catch { continue; }
-    const matched = SOCKET_INODE.exec(target);
-    if (matched !== null) inodes.add(matched[1]);
-  }
-  return inodes;
-}
-
-/** `/proc/net/unix`を読み、inode -> pathの対応を返す。 */
-async function procUnixSocketPaths() {
-  const text = await readFile('/proc/net/unix', 'utf8');
-  const byInode = new Map();
-  for (const line of text.split('\n').slice(1)) {
-    // Num RefCount Protocol Flags Type St Inode Path
-    const fields = line.trim().split(/\s+/u);
-    if (fields.length < 8) continue;
-    const inode = fields[6];
-    const socketPath = fields.slice(7).join(' ');
-    if (socketPath.length === 0) continue;
-    if (!byInode.has(inode)) byInode.set(inode, []);
-    byInode.get(inode).push(socketPath);
-  }
-  return byInode;
-}
-
-/**
- * 指定PIDが開いているunix socketのpath一覧を返す。
- *
- * @returns {Promise<string[]>} 観測できたpath。観測手段が無ければthrowする。
- */
-export async function socketPathsOwnedByPid(pid) {
-  if (process.platform === 'linux') {
-    const inodes = await procSocketInodes(pid);
-    if (inodes.size === 0) return [];
-    const byInode = await procUnixSocketPaths();
-    return [...inodes].flatMap((inode) => byInode.get(inode) ?? []);
-  }
-  const stdout = await runLsof(['-a', '-p', String(pid), '-U', '-F', 'fn']);
-  return stdout.split('\n')
-    .filter((line) => line.startsWith('n'))
-    .map((line) => line.slice(1));
-}
-
-/**
- * 指定socket pathを開いているPID一覧を返す。
- *
- * @returns {Promise<number[]>} 観測できたPID。観測手段が無ければthrowする。
- */
-export async function pidsOwningSocketPath(socketPath) {
-  if (process.platform === 'linux') {
-    const byInode = await procUnixSocketPaths();
-    const wanted = new Set();
-    for (const [inode, paths] of byInode) {
-      if (paths.includes(socketPath)) wanted.add(inode);
-    }
-    if (wanted.size === 0) return [];
-    const pids = new Set();
-    for (const entry of await readdir('/proc')) {
-      if (!/^\d+$/u.test(entry)) continue;
-      let inodes;
-      // 他ユーザーのprocessは読めない。読めないものを「所有していない」へ丸めるが、
-      // これはlsofが権限不足で黙るのと同じ性質であり、判定は所有を**肯定**する側でのみ使う。
-      try { inodes = await procSocketInodes(entry); } catch { continue; }
-      if ([...wanted].some((inode) => inodes.has(inode))) pids.add(Number(entry));
-    }
-    return [...pids];
-  }
-  const stdout = await runLsof(['-t', socketPath]);
-  return stdout.split('\n').map((line) => line.trim())
-    .filter((line) => /^\d+$/u.test(line)).map(Number);
-}
+/**
+ * unix domain socketの所有関係をOS非依存に観測する。
+ *
+ * 管理runtimeは「そのPIDが本当にそのcontrol socketを持っているか」を確かめてから接続する。
+ * この検査は成りすましたsocketへ繋がないための要であり、緩めない。
+ *
+ * 実装は`/usr/sbin/lsof`をhard-codeしていた。**これはmacOS専用のpathで、Linuxでは管理runtime
+ * が丸ごと動かなかった**（CIで実測：実daemonを起動するtestが軒並み`socket owner観測失敗`で
+ * 落ちていた）。移植性の欠陥であってtestの都合ではない。
+ *
+ * Linuxには`/proc`という一次情報があるので、外部commandを介さずに同じことが分かる。
+ * `/proc/<pid>/fd/*`のsymlinkが`socket:[inode]`を指し、`/proc/net/unix`がinodeとpathを結ぶ。
+ * lsofを持たない最小構成のcontainerでも動くので、Linuxでは`/proc`を優先する。
+ *
+ * どちらの手段でも観測できない環境では、**観測できたことにしない**。呼び出し側がfail closed
+ * するために、例外を投げるか空を返す（「所有していない」ではなく「分からない」を返さない設計に
+ * するため、判定は必ず呼び出し側の`some(...)`で行う）。
+ */
+
+import { execFile } from 'node:child_process';
+import { readdir, readFile, readlink } from 'node:fs/promises';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+/** lsofの絶対path候補。PATHは引かない——探索経路を広げるとsocket検査の前提が緩む。 */
+const LSOF_PATHS = Object.freeze(['/usr/sbin/lsof', '/usr/bin/lsof', '/bin/lsof']);
+
+const SOCKET_INODE = /^socket:\[(\d+)\]$/u;
+
+async function runLsof(args) {
+  let lastError = new Error('lsof not found');
+  for (const binary of LSOF_PATHS) {
+    try {
+      const { stdout } = await execFileAsync(binary, args, { encoding: 'utf8' });
+      return stdout;
+    } catch (error) {
+      // ENOENTは「その場所に無い」だけなので次の候補へ。
+      if (error?.code === 'ENOENT') { lastError = error; continue; }
+      // lsofは該当が無いとexit 1を返す。これは観測の失敗ではなく「所有者なし」である。
+      // ここを潰すと、誰も掴んでいないstale socketが観測失敗として扱われ、正常な後片付けが
+      // 止まる（元の呼び出し側も同じ区別をしていた）。
+      if (error?.code === 1 && String(error?.stdout ?? '').trim() === '') return '';
+      throw error;
+    }
+  }
+  throw lastError;
+}
+
+/** `/proc/<pid>/fd`からunix socketのinodeを集める。Linux専用。 */
+async function procSocketInodes(pid) {
+  const entries = await readdir(`/proc/${pid}/fd`);
+  const inodes = new Set();
+  for (const entry of entries) {
+    let target;
+    try { target = await readlink(`/proc/${pid}/fd/${entry}`); } catch { continue; }
+    const matched = SOCKET_INODE.exec(target);
+    if (matched !== null) inodes.add(matched[1]);
+  }
+  return inodes;
+}
+
+/** `/proc/net/unix`を読み、inode -> pathの対応を返す。 */
+async function procUnixSocketPaths() {
+  const text = await readFile('/proc/net/unix', 'utf8');
+  const byInode = new Map();
+  for (const line of text.split('\n').slice(1)) {
+    // Num RefCount Protocol Flags Type St Inode Path
+    const fields = line.trim().split(/\s+/u);
+    if (fields.length < 8) continue;
+    const inode = fields[6];
+    const socketPath = fields.slice(7).join(' ');
+    if (socketPath.length === 0) continue;
+    if (!byInode.has(inode)) byInode.set(inode, []);
+    byInode.get(inode).push(socketPath);
+  }
+  return byInode;
+}
+
+/**
+ * 指定PIDが開いているunix socketのpath一覧を返す。
+ *
+ * @returns {Promise<string[]>} 観測できたpath。観測手段が無ければthrowする。
+ */
+export async function socketPathsOwnedByPid(pid) {
+  if (process.platform === 'linux') {
+    const inodes = await procSocketInodes(pid);
+    if (inodes.size === 0) return [];
+    const byInode = await procUnixSocketPaths();
+    return [...inodes].flatMap((inode) => byInode.get(inode) ?? []);
+  }
+  const stdout = await runLsof(['-a', '-p', String(pid), '-U', '-F', 'fn']);
+  return stdout.split('\n')
+    .filter((line) => line.startsWith('n'))
+    .map((line) => line.slice(1));
+}
+
+/**
+ * 指定socket pathを開いているPID一覧を返す。
+ *
+ * @returns {Promise<number[]>} 観測できたPID。観測手段が無ければthrowする。
+ */
+export async function pidsOwningSocketPath(socketPath) {
+  if (process.platform === 'linux') {
+    const byInode = await procUnixSocketPaths();
+    const wanted = new Set();
+    for (const [inode, paths] of byInode) {
+      if (paths.includes(socketPath)) wanted.add(inode);
+    }
+    if (wanted.size === 0) return [];
+    const pids = new Set();
+    for (const entry of await readdir('/proc')) {
+      if (!/^\d+$/u.test(entry)) continue;
+      let inodes;
+      // 他ユーザーのprocessは読めない。読めないものを「所有していない」へ丸めるが、
+      // これはlsofが権限不足で黙るのと同じ性質であり、判定は所有を**肯定**する側でのみ使う。
+      try { inodes = await procSocketInodes(entry); } catch { continue; }
+      if ([...wanted].some((inode) => inodes.has(inode))) pids.add(Number(entry));
+    }
+    return [...pids];
+  }
+  const stdout = await runLsof(['-t', socketPath]);
+  return stdout.split('\n').map((line) => line.trim())
+    .filter((line) => /^\d+$/u.test(line)).map(Number);
+}