@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-motion-reference-publication-journal.mjs

@@ -0,0 +1,264 @@
+import {
+  getToolcraftMotionReferenceBackupPath,
+  TOOLCRAFT_MOTION_PUBLICATION_JOURNAL_VERSION,
+  validateToolcraftMotionPublicationJournalScope,
+} from "./toolcraft-motion-reference-publication-journal-schema.mjs";
+import {
+  createToolcraftMotionPublicationJournalStore,
+} from "./toolcraft-motion-reference-publication-journal-store.mjs";
+import {
+  requireToolcraftMotionReferenceStagingScope,
+} from "./toolcraft-motion-reference-publication-staging.mjs";
+
+function fail(message, cause) {
+  throw new Error(`Toolcraft motion reference publication journal failed: ${message}`, {
+    cause,
+  });
+}
+
+function requireHeartbeat(heartbeat) {
+  if (typeof heartbeat !== "function") fail("a lock-owner heartbeat is required");
+}
+
+async function rollbackPreparing(store, journal) {
+  try {
+    if (journal.phase !== "rolling-back") {
+      journal.phase = "rolling-back";
+      await store.write(journal);
+    }
+    for (const [index, record] of journal.records.entries()) {
+      if (record.published) {
+        if (!(await store.status(record.finalDirectory))?.isDirectory()) {
+          fail(`published final is incomplete: ${record.finalDirectory}`);
+        }
+        journal.operation = { index, kind: "remove-published" };
+        await store.write(journal);
+        await store.checked(() => store.fileSystem.rm(
+          record.finalDirectory, { force: true, recursive: true },
+        ));
+        record.published = false;
+        journal.operation = null;
+        await store.write(journal);
+      }
+      if (record.backedUp) {
+        const backup = await store.status(record.backupDirectory);
+        if (!backup?.isDirectory()) {
+          fail(`old group backup is incomplete: ${record.backupDirectory}`);
+        }
+        if (await store.status(record.finalDirectory)) {
+          fail(`old group final blocks restoration: ${record.finalDirectory}`);
+        }
+        journal.operation = { index, kind: "restore-backup" };
+        await store.write(journal);
+        await store.checked(() => store.fileSystem.rename(
+          record.backupDirectory, record.finalDirectory,
+        ));
+        record.backedUp = false;
+        journal.operation = null;
+        await store.write(journal);
+      }
+    }
+    await store.remove();
+  } catch (error) {
+    if (error.message?.startsWith("Toolcraft motion reference publication journal failed:")) {
+      throw error;
+    }
+    fail("the complete old group could not be restored", error);
+  }
+}
+
+async function reconcileOperation(store, journal) {
+  if (journal.operation === null) return;
+  const record = journal.records[journal.operation.index];
+  const final = await store.status(record.finalDirectory);
+  const backup = await store.status(record.backupDirectory);
+  const staging = record.stagingDirectory === null ? undefined :
+    await store.status(record.stagingDirectory);
+  if (journal.operation.kind === "backup") {
+    if (backup?.isDirectory() && !final) record.backedUp = true;
+    else if (final?.isDirectory() && !backup) record.backedUp = false;
+    else fail("interrupted backup mutation has ambiguous filesystem state");
+  } else if (journal.operation.kind === "publish" && final?.isDirectory() && !staging) {
+    record.published = true;
+  } else if (journal.operation.kind === "publish" && !final && staging?.isDirectory()) {
+    record.published = false;
+  } else if (journal.operation.kind === "remove-published" && !final) {
+    record.published = false;
+  } else if (journal.operation.kind === "remove-published" && final?.isDirectory()) {
+    record.published = true;
+  } else if (journal.operation.kind === "restore-backup" && final?.isDirectory() && !backup) {
+    record.backedUp = false;
+  } else if (journal.operation.kind === "restore-backup" && !final && backup?.isDirectory()) {
+    record.backedUp = true;
+  } else {
+    fail("interrupted publication or rollback mutation has ambiguous filesystem state");
+  }
+  journal.operation = null;
+}
+
+async function cleanupCommitted(store, journal) {
+  const retainedBackups = [];
+  const warnings = [];
+  for (const record of journal.records) {
+    const final = await store.status(record.finalDirectory);
+    if (record.kind === "publish" && !final?.isDirectory()) {
+      fail(`committed final is missing: ${record.finalDirectory}`);
+    }
+    if (record.kind === "retire" && final) {
+      fail(`committed retired final still exists: ${record.finalDirectory}`);
+    }
+    if (!record.backedUp) continue;
+    await store.heartbeat();
+    try {
+      await store.fileSystem.rm(
+        record.backupDirectory, { force: true, recursive: true },
+      );
+    } catch {
+      retainedBackups.push(record.backupDirectory);
+      warnings.push(`Committed study retained backup for cleanup by the next lock holder: ${record.backupDirectory}`);
+      continue;
+    }
+    await store.heartbeat();
+    record.backedUp = false;
+    await store.write(journal);
+  }
+  if (journal.records.every(({ backedUp }) => !backedUp)) {
+    await store.heartbeat();
+    try {
+      await store.fileSystem.rm(store.journalPath, { force: true });
+    } catch {
+      warnings.push(`Committed studies retained publication journal for cleanup by the next lock holder: ${store.journalPath}`);
+    }
+    await store.heartbeat();
+  }
+  return { committed: true, retainedBackups, warnings };
+}
+
+async function assertNoUnexplainedBackups(store) {
+  const entries = await store.checked(() => store.fileSystem.readdir(
+    store.transactionRoot, { withFileTypes: true },
+  ));
+  if (entries.length > 0) {
+    fail(`unexplained transaction residue exists without a publication journal: ${store.transactionRoot}`);
+  }
+}
+
+export async function recoverToolcraftMotionReferencePublication({
+  artifactRoot,
+  fileSystem,
+  heartbeat,
+  journalPath,
+  sourceIdentity,
+  temporaryRoot,
+  token,
+  transactionRoot,
+}) {
+  requireHeartbeat(heartbeat);
+  const store = createToolcraftMotionPublicationJournalStore({
+    fileSystem, heartbeat, journalPath, sourceIdentity, token, transactionRoot,
+  });
+  const journal = await store.read();
+  if (!journal) {
+    await assertNoUnexplainedBackups(store);
+    return { warnings: [] };
+  }
+  validateToolcraftMotionPublicationJournalScope(journal, {
+    artifactRoot, temporaryRoot, transactionRoot,
+  });
+  await requireToolcraftMotionReferenceStagingScope(journal.records, {
+    allowMissingStagingDirectories: true,
+    fileSystem,
+    sourceIdentity,
+    temporaryRoot,
+  });
+  if (["preparing", "rolling-back"].includes(journal.phase)) {
+    const hadOperation = journal.operation !== null;
+    await reconcileOperation(store, journal);
+    if (hadOperation) await store.write(journal);
+    await rollbackPreparing(store, journal);
+    await assertNoUnexplainedBackups(store);
+    return { warnings: [] };
+  }
+  const cleanup = await cleanupCommitted(store, journal);
+  if (cleanup.warnings.length > 0) {
+    fail(`committed journal cleanup remains incomplete: ${cleanup.warnings.join(" ")}`);
+  }
+  await assertNoUnexplainedBackups(store);
+  return { warnings: [] };
+}
+
+async function createJournal(store, pairs, sourceIdentity) {
+  const records = [];
+  for (const pair of pairs) records.push({
+    backedUp: false,
+    backupDirectory: getToolcraftMotionReferenceBackupPath(
+      store.transactionRoot, pair.finalDirectory,
+    ),
+    finalDirectory: pair.finalDirectory,
+    hadOld: Boolean(await store.status(pair.finalDirectory)),
+    kind: pair.stagingDirectory === null ? "retire" : "publish",
+    published: false,
+    stagingDirectory: pair.stagingDirectory,
+  });
+  if (records.some((record) => record.kind === "retire" && !record.hadOld)) {
+    fail("an obsolete final disappeared before the retirement transaction began");
+  }
+  return {
+    operation: null, phase: "preparing", records, sourceIdentity,
+    version: TOOLCRAFT_MOTION_PUBLICATION_JOURNAL_VERSION,
+  };
+}
+
+export async function publishToolcraftMotionReferenceJournaledGroup(options) {
+  requireHeartbeat(options.heartbeat);
+  const store = createToolcraftMotionPublicationJournalStore(options);
+  const journal = await createJournal(store, options.pairs, options.sourceIdentity);
+  await store.write(journal);
+  try {
+    for (const [index, record] of journal.records.entries()) {
+      if (!record.hadOld) continue;
+      journal.operation = { index, kind: "backup" };
+      await store.write(journal);
+      await store.checked(() => store.fileSystem.rename(
+        record.finalDirectory, record.backupDirectory,
+      ));
+      record.backedUp = true;
+      journal.operation = null;
+      await store.write(journal);
+    }
+    for (const [index, record] of journal.records.entries()) {
+      if (record.kind !== "publish") continue;
+      journal.operation = { index, kind: "publish" };
+      await store.write(journal);
+      await store.checked(() => store.fileSystem.rename(
+        record.stagingDirectory, record.finalDirectory,
+      ));
+      record.published = true;
+      journal.operation = null;
+      await store.write(journal);
+    }
+    for (const record of journal.records) {
+      const final = await store.status(record.finalDirectory);
+      if (record.kind === "publish" && !final?.isDirectory()) {
+        fail(`staged final is incomplete: ${record.finalDirectory}`);
+      }
+      if (record.kind === "retire" && final) {
+        fail(`obsolete final was not retired: ${record.finalDirectory}`);
+      }
+    }
+    journal.phase = "committed";
+    await store.write(journal);
+  } catch (error) {
+    journal.phase = "preparing";
+    try {
+      const hadOperation = journal.operation !== null;
+      await reconcileOperation(store, journal);
+      if (hadOperation) await store.write(journal);
+      await rollbackPreparing(store, journal);
+    } catch (restoreError) {
+      fail(`${error.message}; rollback also failed: ${restoreError.message}`, error);
+    }
+    fail(error.message, error);
+  }
+  return cleanupCommitted(store, journal);
+}

package/templates/starter/scripts/toolcraft-motion-reference-publication-journal.test.mjs

@@ -0,0 +1,377 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  publishToolcraftMotionReferenceJournaledGroup,
+  recoverToolcraftMotionReferencePublication,
+} from "./toolcraft-motion-reference-publication-journal.mjs";
+import {
+  getToolcraftMotionReferenceBackupPath,
+  getToolcraftMotionReferencePublicationJournalPath,
+} from "./toolcraft-motion-reference-publication-journal-schema.mjs";
+
+const sourceIdentity = `motion-reference-v1-${"a".repeat(64)}`;
+const noHeartbeat = async () => {};
+const backupPath = (transactionRoot, finalDirectory) =>
+  getToolcraftMotionReferenceBackupPath(transactionRoot, finalDirectory);
+
+async function exists(target) {
+  return fs.stat(target).then(() => true, (error) => {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  });
+}
+
+test("uses a stable journal sibling and atomic temp-to-journal writes around every rename",
+  async (context) => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "motion-journal-"));
+    context.after(() => fs.rm(root, { force: true, recursive: true }));
+    const lockDirectory = path.join(root, "source.lock");
+    const journalPath = getToolcraftMotionReferencePublicationJournalPath(lockDirectory);
+    const transactionRoot = path.join(root, "transaction");
+    const finalDirectory = path.join(root, "final");
+    const stagingDirectory = path.join(
+      root, `${sourceIdentity}.staging`, path.basename(finalDirectory),
+    );
+    await fs.mkdir(finalDirectory);
+    await fs.writeFile(path.join(finalDirectory, "version"), "old");
+    await fs.mkdir(stagingDirectory, { recursive: true });
+    await fs.mkdir(transactionRoot);
+    await fs.writeFile(path.join(stagingDirectory, "version"), "new");
+    const renames = [];
+    const events = [];
+    const heartbeat = async () => { events.push("heartbeat"); };
+    const fileSystem = {
+      ...fs,
+      rm: async (target, options) => {
+        if (target === journalPath || target.startsWith(transactionRoot)) {
+          events.push("mutation");
+        }
+        return fs.rm(target, options);
+      },
+      rename: async (from, to) => {
+        renames.push([from, to]);
+        if (to === journalPath || from === finalDirectory || from === stagingDirectory) {
+          events.push("mutation");
+        }
+        return fs.rename(from, to);
+      },
+      writeFile: async (target, ...args) => {
+        if (target.startsWith(`${journalPath}.tmp-`)) events.push("mutation");
+        return fs.writeFile(target, ...args);
+      },
+    };
+    const result = await publishToolcraftMotionReferenceJournaledGroup({
+      fileSystem,
+      heartbeat,
+      journalPath,
+      pairs: [{ finalDirectory, stagingDirectory }],
+      sourceIdentity,
+      token: "journal-token",
+      transactionRoot,
+    });
+    assert.equal(journalPath, `${lockDirectory}.publication.json`);
+    assert.equal(result.committed, true);
+    const publicationRename = renames.findIndex(([from]) => from === stagingDirectory);
+    assert.ok(publicationRename > 0);
+    assert.ok(renames.slice(0, publicationRename).some(([from, to]) =>
+      from.startsWith(`${journalPath}.tmp-`) && to === journalPath));
+    assert.ok(renames.filter(([from, to]) =>
+      from.startsWith(`${journalPath}.tmp-`) && to === journalPath).length >= 4);
+    for (const [index, event] of events.entries()) if (event === "mutation") {
+      assert.equal(events[index - 1], "heartbeat");
+      assert.equal(events[index + 1], "heartbeat");
+    }
+    assert.equal(await fs.readFile(path.join(finalDirectory, "version"), "utf8"), "new");
+    assert.equal(await exists(journalPath), false);
+  });
+
+test("rejects noncanonical journal bytes without guessing filesystem state", async (context) => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "motion-journal-"));
+  context.after(() => fs.rm(root, { force: true, recursive: true }));
+  const lockDirectory = path.join(root, "source.lock");
+  const journalPath = getToolcraftMotionReferencePublicationJournalPath(lockDirectory);
+  const transactionRoot = path.join(root, "transaction");
+  const finalDirectory = path.join(root, "final");
+  const stagingDirectory = path.join(
+    root, `${sourceIdentity}.staging`, path.basename(finalDirectory),
+  );
+  await fs.mkdir(stagingDirectory, { recursive: true });
+  await fs.mkdir(transactionRoot);
+  await fs.writeFile(journalPath, JSON.stringify({
+    operation: null,
+    phase: "preparing",
+    records: [{ backedUp: false,
+      backupDirectory: backupPath(transactionRoot, finalDirectory), finalDirectory,
+      hadOld: false, kind: "publish", published: false, stagingDirectory }],
+    sourceIdentity,
+    version: 4,
+  }));
+  await assert.rejects(() => recoverToolcraftMotionReferencePublication({
+    artifactRoot: root,
+    fileSystem: fs,
+    heartbeat: noHeartbeat,
+    journalPath,
+    sourceIdentity,
+    temporaryRoot: root,
+    token: "journal-token",
+    transactionRoot,
+  }), /canonical serialization/iu);
+  assert.equal(await exists(journalPath), true);
+  assert.equal(await exists(finalDirectory), false);
+});
+
+test("rejects a journal backup outside its checked transaction root",
+  async (context) => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "motion-journal-scope-"));
+    context.after(() => fs.rm(root, { force: true, recursive: true }));
+    const journalPath = `${path.join(root, "source.lock")}.publication.json`;
+    const transactionRoot = path.join(root, "transaction");
+    const finalDirectory = path.join(root, "final");
+    const stagingDirectory = path.join(
+      root, `${sourceIdentity}.staging`, path.basename(finalDirectory),
+    );
+    await Promise.all([
+      fs.mkdir(transactionRoot),
+      fs.mkdir(stagingDirectory, { recursive: true }),
+    ]);
+    await fs.writeFile(journalPath, `${JSON.stringify({
+      operation: null,
+      phase: "preparing",
+      records: [{
+        backedUp: false,
+        backupDirectory: path.join(root, "outside-backup"),
+        finalDirectory,
+        hadOld: false,
+        kind: "publish",
+        published: false,
+        stagingDirectory,
+      }],
+      sourceIdentity,
+      version: 4,
+    }, null, 2)}\n`);
+
+    await assert.rejects(() => recoverToolcraftMotionReferencePublication({
+      artifactRoot: root, fileSystem: fs, heartbeat: noHeartbeat, journalPath,
+      sourceIdentity, temporaryRoot: root, token: "journal-token", transactionRoot,
+    }), /canonical unique absolute publication records|transaction roots/iu);
+    assert.equal(await exists(stagingDirectory), true);
+    assert.equal(await exists(finalDirectory), false);
+  });
+
+test("rejects a journal staging symlink before rollback mutation",
+  async (context) => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "motion-journal-stage-"));
+    context.after(() => fs.rm(root, { force: true, recursive: true }));
+    const journalPath = `${path.join(root, "source.lock")}.publication.json`;
+    const transactionRoot = path.join(root, "transaction");
+    const finalDirectory = path.join(root, "final");
+    const backupDirectory = backupPath(transactionRoot, finalDirectory);
+    const outsideParent = path.join(root, "outside");
+    const linkedParent = path.join(root, "linked");
+    const stagingDirectory = path.join(
+      linkedParent, `${sourceIdentity}.staging`, path.basename(finalDirectory),
+    );
+    await Promise.all([
+      fs.mkdir(finalDirectory),
+      fs.mkdir(backupDirectory, { recursive: true }),
+      fs.mkdir(path.join(outsideParent, `${sourceIdentity}.staging`), {
+        recursive: true,
+      }),
+    ]);
+    await Promise.all([
+      fs.writeFile(path.join(finalDirectory, "version"), "new"),
+      fs.writeFile(path.join(backupDirectory, "version"), "old"),
+    ]);
+    await fs.symlink(outsideParent, linkedParent, "dir");
+    await fs.writeFile(journalPath, `${JSON.stringify({
+      operation: null,
+      phase: "preparing",
+      records: [{
+        backedUp: true,
+        backupDirectory,
+        finalDirectory,
+        hadOld: true,
+        kind: "publish",
+        published: true,
+        stagingDirectory,
+      }],
+      sourceIdentity,
+      version: 4,
+    }, null, 2)}\n`);
+
+    await assert.rejects(() => recoverToolcraftMotionReferencePublication({
+      artifactRoot: root, fileSystem: fs, heartbeat: noHeartbeat, journalPath,
+      sourceIdentity, temporaryRoot: root, token: "journal-token", transactionRoot,
+    }), /staging.*links|staging.*link/iu);
+    assert.equal(await fs.readFile(path.join(finalDirectory, "version"), "utf8"),
+      "new");
+    assert.equal(await fs.readFile(path.join(backupDirectory, "version"), "utf8"),
+      "old");
+    assert.equal(await exists(journalPath), true);
+  });
+
+test("reconciles a crash after final rename but before its published-state write",
+  async (context) => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "motion-journal-"));
+    context.after(() => fs.rm(root, { force: true, recursive: true }));
+    const journalPath = `${path.join(root, "source.lock")}.publication.json`;
+    const transactionRoot = path.join(root, "transaction");
+    const finalDirectory = path.join(root, "final");
+    const backupDirectory = backupPath(transactionRoot, finalDirectory);
+    const previousStaging = path.join(
+      root, "previous", `${sourceIdentity}.staging`, path.basename(finalDirectory),
+    );
+    await fs.mkdir(finalDirectory);
+    await fs.mkdir(transactionRoot);
+    await fs.writeFile(path.join(finalDirectory, "version"), "interrupted-new");
+    await fs.mkdir(backupDirectory);
+    await fs.writeFile(path.join(backupDirectory, "version"), "old");
+    const journal = {
+      operation: { index: 0, kind: "publish" },
+      phase: "preparing",
+      records: [{
+        backedUp: true,
+        backupDirectory,
+        finalDirectory,
+        hadOld: true,
+        kind: "publish",
+        published: false,
+        stagingDirectory: previousStaging,
+      }],
+      sourceIdentity,
+      version: 4,
+    };
+    await fs.writeFile(journalPath, `${JSON.stringify(journal, null, 2)}\n`);
+    const events = [];
+    const heartbeat = async () => { events.push("heartbeat"); };
+    const fileSystem = {
+      ...fs,
+      rename: async (from, to) => {
+        if (to === journalPath ||
+            (from === backupDirectory && to === finalDirectory)) {
+          events.push("mutation");
+        }
+        return fs.rename(from, to);
+      },
+      rm: async (target, options) => {
+        if (target === finalDirectory || target === journalPath) {
+          events.push("mutation");
+        }
+        return fs.rm(target, options);
+      },
+      writeFile: async (target, ...args) => {
+        if (target.startsWith(`${journalPath}.tmp-`)) events.push("mutation");
+        return fs.writeFile(target, ...args);
+      },
+    };
+    await recoverToolcraftMotionReferencePublication({
+      artifactRoot: root,
+      fileSystem,
+      heartbeat,
+      journalPath,
+      sourceIdentity,
+      temporaryRoot: root,
+      token: "journal-token",
+      transactionRoot,
+    });
+    assert.equal(await fs.readFile(path.join(finalDirectory, "version"), "utf8"), "old");
+    assert.equal(await exists(backupDirectory), false);
+    assert.equal(await exists(journalPath), false);
+    for (const [index, event] of events.entries()) if (event === "mutation") {
+      assert.equal(events[index - 1], "heartbeat");
+      assert.equal(events[index + 1], "heartbeat");
+    }
+  });
+
+test("recovers the complete old group after a crash following every rollback mutation",
+  async (context) => {
+    for (const crashAfter of [1, 2, 3, 4]) await context.test(
+      `rollback mutation ${crashAfter}`,
+      async (subtest) => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), "motion-rollback-"));
+        subtest.after(() => fs.rm(root, { force: true, recursive: true }));
+        const journalPath = `${path.join(root, "source.lock")}.publication.json`;
+        const transactionRoot = path.join(root, "transaction");
+        await fs.mkdir(transactionRoot);
+        const records = [];
+        const previousStagingRoot = path.join(
+          root, "previous", `${sourceIdentity}.staging`,
+        );
+        for (const name of ["overview", "analysis"]) {
+          const finalDirectory = path.join(root, name);
+          const backupDirectory = backupPath(transactionRoot, finalDirectory);
+          const stagingDirectory = path.join(previousStagingRoot, name);
+          await fs.mkdir(finalDirectory);
+          await fs.writeFile(path.join(finalDirectory, "version"), `new-${name}`);
+          await fs.mkdir(backupDirectory);
+          await fs.writeFile(path.join(backupDirectory, "version"), `old-${name}`);
+          records.push({
+            backedUp: true, backupDirectory, finalDirectory, hadOld: true,
+            kind: "publish", published: true, stagingDirectory,
+          });
+        }
+        const journal = {
+          operation: null,
+          phase: "preparing",
+          records,
+          sourceIdentity,
+          version: 4,
+        };
+        await fs.writeFile(journalPath, `${JSON.stringify(journal, null, 2)}\n`);
+        const finals = new Set(records.map(({ finalDirectory }) => finalDirectory));
+        const backups = new Set(records.map(({ backupDirectory }) => backupDirectory));
+        let mutations = 0;
+        const crash = () => {
+          mutations += 1;
+          if (mutations === crashAfter) {
+            throw Object.assign(new Error(`injected rollback crash ${crashAfter}`), {
+              code: "EIO",
+            });
+          }
+        };
+        const crashingFileSystem = {
+          ...fs,
+          rename: async (from, to) => {
+            await fs.rename(from, to);
+            if (backups.has(from) && finals.has(to)) crash();
+          },
+          rm: async (target, options) => {
+            await fs.rm(target, options);
+            if (finals.has(target)) crash();
+          },
+        };
+        await assert.rejects(() => recoverToolcraftMotionReferencePublication({
+          artifactRoot: root,
+          fileSystem: crashingFileSystem,
+          heartbeat: noHeartbeat,
+          journalPath,
+          sourceIdentity,
+          temporaryRoot: root,
+          token: `crash-${crashAfter}`,
+          transactionRoot,
+        }), /old group|rollback|injected/iu);
+        await recoverToolcraftMotionReferencePublication({
+          artifactRoot: root,
+          fileSystem: fs,
+          heartbeat: noHeartbeat,
+          journalPath,
+          sourceIdentity,
+          temporaryRoot: root,
+          token: `restart-${crashAfter}`,
+          transactionRoot,
+        });
+        for (const { backupDirectory, finalDirectory } of records) {
+          assert.equal(await fs.readFile(path.join(finalDirectory, "version"), "utf8"),
+            `old-${path.basename(finalDirectory)}`);
+          assert.equal(await exists(backupDirectory), false);
+        }
+        assert.equal(await exists(journalPath), false);
+        assert.deepEqual(await fs.readdir(transactionRoot), []);
+        assert.deepEqual((await fs.readdir(root)).filter((name) =>
+          name.includes(".publication.json") || name.includes(".tmp-")), []);
+      });
+  });