@quolu/lattice 0.1.0 → 0.12.2

package/src/runtime-projection.mjs

@@ -178,3 +178,65 @@ export function projectRuntimeState(options = {}) {
     closed,
   };
 }
+
+/**
+ * managed runの一時状態をevent prefixだけから表示用に投影する。
+ *
+ * TODO本体の状態機械とは独立したoverlayであり、hold/carry-over/redispatchを
+ * 相互排他的に保つ。receipt accepted後は運用上の一時状態ではなくなるため
+ * overlayから除く。intake_frozenはevent prefix上の論理状態だけを表し、中央
+ * write gateまで含むmanaged runtimeの実効freeze判定は所有しない。
+ */
+export function projectRuntimeStatusOverlays(options = {}) {
+  if (options === null || typeof options !== 'object' || Array.isArray(options)
+    || !Array.isArray(options.events)) {
+    invalidProjection('eventsの配列が必要');
+  }
+  const { events } = options;
+  // sequence順、未知event、subject等の既存projection契約を先に検証する。
+  const runtimeState = projectRuntimeState({ events });
+  const overlays = new Map();
+
+  const setOverlay = (todoId, state) => {
+    if (typeof todoId !== 'string' || todoId.length === 0) {
+      invalidProjection(`${state} overlayのtodo idが不正`);
+    }
+    overlays.set(todoId, state);
+  };
+
+  for (const event of events) {
+    const todoRef = event.subject?.kind === 'todo' ? event.subject.ref : null;
+    switch (event.kind) {
+      case 'hold_decided':
+        for (const todoId of event.payload?.hold_set ?? []) setOverlay(todoId, 'held');
+        for (const todoId of event.payload?.continue_set ?? []) setOverlay(todoId, 'carry_over');
+        break;
+      case 'carry_over_witnessed':
+      case 'epoch_rebound':
+        if (todoRef === null) invalidProjection(`${event.kind}はtodo subjectが必要`);
+        setOverlay(todoRef, 'carry_over');
+        break;
+      case 'context_invalidated':
+        if (todoRef === null) invalidProjection('context_invalidatedはtodo subjectが必要');
+        if (event.payload?.reauthorized_via === 'epoch_rebind') setOverlay(todoRef, 'carry_over');
+        else if (event.payload?.reauthorized_via === 'redispatch') setOverlay(todoRef, 'redispatch');
+        break;
+      case 'receipt_accepted':
+        if (todoRef === null) invalidProjection('receipt_acceptedはtodo subjectが必要');
+        overlays.delete(todoRef);
+        break;
+      default:
+        break;
+    }
+  }
+
+  const members = (state) => sortedArray(
+    [...overlays.entries()].filter(([, value]) => value === state).map(([todoId]) => todoId),
+  );
+  return {
+    held: members('held'),
+    carry_over: members('carry_over'),
+    redispatch: members('redispatch'),
+    intake_frozen: runtimeState.freeze !== null,
+  };
+}

package/src/seam-transform.mjs

@@ -11,10 +11,11 @@ import {
   validateTransformArtifact,
 } from './artifact-contracts.mjs';
 import { runIsolatedTransform } from './isolation-runner.mjs';
+import { isCanonicalUtcTimestamp } from './timestamp-contract.mjs';
 
 const SHA256 = /^[0-9a-f]{64}$/;
 const SHA1 = /^[0-9a-f]{40}$/;
-const PORTABLE_CODEGRAPH_PROJECTION = 'lattice.codegraph_portable_outcome.v1';
+const PORTABLE_SENSOR_PROJECTION = 'lattice.sensor_portable_outcome.v1';
 const CANDIDATE_ID = 'extract-dispatch-policies';
 const FIXTURE_ENTRY = 'research/fixtures/dispatch-record/src/dispatch-record.mjs';
 const CHANNEL_PATH = 'research/fixtures/dispatch-record/src/dispatch-channel.mjs';
@@ -139,8 +140,8 @@ function portableOutcomeRecord(value) {
     && SHA256.test(value.result_digest);
 }
 
-function assertPortableCodegraphEvidence(codegraph, { querySet, graphEvidence }) {
-  if (!exactRecord(codegraph, [
+function assertPortableLatticeSensorEvidence(sensor, { querySet, graphEvidence }) {
+  if (!exactRecord(sensor, [
     'version',
     'file_count',
     'node_count',
@@ -155,52 +156,52 @@ function assertPortableCodegraphEvidence(codegraph, { querySet, graphEvidence })
     'portable_outcomes_equal',
     'outcomes',
   ])
-    || typeof codegraph.version !== 'string'
-    || codegraph.version.length === 0
-    || !Number.isSafeInteger(codegraph.file_count)
-    || codegraph.file_count <= 0
-    || !Number.isSafeInteger(codegraph.node_count)
-    || codegraph.node_count <= 0
-    || !Number.isSafeInteger(codegraph.edge_count)
-    || codegraph.edge_count <= 0
-    || !exactRecord(codegraph.pending_changes, ['added', 'modified', 'removed'])
-    || Object.values(codegraph.pending_changes).some((count) => count !== 0)
-    || codegraph.pending_refs !== 0
-    || codegraph.worktree_mismatch !== null
-    || codegraph.fresh_index_repetitions !== 2
-    || !Array.isArray(codegraph.raw_outcomes_digests)
-    || codegraph.raw_outcomes_digests.length !== 2
-    || codegraph.raw_outcomes_digests.some((digest) => (
+    || typeof sensor.version !== 'string'
+    || sensor.version.length === 0
+    || !Number.isSafeInteger(sensor.file_count)
+    || sensor.file_count <= 0
+    || !Number.isSafeInteger(sensor.node_count)
+    || sensor.node_count <= 0
+    || !Number.isSafeInteger(sensor.edge_count)
+    || sensor.edge_count <= 0
+    || !exactRecord(sensor.pending_changes, ['added', 'modified', 'removed'])
+    || Object.values(sensor.pending_changes).some((count) => count !== 0)
+    || sensor.pending_refs !== 0
+    || sensor.worktree_mismatch !== null
+    || sensor.fresh_index_repetitions !== 2
+    || !Array.isArray(sensor.raw_outcomes_digests)
+    || sensor.raw_outcomes_digests.length !== 2
+    || sensor.raw_outcomes_digests.some((digest) => (
       typeof digest !== 'string' || !SHA256.test(digest)
     ))
-    || new Set(codegraph.raw_outcomes_digests).size !== 2
-    || codegraph.raw_outcomes_equal !== false
-    || typeof codegraph.portable_outcomes_digest !== 'string'
-    || !SHA256.test(codegraph.portable_outcomes_digest)
-    || codegraph.portable_outcomes_equal !== true
-    || !Array.isArray(codegraph.outcomes)
-    || codegraph.outcomes.length === 0
-    || codegraph.outcomes.some((outcome) => !portableOutcomeRecord(outcome))) {
-    fail('portable Codegraph portability proofが不正');
+    || new Set(sensor.raw_outcomes_digests).size !== 2
+    || sensor.raw_outcomes_equal !== false
+    || typeof sensor.portable_outcomes_digest !== 'string'
+    || !SHA256.test(sensor.portable_outcomes_digest)
+    || sensor.portable_outcomes_equal !== true
+    || !Array.isArray(sensor.outcomes)
+    || sensor.outcomes.length === 0
+    || sensor.outcomes.some((outcome) => !portableOutcomeRecord(outcome))) {
+    fail('portable LatticeSensor portability proofが不正');
   }
 
   if (!Array.isArray(querySet.queries)
-    || codegraph.outcomes.length !== querySet.queries.length
-    || codegraph.outcomes.some((outcome, index) => (
+    || sensor.outcomes.length !== querySet.queries.length
+    || sensor.outcomes.some((outcome, index) => (
       outcome.id !== querySet.queries[index]?.id
       || outcome.operation !== querySet.queries[index]?.operation
     ))) {
-    fail('portable Codegraph evidenceがquery setと一致しない');
+    fail('portable LatticeSensor evidenceがquery setと一致しない');
   }
 
-  const compiledGraphEvidence = codegraph.outcomes.map((outcome) => ({
+  const compiledGraphEvidence = sensor.outcomes.map((outcome) => ({
     id: outcome.id,
     operation: outcome.operation,
     status: outcome.outcome,
     result_digest: outcome.result_digest,
   }));
   if (JSON.stringify(compiledGraphEvidence) !== JSON.stringify(graphEvidence)) {
-    fail('portable Codegraph evidenceがboundary manifestのgraph evidenceと一致しない');
+    fail('portable LatticeSensor evidenceがboundary manifestのgraph evidenceと一致しない');
   }
 }
 
@@ -220,17 +221,16 @@ function assertControlCompilationEvidence(evidence, {
     'executor_head',
     'graph_digest_projection',
     'input_digests',
-    'codegraph',
+    'sensor',
     'artifacts',
     'observed_facts',
     'presentation_note',
   ])
     || evidence.schema !== 'lattice.rc1.control_compilation_evidence.v2'
-    || evidence.graph_digest_projection !== PORTABLE_CODEGRAPH_PROJECTION) {
+    || evidence.graph_digest_projection !== PORTABLE_SENSOR_PROJECTION) {
     fail('portable control compilation evidence v2またはprojectionが不正');
   }
-  if (typeof evidence.observed_at !== 'string'
-    || Number.isNaN(Date.parse(evidence.observed_at))
+  if (!isCanonicalUtcTimestamp(evidence.observed_at)
     || typeof evidence.head !== 'string'
     || !SHA1.test(evidence.head)
     || typeof evidence.executor_head !== 'string'
@@ -250,7 +250,7 @@ function assertControlCompilationEvidence(evidence, {
     || !evidenceArtifactSet(evidence.artifacts.shared_state_negative)) {
     fail('control compilation evidenceまたはcontrol baseが不正');
   }
-  assertPortableCodegraphEvidence(evidence.codegraph, { querySet, graphEvidence });
+  assertPortableLatticeSensorEvidence(evidence.sensor, { querySet, graphEvidence });
   if (evidence.input_digests.query_set !== querySetDigest
     || evidence.input_digests.code_snapshot !== codeSnapshotDigest
     || evidence.artifacts.control.boundary_manifest.digest !== manifestDigest

package/src/{codegraph-adapter.mjs → sensor-adapter.mjs}

@@ -1,7 +1,8 @@
-import { spawn } from 'node:child_process';
 import { lstat, realpath } from 'node:fs/promises';
 import path from 'node:path';
 
+import { spawnSensorCli } from './sensor-runtime.mjs';
+
 const OPERATIONS = new Set(['status', 'query', 'callers', 'callees', 'impact', 'affected']);
 const ANSI_ESCAPE = /\u001B\[[0-?]*[ -/]*[@-~]/g;
 
@@ -23,11 +24,11 @@ function portableCopy(value, insideNode = false) {
 }
 
 /**
- * Codegraph raw outcomeから環境依存telemetryだけを除くdigest projectionを返す。
+ * LatticeSensor raw outcomeから環境依存telemetryだけを除くdigest projectionを返す。
  * @param {unknown} outcome
  * @returns {unknown}
  */
-export function portableCodegraphOutcome(outcome) {
+export function portableSensorOutcome(outcome) {
   const portable = portableCopy(outcome);
   if (!isPlainObject(portable)
     || portable.operation !== 'status'
@@ -208,9 +209,8 @@ function emptyAffectedData(target) {
 
 function defaultExecutor({ args, cwd }) {
   return new Promise((resolve) => {
-    const child = spawn('codegraph', args, {
+    const child = spawnSensorCli(args, {
       cwd,
-      shell: false,
       stdio: ['ignore', 'pipe', 'pipe'],
     });
     let stdout = '';
@@ -389,11 +389,11 @@ async function collectOne({ cwd, query, execute, inspectAffectedPath }) {
 }
 
 /**
- * Collects Codegraph CLI evidence without turning command failures or empty results into independence.
+ * Collects LatticeSensor CLI evidence without turning command failures or empty results into independence.
  * @param {{ cwd: string, querySet: { queries?: object[] }, execute?: Function }} options
  * @returns {Promise<{ cwd: string, outcomes: object[] }>}
  */
-export async function collectCodegraphEvidence({
+export async function collectSensorEvidence({
   cwd,
   querySet,
   execute = defaultExecutor,

package/src/sensor-cli.mjs

@@ -0,0 +1,107 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import sensorPackage from '../sensor/package.json' with { type: 'json' };
+import { spawnSensorCli } from './sensor-runtime.mjs';
+
+const MAX_CAPTURE_BYTES = 1024 * 1024;
+const MAX_DIAGNOSTIC_BYTES = 16 * 1024;
+
+function writeJson(stream, value) {
+  stream.write(`${JSON.stringify(value)}\n`);
+}
+
+function usage(stderr) {
+  writeJson(stderr, {
+    schema: 'lattice.cli_error.v2',
+    code: 'USAGE',
+    message: 'usage: lattice sensor <init|sync> [path] --json',
+  });
+  return 2;
+}
+
+function parse(argv) {
+  if (argv.at(-1) !== '--json') return null;
+  const words = argv.slice(0, -1);
+  if (!['init', 'sync'].includes(words[0]) || words.length > 2) return null;
+  return { command: words[0], path: words[1] ?? '.' };
+}
+
+function execute(command, projectPath) {
+  return new Promise((resolve, reject) => {
+    let captured = 0;
+    const stderrChunks = [];
+    let diagnosticBytes = 0;
+    const hasIndex = existsSync(path.resolve(projectPath, '.lattice/sensor', 'sensor.db'));
+    const sensorArgs = command === 'init' && hasIndex
+      ? ['index', projectPath, '--quiet']
+      : [command, projectPath];
+    const child = spawnSensorCli(sensorArgs, {
+      env: {
+        ...process.env,
+        LATTICE_SENSOR_NO_UPDATE_CHECK: '1',
+        DO_NOT_TRACK: '1',
+        NO_COLOR: '1',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const observe = (chunk, retain = false) => {
+      captured += chunk.length;
+      if (retain && diagnosticBytes < MAX_DIAGNOSTIC_BYTES) {
+        const retained = chunk.subarray(0, MAX_DIAGNOSTIC_BYTES - diagnosticBytes);
+        stderrChunks.push(retained);
+        diagnosticBytes += retained.length;
+      }
+      if (captured > MAX_CAPTURE_BYTES) child.kill('SIGTERM');
+    };
+    child.stdout.on('data', observe);
+    child.stderr.on('data', (chunk) => observe(chunk, true));
+    child.once('error', reject);
+    child.once('close', (code, signal) => resolve({
+      code,
+      signal,
+      overflow: captured > MAX_CAPTURE_BYTES,
+      stderr: Buffer.concat(stderrChunks).toString('utf8').trim(),
+    }));
+  });
+}
+
+export async function runSensorCli({ argv, stdout, stderr }) {
+  const request = parse(argv);
+  if (!request) return usage(stderr);
+  try {
+    const result = await execute(request.command, request.path);
+    if (result.code !== 0 || result.signal || result.overflow) {
+      const notInitialized = request.command === 'sync' && /not initialized/u.test(result.stderr);
+      writeJson(stderr, {
+        schema: 'lattice.cli_error.v2',
+        code: result.overflow ? 'LATTICE_SENSOR_OUTPUT_LIMIT'
+          : notInitialized ? 'LATTICE_SENSOR_NOT_INITIALIZED' : 'LATTICE_SENSOR_COMMAND_FAILED',
+        message: `LatticeSensor ${request.command} failed`,
+        detail: {
+          exit_code: result.code,
+          signal: result.signal,
+          stderr: result.stderr,
+          next_action: notInitialized ? `lattice sensor init ${request.path} --json` : null,
+        },
+      });
+      return 1;
+    }
+    writeJson(stdout, {
+      schema: 'lattice.sensor_command_result.v1',
+      provider: 'lattice',
+      sensor_owner: 'lattice',
+      sensor_version: sensorPackage.version,
+      command: request.command,
+      status: 'ok',
+    });
+    return 0;
+  } catch (error) {
+    writeJson(stderr, {
+      schema: 'lattice.cli_error.v2',
+      code: error?.code === 'LATTICE_SENSOR_UNAVAILABLE' ? error.code : 'LATTICE_SENSOR_COMMAND_FAILED',
+      message: `LatticeSensor ${request.command} failed`,
+      detail: { cause: error?.message ?? 'unknown error' },
+    });
+    return 1;
+  }
+}

package/src/sensor-runtime.mjs

@@ -0,0 +1,48 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { lstatSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+export const LATTICE_SENSOR_CLI = fileURLToPath(
+  new URL('../sensor/dist/bin/lattice-sensor.js', import.meta.url),
+);
+
+export class SensorRuntimeError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'SensorRuntimeError';
+    this.code = 'LATTICE_SENSOR_UNAVAILABLE';
+  }
+}
+
+function assertBundledSensor() {
+  try {
+    const info = lstatSync(LATTICE_SENSOR_CLI);
+    if (!info.isFile() || info.isSymbolicLink()) throw new Error('not a regular file');
+  } catch (error) {
+    throw new SensorRuntimeError(`bundled sensor is unavailable: ${error.message}`);
+  }
+}
+
+export function sensorCliInvocation(args) {
+  if (!Array.isArray(args) || !args.every((arg) => typeof arg === 'string')) {
+    throw new TypeError('sensor args must be an array of strings');
+  }
+  assertBundledSensor();
+  return Object.freeze({ command: process.execPath, args: Object.freeze([LATTICE_SENSOR_CLI, ...args]) });
+}
+
+export function invokeSensorCli(run, args, options) {
+  if (typeof run !== 'function') throw new TypeError('run must be a function');
+  const invocation = sensorCliInvocation(args);
+  return run(invocation.command, invocation.args, options);
+}
+
+export function spawnSensorCli(args, options = {}) {
+  const invocation = sensorCliInvocation(args);
+  return spawn(invocation.command, invocation.args, { ...options, shell: false });
+}
+
+export function spawnSensorCliSync(args, options = {}) {
+  const invocation = sensorCliInvocation(args);
+  return spawnSync(invocation.command, invocation.args, { ...options, shell: false });
+}

package/src/timestamp-contract.mjs

@@ -0,0 +1,8 @@
+const CANONICAL_UTC_MILLISECONDS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+
+/** JavaScript Dateの暦日正規化（例: 2月30日）を受理しないUTC timestamp契約。 */
+export function isCanonicalUtcTimestamp(value) {
+  if (typeof value !== 'string' || !CANONICAL_UTC_MILLISECONDS.test(value)) return false;
+  const parsed = new Date(value);
+  return !Number.isNaN(parsed.valueOf()) && parsed.toISOString() === value;
+}

package/src/todo-chain.mjs

@@ -0,0 +1,178 @@
+import { analyzeDagChains, DagCycleError } from './dag-chain.mjs';
+
+const ASSUMPTIONS = Object.freeze({
+  unit_duration: true,
+  capacity_ignored: true,
+  conflict_ignored: true,
+});
+
+export class TodoChainProjectionError extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = 'TodoChainProjectionError';
+    this.code = code;
+  }
+}
+
+export class TodoChainCycleError extends TodoChainProjectionError {
+  constructor(options) {
+    super('TODO_CHAIN_CYCLE', 'merged todo topology contains a cycle', options);
+    this.name = 'TodoChainCycleError';
+  }
+}
+
+function fail(code, message) {
+  throw new TodoChainProjectionError(code, message);
+}
+
+function isPlainObject(value) {
+  return value !== null
+    && typeof value === 'object'
+    && !Array.isArray(value)
+    && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+function normalizeNodeRef(value, context) {
+  if (!isPlainObject(value)) fail('TODO_CHAIN_INVALID_TOPOLOGY', `${context} must be a node ref`);
+  const { project_id: projectId, plan_key: planKey, task_id: taskId } = value;
+  if (typeof projectId !== 'string' || typeof planKey !== 'string' || typeof taskId !== 'string') {
+    fail('TODO_CHAIN_INVALID_TOPOLOGY', `${context} node ref fields must be strings`);
+  }
+  return { project_id: projectId, plan_key: planKey, task_id: taskId };
+}
+
+function nodeKey(ref) {
+  return JSON.stringify([ref.project_id, ref.plan_key, ref.task_id]);
+}
+
+function compareRefs(left, right) {
+  for (const field of ['project_id', 'plan_key', 'task_id']) {
+    if (left[field] < right[field]) return -1;
+    if (left[field] > right[field]) return 1;
+  }
+  return 0;
+}
+
+function requireArray(value, context) {
+  if (!Array.isArray(value)) fail('TODO_CHAIN_INVALID_TOPOLOGY', `${context} must be an array`);
+  return value;
+}
+
+function normalizeOptions(options) {
+  if (options === undefined) options = {};
+  if (!isPlainObject(options)) {
+    fail('TODO_CHAIN_INVALID_OPTIONS', 'options must be an object');
+  }
+  const allowedKeys = new Set(['countCap', 'representativeLimit']);
+  for (const key of Reflect.ownKeys(options)) {
+    if (typeof key !== 'string' || !allowedKeys.has(key)) {
+      fail('TODO_CHAIN_INVALID_OPTIONS', `unknown option: ${String(key)}`);
+    }
+  }
+
+  const countCap = Object.hasOwn(options, 'countCap') ? options.countCap : 1_000_000;
+  const representativeLimit = Object.hasOwn(options, 'representativeLimit')
+    ? options.representativeLimit
+    : 8;
+  if (!Number.isSafeInteger(countCap) || countCap < 1 || countCap >= Number.MAX_SAFE_INTEGER) {
+    fail(
+      'TODO_CHAIN_INVALID_OPTIONS',
+      'countCap must be a safe integer from 1 through Number.MAX_SAFE_INTEGER - 1',
+    );
+  }
+  if (
+    !Number.isSafeInteger(representativeLimit)
+    || representativeLimit < 0
+    || representativeLimit > 8
+  ) {
+    fail('TODO_CHAIN_INVALID_OPTIONS', 'representativeLimit must be a safe integer from 0 through 8');
+  }
+  return { countCap, representativeLimit };
+}
+
+export function projectTodoChainV1(
+  mergedTodoTopology,
+  options,
+) {
+  const { countCap, representativeLimit } = normalizeOptions(options);
+  if (!isPlainObject(mergedTodoTopology)) {
+    fail('TODO_CHAIN_INVALID_TOPOLOGY', 'mergedTodoTopology must be an object');
+  }
+
+  const nodes = requireArray(mergedTodoTopology.nodes, 'nodes');
+  const hardEdges = requireArray(mergedTodoTopology.hard_edges, 'hard_edges');
+  const joins = requireArray(mergedTodoTopology.joins, 'joins');
+  const refsByKey = new Map();
+
+  for (let index = 0; index < nodes.length; index += 1) {
+    const ref = normalizeNodeRef(nodes[index], `nodes[${index}]`);
+    const key = nodeKey(ref);
+    if (refsByKey.has(key)) fail('TODO_CHAIN_DUPLICATE_NODE', `duplicate node ref at nodes[${index}]`);
+    refsByKey.set(key, ref);
+  }
+
+  const edgeKeys = new Set();
+  const edges = [];
+  const addEdge = (fromValue, toValue, context) => {
+    const fromRef = normalizeNodeRef(fromValue, `${context}.from`);
+    const toRef = normalizeNodeRef(toValue, `${context}.to`);
+    const from = nodeKey(fromRef);
+    const to = nodeKey(toRef);
+    if (!refsByKey.has(from) || !refsByKey.has(to)) {
+      fail('TODO_CHAIN_DANGLING_EDGE', `${context} references a node absent from nodes`);
+    }
+    const edgeKey = JSON.stringify([from, to]);
+    if (edgeKeys.has(edgeKey)) return;
+    edgeKeys.add(edgeKey);
+    edges.push([from, to]);
+  };
+
+  for (let index = 0; index < hardEdges.length; index += 1) {
+    const edge = hardEdges[index];
+    if (!isPlainObject(edge)) fail('TODO_CHAIN_INVALID_TOPOLOGY', `hard_edges[${index}] must be an object`);
+    addEdge(edge.from, edge.to, `hard_edges[${index}]`);
+  }
+
+  for (let joinIndex = 0; joinIndex < joins.length; joinIndex += 1) {
+    const join = joins[joinIndex];
+    if (!isPlainObject(join)) fail('TODO_CHAIN_INVALID_TOPOLOGY', `joins[${joinIndex}] must be an object`);
+    const after = requireArray(join.after, `joins[${joinIndex}].after`);
+    for (let afterIndex = 0; afterIndex < after.length; afterIndex += 1) {
+      addEdge(
+        after[afterIndex],
+        join.before,
+        `joins[${joinIndex}].after[${afterIndex}]`,
+      );
+    }
+  }
+
+  let analysis;
+  try {
+    analysis = analyzeDagChains([...refsByKey.keys()], edges, {
+      countCap,
+      representativeLimit,
+      compare: (left, right) => compareRefs(refsByKey.get(left), refsByKey.get(right)),
+    });
+  } catch (error) {
+    if (error instanceof DagCycleError) throw new TodoChainCycleError({ cause: error });
+    throw error;
+  }
+
+  const toRef = (key) => ({ ...refsByKey.get(key) });
+  return {
+    schema: 'lattice.todo_chain.v1',
+    maximum_dependency_depth: analysis.maximumDepth,
+    longest_chain_node_refs: analysis.longestChainNodes.map(toRef),
+    longest_chain_edges: analysis.longestChainEdges.map(([from, to]) => ({
+      from: toRef(from),
+      to: toRef(to),
+    })),
+    longest_chain_count: analysis.longestChainCount,
+    limits: {
+      count_cap: countCap,
+      representative_limit: representativeLimit,
+    },
+    representative_chains: analysis.representativeChains.map((chain) => chain.map(toRef)),
+    assumptions: { ...ASSUMPTIONS },
+  };
+}