@work-graph/cli 0.2.0

package/vendor/src/pvrgTaskScope.mjs

@@ -0,0 +1,152 @@
+import { buildUnifiedLinkageProjectionV1 } from './unifiedLinkageProjection.mjs';
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+const EXPAND_RELATIONS = new Set(['targets', 'depends_on', 'references', 'verifies', 'edits']);
+const DEFAULT_MAX_NODES = 24;
+const DEFAULT_MAX_DEPTH = 2;
+
+function nodeKey(node) {
+  return `${node.kind}:${node.id}`;
+}
+
+function workNode(item) {
+  return {
+    kind: 'work',
+    id: item.id,
+    title: item.title,
+    status: item.status,
+    targetFiles: [...(item.targetFiles ?? [])].sort(compareText),
+    traceStatus: item.traceStatus ?? '',
+  };
+}
+
+function fileNode(path) {
+  return {
+    kind: 'file',
+    id: path,
+    path,
+  };
+}
+
+function extractFilePath(link) {
+  if (link.to.kind === 'file') {
+    return link.to.id;
+  }
+
+  if ((link.to.kind === 'symbol' || link.to.kind === 'range') && link.to.locator?.path) {
+    return link.to.locator.path;
+  }
+
+  return null;
+}
+
+export function buildPvrgTaskScopeSlice(items, taskId, options = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const itemById = new Map(items.map((item) => [item.id, item]));
+  const task = itemById.get(taskId);
+  if (task === undefined) {
+    throw new Error(`unknown task id: ${taskId}`);
+  }
+
+  const maxNodes = Number.isInteger(options.maxNodes) && options.maxNodes > 0 ? options.maxNodes : DEFAULT_MAX_NODES;
+  const maxDepth = Number.isInteger(options.maxDepth) && options.maxDepth >= 0 ? options.maxDepth : DEFAULT_MAX_DEPTH;
+  const linkage = options.linkage ?? buildUnifiedLinkageProjectionV1(items, options);
+
+  const nodes = new Map([[nodeKey(workNode(task)), workNode(task)]]);
+  const edges = [];
+  const queue = [{ workId: task.id, depth: 0 }];
+  const visitedWork = new Set([task.id]);
+
+  while (queue.length > 0 && nodes.size < maxNodes) {
+    const current = queue.shift();
+    const currentItem = itemById.get(current.workId);
+    if (currentItem === undefined) {
+      continue;
+    }
+
+    for (const path of currentItem.targetFiles ?? []) {
+      const file = fileNode(path);
+      nodes.set(nodeKey(file), file);
+      edges.push({
+        from: { kind: 'work', id: current.workId },
+        to: { kind: 'file', id: path },
+        relation: 'targets',
+        source: 'work.target_files',
+        confidence: 'low',
+      });
+    }
+
+    for (const link of linkage.links) {
+      if (link.sourceWorkId !== current.workId && link.from.id !== current.workId) {
+        continue;
+      }
+
+      if (!EXPAND_RELATIONS.has(link.relation)) {
+        continue;
+      }
+
+      edges.push({
+        from: link.from,
+        to: link.to,
+        relation: link.relation,
+        source: link.sourceLabel ?? link.source,
+        confidence: link.confidence,
+      });
+
+      const filePath = extractFilePath(link);
+      if (filePath !== null && nodes.size < maxNodes) {
+        nodes.set(nodeKey(fileNode(filePath)), fileNode(filePath));
+      }
+
+      if (link.to.kind === 'work' && current.depth < maxDepth && !visitedWork.has(link.to.id) && nodes.size < maxNodes) {
+        const related = itemById.get(link.to.id);
+        if (related !== undefined) {
+          visitedWork.add(link.to.id);
+          nodes.set(nodeKey(workNode(related)), workNode(related));
+          queue.push({ workId: link.to.id, depth: current.depth + 1 });
+        }
+      }
+    }
+
+    for (const dependencyId of currentItem.dependsOn ?? []) {
+      const dependency = itemById.get(dependencyId);
+      if (dependency === undefined) {
+        continue;
+      }
+
+      nodes.set(nodeKey(workNode(dependency)), workNode(dependency));
+      edges.push({
+        from: { kind: 'work', id: current.workId },
+        to: { kind: 'work', id: dependencyId },
+        relation: 'depends_on',
+        source: 'work.depends_on',
+        confidence: 'high',
+      });
+
+      if (current.depth < maxDepth && !visitedWork.has(dependencyId) && nodes.size < maxNodes) {
+        visitedWork.add(dependencyId);
+        queue.push({ workId: dependencyId, depth: current.depth + 1 });
+      }
+    }
+  }
+
+  const sortedNodes = [...nodes.values()].sort((left, right) => compareText(nodeKey(left), nodeKey(right)));
+  const sortedEdges = edges.sort((left, right) =>
+    compareText(`${left.from.kind}:${left.from.id}\0${left.relation}\0${left.to.kind}:${left.to.id}`, `${right.from.kind}:${right.from.id}\0${right.relation}\0${right.to.kind}:${right.to.id}`),
+  );
+
+  return {
+    schema: 'pvrg.task-scope.slice.v1',
+    seedWorkId: taskId,
+    maxNodes,
+    maxDepth,
+    truncated: nodes.size >= maxNodes,
+    nodeCount: sortedNodes.length,
+    edgeCount: sortedEdges.length,
+    nodes: sortedNodes.slice(0, maxNodes),
+    edges: sortedEdges,
+  };
+}

package/vendor/src/releaseGateMatrix.mjs

@@ -0,0 +1,188 @@
+import { VERIFICATION_MATRIX } from './verificationLoop.mjs';
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export const RELEASE_GATE_TIERS = ['mandatory', 'mandatory-integration', 'optional-env', 'optional-llm'];
+
+export const RELEASE_GATE_ROWS = [
+  {
+    id: 'deterministic-test-suite',
+    tier: 'mandatory',
+    title: 'Work Graph deterministic test suite',
+    command: 'npm run test:deterministic',
+    registerPhase: 'all',
+    blocksRelease: true,
+  },
+  {
+    id: 'backlog-schema-lint',
+    tier: 'mandatory',
+    title: 'Backlog schema lint',
+    command: 'npm run lint:backlog',
+    registerPhase: 'all',
+    blocksRelease: true,
+  },
+  {
+    id: 'ci-mandatory-bundle',
+    tier: 'mandatory',
+    title: 'CI mandatory bundle (tests + lint)',
+    command: 'npm run ci:mandatory',
+    registerPhase: 'all',
+    blocksRelease: true,
+  },
+  {
+    id: 'daemon-live-loop-integration',
+    tier: 'mandatory-integration',
+    title: 'Daemon tick + live-loop integration fixtures',
+    command: 'tests/workGraphDaemonIntegration.test.mjs',
+    registerPhase: 'phase-2+',
+    blocksRelease: true,
+  },
+  {
+    id: 'intent-tree-parity',
+    tier: 'mandatory-integration',
+    title: 'Intent tree migration snapshot parity',
+    command: 'tests/intentTreeMigration.test.mjs (equivalence)',
+    registerPhase: 'phase-3+',
+    blocksRelease: true,
+  },
+  {
+    id: 'compiler-roundtrip-fixture',
+    tier: 'mandatory-integration',
+    title: 'Compiler round-trip CLI on fixture step',
+    command: 'npm run compiler:roundtrip -- tests/fixtures/compiler-roundtrip/sample.compiler.bvc',
+    registerPhase: 'phase-5+',
+    blocksRelease: true,
+  },
+  {
+    id: 'code-gap-analyzer-fixture',
+    tier: 'mandatory-integration',
+    title: 'Code-gap analyzer CLI on fixture repo',
+    command: 'node --test tests/codeGapAnalyzer.test.mjs',
+    registerPhase: 'phase-5+',
+    blocksRelease: true,
+  },
+  {
+    id: 'onebase-go-optional',
+    tier: 'optional-env',
+    title: 'OneBase go test (environment)',
+    command: 'npm run test:optional:onebase',
+    registerPhase: 'phase-7+',
+    blocksRelease: false,
+  },
+  {
+    id: 'onebase-check-optional',
+    tier: 'optional-env',
+    title: 'OneBase config check (CLI)',
+    command: 'npm run test:optional:onebase-check',
+    registerPhase: 'phase-7+',
+    blocksRelease: false,
+  },
+  {
+    id: 'optional-blocked-onebase-go-preflight',
+    tier: 'optional-env',
+    title: 'OneBase go preflight blocked evidence fixture',
+    command: 'npm run eval:optional:blocked-onebase-go',
+    registerPhase: 'phase-7+',
+    blocksRelease: false,
+  },
+  {
+    id: 'lowcode-verify-optional',
+    tier: 'optional-env',
+    title: 'Low-code arch-rules scaffold verify',
+    command: 'npm run verify:lowcode',
+    registerPhase: 'audit-gap+',
+    blocksRelease: false,
+  },
+  {
+    id: 'golden-path-llm-optional',
+    tier: 'optional-llm',
+    title: 'Golden path LLM eval',
+    command: 'npm run test:optional:golden-path-llm',
+    registerPhase: 'phase-8+',
+    blocksRelease: false,
+  },
+  {
+    id: 'optional-llm-claim-no-eligible',
+    tier: 'optional-llm',
+    title: 'Optional LLM: claim-no-eligible fixture',
+    command: 'npm run eval:optional:claim-no-eligible',
+    registerPhase: 'phase-8+',
+    blocksRelease: false,
+  },
+  {
+    id: 'optional-llm-loop-hint',
+    tier: 'optional-llm',
+    title: 'Optional LLM: loop-hint repeat-tool fixture',
+    command: 'npm run eval:optional:loop-hint',
+    registerPhase: 'phase-8+',
+    blocksRelease: false,
+  },
+  {
+    id: 'optional-llm-live-eval',
+    tier: 'optional-llm',
+    title: 'Live LLM eval (golden path rubric)',
+    command: 'npm run eval:live-llm',
+    registerPhase: 'phase-8+',
+    blocksRelease: false,
+  },
+  {
+    id: 'operator-dashboard-e2e',
+    tier: 'optional-env',
+    title: 'Playwright operator dashboard smoke',
+    command: 'npm run test:e2e',
+    registerPhase: 'phase-10+',
+    blocksRelease: false,
+  },
+  {
+    id: 'optional-gvm-verify',
+    tier: 'optional-env',
+    title: 'Optional GVM verify worker preflight stub',
+    command: 'npm run eval:optional:gvm-verify',
+    registerPhase: 'phase-11+',
+    blocksRelease: false,
+  },
+  {
+    id: 'gbc-module-slice-pilot',
+    tier: 'optional-env',
+    title: 'GBC module slice pilot probe (read-only)',
+    command: 'npm run probe:gbc-module-slice-pilot',
+    registerPhase: 'phase-11+',
+    blocksRelease: false,
+  },
+];
+
+export function buildReleaseGateMatrix() {
+  const rows = [...RELEASE_GATE_ROWS].sort((left, right) => compareText(left.id, right.id));
+  const byTier = Object.fromEntries(
+    RELEASE_GATE_TIERS.map((tier) => [tier, rows.filter((row) => row.tier === tier)]),
+  );
+
+  return {
+    schema: 'workgraph.release.gate.matrix.v1',
+    tiers: [...RELEASE_GATE_TIERS],
+    rows,
+    byTier,
+    verificationMatrix: VERIFICATION_MATRIX,
+    policy: {
+      mandatoryCommand: 'npm run ci:mandatory',
+      deterministicCommand: 'npm run test:deterministic',
+      backlogLintCommand: 'npm run lint:backlog',
+      optionalEnvCommand: 'npm run test:optional:onebase',
+      optionalBlockedOnebaseGoCommand: 'npm run eval:optional:blocked-onebase-go',
+      optionalBlockedOnebaseGoEnv: 'Deterministic stub; no Go toolchain or live LLM required',
+      optionalLlmCommands: [
+        'npm run test:optional:golden-path-llm',
+        'npm run eval:optional:claim-no-eligible',
+        'npm run eval:optional:loop-hint',
+        'npm run eval:live-llm',
+      ],
+      optionalLlmCommand: 'npm run test:optional:golden-path-llm',
+      optionalE2eCommand: 'npm run test:e2e',
+      optionalE2eEnv: 'IOHASC_E2E_REAL_LLM not required; Playwright uses isolated fixture via WORKGRAPH_E2E_ROOT',
+      optionalGvmVerifyCommand: 'npm run eval:optional:gvm-verify',
+      optionalGvmVerifyEnv: 'IOHASC_GVM_VERIFY=1 enables stub preflight; skips when .iohasc/cache wasm slices missing',
+      optionalGbcPilotCommand: 'npm run probe:gbc-module-slice-pilot',
+      modelQualityNeverBlocksMandatory: true,
+    },
+  };
+}

package/vendor/src/schematicView.mjs

@@ -0,0 +1,305 @@
+import {
+  GRAPH_CANVAS_VIEW_FULL,
+  GRAPH_CANVAS_VIEW_PIPELINE,
+  SCHEMATIC_LAYOUT_PROFILE,
+  SCHEMATIC_PIPELINE_LAYOUT_PROFILE,
+  filterGraphForViewMode,
+  placeGraphCanvasNodes,
+  resolveLayoutProfileForViewMode,
+} from './graphCanvasLayout.mjs';
+
+export { GRAPH_CANVAS_VIEW_FULL, GRAPH_CANVAS_VIEW_PIPELINE };
+
+const NODE_WIDTH = 232;
+const NODE_MIN_HEIGHT = 112;
+const COL_GAP = 72;
+const ROW_GAP = 96;
+const OFFSET_X = 40;
+const OFFSET_Y = 40;
+const NODE_PADDING_X = 28;
+const HEADER_BLOCK_HEIGHT = 54;
+const SUMMARY_LINE_HEIGHT = 22;
+const SUMMARY_CHARS_PER_LINE = 26;
+
+const GRID_CONFIG = {
+  nodeWidth: NODE_WIDTH,
+  nodeMinHeight: NODE_MIN_HEIGHT,
+  colGap: COL_GAP,
+  rowGap: ROW_GAP,
+  offsetX: OFFSET_X,
+  offsetY: OFFSET_Y,
+};
+
+/** @typedef {{ id: string, title: string, summary: string, layer: string, action?: string, target?: string, protocolPath?: string }} SchematicNodeDef */
+/** @typedef {{ id: string, from: string, to: string, type: string, label: string, upstream?: boolean }} SchematicEdgeDef */
+
+/** @type {SchematicNodeDef[]} */
+export const SCHEMATIC_NODE_DEFS = [
+  {
+    id: 'intent-tree',
+    title: 'Дерево intent',
+    summary: 'Каноничная раскладка .bvc атомов: корни intent, протоколы и задачи как устойчивая поверхность авторинга.',
+    layer: 'авторинг',
+    protocolPath: 'intent/index.bvc',
+  },
+  {
+    id: 'work-graph',
+    title: 'Work Graph',
+    summary: 'Источник правды runtime: статусы, depends_on, target files, blockers и transition gates.',
+    layer: 'рантайм',
+    action: 'view:board',
+  },
+  {
+    id: 'runner',
+    title: 'Runner задач',
+    summary: 'Производная очередь и локальный запуск worker поверх runnable WorkItem projections.',
+    layer: 'исполнение',
+    protocolPath: 'protocols/agent-worker-adapter.bvc',
+  },
+  {
+    id: 'evidence',
+    title: 'Доказательства',
+    summary: 'Записи проверок, worker runs, blockers и gate outcomes, связанные с WorkItems.',
+    layer: 'проверка',
+    protocolPath: 'protocols/evidence-model-v1.bvc',
+  },
+  {
+    id: 'memory',
+    title: 'Память проекта',
+    summary: 'Устойчивые решения, инварианты и факты, извлечённые из done work и operator review.',
+    layer: 'память',
+    protocolPath: 'protocols/project-memory-v1.bvc',
+  },
+  {
+    id: 'graph-rag',
+    title: 'Graph / RAG',
+    summary: 'Производный context slice поверх Work Graph, доказательств, памяти и adapter facts для retrieval.',
+    layer: 'проекция',
+    action: 'view:board',
+    protocolPath: 'protocols/pvrg-graph-rag-minimal.bvc',
+  },
+  {
+    id: 'ui',
+    title: 'UI оператора',
+    summary: 'Доска, backlog, architecture map, schematic view и task detail drawer для operator loop.',
+    layer: 'проекция',
+    action: 'view:board',
+    protocolPath: 'ui/operator-dashboard.bvc',
+  },
+  {
+    id: 'domains',
+    title: 'Домены',
+    summary: 'L1 hub прикладных verticals: OneBase и Marketplace (L2) с maps_to на Work Graph.',
+    layer: 'домен',
+    protocolPath: 'intent/domains',
+  },
+  {
+    id: 'storage',
+    title: 'Хранилище / Snapshot',
+    summary: '.bvc canon и deterministic JSON exports, пересобираемые для dashboard, worker и tests.',
+    layer: 'хранилище',
+    protocolPath: 'work/backlog.bvc',
+  },
+];
+
+/** @type {SchematicEdgeDef[]} */
+export const SCHEMATIC_EDGE_DEFS = [
+  { id: 'intent-work', from: 'intent-tree', to: 'work-graph', type: 'feeds', label: 'питает' },
+  { id: 'work-runner', from: 'work-graph', to: 'runner', type: 'uses', label: 'использует' },
+  { id: 'runner-evidence', from: 'runner', to: 'evidence', type: 'feeds', label: 'пишет' },
+  { id: 'evidence-work', from: 'evidence', to: 'work-graph', type: 'validates', label: 'проверяет', upstream: true },
+  { id: 'evidence-memory', from: 'evidence', to: 'memory', type: 'feeds', label: 'пополняет' },
+  { id: 'memory-graph', from: 'memory', to: 'graph-rag', type: 'feeds', label: 'даёт контекст' },
+  { id: 'graph-ui', from: 'graph-rag', to: 'ui', type: 'feeds', label: 'показывает' },
+  { id: 'work-ui', from: 'work-graph', to: 'ui', type: 'feeds', label: 'показывает' },
+  { id: 'storage-work', from: 'storage', to: 'work-graph', type: 'rebuilds', label: 'пересобирает', upstream: true },
+  { id: 'storage-evidence', from: 'storage', to: 'evidence', type: 'rebuilds', label: 'пересобирает', upstream: true },
+  { id: 'storage-memory', from: 'storage', to: 'memory', type: 'rebuilds', label: 'пересобирает', upstream: true },
+  { id: 'storage-graph', from: 'storage', to: 'graph-rag', type: 'rebuilds', label: 'пересобирает', upstream: true },
+  { id: 'domains-work', from: 'domains', to: 'work-graph', type: 'maps_to', label: 'сопоставляется', upstream: true },
+];
+
+function estimateSummaryLines(summary, width) {
+  const charsPerLine = Math.max(
+    18,
+    Math.floor((width - NODE_PADDING_X) / (NODE_WIDTH / SUMMARY_CHARS_PER_LINE)),
+  );
+  return Math.max(1, Math.ceil(String(summary).length / charsPerLine));
+}
+
+function estimateNodeHeight(summary, width) {
+  const lines = estimateSummaryLines(summary, width);
+  return Math.max(
+    NODE_MIN_HEIGHT,
+    HEADER_BLOCK_HEIGHT + lines * SUMMARY_LINE_HEIGHT + 20,
+  );
+}
+
+/**
+ * @param {object} [options]
+ * @returns {{
+ *   schema: 'schematic.view.v1',
+ *   nodes: Array<SchematicNodeDef & { x: number, y: number, width: number, height: number }>,
+ *   edges: Array<SchematicEdgeDef & { fromNode: object, toNode: object }>,
+ *   width: number,
+ *   height: number,
+ *   viewMode: string,
+ *   layoutProfile: object,
+ * }}
+ */
+export function buildSchematicViewModel(options = {}) {
+  const viewMode = options.viewMode ?? GRAPH_CANVAS_VIEW_FULL;
+  const layoutProfile = options.layoutProfile
+    ?? resolveLayoutProfileForViewMode(viewMode, {
+      full: SCHEMATIC_LAYOUT_PROFILE,
+      pipeline: SCHEMATIC_PIPELINE_LAYOUT_PROFILE,
+    });
+
+  const filtered = filterGraphForViewMode({
+    nodes: SCHEMATIC_NODE_DEFS,
+    nodeIds: SCHEMATIC_NODE_DEFS.map((node) => node.id),
+    edges: SCHEMATIC_EDGE_DEFS,
+    viewMode,
+    pipelineNodeIds: layoutProfile.pipelineNodeIds ?? [],
+  });
+
+  const placed = placeGraphCanvasNodes({
+    items: filtered.nodes,
+    edges: filtered.edges,
+    layoutProfile,
+    estimateSize: (node, slot) => {
+      const colSpan = slot.colSpan ?? 1;
+      const width = NODE_WIDTH * colSpan + COL_GAP * Math.max(0, colSpan - 1);
+      return {
+        width,
+        height: estimateNodeHeight(node.summary, width),
+      };
+    },
+    config: GRID_CONFIG,
+  });
+
+  const nodes = placed.map((node) => ({
+    ...node.item,
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height,
+    col: node.col,
+    row: node.row,
+  }));
+
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const edges = filtered.edges.map((edge) => ({
+    ...edge,
+    fromNode: nodeById.get(edge.from),
+    toNode: nodeById.get(edge.to),
+  }))
+    .filter((edge) => edge.fromNode && edge.toNode)
+    .map((edge) => ({
+      ...edge,
+      geometry: schematicEdgeGeometry(edge),
+    }));
+
+  const maxX = Math.max(...nodes.map((node) => node.x + node.width));
+  const maxY = Math.max(...nodes.map((node) => node.y + node.height));
+
+  return {
+    schema: 'schematic.view.v1',
+    nodes,
+    edges,
+    width: maxX + OFFSET_X,
+    height: maxY + OFFSET_Y,
+    viewMode,
+    layoutProfile,
+  };
+}
+
+function anchorX(node, towardX) {
+  const ratio = (towardX - node.x) / node.width;
+  return node.x + node.width * Math.max(0.12, Math.min(0.88, ratio));
+}
+
+/**
+ * @param {ReturnType<typeof buildSchematicViewModel>['edges'][number]} edge
+ */
+export function schematicEdgeGeometry(edge) {
+  const from = edge.fromNode;
+  const to = edge.toNode;
+  const fromCx = from.x + from.width / 2;
+  const fromCy = from.y + from.height / 2;
+  const toCx = to.x + to.width / 2;
+  const toCy = to.y + to.height / 2;
+  const dx = toCx - fromCx;
+  const dy = toCy - fromCy;
+
+  let startX;
+  let startY;
+  let endX;
+  let endY;
+  let orientation;
+
+  if (from.row !== to.row) {
+    orientation = 'vertical';
+    const startBiasX = anchorX(from, toCx);
+    const endBiasX = anchorX(to, fromCx);
+    if (to.row > from.row) {
+      startX = startBiasX;
+      startY = from.y + from.height;
+      endX = endBiasX;
+      endY = to.y;
+    } else {
+      startX = startBiasX;
+      startY = from.y;
+      endX = endBiasX;
+      endY = to.y + to.height;
+    }
+  } else if (Math.abs(dx) >= Math.abs(dy) * 0.55) {
+    orientation = 'horizontal';
+    if (dx > 0) {
+      startX = from.x + from.width;
+      startY = fromCy;
+      endX = to.x;
+      endY = toCy;
+    } else {
+      startX = from.x;
+      startY = fromCy;
+      endX = to.x + to.width;
+      endY = toCy;
+    }
+  } else {
+    orientation = 'vertical';
+    const startBiasX = anchorX(from, toCx);
+    const endBiasX = anchorX(to, fromCx);
+    if (dy >= 0) {
+      startX = startBiasX;
+      startY = from.y + from.height;
+      endX = endBiasX;
+      endY = to.y;
+    } else {
+      startX = startBiasX;
+      startY = from.y;
+      endX = endBiasX;
+      endY = to.y + to.height;
+    }
+  }
+
+  const bend = Math.max(32, Math.min(88, (Math.abs(dx) + Math.abs(dy)) * 0.22));
+  const d = orientation === 'vertical'
+    ? `M ${startX} ${startY} C ${startX} ${startY + Math.sign(dy || 1) * bend}, ${endX} ${endY - Math.sign(dy || 1) * bend}, ${endX} ${endY}`
+    : (() => {
+      const midX = startX + (endX - startX) / 2;
+      return `M ${startX} ${startY} C ${midX} ${startY}, ${midX} ${endY}, ${endX} ${endY}`;
+    })();
+
+  return {
+    d,
+    startX,
+    startY,
+    endX,
+    endY,
+    orientation,
+    upstream: Boolean(edge.upstream),
+    labelX: (startX + endX) / 2,
+    labelY: orientation === 'horizontal' ? startY - 10 : startY + (endY - startY) / 2,
+  };
+}