amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/workspace-publication-invariants.test.js

@@ -2,7 +2,6 @@
 
 const test = require('node:test');
 const assert = require('node:assert/strict');
-const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -22,22 +21,19 @@ fs.writeFileSync(
 );
 
 const { closeLocalDb } = require('../state/db');
-const replicas = require('../state/replicas');
 const {
+  _test: checkpointTest,
   CHECKPOINT_CONTRACT,
+  checkpointFile,
   sameTransition,
 } = require('../workspace/checkpoint');
-const { classifyBranchRefs } = require('../workspace/reducer');
-const projectStream = require('../workspace/project-stream');
-const wall = require('../workspace/wall');
-
-const PROJECT = '018f0000-0000-7000-8000-000000000040';
-const HEAD = 'a'.repeat(40);
-const project = wall.bindProject(
-  PROJECT,
-  '11111111-1111-4111-8111-111111111111',
-  path.join(tempRoot, 'repo'),
-);
+const { parkedForState } = require('../workspace/reducer');
+const {
+  compactWallText,
+  hasLocalContribution,
+  publicationStatus,
+  stampCards,
+} = require('../workspace/wall');
 
 test.after(() => {
   closeLocalDb();
@@ -46,210 +42,271 @@ test.after(() => {
 
 const rules = {
   card: {
-    identity: 'HEAD, complete branch map, and checkpoint content',
-    ownership: 'local until that exact value returns officially',
-    liveness: 'one durable outbox proposal retries',
-    gating: 'publish only while current',
+    identity: 'branch-and-commit-content',
+    ownership: 'originator-publishes',
+    liveness: 'shared-wall-outbox',
+    gating: 'defines-winning-card',
+  },
+  branch: {
+    identity: 'ref-name-and-commit-content',
+    ownership: 'originator-publishes',
+    liveness: 'shared-wall-outbox',
+    gating: 'per-ref-rail-order',
   },
   checkpoint: {
-    identity: 'exact from and to working-tree content',
-    ownership: 'local until that exact value returns officially',
-    liveness: 'one durable outbox proposal retries',
-    gating: 'compare-and-set from the current card',
+    identity: 'from-and-to-content',
+    ownership: 'originator-publishes',
+    liveness: 'shared-wall-outbox',
+    gating: 'winning-card-only',
   },
-  snapshot: {
-    identity: 'canonical state through one official version',
-    ownership: 'server-derived only',
-    liveness: 'hydrate then replay the contiguous tail',
-    gating: 'never creates a content event',
+  parked: {
+    identity: 'commit-and-object-content',
+    ownership: 'holder-publishes-until-acknowledged',
+    liveness: 'shared-wall-outbox',
+    gating: 'inside-winning-card-checkpoint',
   },
-  transport: {
-    identity: 'content-addressed bytes',
-    ownership: 'no repo meaning',
-    liveness: 'repair or surface; never wait forever',
-    gating: 'all bytes exist before numbering',
+  compaction: {
+    identity: 'derived-deletion',
+    ownership: 'any-machine-may-compact',
+    liveness: 'not-semantic-state',
+    gating: 'commutative-with-writers',
   },
 };
 
-test('the complete publication model has four properties and no hidden value type', () => {
-  assert.deepEqual(Object.keys(rules), ['card', 'checkpoint', 'snapshot', 'transport']);
+test('the publication model has one explicit rule for every value and property', () => {
+  assert.deepEqual(Object.keys(rules), ['card', 'branch', 'checkpoint', 'parked', 'compaction']);
   for (const rule of Object.values(rules)) {
     assert.deepEqual(Object.keys(rule), ['identity', 'ownership', 'liveness', 'gating']);
     assert.equal(Object.values(rule).every(Boolean), true);
   }
+  assert.deepEqual(
+    new Set(['card', 'branch', 'checkpoint', 'parked'].map((name) => rules[name].liveness)),
+    new Set(['shared-wall-outbox']),
+  );
 });
 
-function chunks(byte = 'a', bytes = 1) {
-  const list = [{ sha256: byte.repeat(64), bytes }];
-  return {
-    checksum: crypto.createHash('sha256').update(JSON.stringify(list)).digest('hex'),
-    bytes,
-    chunks: list,
-  };
-}
-
-function bundle(oid = HEAD, byte = 'a') {
-  return {
-    kind: 'bundle',
-    contract: projectStream.BUNDLE_CONTRACT,
-    resourceId: PROJECT,
-    oid,
-    ref: `refs/amalgm/exports/${oid}`,
-    ...chunks(byte),
-  };
-}
-
-function cardSet() {
-  return {
-    kind: 'card.set',
-    card: projectStream.CARD_CONTRACT,
-    head: { branch: 'main', oid: HEAD, detached: false },
-    objects: bundle(),
-    branches: [{ name: 'main', oid: HEAD, objects: bundle() }],
-    checkpoint: {
-      checkpoint: projectStream.CHECKPOINT_CONTRACT,
-      baseOid: HEAD,
-      branch: 'main',
-      value: { revision: null, indexDiff: '', worktreeDiff: '' },
-    },
-  };
-}
-
-test('publication requires one current applied position and no unresolved send', () => {
-  projectStream.writeSnapshot(project.file, projectStream.emptySnapshot(PROJECT));
-  replicas.registerReplica({
-    resourceId: PROJECT,
-    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${PROJECT}`,
-    localPath: project.file,
-    contract: projectStream.STREAM_CONTRACT,
-    schemaVersion: 2,
+test('publication requires one current applied rail position and no unresolved send', () => {
+  const repoKey = 'root:currentness';
+  const resourceId = require('../workspace/wall').projectResourceId(repoKey);
+  const file = path.join(tempRoot, 'currentness.jsonl');
+  fs.writeFileSync(file, '');
+  const opened = require('../state/docs').openDoc(file);
+  require('../state/replicas').registerReplica({
+    resourceId,
+    localResource: opened.resource,
+    localPath: file,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
     authorityEpoch: 1,
     appliedVersion: 12,
-    snapshotVersion: 0,
   });
 
-  assert.equal(wall.publicationStatus(project.repoKey, { appliedThrough: 11 }).current, false);
-  assert.equal(wall.publicationStatus(project.repoKey, { appliedThrough: 12 }).current, true);
-
-  projectStream.publish(project, cardSet(), 'mut_publication_gate_01');
-  const waiting = wall.publicationStatus(project.repoKey, { appliedThrough: 12 });
-  assert.equal(waiting.pending, 1);
-  assert.equal(waiting.current, false);
+  assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 11 }), {
+    receivedThrough: 12,
+    appliedThrough: 11,
+    pending: 0,
+    current: false,
+  });
+  assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 12 }), {
+    receivedThrough: 12,
+    appliedThrough: 12,
+    pending: 0,
+    current: true,
+  });
+  require('../state/docs').writeDocText(file, 'pending\n');
+  assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 12 }), {
+    receivedThrough: 12,
+    appliedThrough: 12,
+    pending: 1,
+    current: false,
+  });
 });
 
-test('server stamps and object locators do not invent new repo meaning', () => {
+test('server rail numbers do not change checkpoint or parked identity', () => {
+  const oid = 'a'.repeat(40);
   const transition = {
     checkpoint: CHECKPOINT_CONTRACT,
     machine: 'machine-a',
-    repoKey: project.repoKey,
+    repoKey: 'root:test',
     branch: 'main',
-    baseOid: HEAD,
+    baseOid: oid,
     from: { revision: null, indexDiff: '', worktreeDiff: '' },
-    to: { revision: 'b'.repeat(64), indexDiff: '', worktreeDiff: 'patch-a' },
+    to: { revision: 'work-a', indexDiff: '', worktreeDiff: 'patch-a' },
+    parked: [{
+      oid: 'b'.repeat(40),
+      ref: `refs/amalgm/parked/${'b'.repeat(40)}`,
+      objects: { kind: 'bundle', checksum: 'c'.repeat(64) },
+    }],
   };
   assert.equal(sameTransition(transition, {
     ...transition,
-    mutationId: 'mut_server_metadata_0001',
+    mutationId: 'mut_server_metadata',
     version: 41,
+    parked: transition.parked.map((entry) => ({ ...entry, version: 41 })),
   }), true);
-
-  const first = {
-    head: { branch: 'main', oid: HEAD, detached: false },
-    refs: [{ name: 'main', oid: HEAD, objects: bundle(HEAD, 'a') }],
-  };
-  const second = {
-    ...first,
-    objects: bundle(HEAD, 'b'),
-    refs: [{ ...first.refs[0], objects: bundle(HEAD, 'c') }],
-  };
-  assert.equal(wall._test.sameCardState(first, second), true);
-  assert.equal(wall._test.sameCardState(first, {
-    ...second,
-    refs: [{ ...second.refs[0], oid: 'd'.repeat(40) }],
+  assert.equal(sameTransition(transition, {
+    ...transition,
+    to: { ...transition.to, revision: 'different-work' },
+  }), false);
+  assert.equal(sameTransition(transition, {
+    ...transition,
+    parked: transition.parked.map((entry) => ({
+      ...entry,
+      objects: { ...entry.objects, checksum: 'd'.repeat(64) },
+    })),
   }), false);
 });
 
-test('only exact durable branch intent can hold a local value against the rail', () => {
-  const a = 'a'.repeat(40);
-  const b = 'b'.repeat(40);
-  const c = 'c'.repeat(40);
-  const d = 'd'.repeat(40);
-  const card = { head: { branch: 'main', oid: HEAD } };
-  const owned = {
-    base: {
-      card: {
-        head: card.head,
-        branches: [{ name: 'feature', oid: a }],
-      },
-    },
-    local: {
-      card: {
-        head: card.head,
-        branches: [{ name: 'feature', oid: c }],
-      },
-    },
+test('receivers stay silent and only unacknowledged local parked work republishes', () => {
+  const head = 'a'.repeat(40);
+  const local = {
+    head: { branch: 'main', oid: head, detached: false },
+    refs: [{ name: 'main', oid: head }],
+  };
+  const transition = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine: 'machine-a',
+    repoKey: 'root:test',
+    branch: 'main',
+    baseOid: head,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'shared-work', indexDiff: '', worktreeDiff: 'patch' },
+    parked: [],
   };
+  const plan = {
+    card: { head: { branch: 'main', oid: head, detached: false } },
+    branches: [{ name: 'main', oid: head }],
+    transitions: [{ ...transition, version: 9 }],
+  };
+  const baseline = {
+    branch: 'main',
+    baseOid: head,
+    branches: [{ name: 'main', oid: head }],
+  };
+  assert.equal(hasLocalContribution(local, plan, baseline, transition), false);
 
-  const first = classifyBranchRefs(
-    {
-      card,
-      branches: [
-        { name: 'main', oid: HEAD },
-        { name: 'feature', oid: b },
-      ],
-    },
-    [
-      { name: 'main', oid: HEAD },
-      { name: 'feature', oid: c },
-    ],
-    owned,
+  const localParked = { oid: 'b'.repeat(40), objects: { kind: 'bundle', checksum: 'local' } };
+  const unsentParked = { oid: 'c'.repeat(40), objects: { kind: 'bundle', checksum: 'unsent' } };
+  const peerParked = {
+    oid: 'd'.repeat(40),
+    objects: { kind: 'bundle', checksum: 'peer' },
+    version: 9,
+  };
+  assert.deepEqual(
+    checkpointTest.localParkedEntries(
+      { ...transition, parked: [localParked] },
+      { parked: [peerParked, unsentParked] },
+      local,
+    ),
+    [localParked, unsentParked],
   );
-  assert.deepEqual(first.changes, []);
-  assert.deepEqual(first.pending, [{ name: 'feature', oid: c }]);
-
-  const acknowledged = classifyBranchRefs(
-    {
-      card,
-      branches: [
-        { name: 'main', oid: HEAD },
-        { name: 'feature', oid: c },
-      ],
-    },
-    [
-      { name: 'main', oid: HEAD },
-      { name: 'feature', oid: c },
-    ],
-    null,
+  assert.deepEqual(parkedForState([localParked], [], []), [localParked]);
+  assert.deepEqual(
+    parkedForState([localParked], [{ ...localParked, version: 10 }], []),
+    [{ ...localParked, version: 10 }],
   );
-  assert.deepEqual(acknowledged.pending, []);
-
-  const later = classifyBranchRefs(
-    {
-      card,
-      branches: [
-        { name: 'main', oid: HEAD },
-        { name: 'feature', oid: d },
-      ],
-    },
-    [
-      { name: 'main', oid: HEAD },
-      { name: 'feature', oid: c },
+  assert.deepEqual(parkedForState([{ ...localParked, version: 10 }], [], []), []);
+});
+
+test('card, branch, checkpoint, and parked work ride one wall mutation', () => {
+  const repoKey = 'https://github.com/amalgm-inc/publication-invariant-test';
+  const head = 'a'.repeat(40);
+  const parkedOid = 'b'.repeat(40);
+  const checkpoint = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine: 'machine-a',
+    repoKey,
+    branch: 'main',
+    baseOid: head,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'work-a', indexDiff: '', worktreeDiff: 'patch-a' },
+    parked: [{
+      oid: parkedOid,
+      ref: `refs/amalgm/parked/${parkedOid}`,
+      objects: { kind: 'bundle', checksum: 'c'.repeat(64) },
+    }],
+  };
+  const file = checkpointFile('machine-a', repoKey);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(checkpoint)}\n`);
+
+  const mutationId = 'mut_one_shared_wall_outbox';
+  const stamped = stampCards([{
+    card: 'repo-card@2',
+    machine: 'machine-a',
+    replica: 'rpl_publication_test',
+    kind: 'primary',
+    repo: { remote: repoKey },
+    head: { branch: 'main', oid: head, detached: false },
+    refs: [
+      { name: 'main', oid: head },
+      { name: 'feature', oid: head },
     ],
-    null,
-  );
-  assert.deepEqual(later.changes, [{ branch: 'feature', expectedOid: c, oid: d }]);
+    health: 'healthy',
+  }], [], null, null, mutationId, {
+    repoKey,
+    resourceId: 'shr_publication_invariant_test',
+  })[0];
+
+  assert.equal(stamped.positionMutationId, mutationId);
+  assert.equal(stamped.branches.every((ref) => ref.mutationId === mutationId), true);
+  assert.equal(stamped.checkpoints[0].mutationId, mutationId);
+  assert.equal(stamped.checkpoints[0].parked[0].oid, parkedOid);
 });
 
-test('a card waits for every referenced commit without creating transport events', () => {
-  const pending = {
-    head: { branch: 'main', oid: HEAD, detached: false },
-    objects: { kind: 'pending' },
-    refs: [{ name: 'main', oid: HEAD, objects: { kind: 'pending' } }],
+test('two concurrent compacting publishers converge without losing either latest value', () => {
+  const Y = require('yjs');
+  const repoKey = 'root:compaction-collision';
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@4',
+    project: repoKey,
+    machine,
+    mutationId: `mut_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  const baseText = [
+    line('machine-a', 'old-a'),
+    line('machine-b', 'old-b'),
+    line('machine-a', 'current-a'),
+    line('machine-b', 'current-b'),
+    '',
+  ].join('\n');
+  const compacted = compactWallText(baseText, repoKey);
+  const removedBytes = baseText.length - compacted.length;
+  assert.ok(removedBytes > 0);
+
+  const base = new Y.Doc();
+  base.getText('content').insert(0, baseText);
+  const baseUpdate = Y.encodeStateAsUpdate(base);
+  const baseVector = Y.encodeStateVector(base);
+  const publisherUpdate = (machine, value) => {
+    const writer = new Y.Doc();
+    Y.applyUpdate(writer, baseUpdate);
+    const text = writer.getText('content');
+    text.delete(0, removedBytes);
+    text.insert(text.length, `${line(machine, value)}\n`);
+    return Y.encodeStateAsUpdate(writer, baseVector);
   };
-  assert.equal(wall._test.hasPendingContributionObjects(pending), true);
-  assert.equal(wall._test.hasPendingContributionObjects({
-    ...pending,
-    objects: bundle(),
-    refs: [{ ...pending.refs[0], objects: bundle() }],
-  }), false);
+  const updateA = publisherUpdate('machine-a', 'latest-a');
+  const updateB = publisherUpdate('machine-b', 'latest-b');
+  const replicas = [
+    [updateA, updateB],
+    [updateB, updateA],
+  ].map((order) => {
+    const replica = new Y.Doc();
+    Y.applyUpdate(replica, baseUpdate);
+    for (const update of order) Y.applyUpdate(replica, update);
+    return replica.getText('content').toString();
+  });
+
+  assert.equal(replicas[0], replicas[1]);
+  const latest = new Map();
+  for (const raw of replicas[0].trim().split('\n')) {
+    const entry = JSON.parse(raw);
+    latest.set(entry.machine, entry.cards[0].value);
+  }
+  assert.deepEqual(Object.fromEntries(latest), {
+    'machine-a': 'latest-a',
+    'machine-b': 'latest-b',
+  });
 });