amalgm 0.1.238 → 0.1.240

package/runtime/scripts/amalgm-mcp/workspace/checkpoint.js

@@ -13,7 +13,10 @@
  * real local edit or revert is one new transition.
  *
  * Checkpoint files below are local capture cache only. Their operations ride
- * inside the machine wall, so the entire repo has one ordered stream.
+ * inside the project stream, so the entire repo has one ordered rail.
+ *
+ * Axiom 4: only an exact local observation may create or update intent.
+ * Proven by workspace-local-intent.test.js.
  */
 
 const crypto = require('crypto');
@@ -23,9 +26,10 @@ const { AMALGM_DIR } = require('../config');
 const { appendStateEvent, subscribeStateEvents } = require('../state/events');
 const { machineId } = require('./identity');
 const { listRepoCards } = require('./cards');
-const { captureCheckpoint } = require('./git');
+const durable = require('./durable');
+const { describeBytes, manifestChecksum, sha256 } = require('./content');
 
-const CHECKPOINT_CONTRACT = 'repo-checkpoint@9';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@11';
 const MAX_INLINE_DIFF_BYTES = 512 * 1024;
 const PUBLISH_QUIET_MS = 25;
 const RECONCILE_INTERVAL_MS = 30_000;
@@ -54,7 +58,7 @@ function checkpointFile(machine, repoKey) {
     .update(`${CHECKPOINT_CONTRACT}|${machine}|${repoKey}`)
     .digest('hex')
     .slice(0, 24);
-  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v9', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v11', `${digest}.json`);
 }
 
 /**
@@ -85,15 +89,44 @@ function canonicalPatch(diff) {
   return patchSections(diff).join('');
 }
 
+function sectionIdentity(text) {
+  return manifestChecksum(describeBytes(Buffer.from(text, 'utf8')));
+}
+
+function revisionOfSections(baseOid, indexSections, worktreeSections) {
+  const index = [...indexSections].sort();
+  const worktree = [...worktreeSections].sort();
+  if (index.length === 0 && worktree.length === 0) return null;
+  return sha256(Buffer.from(JSON.stringify({ baseOid, index, worktree }), 'utf8'));
+}
+
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {
-  return indexDiff === '' && worktreeDiff === ''
-    ? null
-    : crypto.createHash('sha256')
-      .update(
-        `${baseOid}\nindex\n${canonicalPatch(indexDiff)}\nworktree\n${canonicalPatch(worktreeDiff)}`,
-        'utf8',
-      )
-      .digest('hex');
+  return revisionOfSections(
+    baseOid,
+    patchSections(indexDiff).map(sectionIdentity),
+    patchSections(worktreeDiff).map(sectionIdentity),
+  );
+}
+
+function revisionOfValue(baseOid, value) {
+  if (
+    typeof value?.indexDiff === 'string'
+    && typeof value?.worktreeDiff === 'string'
+  ) return revisionOf(baseOid, value.indexDiff, value.worktreeDiff);
+  if (!value?.sections) throw new Error('checkpoint value has no content');
+  const identities = (layer) => {
+    if (!Array.isArray(value.sections[layer])) throw new Error('checkpoint sections are invalid');
+    return value.sections[layer].map((section) => {
+      if (typeof section?.text === 'string' && section.text.length > 0) {
+        return sectionIdentity(section.text);
+      }
+      if (/^[0-9a-f]{64}$/.test(String(section?.payload?.checksum || ''))) {
+        return section.payload.checksum;
+      }
+      throw new Error('checkpoint section has no content identity');
+    });
+  };
+  return revisionOfSections(baseOid, identities('index'), identities('worktree'));
 }
 
 function parseCheckpoint(text) {
@@ -126,8 +159,7 @@ function stampCheckpointMutation(machine, repoKey, checkpoint, mutationId) {
   if (!existing || !sameTransition(existing, checkpoint)) return false;
   if (existing.mutationId === mutationId) return true;
   const file = checkpointFile(machine, repoKey);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify({ ...existing, mutationId })}\n`);
+  durable.writeJson(file, { ...existing, mutationId });
   return true;
 }
 
@@ -138,21 +170,12 @@ function valueIdentity(value) {
   });
 }
 
-function parkedIdentity(parked) {
-  return JSON.stringify((parked || []).map((entry) => {
-    const stable = { ...entry };
-    delete stable.version;
-    return stable;
-  }));
-}
-
 function sameTransition(left, right) {
   return left
     && left.baseOid === right.baseOid
     && left.branch === right.branch
     && valueIdentity(left.from) === valueIdentity(right.from)
-    && valueIdentity(left.to) === valueIdentity(right.to)
-    && parkedIdentity(left.parked) === parkedIdentity(right.parked);
+    && valueIdentity(left.to) === valueIdentity(right.to);
 }
 
 function sectionEntry(machine, repoKey, baseOid, layer, text, external) {
@@ -248,41 +271,366 @@ function checkpointValueReady(value) {
   return !value?.payload || value.payload.kind === 'chunks';
 }
 
-function checkpointForSharedState({
-  machine,
-  repoKey,
-  branch,
-  baseOid,
-  sharedValue,
-  parked,
-  capturedAt = new Date().toISOString(),
-}) {
-  if (parked.length === 0) return null;
+function exactCard(card) {
   return {
+    head: {
+      branch: card.head.branch ?? null,
+      oid: card.head.oid,
+      detached: Boolean(card.head.detached),
+    },
+    objects: card.objects,
+    branches: (card.refs || card.branches || []).map((branch) => ({
+      name: branch.name,
+      oid: branch.oid,
+      objects: branch.objects,
+    })).sort((left, right) => left.name.localeCompare(right.name)),
+  };
+}
+
+function intentBase(state) {
+  if (
+    state?.verificationContract !== 'verified-repo-state@1'
+    || state.materialized !== true
+    || !Number.isInteger(state.appliedThrough)
+    || state.appliedThrough < 0
+    || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(String(state.targetCard?.oid || ''))
+    || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(String(state.heldIndexTree || ''))
+    || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(String(state.heldTree || ''))
+    || !Array.isArray(state.branches)
+  ) return null;
+  return {
+    through: state.appliedThrough,
+    card: {
+      head: {
+        branch: state.targetCard.branch ?? null,
+        oid: state.targetCard.oid,
+        detached: !state.targetCard.branch,
+      },
+      branches: state.branches.map((branch) => ({
+        name: branch.name,
+        oid: branch.oid,
+      })).sort((left, right) => left.name.localeCompare(right.name)),
+    },
+    indexTree: state.heldIndexTree,
+    worktreeTree: state.heldTree,
+  };
+}
+
+function hasIntentEffect(base, local) {
+  const card = require('./intent')._test.cardState;
+  return JSON.stringify(card(base.card)) !== JSON.stringify(card(local.card))
+    || base.indexTree !== local.indexTree
+    || base.worktreeTree !== local.worktreeTree;
+}
+
+async function initialIntentBase(project, card) {
+  if (project.ownerUserId !== require('./identity').userId()) return null;
+  const replica = require('../state/replicas').getReplicaByResourceId(project.resourceId);
+  if (!replica || replica.appliedVersion !== 0) return null;
+  const snapshot = require('./project-stream').readSnapshot(project.file, project.resourceId);
+  if (snapshot.version !== 0 || snapshot.card !== null || snapshot.checkpoint !== null) return null;
+  const emptyTree = await require('./transition').emptyTree(card.path);
+  return {
+    through: 0,
+    card: null,
+    indexTree: emptyTree,
+    worktreeTree: emptyTree,
+  };
+}
+
+async function gitlinkPaths(card, observed) {
+  const merge = require('./merge');
+  const trees = new Set([
+    observed.value.indexTree,
+    observed.value.worktreeTree,
+    card.head.oid,
+    ...(card.refs || card.branches || []).map((branch) => branch.oid),
+  ].filter(Boolean));
+  const paths = new Set();
+  for (const tree of trees) {
+    for (const entry of await merge.gitlinksInTree(card.path, tree)) paths.add(entry);
+  }
+  return [...paths].sort();
+}
+
+/**
+ * Capture is the only place physical state may become local authorship.
+ * It requires a verified baseline (or an already-owned intent) and runs only
+ * outside the reducer's materialization section.
+ */
+async function recordObservedIntent(
+  project,
+  card,
+  checkpoint,
+  base,
+  observed,
+  options = {},
+) {
+  const intents = require('./intent');
+  const local = {
+    card: exactCard(card),
+    checkpoint: {
+      checkpoint: CHECKPOINT_CONTRACT,
+      baseOid: card.head.oid,
+      branch: card.head.branch ?? null,
+      value: checkpoint.to,
+    },
+    indexTree: observed.value.indexTree,
+    worktreeTree: observed.value.worktreeTree,
+    physicalDigest: observed.digest,
+  };
+  const links = await gitlinkPaths(card, observed);
+  const terminal = links.length > 0
+    ? {
+      code: 'unsupported_gitlink',
+      message: `unsupported gitlink/submodule at ${links[0]}`,
+    }
+    : null;
+  const previous = intents.readIntent(project);
+  const previousSuccessor = previous?.successor || null;
+  if (previous?.terminal && observed.digest === previous.local.physicalDigest) {
+    return {
+      state: 'rejected',
+      reason: previous.terminal.code,
+      intent: previous,
+      unchanged: true,
+    };
+  }
+  if (
+    previousSuccessor?.terminal
+    && observed.digest === previousSuccessor.local.physicalDigest
+  ) {
+    return {
+      state: 'rejected',
+      reason: previousSuccessor.terminal.code,
+      intent: previous,
+      successor: previousSuccessor,
+      unchanged: true,
+    };
+  }
+  const nextSemanticDigest = intents._test.semanticDigest({ local });
+  const acknowledgement = previous
+    ? intents.officialAcknowledgement(project, previous)
+    : null;
+  if (
+    acknowledgement
+    && previous.semanticDigest === nextSemanticDigest
+    && base.through <= acknowledgement.version
+  ) {
+    if (previousSuccessor) intents.clearSuccessor(project, previous);
+    return { state: 'silent', reason: 'officially-acknowledged' };
+  }
+  const mayReplaceAnchored = Boolean(
+    previous?.publication
+    && (
+      previous.semanticDigest === options.replaceAnchoredIntent
+      || (acknowledgement && acknowledgement.version <= base.through)
+      || intents.publicationMayRebase(project, previous, base.through)
+    )
+  );
+  if (
+    previous?.publication
+    && previous.semanticDigest !== nextSemanticDigest
+    && !mayReplaceAnchored
+  ) {
+    const successor = intents.writeSuccessor(project, previous, {
+      local,
+      terminal,
+    });
+    if (!successor) {
+      return {
+        state: 'waiting',
+        reason: 'local-intent-moving',
+        intent: previous,
+      };
+    }
+    return {
+      state: terminal ? 'rejected' : 'captured',
+      reason: terminal ? terminal.code : 'successor-captured',
+      intent: previous,
+      successor,
+      mayMaterialize: true,
+    };
+  }
+  if (!terminal && !hasIntentEffect(base, local)) {
+    if (
+      options.preserveNoEffectIntent === true
+      && previous
+      && !previous.publication
+    ) {
+      const saved = intents.writeIntent(project, {
+        base,
+        local,
+        terminal: null,
+        publication: null,
+        birthMutationId: previous.birthMutationId,
+        preserveBirthMutationId: true,
+      });
+      return {
+        state: 'captured',
+        reason: 'identity-confirmation',
+        intent: saved,
+      };
+    }
+    if (!previous?.publication || mayReplaceAnchored) {
+      intents.clearIntent(project);
+      return { state: 'silent', reason: 'no-local-effect' };
+    }
+    if (acknowledgement && acknowledgement.version <= base.through) {
+      return { state: 'silent', reason: 'officially-acknowledged' };
+    }
+  }
+  const candidate = {
+    base,
+    local,
+    terminal,
+    successor: null,
+    publication: (
+      previous?.semanticDigest === nextSemanticDigest
+      && previous.publication?.baseThrough === base.through
+    )
+      ? previous.publication
+      : null,
+    birthMutationId: options.preserveBirthMutationId === true
+      ? previous?.birthMutationId
+      : mayReplaceAnchored
+        ? previousSuccessor?.birthMutationId
+        : null,
+    preserveBirthMutationId: options.preserveBirthMutationId === true,
+  };
+  const saved = intents.writeIntent(project, candidate);
+  return terminal
+    ? { state: 'rejected', reason: terminal.code, intent: saved }
+    : { state: 'captured', intent: saved };
+}
+
+async function captureIntentObservationWithinTurn(project, card, checkpoint) {
+  const reducer = require('./reducer');
+  const state = reducer.readRepoState(project.repoKey, project.resourceId);
+  const base = intentBase(state) || await initialIntentBase(project, card);
+  if (!base) {
+    return { state: 'silent', reason: 'no-verified-baseline' };
+  }
+  const observed = await reducer.observePhysicalRepo(card.path);
+  if (observed.state !== 'ready') return { state: 'waiting', reason: 'local-state-moving' };
+  const observedRevision = revisionOf(
+    observed.captured.baseOid,
+    observed.captured.indexDiff,
+    observed.captured.worktreeDiff,
+  );
+  const observedCard = {
+    head: {
+      branch: observed.value.head.branch ?? null,
+      oid: observed.value.head.oid,
+      detached: !observed.value.head.branch,
+    },
+    branches: observed.value.branches,
+  };
+  const intents = require('./intent');
+  if (
+    observed.captured.baseOid !== card.head.oid
+    || (
+      checkpoint
+      && (
+        checkpoint.to?.revision !== observedRevision
+        || checkpoint.baseOid !== observed.captured.baseOid
+        || (checkpoint.branch ?? null) !== (observed.value.head.branch ?? null)
+      )
+    )
+    || JSON.stringify(intents._test.cardState(exactCard(card)))
+      !== JSON.stringify(intents._test.cardState(observedCard))
+  ) {
+    return { state: 'waiting', reason: 'local-state-moving' };
+  }
+  const to = checkpointValue(
+    machineId(),
+    project.repoKey,
+    observed.captured.baseOid,
+    observed.captured.indexDiff,
+    observed.captured.worktreeDiff,
+  );
+  if (!checkpointValueReady(to)) {
+    return { state: 'waiting', reason: 'checkpoint-payload-pending' };
+  }
+  const capturedCheckpoint = {
     checkpoint: CHECKPOINT_CONTRACT,
-    machine,
-    repoKey,
-    branch,
-    baseOid,
-    from: sharedValue,
-    to: sharedValue,
-    parked,
-    capturedAt,
+    machine: machineId(),
+    repoKey: project.repoKey,
+    branch: observed.value.head.branch ?? null,
+    baseOid: observed.captured.baseOid,
+    from: checkpoint?.from || null,
+    to,
+    capturedAt: new Date().toISOString(),
   };
+  if (!intents.readIntent(project) && observed.digest === state?.observedPhysicalDigest) {
+    return {
+      state: 'silent',
+      reason: 'verified-state',
+      checkpoint: capturedCheckpoint,
+    };
+  }
+  const result = await recordObservedIntent(
+    project,
+    card,
+    capturedCheckpoint,
+    base,
+    observed,
+  );
+  return { ...result, checkpoint: capturedCheckpoint };
 }
 
-function localParkedEntries(existing, reduced, card) {
-  const published = new Set((reduced?.parked || []).filter((entry) => (
-    Number.isInteger(entry.version) && entry.version > 0
-  )).map((entry) => entry.oid));
-  const held = existing?.baseOid === card.head?.oid
-    && existing.branch === card.head?.branch
-    ? (existing.parked || []).filter((entry) => !published.has(entry.oid))
-    : [];
-  const unpublished = (reduced?.parked || []).filter((entry) => (
-    !Number.isInteger(entry.version) || entry.version < 1
-  ));
-  return [...new Map([...held, ...unpublished].map((entry) => [entry.oid, entry])).values()];
+function captureIntentObservation(project, card, checkpoint) {
+  return require('./reducer').withRepoTurn(
+    project.repoKey,
+    'capture',
+    () => captureIntentObservationWithinTurn(project, card, checkpoint),
+  );
+}
+
+async function captureLocalIntent(project, card, checkpoint) {
+  const { checkpoint: capturedCheckpoint, ...outcome } = await captureIntentObservation(
+    project,
+    card,
+    checkpoint,
+  );
+  return outcome;
+}
+
+/**
+ * A valid apply WAL is also an exact baseline. Recovery first resolves every
+ * source/target component to target while retaining values that equal
+ * neither. Only then does this function durably name the retained state as
+ * local intent over the official WAL target.
+ */
+async function captureIntentAgainst(project, card, base, observed, options = {}) {
+  if (!base || observed?.state !== 'ready' || !observed.captured) {
+    return { state: 'waiting', reason: 'local-state-moving' };
+  }
+  const to = checkpointValue(
+    machineId(),
+    project.repoKey,
+    card.head.oid,
+    observed.captured.indexDiff,
+    observed.captured.worktreeDiff,
+  );
+  if (!checkpointValueReady(to)) {
+    return { state: 'waiting', reason: 'checkpoint-payload-pending' };
+  }
+  return recordObservedIntent(project, card, { to }, base, observed, options);
+}
+
+/**
+ * Observe one card and turn a real local change into durable intent.
+ *
+ * The reducer calls this before ordered apply so an inbound event cannot beat
+ * the debounced filesystem watcher. It still obeys the same capture rule:
+ * without a verified baseline, the physical checkout is not authorship.
+ */
+async function captureIntentForCard(project, card) {
+  if (!project || !card?.head?.oid) {
+    return { state: 'silent', reason: 'no-registered-card' };
+  }
+  return captureLocalIntent(project, card, null);
 }
 
 function readCheckpointValue(baseOid, value) {
@@ -344,28 +692,6 @@ function readCheckpointValue(baseOid, value) {
   return { state: 'ready', indexDiff, worktreeDiff };
 }
 
-function checkpointBaseReady(card, reduced, publication) {
-  return Boolean(
-    reduced
-    && publication?.current
-    && reduced.baseOid === card.head?.oid
-    && reduced.branch === card.head?.branch
-    && typeof reduced.indexDiff === 'string'
-    && typeof reduced.worktreeDiff === 'string'
-  );
-}
-
-function checkpointWasAcknowledged(checkpoint, card, localRevision, version) {
-  return Boolean(
-    checkpoint
-    && Number.isInteger(version)
-    && version > 0
-    && checkpoint.baseOid === card.head?.oid
-    && checkpoint.branch === card.head?.branch
-    && checkpoint.to?.revision === localRevision
-  );
-}
-
 function checkpointMayPublish(repoKey) {
   return !require('./reducer').isMaterializing(repoKey);
 }
@@ -376,125 +702,62 @@ async function publishPass(replicaId = null) {
   for (const card of listRepoCards()) {
     if (replicaId && card.replica !== replicaId) continue;
     if (card.health !== 'healthy' || card.kind !== 'primary' || card.operation !== 'none') continue;
-    const repoKey = repoKeyOfCard(card);
+    const wall = require('./wall');
+    const project = wall.projectForPath(card.path);
+    const repoKey = project?.repoKey;
     if (!repoKey || !card.head?.oid) continue;
     if (!checkpointMayPublish(repoKey)) {
       run.waiting += 1;
       continue;
     }
     try {
-      const wall = require('./wall');
-      const reduced = require('./reducer').readRepoState(
-        repoKey,
-        wall.projectForRepo(repoKey)?.resourceId,
-      );
-      if (!checkpointBaseReady(card, reduced, wall.publicationStatus(repoKey, reduced))) {
+      const intent = await captureIntentObservation(project, card, null);
+      if (intent.state === 'waiting') {
         run.waiting += 1;
         continue;
       }
-
-      const captured = await captureCheckpoint(card.path);
-      if (captured.indexDiff === null || captured.baseOid !== card.head.oid) {
-        run.waiting += 1;
+      if (intent.state === 'rejected') {
+        if (intent.unchanged) run.skips += 1;
+        else run.failures += 1;
         continue;
       }
-      const sharedRevision = revisionOf(card.head.oid, reduced.indexDiff, reduced.worktreeDiff);
-      const localRevision = revisionOf(card.head.oid, captured.indexDiff, captured.worktreeDiff);
-      const file = checkpointFile(machine, repoKey);
-      const existing = readCheckpoint(machine, repoKey);
-      const parked = await Promise.all(localParkedEntries(existing, reduced, card).map(async (entry) => ({
-        ...entry,
-        objects: await require('./objects').bundleSourceFor(card.path, repoKey, entry.oid),
-      })));
-      if (!wall.publicationStatus(repoKey, reduced).current) {
-        run.waiting += 1;
+      if (!intent.checkpoint) {
+        run.skips += 1;
         continue;
       }
-
-      // Exact equality means the working tree has no pending file write.
-      // Remove an accepted local transition. A newly archived commit still
-      // rides as metadata on one no-op transition until the rail accepts it.
-      if (sharedRevision === localRevision) {
-        const refreshed = checkpointForSharedState({
-          machine,
-          repoKey,
-          branch: card.head.branch,
-          baseOid: card.head.oid,
-          sharedValue: checkpointValue(
-            machine,
-            repoKey,
-            card.head.oid,
-            reduced.indexDiff,
-            reduced.worktreeDiff,
-          ),
-          parked,
-        });
-        if (!refreshed) {
-          const project = wall.projectForRepo(repoKey);
-          const version = wall.mutationVersion(
-            project?.resourceId,
-            existing?.mutationId,
-            repoKey,
-          );
-          if (checkpointWasAcknowledged(existing, card, localRevision, version)) {
-            run.skips += 1;
-            continue;
-          }
+      const file = checkpointFile(machine, repoKey);
+      const existing = readCheckpoint(machine, repoKey);
+      const to = intent.checkpoint.to;
+      const snapshot = project && fs.existsSync(project.file)
+        ? require('./project-stream').readSnapshot(project.file, project.resourceId)
+        : null;
+      const onOfficialCard = snapshot?.card
+        && wall._test.sameCardState(card, snapshot.card);
+      const from = onOfficialCard
+        ? snapshot.checkpoint.value
+        : { revision: null, indexDiff: '', worktreeDiff: '' };
+      const envelope = {
+        ...intent.checkpoint,
+        from,
+      };
+      if (onOfficialCard && valueIdentity(from) === valueIdentity(to)) {
+        if (existing) {
           fs.rmSync(file, { force: true });
-          run.skips += 1;
-          continue;
-        }
-        if (refreshed && !sameTransition(existing, refreshed)) {
-          fs.writeFileSync(file, `${JSON.stringify(refreshed)}\n`);
           appendStateEvent({
             resource: 'repo-checkpoints',
-            op: 'update',
+            op: 'delete',
             id: card.replica,
-            value: refreshed,
-            source: 'repo-checkpoint:parked-objects',
+            source: 'repo-checkpoint:covered',
           });
-          run.published += 1;
-          continue;
         }
         run.skips += 1;
         continue;
       }
-
-      const from = checkpointValue(
-        machine,
-        repoKey,
-        card.head.oid,
-        reduced.indexDiff,
-        reduced.worktreeDiff,
-      );
-      const to = checkpointValue(
-        machine,
-        repoKey,
-        card.head.oid,
-        captured.indexDiff,
-        captured.worktreeDiff,
-      );
-      if (!checkpointValueReady(from) || !checkpointValueReady(to)) {
-        run.waiting += 1;
-        continue;
-      }
-      const envelope = {
-        checkpoint: CHECKPOINT_CONTRACT,
-        machine,
-        repoKey,
-        branch: card.head.branch,
-        baseOid: card.head.oid,
-        from,
-        to,
-        parked,
-        capturedAt: new Date().toISOString(),
-      };
       if (sameTransition(existing, envelope)) {
         run.skips += 1;
         continue;
       }
-      fs.mkdirSync(path.dirname(file), { recursive: true });
-      fs.writeFileSync(file, `${JSON.stringify(envelope)}\n`);
+      durable.writeJson(file, envelope);
       appendStateEvent({
         resource: 'repo-checkpoints',
         op: existing ? 'update' : 'insert',
@@ -582,11 +845,7 @@ function checkpointStats() {
 
 module.exports = {
   _test: {
-    checkpointBaseReady,
-    checkpointForSharedState,
     checkpointMayPublish,
-    checkpointWasAcknowledged,
-    localParkedEntries,
   },
   CHECKPOINT_CONTRACT,
   MAX_INLINE_DIFF_BYTES,
@@ -594,12 +853,16 @@ module.exports = {
   checkpointStats,
   checkpointValue,
   checkpointValueReady,
+  captureIntentAgainst,
+  captureIntentForCard,
+  captureLocalIntent,
   parseCheckpoint,
   publishCheckpoints,
   readCheckpoint,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
+  revisionOfValue,
   sameTransition,
   stampCheckpointMutation,
   startCheckpointService,