amalgm 0.1.238 → 0.1.240

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

@@ -2,6 +2,7 @@
 
 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');
@@ -21,20 +22,22 @@ fs.writeFileSync(
 );
 
 const { closeLocalDb } = require('../state/db');
+const replicas = require('../state/replicas');
 const {
-  _test: checkpointTest,
   CHECKPOINT_CONTRACT,
-  checkpointFile,
   sameTransition,
 } = require('../workspace/checkpoint');
-const { parkedForState } = require('../workspace/reducer');
-const {
-  _test: wallTest,
-  hasLocalContribution,
-  publicationStatus,
-  stampCards,
-} = require('../workspace/wall');
+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'),
+);
 
 test.after(() => {
   closeLocalDb();
@@ -43,308 +46,210 @@ test.after(() => {
 
 const rules = {
   card: {
-    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',
+    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',
   },
   checkpoint: {
-    identity: 'from-and-to-content',
-    ownership: 'originator-publishes',
-    liveness: 'shared-wall-outbox',
-    gating: 'winning-card-only',
-  },
-  parked: {
-    identity: 'commit-and-object-content',
-    ownership: 'holder-publishes-until-acknowledged',
-    liveness: 'shared-wall-outbox',
-    gating: 'inside-winning-card-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',
   },
   snapshot: {
-    identity: 'state-through-official-version',
-    ownership: 'authority-derived',
-    liveness: 'hydrates-then-replays-tail',
-    gating: 'never-a-new-event',
+    identity: 'canonical state through one official version',
+    ownership: 'server-derived only',
+    liveness: 'hydrate then replay the contiguous tail',
+    gating: 'never creates a content event',
+  },
+  transport: {
+    identity: 'content-addressed bytes',
+    ownership: 'no repo meaning',
+    liveness: 'repair or surface; never wait forever',
+    gating: 'all bytes exist before numbering',
   },
 };
 
-test('the publication model has one explicit rule for every value and property', () => {
-  assert.deepEqual(Object.keys(rules), ['card', 'branch', 'checkpoint', 'parked', 'snapshot']);
+test('the complete publication model has four properties and no hidden value type', () => {
+  assert.deepEqual(Object.keys(rules), ['card', 'checkpoint', 'snapshot', 'transport']);
   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']),
-  );
 });
 
-test('publication requires one current applied rail position and no unresolved send', () => {
-  const repoKey = 'root:currentness';
-  const project = require('../workspace/wall').projectForRepo(repoKey);
-  const resourceId = project.resourceId;
-  const file = project.file;
-  projectStream.writeSnapshot(file, projectStream._test.emptySnapshot(repoKey));
-  require('../state/replicas').registerReplica({
-    resourceId,
-    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`,
-    localPath: file,
+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: 1,
+    schemaVersion: 2,
     authorityEpoch: 1,
     appliedVersion: 12,
+    snapshotVersion: 0,
   });
 
-  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,
-  });
-  projectStream.publish(project, {
-    wall: 'code-project@6',
-    project: repoKey,
-    machine: 'machine-a',
-    mutationId: 'mut_currentness_pending_01',
-    publishedAt: '2026-07-26T00:00:00.000Z',
-    cards: [],
-  });
-  assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 12 }), {
-    receivedThrough: 12,
-    appliedThrough: 12,
-    pending: 1,
-    current: false,
-  });
+  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);
 });
 
-test('server rail numbers do not change checkpoint or parked identity', () => {
-  const oid = 'a'.repeat(40);
+test('server stamps and object locators do not invent new repo meaning', () => {
   const transition = {
     checkpoint: CHECKPOINT_CONTRACT,
     machine: 'machine-a',
-    repoKey: 'root:test',
+    repoKey: project.repoKey,
     branch: 'main',
-    baseOid: oid,
+    baseOid: HEAD,
     from: { revision: null, indexDiff: '', worktreeDiff: '' },
-    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) },
-    }],
+    to: { revision: 'b'.repeat(64), indexDiff: '', worktreeDiff: 'patch-a' },
   };
   assert.equal(sameTransition(transition, {
     ...transition,
-    mutationId: 'mut_server_metadata',
+    mutationId: 'mut_server_metadata_0001',
     version: 41,
-    parked: transition.parked.map((entry) => ({ ...entry, version: 41 })),
   }), true);
-  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('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 first = {
+    head: { branch: 'main', oid: HEAD, detached: false },
+    refs: [{ name: 'main', oid: HEAD, objects: bundle(HEAD, 'a') }],
   };
-  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 }],
+  const second = {
+    ...first,
+    objects: bundle(HEAD, 'b'),
+    refs: [{ ...first.refs[0], objects: bundle(HEAD, 'c') }],
   };
-  assert.equal(hasLocalContribution(local, plan, baseline, transition), false);
-
-  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: [{ ...localParked, version: 10 }, peerParked, unsentParked] },
-      local,
-    ),
-    [unsentParked],
-  );
-  assert.deepEqual(parkedForState([localParked], [], []), [localParked]);
-  assert.deepEqual(
-    parkedForState([localParked], [{ ...localParked, version: 10 }], []),
-    [{ ...localParked, version: 10 }],
-  );
-  assert.deepEqual(parkedForState([{ ...localParked, version: 10 }], [], []), []);
+  assert.equal(wall._test.sameCardState(first, second), true);
+  assert.equal(wall._test.sameCardState(first, {
+    ...second,
+    refs: [{ ...second.refs[0], oid: 'd'.repeat(40) }],
+  }), false);
 });
 
-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) },
-    }],
+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 }],
+      },
+    },
   };
-  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 },
+  const first = classifyBranchRefs(
+    {
+      card,
+      branches: [
+        { name: 'main', oid: HEAD },
+        { name: 'feature', oid: b },
+      ],
+    },
+    [
+      { name: 'main', oid: HEAD },
+      { name: 'feature', oid: c },
     ],
-    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);
+    owned,
+  );
+  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(acknowledged.pending, []);
+
+  const later = classifyBranchRefs(
+    {
+      card,
+      branches: [
+        { name: 'main', oid: HEAD },
+        { name: 'feature', oid: d },
+      ],
+    },
+    [
+      { name: 'main', oid: HEAD },
+      { name: 'feature', oid: c },
+    ],
+    null,
+  );
+  assert.deepEqual(later.changes, [{ branch: 'feature', expectedOid: c, oid: d }]);
 });
 
-test('a new card waits for its bundle instead of publishing transport metadata twice', () => {
-  const oldOid = 'a'.repeat(40);
-  const newOid = 'b'.repeat(40);
-  const plan = {
-    card: { head: { branch: 'main', oid: oldOid, detached: false } },
-    branches: [{ name: 'main', oid: oldOid }],
-  };
+test('a card waits for every referenced commit without creating transport events', () => {
   const pending = {
-    head: { branch: 'main', oid: newOid, detached: false },
+    head: { branch: 'main', oid: HEAD, detached: false },
     objects: { kind: 'pending' },
-    refs: [{ name: 'main', oid: newOid, objects: { kind: 'pending' } }],
+    refs: [{ name: 'main', oid: HEAD, objects: { kind: 'pending' } }],
   };
-  const ready = {
+  assert.equal(wall._test.hasPendingContributionObjects(pending), true);
+  assert.equal(wall._test.hasPendingContributionObjects({
     ...pending,
-    objects: { kind: 'bundle' },
-    refs: pending.refs.map((ref) => ({ ...ref, objects: { kind: 'bundle' } })),
-  };
-
-  assert.equal(wallTest.hasPendingContributionObjects(pending, plan), true);
-  assert.equal(wallTest.hasPendingContributionObjects(ready, plan), false);
-});
-
-test('an unnumbered branch waits for its bundle before sharing the card', () => {
-  const oid = 'b'.repeat(40);
-  const card = {
-    head: { branch: 'main', oid: 'a'.repeat(40) },
-    refs: [{ name: 'topic', oid, objects: { kind: 'pending' } }],
-  };
-  const plan = {
-    card: { head: { branch: 'main', oid: 'a'.repeat(40) } },
-    branches: [{ name: 'topic', oid, version: null }],
-  };
-  assert.equal(wallTest.hasPendingContributionObjects(card, plan), true);
-  plan.branches[0].version = 50;
-  assert.equal(wallTest.hasPendingContributionObjects(card, plan), false);
-});
-
-test('transport metadata without a real card, branch, or checkpoint change is silent', () => {
-  const previousMutation = 'mut_previous_content';
-  const metadataOnly = [{
-    positionMutationId: previousMutation,
-    branches: [{ name: 'main', mutationId: previousMutation }],
-    checkpoints: [{ mutationId: previousMutation }],
-  }];
-  assert.equal(wallTest.cardsUseMutation(metadataOnly, 'mut_new_transport_metadata'), false);
-  assert.equal(wallTest.cardsUseMutation([{
-    ...metadataOnly[0],
-    checkpoints: [{ mutationId: 'mut_real_checkpoint' }],
-  }], 'mut_real_checkpoint'), true);
-});
-
-test('a snapshot is exactly one latest numbered record per machine', () => {
-  const project = 'root:snapshot';
-  const snapshot = projectStream._test.emptySnapshot(project);
-  const record = (machine, mutationId, value) => ({
-    wall: 'code-project@6',
-    project,
-    machine,
-    mutationId,
-    publishedAt: '2026-07-26T00:00:00.000Z',
-    cards: [{ value }],
-  });
-  const afterA = projectStream._test.applyRecord(
-    snapshot,
-    record('machine-a', 'mut_snapshot_machine_a1', 'old-a'),
-    1,
-  );
-  const afterB = projectStream._test.applyRecord(
-    afterA,
-    record('machine-b', 'mut_snapshot_machine_b1', 'current-b'),
-    2,
-  );
-  const compacted = projectStream._test.applyRecord(
-    afterB,
-    record('machine-a', 'mut_snapshot_machine_a2', 'current-a'),
-    3,
-  );
-  assert.equal(compacted.version, 3);
-  assert.deepEqual(
-    compacted.records.map((entry) => [entry.machine, entry.version, entry.cards[0].value]),
-    [
-      ['machine-a', 3, 'current-a'],
-      ['machine-b', 2, 'current-b'],
-    ],
-  );
+    objects: bundle(),
+    refs: [{ ...pending.refs[0], objects: bundle() }],
+  }), false);
 });

package/runtime/scripts/amalgm-mcp/tests/workspace-reducer-liveness.test.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+const { repairDelayForPass } = require('../workspace/reducer');
+
+test('every non-terminal wait gets the same bounded repair retry', () => {
+  assert.equal(
+    repairDelayForPass([{ state: 'waiting', reason: 'a-new-reason-the-code-has-never-seen' }]),
+    1_000,
+  );
+  assert.equal(
+    repairDelayForPass([{ state: 'waiting', reason: 'another-reason' }]),
+    1_000,
+  );
+});
+
+test('a materialization pass is verified again after it moves the repo', () => {
+  assert.equal(repairDelayForPass([{ state: 'in-sync' }], true), 1_000);
+});
+
+test('settled repos and terminal corruption do not enter a fast retry loop', () => {
+  assert.equal(repairDelayForPass([{ state: 'in-sync' }]), null);
+  assert.equal(repairDelayForPass([{ state: 'error', reason: 'invalid official payload' }]), null);
+});