amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/workspace-native-file-transaction.test.js

@@ -1,364 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { execFile, execFileSync, spawn } = require('node:child_process');
-const { promisify } = require('node:util');
-
-const execFileAsync = promisify(execFile);
-
-test('checked-in descriptor-relative transaction binaries match their exact source', async () => {
-  const verifier = path.join(
-    __dirname,
-    '..',
-    'workspace',
-    'native-file-transaction',
-    'verify.mjs',
-  );
-  const { stdout } = await execFileAsync(process.execPath, [verifier]);
-  assert.match(stdout, /verified source [a-f0-9]{64} and 2 binaries/);
-});
-
-test('native process lifetime distinguishes live owners from exited PIDs', () => {
-  const platform = process.platform === 'darwin' && process.arch === 'arm64'
-    ? 'darwin-arm64'
-    : process.platform === 'linux' && process.arch === 'x64'
-      ? 'linux-x64'
-      : null;
-  if (platform === null) return;
-  const executable = path.join(
-    __dirname,
-    '..',
-    'workspace',
-    'native-file-transaction',
-    'bin',
-    platform,
-    'amalgm-file-transaction',
-  );
-  const identity = (pid) => JSON.parse(execFileSync(executable, [], {
-    input: JSON.stringify({
-      action: 'identity',
-      backend: 'process-identity',
-      pid,
-    }),
-    encoding: 'utf8',
-  }));
-
-  const current = identity(process.pid);
-  assert.equal(current.status, 'identified');
-  assert.match(current.identity, /.+/);
-  assert.equal(identity(1).status, 'identified');
-  assert.deepEqual(identity(2_147_483_647), { status: 'exited' });
-});
-
-test('same bytes on a replacement inode do not satisfy an exact document predecessor', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-file-cas-test-'));
-  const file = path.join(root, 'document.md');
-  fs.writeFileSync(file, 'same bytes\n', 'utf8');
-  const docDisk = require('../state/doc-disk');
-  const native = require('../workspace/native-file-transaction/client');
-  const expected = docDisk.observe(file);
-
-  const replacement = path.join(root, 'replacement.md');
-  fs.writeFileSync(replacement, 'same bytes\n', 'utf8');
-  fs.renameSync(replacement, file);
-
-  const targetContent = Buffer.from('new target\n', 'utf8');
-  const transaction = {
-    root: expected.root,
-    rootDev: expected.rootDev,
-    rootIno: expected.rootIno,
-    path: expected.relativePath,
-    id: crypto.createHash('sha256').update('same-byte-inode-cas').digest('hex'),
-    operation: 'same-byte-inode-cas',
-    expected: expected.identity,
-    target: docDisk.byteIdentity(targetContent),
-  };
-  try {
-    const result = native.run(transaction, 'apply', targetContent);
-    assert.equal(result.status, 'changed');
-    assert.equal(fs.readFileSync(file, 'utf8'), 'same bytes\n');
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('document observation stays with one physical parent across rename and replacement', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-file-observe-test-'));
-  const parent = path.join(root, 'registered-parent');
-  const renamed = path.join(root, 'uuid-owned-parent');
-  const file = path.join(parent, 'document.md');
-  fs.mkdirSync(parent);
-  fs.writeFileSync(file, 'owned bytes\n', 'utf8');
-  const originalParent = fs.statSync(parent, { bigint: true });
-  const child = spawn(process.execPath, [
-    '-e',
-    'const fs=require("fs");'
-      + `setTimeout(()=>{fs.renameSync(${JSON.stringify(parent)},${JSON.stringify(renamed)});`
-      + `fs.mkdirSync(${JSON.stringify(parent)});`
-      + `fs.writeFileSync(${JSON.stringify(file)},"unrelated bytes\\n","utf8");},75);`,
-  ], { stdio: 'ignore' });
-
-  try {
-    const observed = require('../state/doc-disk').observe(file, {
-      pauseAfterParentOpen: 350,
-    });
-    assert.equal(observed.text, 'owned bytes\n');
-    assert.equal(observed.rootDev, originalParent.dev.toString());
-    assert.equal(observed.rootIno, originalParent.ino.toString());
-    assert.notEqual(observed.text, fs.readFileSync(file, 'utf8'));
-  } finally {
-    child.unref();
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('receipt release keeps proof when its physical parent moved', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-receipt-move-test-'));
-  const parent = path.join(root, 'original-parent');
-  const movedParent = path.join(root, 'moved-parent');
-  const file = path.join(parent, 'document.md');
-  fs.mkdirSync(parent);
-  fs.writeFileSync(file, 'before\n', 'utf8');
-  const docDisk = require('../state/doc-disk');
-  const native = require('../workspace/native-file-transaction/client');
-  const expected = docDisk.observe(file);
-  const targetContent = Buffer.from('after\n', 'utf8');
-  const transaction = {
-    root: expected.root,
-    rootDev: expected.rootDev,
-    rootIno: expected.rootIno,
-    path: expected.relativePath,
-    id: crypto.createHash('sha256').update('moved-receipt-parent').digest('hex'),
-    operation: 'moved-receipt-parent',
-    expected: expected.identity,
-    target: docDisk.byteIdentity(targetContent),
-  };
-
-  try {
-    assert.equal(
-      native.run(transaction, 'apply', targetContent).status,
-      'applied',
-    );
-    fs.renameSync(parent, movedParent);
-
-    const retained = native.run(transaction, 'release');
-    assert.equal(retained.status, 'pending');
-    assert.match(retained.reason, /receipt parent is unavailable/);
-    assert.equal(
-      fs.existsSync(path.join(
-        movedParent,
-        `.amalgm-apply-${transaction.id}`,
-      )),
-      true,
-    );
-
-    const rebound = native.run({
-      ...transaction,
-      root: fs.realpathSync(movedParent),
-    }, 'release');
-    assert.equal(rebound.status, 'released');
-    assert.equal(
-      fs.existsSync(path.join(
-        movedParent,
-        `.amalgm-apply-${transaction.id}`,
-      )),
-      false,
-    );
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('exclusive tree moves preserve a destination created during the rename window', () => {
-  const native = require('../workspace/native-file-transaction/client');
-  for (const kind of ['file', 'directory']) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), `amalgm-tree-cas-${kind}-`));
-    const source = path.join(root, `source-${kind}`);
-    const destination = path.join(root, `destination-${kind}`);
-    if (kind === 'directory') {
-      fs.mkdirSync(source);
-      fs.writeFileSync(path.join(source, 'value.txt'), 'source directory\n', 'utf8');
-    } else {
-      fs.writeFileSync(source, 'source file\n', 'utf8');
-    }
-    const rootStats = fs.lstatSync(root, { bigint: true });
-    const sourceStats = fs.lstatSync(source, { bigint: true });
-    const child = spawn(process.execPath, [
-      '-e',
-      'const fs=require("fs");'
-        + `setTimeout(()=>{`
-        + (kind === 'directory'
-          ? `fs.mkdirSync(${JSON.stringify(destination)});`
-            + `fs.writeFileSync(${JSON.stringify(path.join(destination, 'value.txt'))},"racing directory\\n","utf8");`
-          : `fs.writeFileSync(${JSON.stringify(destination)},"racing file\\n","utf8");`)
-        + '},75);',
-    ], { stdio: 'ignore' });
-
-    try {
-      const result = native.moveNoReplace({
-        root: fs.realpathSync(root),
-        rootDev: rootStats.dev.toString(),
-        rootIno: rootStats.ino.toString(),
-        source: path.basename(source),
-        sourceIdentity: {
-          kind: kind === 'directory' ? 'folder' : kind,
-          dev: sourceStats.dev.toString(),
-          ino: sourceStats.ino.toString(),
-        },
-        sourceParentIdentity: {
-          kind: 'folder',
-          dev: rootStats.dev.toString(),
-          ino: rootStats.ino.toString(),
-        },
-        targetParentIdentity: {
-          kind: 'folder',
-          dev: rootStats.dev.toString(),
-          ino: rootStats.ino.toString(),
-        },
-        path: path.basename(destination),
-        id: crypto.createHash('sha256').update(`tree-cas-${kind}`).digest('hex'),
-        operation: `tree-cas-${kind}`,
-      }, {
-        pauseBeforeInstall: 300,
-      });
-      assert.equal(result.status, 'changed');
-      assert.match(result.reason, /destination changed/);
-      if (kind === 'directory') {
-        assert.equal(
-          fs.readFileSync(path.join(source, 'value.txt'), 'utf8'),
-          'source directory\n',
-        );
-        assert.equal(
-          fs.readFileSync(path.join(destination, 'value.txt'), 'utf8'),
-          'racing directory\n',
-        );
-      } else {
-        assert.equal(fs.readFileSync(source, 'utf8'), 'source file\n');
-        assert.equal(fs.readFileSync(destination, 'utf8'), 'racing file\n');
-      }
-    } finally {
-      child.unref();
-      fs.rmSync(root, { recursive: true, force: true });
-    }
-  }
-});
-
-test('exclusive tree moves restore a source name swapped during the rename window', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-tree-source-cas-'));
-  const source = path.join(root, 'source.txt');
-  const movedOriginal = path.join(root, 'moved-original.txt');
-  const destination = path.join(root, 'destination.txt');
-  fs.writeFileSync(source, 'original source\n', 'utf8');
-  const rootStats = fs.lstatSync(root, { bigint: true });
-  const sourceStats = fs.lstatSync(source, { bigint: true });
-  const child = spawn(process.execPath, [
-    '-e',
-    'const fs=require("fs");'
-      + `setTimeout(()=>{`
-      + `fs.renameSync(${JSON.stringify(source)},${JSON.stringify(movedOriginal)});`
-      + `fs.writeFileSync(${JSON.stringify(source)},"replacement source\\n","utf8");`
-      + '},75);',
-  ], { stdio: 'ignore' });
-
-  try {
-    const result = require('../workspace/native-file-transaction/client')
-      .moveNoReplace({
-        root: fs.realpathSync(root),
-        rootDev: rootStats.dev.toString(),
-        rootIno: rootStats.ino.toString(),
-        source: path.basename(source),
-        sourceIdentity: {
-          kind: 'file',
-          dev: sourceStats.dev.toString(),
-          ino: sourceStats.ino.toString(),
-        },
-        sourceParentIdentity: {
-          kind: 'folder',
-          dev: rootStats.dev.toString(),
-          ino: rootStats.ino.toString(),
-        },
-        targetParentIdentity: {
-          kind: 'folder',
-          dev: rootStats.dev.toString(),
-          ino: rootStats.ino.toString(),
-        },
-        path: path.basename(destination),
-        id: crypto.createHash('sha256').update('tree-source-cas').digest('hex'),
-        operation: 'tree-source-cas',
-      }, {
-        pauseBeforeInstall: 300,
-      });
-    assert.equal(result.status, 'changed');
-    assert.match(result.reason, /source changed during exclusive move and was restored/);
-    assert.equal(fs.existsSync(destination), false);
-    assert.equal(fs.readFileSync(source, 'utf8'), 'replacement source\n');
-    assert.equal(fs.readFileSync(movedOriginal, 'utf8'), 'original source\n');
-  } finally {
-    child.unref();
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('exclusive tree moves retain both names when a second source wins the undo race', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-tree-source-both-'));
-  const source = path.join(root, 'source.txt');
-  const movedOriginal = path.join(root, 'moved-original.txt');
-  const destination = path.join(root, 'destination.txt');
-  fs.writeFileSync(source, 'original source\n', 'utf8');
-  const rootStats = fs.lstatSync(root, { bigint: true });
-  const sourceStats = fs.lstatSync(source, { bigint: true });
-  const child = spawn(process.execPath, [
-    '-e',
-    'const fs=require("fs");'
-      + `setTimeout(()=>{`
-      + `fs.renameSync(${JSON.stringify(source)},${JSON.stringify(movedOriginal)});`
-      + `fs.writeFileSync(${JSON.stringify(source)},"first replacement\\n","utf8");`
-      + '},250);'
-      + `setTimeout(()=>{`
-      + `fs.writeFileSync(${JSON.stringify(source)},"second replacement\\n","utf8");`
-      + '},900);',
-  ], { stdio: 'ignore' });
-  try {
-    const result = require('../workspace/native-file-transaction/client')
-      .moveNoReplace({
-        root: fs.realpathSync(root),
-        rootDev: rootStats.dev.toString(),
-        rootIno: rootStats.ino.toString(),
-        source: path.basename(source),
-        sourceIdentity: {
-          kind: 'file',
-          dev: sourceStats.dev.toString(),
-          ino: sourceStats.ino.toString(),
-        },
-        sourceParentIdentity: {
-          kind: 'folder',
-          dev: rootStats.dev.toString(),
-          ino: rootStats.ino.toString(),
-        },
-        targetParentIdentity: {
-          kind: 'folder',
-          dev: rootStats.dev.toString(),
-          ino: rootStats.ino.toString(),
-        },
-        path: path.basename(destination),
-        id: crypto.createHash('sha256').update('tree-source-both').digest('hex'),
-        operation: 'tree-source-both',
-      }, {
-        pauseBeforeInstall: 600,
-        pauseAfterTreeMove: 600,
-      });
-    assert.equal(result.status, 'changed');
-    assert.match(result.reason, /both entries were retained/);
-    assert.equal(fs.readFileSync(movedOriginal, 'utf8'), 'original source\n');
-    assert.equal(fs.readFileSync(destination, 'utf8'), 'first replacement\n');
-    assert.equal(fs.readFileSync(source, 'utf8'), 'second replacement\n');
-  } finally {
-    child.unref();
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});

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

@@ -1,185 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const test = require('node:test');
-
-const provenance = require('../workspace/provenance');
-
-const {
-  ACTION,
-  CLASS,
-  STATE,
-  TRANSITIONS,
-  allStates,
-  provenanceClass,
-  publicationState,
-  requireTransition,
-} = provenance;
-
-const key = (from, action, to) => `${from} --${action}--> ${to}`;
-
-test('managed bytes have exactly three provenance classes', () => {
-  assert.deepEqual(Object.values(CLASS), [
-    'officially-applied',
-    'journaled-local-intent',
-    'unknown-provenance',
-  ]);
-  assert.deepEqual(
-    [...new Set(allStates.map(provenanceClass))].sort(),
-    Object.values(CLASS).sort(),
-  );
-  assert.equal(allStates.every((state) => provenanceClass(state) !== null), true);
-});
-
-test('the complete provenance transition relation has no implicit branch', () => {
-  const legal = new Set(TRANSITIONS.map((entry) => key(
-    entry.from,
-    entry.action,
-    entry.to,
-  )));
-  assert.equal(legal.size, TRANSITIONS.length, 'every transition is named once');
-
-  for (const from of allStates) {
-    for (const action of Object.values(ACTION)) {
-      for (const to of allStates) {
-        const transitionKey = key(from, action, to);
-        if (legal.has(transitionKey)) {
-          const entry = TRANSITIONS.find((candidate) => (
-            key(candidate.from, candidate.action, candidate.to) === transitionKey
-          ));
-          assert.ok(entry.facts.length > 0, `${transitionKey} names its durable facts`);
-          assert.equal(
-            requireTransition(from, action, to, entry.facts),
-            entry,
-            transitionKey,
-          );
-        } else {
-          assert.throws(
-            () => requireTransition(from, action, to),
-            /illegal provenance transition/,
-            transitionKey,
-          );
-        }
-      }
-    }
-  }
-});
-
-test('publication substates keep numbering, folding, and physical apply distinct', () => {
-  const publication = {
-    mutationId: 'mutation_provenance_state_01',
-    numberedVersion: null,
-    numberedAt: null,
-    foldedAt: null,
-  };
-  assert.equal(publicationState(null), STATE.CAPTURED);
-  assert.equal(publicationState(publication), STATE.RESERVED);
-  assert.equal(publicationState({
-    ...publication,
-    numberedVersion: 51,
-    numberedAt: '2026-07-27T00:00:00.000Z',
-  }), STATE.NUMBERED);
-  assert.equal(publicationState({
-    ...publication,
-    numberedVersion: 51,
-    numberedAt: '2026-07-27T00:00:00.000Z',
-    foldedAt: '2026-07-27T00:00:01.000Z',
-  }), STATE.FOLDED);
-
-  assert.throws(
-    () => requireTransition(
-      STATE.RESERVED,
-      ACTION.NUMBER,
-      STATE.NUMBERED,
-      ['publication-id', 'official-version'],
-    ),
-    /server-receipt/,
-  );
-  assert.throws(
-    () => requireTransition(
-      STATE.NUMBERED,
-      ACTION.APPLY,
-      STATE.OFFICIAL,
-      [],
-    ),
-    /illegal provenance transition/,
-    'numbered work must fold before physical apply',
-  );
-});
-
-test('unknown bytes can only verify, capture, or remain unknown', () => {
-  const outgoing = TRANSITIONS
-    .filter((entry) => entry.from === STATE.UNKNOWN)
-    .map((entry) => [entry.action, entry.to])
-    .sort();
-  assert.deepEqual(outgoing, [
-    [ACTION.CAPTURE, STATE.CAPTURED],
-    [ACTION.OBSERVE_UNKNOWN, STATE.UNKNOWN],
-    [ACTION.RECOVER, STATE.UNKNOWN],
-    [ACTION.SNAPSHOT, STATE.OFFICIAL],
-    [ACTION.SNAPSHOT, STATE.UNKNOWN],
-    [ACTION.VERIFY, STATE.OFFICIAL],
-  ].sort());
-  assert.equal(
-    outgoing.some(([action]) => (
-      action === ACTION.RESERVE
-      || action === ACTION.RETRY
-      || action === ACTION.APPLY
-    )),
-    false,
-  );
-});
-
-test('server compaction, local journal prune, and intent retirement are distinct', () => {
-  const prunes = TRANSITIONS.filter((entry) => entry.action === ACTION.PRUNE);
-  assert.deepEqual(prunes[0], {
-    from: STATE.FOLDED,
-    action: ACTION.PRUNE,
-    to: STATE.FOLDED,
-    facts: [
-      'official-fold',
-      'durable-folded-intent',
-    ],
-  });
-  assert.deepEqual(prunes[1], {
-    from: STATE.OFFICIAL,
-    action: ACTION.PRUNE,
-    to: STATE.OFFICIAL,
-    facts: [
-      'official-fold',
-      'physical-verification',
-      'applied-cursor',
-    ],
-  });
-  const compact = TRANSITIONS.find((entry) => entry.action === ACTION.COMPACT);
-  assert.deepEqual(compact.facts, [
-    'retained-server-receipt',
-    'verified-server-snapshot',
-  ]);
-  const physicalApply = TRANSITIONS.find((entry) => (
-    entry.from === STATE.FOLDED
-    && entry.action === ACTION.APPLY
-    && entry.to === STATE.OFFICIAL
-  ));
-  assert.deepEqual(physicalApply.facts.slice(-3), [
-    'physical-verification',
-    'applied-cursor',
-    'intent-retired',
-  ]);
-});
-
-test('WAL recovery keeps source and target provenance but exposes any third value', () => {
-  for (const state of allStates.filter((candidate) => candidate !== STATE.UNKNOWN)) {
-    assert.ok(TRANSITIONS.some((entry) => (
-      entry.from === state
-      && entry.action === ACTION.RECOVER
-      && entry.to === state
-    )));
-    assert.ok(TRANSITIONS.some((entry) => (
-      entry.from === state
-      && entry.action === ACTION.RECOVER
-      && entry.to === STATE.UNKNOWN
-      && entry.facts.includes('exact-third-value-observation')
-    )));
-  }
-});

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

@@ -1,26 +0,0 @@
-'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);
-});

package/runtime/scripts/amalgm-mcp/tests/workspace-sync-stats.test.js

@@ -1,119 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const test = require('node:test');
-const {
-  autoUpdateDisabled,
-  digest,
-  folderFor,
-  pendingIntentValue,
-  syncFingerprintFiles,
-  verificationFor,
-} = require('../workspace/sync-stats')._test;
-
-test('snapshot digest is content-derived rather than key-order-derived', () => {
-  assert.equal(
-    digest({ version: 7, records: [{ machine: 'm', cards: [] }] }),
-    digest({ records: [{ cards: [], machine: 'm' }], version: 7 }),
-  );
-});
-
-test('registered folder UUID and exact path identify the listening checkout', () => {
-  const project = { repoKey: 'repo', path: '/code/repo' };
-  const cards = [{
-    kind: 'primary',
-    path: '/wrong',
-    repo: { remote: 'repo' },
-  }];
-  const workspaces = [{ id: 'folder-uuid', path: '/code/repo' }];
-  assert.deepEqual(folderFor(project, cards, workspaces), {
-    card: cards[0],
-    folderPath: '/code/repo',
-    folderUuid: 'folder-uuid',
-  });
-});
-
-test('verification exposes one pending intent and named waits without hidden branches', () => {
-  const pendingIntent = {
-    baseThrough: 4,
-    semanticDigest: 'intent',
-    mutationId: null,
-    terminalCode: null,
-  };
-  const value = verificationFor({
-    verificationContract: 'verified-repo-state@1',
-    appliedThrough: 4,
-    materialized: false,
-    targetDigest: 'target',
-    expectedPhysicalDigest: 'expected',
-    observedPhysicalDigest: 'observed',
-  }, {
-    state: 'waiting',
-    reason: 'physical-state-mismatch',
-  }, pendingIntent);
-  assert.equal(value.appliedThrough, 4);
-  assert.equal(value.materialized, false);
-  assert.equal(value.pendingIntent, pendingIntent);
-  assert.equal(Object.hasOwn(value, 'pendingCard'), false);
-  assert.equal(Object.hasOwn(value, 'pendingRefs'), false);
-  assert.equal(Object.hasOwn(value, 'pendingCheckpoint'), false);
-  assert.deepEqual(value.waiting, [
-    { state: 'waiting', reason: 'physical-state-mismatch' },
-  ]);
-});
-
-test('verification keeps the open successor visible after its predecessor is numbered', () => {
-  assert.deepEqual(pendingIntentValue({
-    base: { through: 4 },
-    semanticDigest: 'predecessor',
-    publication: { mutationId: 'mutation-a' },
-    terminal: null,
-    successor: {
-      predecessorSemanticDigest: 'predecessor',
-      semanticDigest: 'successor',
-      terminal: null,
-    },
-  }, false), {
-    baseThrough: 4,
-    semanticDigest: 'predecessor',
-    mutationId: 'mutation-a',
-    terminalCode: null,
-    successor: {
-      predecessorSemanticDigest: 'predecessor',
-      semanticDigest: 'successor',
-      mutationId: null,
-      terminalCode: null,
-    },
-  });
-});
-
-test('auto-update state reflects only the runtime launch policy', () => {
-  assert.equal(autoUpdateDisabled({ AMALGM_DISABLE_AUTO_UPDATE: '1' }), true);
-  assert.equal(autoUpdateDisabled({ AMALGM_AUTO_UPDATE: 'off' }), true);
-  assert.equal(autoUpdateDisabled({ AMALGM_AUTO_UPDATE: '1' }), false);
-});
-
-test('the sync fingerprint follows the complete state and workspace trees', () => {
-  for (const file of [
-    'state/doc-disk.js',
-    'state/docs.js',
-    'workspace/native-file-transaction/client.js',
-    'workspace/native-file-transaction/main.go',
-    'workspace/native-file-transaction/manifest.json',
-    'workspace/transition.js',
-  ]) {
-    assert.ok(syncFingerprintFiles.includes(file), `${file} must be release-bound`);
-  }
-  assert.ok(
-    syncFingerprintFiles.some((file) => (
-      file === 'workspace/native-file-transaction/bin/darwin-arm64/amalgm-file-transaction'
-    )),
-    'the Darwin helper must be release-bound',
-  );
-  assert.ok(
-    syncFingerprintFiles.some((file) => (
-      file === 'workspace/native-file-transaction/bin/linux-x64/amalgm-file-transaction'
-    )),
-    'the Linux helper must be release-bound',
-  );
-});