amalgm 0.1.238 → 0.1.240

package/runtime/scripts/amalgm-mcp/tests/state-mutations.test.js

@@ -28,6 +28,8 @@ const {
   pruneMutationJournal,
 } = require('../state/mutations');
 const { getReplicaByResourceId, registerReplica } = require('../state/replicas');
+const { codeProjectOrderIsDurable } = require('../state/mutation-contracts');
+const projectStream = require('../workspace/project-stream');
 
 const localInput = {
   channelId: 'doc:local-journal-test',
@@ -139,6 +141,20 @@ test('a lost local acknowledgement reuses the journal row and event', () => {
     listMutations({ database: db }).filter((mutation) => mutation.mutationId === localInput.mutationId).length,
     1,
   );
+  assert.deepEqual(
+    listMutations({
+      database: db,
+      localResource: localInput.localResource,
+    }).map((mutation) => mutation.mutationId),
+    [localInput.mutationId],
+  );
+  assert.deepEqual(
+    listMutations({
+      database: db,
+      localResource: 'doc:unrelated-resource',
+    }),
+    [],
+  );
   assert.equal(
     listEventsAfter(0).filter((event) => event.mutationId === localInput.mutationId).length,
     1,
@@ -312,6 +328,169 @@ test('the official tail reconciles a locally materialized mutation after its ack
   );
 });
 
+test('an early acknowledgement cannot advance past an unapplied predecessor', () => {
+  const db = openLocalDb();
+  const resourceId = 'shr_orderedprojectionabc';
+  const localSecond = {
+    ...sharedInput,
+    channelId: `resource:${resourceId}`,
+    sharedResourceId: resourceId,
+    localResource: 'doc:ordered-projection-test',
+    mutationId: 'mut_ordered_projection_02',
+    operation: { kind: 'delta', yjs: 'ERIT' },
+  };
+  registerReplica({
+    resourceId,
+    localResource: localSecond.localResource,
+    localPath: path.join(tempRoot, 'ordered-projection.md'),
+    contract: localSecond.contract,
+    schemaVersion: localSecond.schemaVersion,
+    authorityEpoch: localSecond.authorityEpoch,
+    appliedVersion: 0,
+    snapshotVersion: 0,
+  }, { database: db });
+  commitLocalMutation(localSecond, {
+    database: db,
+    materialize() {},
+    event: eventFor(localSecond),
+  });
+
+  const acknowledged = acknowledgeCloudMutation(
+    resourceId,
+    localSecond.mutationId,
+    { version: 2, committedAt: '2026-07-14T18:00:20.000Z' },
+    { database: db },
+  );
+  assert.equal(acknowledged.mutation.officialCloudVersion, 2);
+  assert.equal(acknowledged.mutation.officialProjectedAt, null);
+  assert.equal(
+    getReplicaByResourceId(resourceId, { database: db }).appliedVersion,
+    0,
+    'an acknowledgement records order but does not claim that order was applied',
+  );
+
+  const firstEnvelope = {
+    resourceId,
+    authorityEpoch: 1,
+    mutationId: 'mut_ordered_projection_01',
+    deviceId: 'device-test-peer',
+    baseVersion: 0,
+    contract: localSecond.contract,
+    schemaVersion: localSecond.schemaVersion,
+    operationKind: 'delta',
+    operation: { kind: 'delta', yjs: 'FBUW' },
+  };
+  const first = journalCloudMutation({
+    localResource: localSecond.localResource,
+    version: 1,
+    committedAt: '2026-07-14T18:00:19.000Z',
+    envelope: firstEnvelope,
+  }, { database: db });
+  completeMaterializedMutation(
+    first.mutation.channelId,
+    first.mutation.mutationId,
+    eventFor({
+      ...localSecond,
+      mutationId: firstEnvelope.mutationId,
+      operation: firstEnvelope.operation,
+    }),
+    { database: db },
+  );
+  assert.equal(
+    getReplicaByResourceId(resourceId, { database: db }).appliedVersion,
+    1,
+    'applying N-1 still cannot skip the acknowledged but unapplied N',
+  );
+
+  const second = journalCloudMutation({
+    localResource: localSecond.localResource,
+    version: 2,
+    committedAt: '2026-07-14T18:00:20.000Z',
+    envelope: {
+      resourceId,
+      authorityEpoch: localSecond.authorityEpoch,
+      mutationId: localSecond.mutationId,
+      deviceId: localSecond.deviceId,
+      baseVersion: localSecond.baseCloudVersion,
+      contract: localSecond.contract,
+      schemaVersion: localSecond.schemaVersion,
+      operationKind: localSecond.operationKind,
+      operation: localSecond.operation,
+    },
+  }, { database: db });
+  assert.equal(second.alreadyApplied, true);
+  assert.ok(second.mutation.officialProjectedAt);
+  assert.equal(getReplicaByResourceId(resourceId, { database: db }).appliedVersion, 2);
+  assert.equal(
+    listEventsAfter(0).filter((event) => (
+      event.resource === localSecond.localResource
+      && event.mutationId === localSecond.mutationId
+    )).length,
+    1,
+    'the official confirmation does not replay an already-local non-code write',
+  );
+});
+
+test('a code publication is either fully outbox-ready or absent after a SQLite abort', () => {
+  const db = openLocalDb();
+  const resourceId = '018f0000-0000-7000-8000-000000000061';
+  const input = {
+    channelId: `resource:${resourceId}`,
+    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`,
+    sharedResourceId: resourceId,
+    mutationId: 'mut_code_atomic_commit_01',
+    deviceId: 'device-code-atomic',
+    authorityEpoch: 1,
+    baseCloudVersion: 0,
+    contract: projectStream.STREAM_CONTRACT,
+    schemaVersion: 2,
+    operationKind: 'code.publish',
+    operation: {
+      kind: 'code.publish',
+      project: resourceId,
+      delta: { kind: 'test-only' },
+    },
+  };
+  const event = {
+    resource: input.localResource,
+    op: 'update',
+    id: path.join(tempRoot, 'atomic-code.json'),
+    source: 'test:code-atomic',
+  };
+  db.exec(`
+    CREATE TRIGGER abort_code_atomic_commit
+    BEFORE UPDATE OF mutation_state ON mutation_journal
+    WHEN NEW.mutation_id = 'mut_code_atomic_commit_01'
+      AND NEW.mutation_state = 'saved-local'
+    BEGIN
+      SELECT RAISE(ABORT, 'simulated SQLite abort');
+    END;
+  `);
+
+  assert.throws(
+    () => commitLocalMutation(input, { database: db, event }),
+    /simulated SQLite abort/,
+  );
+  assert.equal(
+    getMutation(input.channelId, input.mutationId, { database: db }),
+    null,
+    'the journal insert rolls back with the outbox-ready update',
+  );
+  assert.equal(
+    listEventsAfter(0).filter((entry) => entry.mutationId === input.mutationId).length,
+    0,
+  );
+
+  db.exec('DROP TRIGGER abort_code_atomic_commit');
+  const retried = commitLocalMutation(input, { database: db, event });
+  assert.equal(retried.mutation.state, 'saved-local');
+  assert.ok(retried.mutation.eventSeq);
+  assert.equal(
+    listEventsAfter(0).filter((entry) => entry.mutationId === input.mutationId).length,
+    1,
+  );
+});
+
 test('retention deletes only completed rows and preserves unresolved cloud work', () => {
   const db = openLocalDb();
   const pendingInput = {
@@ -344,3 +523,133 @@ test('retention deletes only completed rows and preserves unresolved cloud work'
   assert.equal(getMutation(pendingInput.channelId, pendingInput.mutationId, { database: db }).state, 'saved-local');
   assert.equal(getMutation(rejectedInput.channelId, rejectedInput.mutationId, { database: db }).state, 'rejected');
 });
+
+test('retention keeps a code mutation until its official fold has another durable recovery fact', () => {
+  const db = openLocalDb();
+  const resourceId = '018f0000-0000-7000-8000-000000000060';
+  const file = path.join(tempRoot, 'code-prune-guard.json');
+  const mutationId = 'mut_code_prune_guard_01';
+  const deviceId = 'device-code-prune';
+  const oid = 'a'.repeat(40);
+  const chunks = [{ sha256: 'b'.repeat(64), bytes: 1 }];
+  const bundle = {
+    kind: 'bundle',
+    contract: projectStream.BUNDLE_CONTRACT,
+    resourceId,
+    oid,
+    ref: `refs/amalgm/exports/${oid}`,
+    checksum: require('crypto').createHash('sha256').update(JSON.stringify(chunks)).digest('hex'),
+    bytes: 1,
+    chunks,
+  };
+  const operation = {
+    kind: 'code.publish',
+    project: resourceId,
+    delta: {
+      kind: 'card.set',
+      card: projectStream.CARD_CONTRACT,
+      head: { branch: 'main', oid, detached: false },
+      objects: bundle,
+      branches: [{ name: 'main', oid, objects: bundle }],
+      checkpoint: {
+        checkpoint: projectStream.CHECKPOINT_CONTRACT,
+        baseOid: oid,
+        branch: 'main',
+        value: { revision: null, indexDiff: '', worktreeDiff: '' },
+      },
+    },
+  };
+  const input = {
+    channelId: `resource:${resourceId}`,
+    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`,
+    sharedResourceId: resourceId,
+    mutationId,
+    deviceId,
+    authorityEpoch: 1,
+    baseCloudVersion: 0,
+    contract: projectStream.STREAM_CONTRACT,
+    schemaVersion: 2,
+    operationKind: 'code.publish',
+    operation,
+  };
+  projectStream.writeSnapshot(file, projectStream._test.emptySnapshot(resourceId));
+  registerReplica({
+    resourceId,
+    localResource: input.localResource,
+    localPath: file,
+    contract: input.contract,
+    schemaVersion: input.schemaVersion,
+    authorityEpoch: input.authorityEpoch,
+    appliedVersion: 0,
+    snapshotVersion: 0,
+  }, { database: db });
+  commitLocalMutation(input, {
+    database: db,
+    event: {
+      resource: input.localResource,
+      op: 'update',
+      id: file,
+      source: 'test:code-project-outbox',
+    },
+  });
+  const claimed = claimCloudMutations({ database: db })
+    .find((entry) => entry.mutation.mutationId === mutationId);
+  acknowledgeCloudMutation(
+    resourceId,
+    mutationId,
+    { version: 1, committedAt: '2026-07-14T19:00:01.000Z' },
+    { database: db },
+  );
+  db.prepare('UPDATE mutation_journal SET updated_at = ? WHERE mutation_id = ?')
+    .run('2026-07-13T00:00:00.000Z', mutationId);
+
+  pruneMutationJournal({
+    database: db,
+    cutoffIso: '2026-07-14T00:00:00.000Z',
+    batchSize: 100,
+  });
+  assert.ok(
+    getMutation(input.channelId, mutationId, { database: db }),
+    'the journal remains while it is the only durable copy of the official number',
+  );
+  assert.equal(projectStream.readSnapshot(file, resourceId).version, 0);
+
+  projectStream.applyCloudMutation({
+    version: 1,
+    committedAt: '2026-07-14T19:00:01.000Z',
+    envelope: claimed.envelope,
+  }, { database: db });
+  const journalRow = db.prepare(
+    'SELECT * FROM mutation_journal WHERE mutation_id = ?',
+  ).get(mutationId);
+  const canonicalSnapshot = projectStream.readSnapshot(file, resourceId);
+  assert.equal(
+    codeProjectOrderIsDurable(journalRow, { database: db, snapshotCache: new Map() }),
+    true,
+  );
+  fs.writeFileSync(file, `${JSON.stringify({
+    schemaVersion: 2,
+    project: resourceId,
+    version: 1,
+    card: null,
+    checkpoint: null,
+  })}\n`);
+  assert.equal(
+    codeProjectOrderIsDurable(journalRow, { database: db, snapshotCache: new Map() }),
+    false,
+    'snapshot-shaped JSON is not a canonical verified official snapshot',
+  );
+  projectStream.writeSnapshot(file, canonicalSnapshot);
+  db.prepare('UPDATE mutation_journal SET updated_at = ? WHERE mutation_id = ?')
+    .run('2026-07-13T00:00:00.000Z', mutationId);
+  pruneMutationJournal({
+    database: db,
+    cutoffIso: '2026-07-14T00:00:00.000Z',
+    batchSize: 100,
+  });
+  assert.ok(
+    getMutation(input.channelId, mutationId, { database: db }),
+    'an unbound snapshot alone cannot replace the local folded-intent recovery fact',
+  );
+  assert.equal(projectStream.readSnapshot(file, resourceId).version, 1);
+});