@underpostnet/cyberia 3.3.73 → 3.3.77

package/test/unit/conf-resolution.test.js

@@ -35,6 +35,7 @@ import {
   resolveHostKeyContext,
   resolveReplicaCount,
   syncDeployIdSources,
+  syncDeployIdSourcesBack,
   syncPrivateConf,
   updatePrivateEngineTestRepo,
   updatePrivateTemplateRepo,
@@ -712,6 +713,23 @@ describe('private conf sync', () => {
     expect(copied).to.include('./engine-private/catalog/items.json -> ../engine-core-private/catalog/items.json');
   });
 
+  // Regression: an instance backup that dropped an item left the item's stale atlas in the
+  // mirror, and the pod restored it over the current one from another instance.
+  it('replaces each payload entry in the checkout instead of merging into it', () => {
+    const calls = [];
+    checkout({ present: true });
+    vi.spyOn(fs, 'readdirSync').mockReturnValue([]);
+    vi.spyOn(fs, 'removeSync').mockImplementation((target) => calls.push(`remove ${target}`));
+    vi.spyOn(fs, 'copySync').mockImplementation((src, dest) => calls.push(`copy ${src} -> ${dest}`));
+    withEnv({ GITHUB_USERNAME: 'fixture-org' }, () => syncPrivateConf('dd-core', ['cyberia-instances/TEST']));
+    const remove = calls.indexOf('remove ../engine-core-private/cyberia-instances/TEST');
+    const copy = calls.indexOf(
+      'copy ./engine-private/cyberia-instances/TEST -> ../engine-core-private/cyberia-instances/TEST',
+    );
+    expect(remove).to.be.greaterThan(-1);
+    expect(copy).to.be.greaterThan(remove);
+  });
+
   it('mirrors the cron conf the checkout declares', () => {
     const copied = [];
     checkout({ present: true, cronId: 'dd-cron' });
@@ -740,17 +758,50 @@ describe('private conf sync', () => {
     expect(syncDeployIdSources([])).to.equal(false);
   });
 
-  it('moves every declared source that is present, skipping the rest', () => {
-    const moved = [];
-    vi.spyOn(fs, 'existsSync').mockImplementation((filePath) => `${filePath}`.includes('present'));
-    vi.spyOn(fs, 'moveSync').mockImplementation((src, dest) => moved.push(`${src} -> ${dest}`));
+  it('copies in only the sources the engine tree lacks, and never moves', () => {
+    // Regression: the repo copy used to be moved over the engine copy, so a build discarded
+    // every edit made in the engine tree and left the repo reading as wholesale deletions.
+    const calls = [];
+    const present = new Set(['../engine-x/src/new.js', '../engine-x/src/edited.js', 'src/api/edited.js']);
+    vi.spyOn(fs, 'mkdirSync').mockImplementation(() => {});
+    vi.spyOn(fs, 'existsSync').mockImplementation((filePath) => present.has(`${filePath}`));
+    vi.spyOn(fs, 'removeSync').mockImplementation((target) => calls.push(`remove ${target}`));
+    vi.spyOn(fs, 'copySync').mockImplementation((src, dest) => calls.push(`copy ${src} -> ${dest}`));
+    vi.spyOn(fs, 'moveSync').mockImplementation(() => calls.push('move'));
     expect(
       syncDeployIdSources([
-        ['src/present.js', 'src/api/present.js'],
-        ['src/absent.js', 'src/api/absent.js'],
+        ['../engine-x/src/new.js', 'src/api/new.js'],
+        ['../engine-x/src/edited.js', 'src/api/edited.js'],
+        ['../engine-x/src/absent.js', 'src/api/absent.js'],
       ]),
     ).to.equal(true);
-    expect(moved).to.deep.equal(['src/present.js -> src/api/present.js']);
+    expect(calls).to.deep.equal([
+      // The engine copy wins: it is mirrored out before anything is copied in.
+      'remove ../engine-x/src/edited.js',
+      'copy src/api/edited.js -> ../engine-x/src/edited.js',
+      'copy ../engine-x/src/new.js -> src/api/new.js',
+    ]);
+  });
+
+  it('mirrors every source the tree holds back to its repo, replacing it whole', () => {
+    // The engine ignores the moved-in paths, so the source repo is the only place a change to
+    // them is diffed; replacing rather than overlaying makes deletions reach that diff too.
+    const calls = [];
+    vi.spyOn(fs, 'existsSync').mockImplementation((filePath) => `${filePath}`.includes('present'));
+    vi.spyOn(fs, 'removeSync').mockImplementation((target) => calls.push(`remove ${target}`));
+    vi.spyOn(fs, 'copySync').mockImplementation((src, dest) => calls.push(`copy ${src} -> ${dest}`));
+    vi.spyOn(fs, 'moveSync').mockImplementation(() => calls.push('move'));
+    expect(
+      syncDeployIdSourcesBack([
+        ['../engine-x/src/present.js', 'src/api/present.js'],
+        ['../engine-x/src/absent.js', 'src/api/absent.js'],
+      ]),
+    ).to.deep.equal(['../engine-x/src/present.js']);
+    expect(calls).to.deep.equal([
+      'remove ../engine-x/src/present.js',
+      'copy src/api/present.js -> ../engine-x/src/present.js',
+    ]);
+    expect(syncDeployIdSourcesBack()).to.deep.equal([]);
   });
 });
 

package/test/unit/coverage-artifact.test.js

@@ -13,95 +13,186 @@ import { expect } from 'chai';
 import fs from 'fs-extra';
 import {
   COVERAGE_BUNDLE_DIRECTORY,
-  bundleCoverageReport,
+  bundleCoverageReports,
   coverageReportCandidates,
+  coverageReportCommand,
+  coverageReportsFactory,
   coverageUnavailablePage,
+  deployCoverageReports,
   resolveCoverageReportPath,
 } from '../../src/server/build/coverage.js';
 import { EXECUTION_PROFILE_ENV_KEY } from '../../src/server/build/execution.js';
 import { isTestRuntime, runtimeStatusWritable } from '../../src/server/runtime/runtime-status.js';
 
+describe('coverage report declaration', () => {
+  it('reads each declared report with its label defaulting to the id', () => {
+    expect(coverageReportsFactory({ coverage: [{ id: 'engine', suite: 'unit' }] })).to.deep.equal([
+      { id: 'engine', label: 'engine', suite: 'unit', path: undefined },
+    ]);
+  });
+
+  it('declares nothing for a deploy without coverage', () => {
+    expect(coverageReportsFactory({})).to.deep.equal([]);
+    expect(coverageReportsFactory(undefined)).to.deep.equal([]);
+  });
+
+  it('rejects an entry without exactly one source, a non-slug id, or a repeated id', () => {
+    expect(() => coverageReportsFactory({ coverage: [{ id: 'x' }] })).to.throw("exactly one of 'suite' or 'path'");
+    expect(() => coverageReportsFactory({ coverage: [{ id: 'x', suite: 'unit', path: './' }] })).to.throw(
+      'exactly one',
+    );
+    expect(() => coverageReportsFactory({ coverage: [{ id: 'Bad Id', suite: 'unit' }] })).to.throw('slug');
+    expect(() =>
+      coverageReportsFactory({
+        coverage: [
+          { id: 'x', suite: 'unit' },
+          { id: 'x', suite: 'app' },
+        ],
+      }),
+    ).to.throw('declared twice');
+  });
+
+  it("collects a deploy's reports across routes once each", () => {
+    const route = { docs: { coverage: [{ id: 'engine', suite: 'unit' }] } };
+    const confServer = { 'a.test': { '/': route, '/store': route }, 'b.test': { '/': {} } };
+    expect(deployCoverageReports(confServer).map(({ id }) => id)).to.deep.equal(['engine']);
+  });
+
+  it('refuses one id declared with two sources', () => {
+    const confServer = {
+      'a.test': {
+        '/': { docs: { coverage: [{ id: 'engine', suite: 'unit' }] } },
+        '/store': { docs: { coverage: [{ id: 'engine', suite: 'app' }] } },
+      },
+    };
+    expect(() => deployCoverageReports(confServer)).to.throw('two different sources');
+  });
+
+  it('names the command that produces each kind of report', () => {
+    expect(coverageReportCommand({ suite: 'unit,infra,app' })).to.equal('node bin test unit,infra,app');
+    expect(coverageReportCommand({ path: './hardhat/' })).to.equal('npm run coverage --prefix ./hardhat');
+  });
+});
+
 describe('coverage report resolution', () => {
   let fixturePath;
+  let cwd;
 
+  // The bundled candidate is cwd-relative, and a published deploy artifact (the tree a
+  // downstream CI runs this suite in) carries real reports under it; resolve against the
+  // fixture, never the tree.
   beforeEach(() => {
     fixturePath = fs.mkdtempSync('/tmp/engine-coverage-artifact-');
+    cwd = process.cwd();
+    process.chdir(fixturePath);
   });
 
   afterEach(() => {
+    process.chdir(cwd);
     fs.removeSync(fixturePath);
   });
 
-  it('looks for a run output first and the bundled artifact last', () => {
-    expect(coverageReportCandidates('/src/')).to.deep.equal([
+  it("looks for a suite's own run output first and the bundled artifact last", () => {
+    expect(coverageReportCandidates({ id: 'engine', suite: 'unit,infra,app' })).to.deep.equal([
+      'coverage/unit-infra-app',
+      `${COVERAGE_BUNDLE_DIRECTORY}/engine`,
+    ]);
+  });
+
+  it("looks through an external tree's report layouts before the bundled artifact", () => {
+    expect(coverageReportCandidates({ id: 'hardhat', path: '/src/' })).to.deep.equal([
       '/src/coverage/html',
       '/src/coverage/lcov-report',
       '/src/coverage',
-      `/src/${COVERAGE_BUNDLE_DIRECTORY}`,
+      `${COVERAGE_BUNDLE_DIRECTORY}/hardhat`,
     ]);
   });
 
-  it('has nowhere to look without a source tree', () => {
-    expect(coverageReportCandidates(undefined)).to.deep.equal([]);
-    expect(resolveCoverageReportPath(undefined)).to.equal(undefined);
-  });
-
   it('ignores a coverage directory that carries no HTML index', () => {
     fs.outputFileSync(`${fixturePath}/coverage/lcov.info`, 'TN:\n');
-    expect(resolveCoverageReportPath(fixturePath)).to.equal(undefined);
+    expect(resolveCoverageReportPath({ id: 'x', path: fixturePath })).to.equal(undefined);
   });
 
-  it('resolves the bundled artifact when no run wrote a report', () => {
-    fs.outputFileSync(`${fixturePath}/${COVERAGE_BUNDLE_DIRECTORY}/index.html`, '<!doctype html>');
-    expect(resolveCoverageReportPath(fixturePath)).to.equal(`${fixturePath}/${COVERAGE_BUNDLE_DIRECTORY}`);
+  it('resolves the report of the selection the deploy names, not the last run made', () => {
+    fs.outputFileSync(`${fixturePath}/coverage/unit-infra-app-cyberia/index.html`, '<!doctype html>');
+    fs.outputFileSync(`${fixturePath}/coverage/cyberia/index.html`, '<!doctype html>');
+    expect(resolveCoverageReportPath({ id: 'x', suite: 'cyberia' })).to.equal('coverage/cyberia');
+    expect(resolveCoverageReportPath({ id: 'x', suite: 'unit,infra,app' })).to.equal(undefined);
+  });
+
+  it('falls back to the report a deploy artifact already carries', () => {
+    fs.outputFileSync(`${fixturePath}/${COVERAGE_BUNDLE_DIRECTORY}/hardhat/index.html`, '<!doctype html>');
+    expect(resolveCoverageReportPath({ id: 'hardhat', path: `${fixturePath}/hardhat` })).to.equal(
+      `${COVERAGE_BUNDLE_DIRECTORY}/hardhat`,
+    );
   });
 });
 
 describe('coverage bundling into a deploy artifact', () => {
   let fixturePath;
+  let cwd;
 
+  // The bundled candidate is cwd-relative, and a published deploy artifact (the tree a
+  // downstream CI runs this suite in) carries real reports under it; resolve against the
+  // fixture, never the tree.
   beforeEach(() => {
     fixturePath = fs.mkdtempSync('/tmp/engine-coverage-artifact-');
+    cwd = process.cwd();
+    process.chdir(fixturePath);
   });
 
   afterEach(() => {
+    process.chdir(cwd);
     fs.removeSync(fixturePath);
   });
 
-  it('carries the report into the artifact at the published path', () => {
-    fs.outputFileSync(`${fixturePath}/engine/coverage/lcov-report/index.html`, '<!doctype html><title>report</title>');
-    fs.outputFileSync(`${fixturePath}/engine/coverage/lcov-report/base.css`, 'body {}');
+  it('carries each report into the artifact under its own id', () => {
+    fs.outputFileSync(`${fixturePath}/hardhat/coverage/html/index.html`, '<!doctype html><title>report</title>');
+    fs.outputFileSync(`${fixturePath}/hardhat/coverage/html/base.css`, 'body {}');
 
-    const result = bundleCoverageReport(`${fixturePath}/engine`, `${fixturePath}/template`);
+    const [result] = bundleCoverageReports(
+      [{ id: 'hardhat', path: `${fixturePath}/hardhat` }],
+      `${fixturePath}/template`,
+    );
 
     expect(result.bundled).to.equal(true);
-    expect(result.to).to.equal(`${fixturePath}/template/${COVERAGE_BUNDLE_DIRECTORY}`);
+    expect(result.to).to.equal(`${fixturePath}/template/${COVERAGE_BUNDLE_DIRECTORY}/hardhat`);
     expect(fs.readFileSync(`${result.to}/index.html`, 'utf8')).to.include('report');
     expect(fs.existsSync(`${result.to}/base.css`)).to.equal(true);
   });
 
   it('replaces a previously bundled report rather than merging into it', () => {
-    fs.outputFileSync(`${fixturePath}/template/${COVERAGE_BUNDLE_DIRECTORY}/stale.html`, 'stale');
-    fs.outputFileSync(`${fixturePath}/engine/coverage/html/index.html`, '<!doctype html><title>fresh</title>');
+    fs.outputFileSync(`${fixturePath}/template/${COVERAGE_BUNDLE_DIRECTORY}/hardhat/stale.html`, 'stale');
+    fs.outputFileSync(`${fixturePath}/hardhat/coverage/index.html`, '<!doctype html><title>fresh</title>');
 
-    const { to } = bundleCoverageReport(`${fixturePath}/engine`, `${fixturePath}/template`);
+    const [{ to }] = bundleCoverageReports(
+      [{ id: 'hardhat', path: `${fixturePath}/hardhat` }],
+      `${fixturePath}/template`,
+    );
 
     expect(fs.existsSync(`${to}/stale.html`)).to.equal(false);
     expect(fs.readFileSync(`${to}/index.html`, 'utf8')).to.include('fresh');
   });
 
-  it('reports that nothing was bundled without creating the directory', () => {
-    const result = bundleCoverageReport(`${fixturePath}/engine`, `${fixturePath}/template`);
-
-    expect(result.bundled).to.equal(false);
+  it('reports what was not bundled without creating its directory', () => {
+    const [result] = bundleCoverageReports(
+      [{ id: 'hardhat', path: `${fixturePath}/hardhat` }],
+      `${fixturePath}/template`,
+    );
+
+    expect(result).to.deep.equal({
+      id: 'hardhat',
+      bundled: false,
+      to: `${fixturePath}/template/${COVERAGE_BUNDLE_DIRECTORY}/hardhat`,
+    });
     expect(fs.existsSync(result.to)).to.equal(false);
   });
 
-  it('renders a static unavailable page that never points at a runtime test run', () => {
-    const page = coverageUnavailablePage();
+  it('renders a static unavailable page naming the report and the run that produces it', () => {
+    const page = coverageUnavailablePage({ id: 'engine', suite: 'unit,infra,app' });
     expect(page).to.include('Coverage report unavailable');
-    expect(page).to.include('npm run test:coverage');
-    expect(page).to.include(COVERAGE_BUNDLE_DIRECTORY);
+    expect(page).to.include('node bin test unit,infra,app');
+    expect(page).to.include(`${COVERAGE_BUNDLE_DIRECTORY}/engine`);
     expect(page).not.to.include('<script');
   });
 });

package/test/unit/cyberia/instance-backup.test.js

@@ -0,0 +1,183 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// The restore path only routes documents; the collections are in-memory stand-ins, IPFS is
+// unreachable, and the static frame writer is a no-op, so what is asserted is the routing.
+const models = {};
+vi.mock('../../../src/db/DataBaseProvider.js', () => ({
+  DataBaseProviderService: { getModel: (name) => models[name] },
+}));
+vi.mock('../../../src/api/ipfs/ipfs.service.js', () => ({ createPinRecord: async () => ({}) }));
+vi.mock('../../../src/projects/cyberia/ipfs-client.js', () => ({ IpfsClient: { addToIpfs: async () => null } }));
+vi.mock('../../../src/projects/cyberia/object-layer.js', () => ({
+  ObjectLayerEngine: { writeStaticFrameAssets: async () => [], computeAndSaveFinalSha256: async () => ({}) },
+}));
+// The generator pulls in jimp, a cyberia product dependency the engine runner does not install;
+// every store method that would reach it is spied out below, so only the constant is needed.
+vi.mock('../../../src/projects/cyberia/atlas-sprite-sheet-generator.js', () => ({
+  AtlasSpriteSheetGenerator: {},
+  DEFAULT_ATLAS_UPSCALE_FACTOR: 20,
+}));
+
+const { AtlasSpriteSheetStore } = await import('../../../src/projects/cyberia/atlas-sprite-sheet-store.js');
+const { atlasBackupFileKey, readObjectLayerBackup, restoreObjectLayerBackup } =
+  await import('../../../src/projects/cyberia/instance-backup.js');
+
+/** A collection that remembers what was created and hands the last upsert back as the live document. */
+const collection = () => {
+  const created = [];
+  let live = null;
+  const query = (value) => Object.assign(Promise.resolve(value), { populate: () => Promise.resolve(value) });
+  return {
+    created,
+    deleteOne: async () => ({ deletedCount: 0 }),
+    create: async (doc) => (created.push(doc), doc),
+    findByItemId: () => query(live),
+    upsertByItemId: async (doc) => {
+      live = { ...doc, markModified() {}, save: async () => live };
+      return live;
+    },
+    get live() {
+      return live;
+    },
+  };
+};
+
+let backupDir;
+const write = (rel, value) => writeFile(join(backupDir, rel), Buffer.isBuffer(value) ? value : JSON.stringify(value));
+
+beforeAll(async () => {
+  backupDir = await mkdtemp(join(tmpdir(), 'cyberia-backup-'));
+  for (const dir of ['object-layers', 'render-frames', 'atlas-sprite-sheets', 'files', 'ipfs/content']) {
+    await mkdir(join(backupDir, dir), { recursive: true });
+  }
+  await write('object-layers/hatchet.json', {
+    _id: 'ol1',
+    cid: 'cid-data',
+    objectLayerRenderFramesId: 'rf1',
+    atlasSpriteSheetId: 'at1',
+    data: { item: { id: 'hatchet', type: 'weapon' }, render: { cid: 'cid-png', metadataCid: 'cid-meta' } },
+  });
+  await write('render-frames/hatchet.json', { _id: 'rf1', frames: {}, colors: [], frame_duration: 100 });
+  await write('atlas-sprite-sheets/hatchet.json', {
+    _id: 'at1',
+    fileId: 'f-full',
+    minifyFileId: 'f-min',
+    idlePreviewFileId: 'f-idle',
+    cid: 'cid-png',
+  });
+  // Files are matched on _id, never on name: one is misnamed on purpose, one is a bystander.
+  await write('files/whatever.json', {
+    _id: 'f-full',
+    name: 'hatchet-atlas.png',
+    data: { $base64: Buffer.from('PNG').toString('base64') },
+  });
+  await write('files/atlas-minify-hatchet.json', {
+    _id: 'f-min',
+    name: 'hatchet-minify.png',
+    data: { type: 'Buffer', data: [1, 2, 3] },
+  });
+  await write('files/atlas-idle-hatchet.json', { _id: 'f-idle', name: 'hatchet-idle.png', data: { $base64: 'AA==' } });
+  await write('files/atlas-sword.json', { _id: 'f-other', name: 'sword-atlas.png', data: { $base64: 'AA==' } });
+  await write('ipfs/content/cid-data.bin', Buffer.from('data'));
+  await write('ipfs/content/cid-png.bin', Buffer.from('png'));
+  // cid-meta has no payload on purpose.
+});
+
+afterAll(() => rm(backupDir, { recursive: true, force: true }));
+
+describe('reading one object layer out of an instance backup', () => {
+  it('gathers the object layer and every document it references', () => {
+    const backup = readObjectLayerBackup({ backupDir, itemId: 'hatchet' });
+    expect(backup.objectLayer.data.item.id).toBe('hatchet');
+    expect(backup.renderFrames._id).toBe('rf1');
+    expect(backup.atlas._id).toBe('at1');
+  });
+
+  it('resolves the atlas render Files by _id and leaves other Files alone', () => {
+    const { files } = readObjectLayerBackup({ backupDir, itemId: 'hatchet' });
+    expect(files.map((f) => f._id).sort()).toEqual(['f-full', 'f-idle', 'f-min']);
+  });
+
+  it('names each exported render after its atlas field', () => {
+    expect(atlasBackupFileKey('fileId', 'hatchet')).toBe('atlas-hatchet');
+    expect(atlasBackupFileKey('minifyFileId', 'hatchet')).toBe('atlas-minify-hatchet');
+    expect(atlasBackupFileKey('idlePreviewFileId', 'hatchet')).toBe('atlas-idle-hatchet');
+  });
+
+  it('decodes both File byte encodings the export can write', () => {
+    const { files } = readObjectLayerBackup({ backupDir, itemId: 'hatchet' });
+    const byId = Object.fromEntries(files.map((f) => [f._id, f.data]));
+    expect(Buffer.isBuffer(byId['f-full']) && byId['f-full'].toString()).toBe('PNG');
+    expect(Buffer.isBuffer(byId['f-min']) && [...byId['f-min']]).toEqual([1, 2, 3]);
+  });
+
+  it('collects only the payloads the backup actually carries', () => {
+    const { payloads } = readObjectLayerBackup({ backupDir, itemId: 'hatchet' });
+    expect([...payloads.keys()].sort()).toEqual(['cid-data', 'cid-png']);
+    expect(payloads.get('cid-png').toString()).toBe('png');
+  });
+
+  it('names the backup and item when the item is missing', () => {
+    expect(() => readObjectLayerBackup({ backupDir, itemId: 'ghost' })).toThrow(/no object layer 'ghost'/);
+  });
+
+  it('tolerates an item with no atlas or render frames yet', async () => {
+    await write('object-layers/bare.json', { _id: 'ol2', data: { item: { id: 'bare', type: 'floor' } } });
+    const backup = readObjectLayerBackup({ backupDir, itemId: 'bare' });
+    expect(backup.atlas).toBeNull();
+    expect(backup.renderFrames).toBeNull();
+    expect(backup.files).toEqual([]);
+    expect(backup.payloads.size).toBe(0);
+  });
+});
+
+describe('restoring one object layer from an instance backup', () => {
+  let persist;
+  let idle;
+
+  beforeEach(() => {
+    for (const name of ['ObjectLayer', 'ObjectLayerRenderFrames', 'AtlasSpriteSheet', 'File'])
+      models[name] = collection();
+    persist = vi.spyOn(AtlasSpriteSheetStore, 'persist').mockResolvedValue({
+      atlasDoc: { _id: 'at-rebuilt' },
+      atlasCid: 'cid-rebuilt-png',
+      atlasMetadataCid: 'cid-rebuilt-meta',
+    });
+    idle = vi.spyOn(AtlasSpriteSheetStore, 'syncIdlePreview').mockResolvedValue({ status: 'unchanged' });
+    vi.spyOn(AtlasSpriteSheetStore, 'pruneOrphanRenders').mockResolvedValue(0);
+  });
+
+  afterAll(() => vi.restoreAllMocks());
+
+  it('keeps the atlas the backup carries when it holds its minified render', async () => {
+    await restoreObjectLayerBackup({ backupDir, itemId: 'hatchet', options: {} });
+    expect(models.AtlasSpriteSheet.created[0].minifyFileId).toBe('f-min');
+    expect(persist).not.toHaveBeenCalled();
+    expect(idle).toHaveBeenCalledWith({ itemKey: 'hatchet', options: {} });
+    expect(models.ObjectLayer.live.data.render).toEqual({ cid: 'cid-png', metadataCid: 'cid-meta' });
+  });
+
+  // Regression: a backup written before the minified render existed restored an atlas the
+  // blob route could not serve, and the client runtime got a 500 for every entity wearing it.
+  it('rebuilds the atlas a backup restores without its minified render and relinks the item', async () => {
+    await write('object-layers/relic.json', {
+      _id: 'ol3',
+      objectLayerRenderFramesId: 'rf3',
+      atlasSpriteSheetId: 'at3',
+      data: { item: { id: 'relic', type: 'skin' }, render: { cid: 'cid-old-png', metadataCid: 'cid-old-meta' } },
+    });
+    const frames = { _id: 'rf3', frames: { down_idle: [] }, colors: [], frame_duration: 100 };
+    await write('render-frames/relic.json', frames);
+    await write('atlas-sprite-sheets/relic.json', { _id: 'at3', fileId: 'f-relic', minifyFileId: null });
+
+    await restoreObjectLayerBackup({ backupDir, itemId: 'relic', options: {} });
+
+    expect(persist).toHaveBeenCalledWith({ itemKey: 'relic', objectLayerRenderFrames: frames, options: {} });
+    const { live } = models.ObjectLayer;
+    expect(live.atlasSpriteSheetId).toBe('at-rebuilt');
+    expect(live.data.render).toEqual({ cid: 'cid-rebuilt-png', metadataCid: 'cid-rebuilt-meta' });
+  });
+});