amalgm 0.1.245 → 0.1.246

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

@@ -28,8 +28,6 @@ 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',
@@ -141,20 +139,6 @@ 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,
@@ -328,169 +312,6 @@ 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 = {
@@ -523,133 +344,3 @@ 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);
-});