@underpostnet/cyberia 3.3.73 → 3.3.77

package/test/integration/app/cyberia/fallback-world-capture.test.js

@@ -8,6 +8,7 @@ import {
   captureFallbackWorld,
   captureMapCode,
 } from '../../../../src/api/cyberia-instance/cyberia-fallback-capture.js';
+import { fallbackAudioConfig } from '../../../../src/projects/cyberia/seed-audio.js';
 import {
   DefaultCyberiaActions,
   DefaultCyberiaQuests,
@@ -73,7 +74,13 @@ class FakeModel {
   }
 }
 
-const buildModels = ({ objectLayerItemIds = [], seeded = {} } = {}) => ({
+// Every asset the fallback audio configuration binds, as `cyberia audio --import` would leave them.
+const AUDIO_CONFIG = fallbackAudioConfig();
+const importedAudioCodes = () => [
+  ...new Set([...AUDIO_CONFIG.events.map((e) => e.audioCode), ...AUDIO_CONFIG.maps.map((m) => m.defaultMusic)]),
+];
+
+const buildModels = ({ objectLayerItemIds = [], audioCodes = importedAudioCodes(), seeded = {} } = {}) => ({
   CyberiaInstance: new FakeModel(seeded.instances),
   CyberiaInstanceConf: new FakeModel(seeded.confs),
   CyberiaMap: new FakeModel(seeded.maps),
@@ -82,6 +89,8 @@ const buildModels = ({ objectLayerItemIds = [], seeded = {} } = {}) => ({
   CyberiaSkill: new FakeModel(seeded.skills),
   CyberiaEntityTypeDefault: new FakeModel(seeded.entityTypeDefaults),
   CyberiaDialogue: new FakeModel(seeded.dialogues),
+  CyberiaMapAudioConf: new FakeModel(seeded.audioConfs),
+  CyberiaAudio: new FakeModel(audioCodes.map((code) => ({ code }))),
   ObjectLayer: new FakeModel(objectLayerItemIds.map((id) => ({ data: { item: { id } } }))),
 });
 
@@ -166,7 +175,9 @@ describe('planFallbackCapture', () => {
   it('stamps the instance code onto a fully defaulted conf document', () => {
     expect(plan.conf.instanceCode).to.equal(INSTANCE_CODE);
     expect(plan.conf.tickRate).to.equal(world.config.tickRate);
-    expect(plan.conf.entityDefaults).to.be.an('array').that.is.not.empty;
+    // The captured conf references no entity-type default: the fallback world runs on the
+    // canonical set, and referencing nothing is what says so.
+    expect(plan.conf.entityDefaults).to.deep.equal([]);
     expect(plan.conf.equipmentRules).to.be.an('object');
   });
 
@@ -251,3 +262,77 @@ describe('captureFallbackWorld', () => {
     expect(result.missingObjectLayerItemIds).to.deep.equal(['coin']);
   });
 });
+
+describe('captureFallbackWorld — audio configuration', () => {
+  const world = generateFallbackWorld();
+  const plan = planFallbackCapture({ world, instanceCode: INSTANCE_CODE });
+
+  const run = async (overrides = {}) => {
+    const models = buildModels({ objectLayerItemIds: plan.itemIds, ...overrides });
+    const result = await captureFallbackWorld({
+      models,
+      world,
+      instanceCode: INSTANCE_CODE,
+      keepFallbackCodes: !!overrides.keepFallbackCodes,
+    });
+    return { models, result };
+  };
+
+  it('writes one configuration per captured map, under the captured map code', async () => {
+    const { models, result } = await run();
+    // The client asks for audio by map code, so a namespaced capture needs its own documents.
+    expect(result.audio.audioConfs).to.equal(AUDIO_CONFIG.maps.length);
+    expect(models.CyberiaMapAudioConf.docs.map((d) => d.mapCode)).to.deep.equal(
+      AUDIO_CONFIG.maps.map((m) => captureMapCode(m.mapCode, INSTANCE_CODE)),
+    );
+    for (const doc of models.CyberiaMapAudioConf.docs) {
+      expect(doc.mapCode).to.not.include('fallback-map-');
+      expect(plan.instance.cyberiaMapCodes).to.include(doc.mapCode);
+      expect(doc.events.map((e) => e.logicEventId)).to.deep.equal(AUDIO_CONFIG.events.map((e) => e.logicEventId));
+      expect(doc.settings).to.deep.equal(AUDIO_CONFIG.settings);
+    }
+    expect(result.audio.missingAudioCodes).to.deep.equal([]);
+  });
+
+  it('binds a logic event to an audio code, carrying no asset of its own', async () => {
+    const { models } = await run();
+    const [doc] = models.CyberiaMapAudioConf.docs;
+    const projectile = doc.events.find((e) => e.logicEventId === 'projectile');
+    expect(projectile.audioCode).to.equal('shoot');
+    expect(projectile).to.not.have.property('audioId');
+    expect(doc.defaultMusic).to.equal(AUDIO_CONFIG.maps[0].defaultMusic);
+  });
+
+  it('leaves a code with no imported asset unbound, and reports it', async () => {
+    const { models, result } = await run({ audioCodes: importedAudioCodes().filter((code) => code !== 'shoot') });
+    expect(result.audio.missingAudioCodes).to.deep.equal(['shoot']);
+    for (const doc of models.CyberiaMapAudioConf.docs) {
+      expect(doc.events.some((e) => e.audioCode === 'shoot')).to.equal(false);
+    }
+  });
+
+  it('clears a default music the world has not imported', async () => {
+    const { models, result } = await run({ audioCodes: [] });
+    expect(result.audio.missingAudioCodes).to.deep.equal(importedAudioCodes().sort());
+    for (const doc of models.CyberiaMapAudioConf.docs) {
+      expect(doc.defaultMusic).to.equal('');
+      expect(doc.events).to.deep.equal([]);
+    }
+  });
+
+  it('writes the canonical map codes under keepFallbackCodes', async () => {
+    const { models } = await run({ keepFallbackCodes: true });
+    expect(models.CyberiaMapAudioConf.docs.map((d) => d.mapCode)).to.deep.equal(
+      AUDIO_CONFIG.maps.map((m) => m.mapCode),
+    );
+  });
+
+  it('is idempotent — a second capture converges on the same configuration', async () => {
+    const models = buildModels({ objectLayerItemIds: plan.itemIds });
+    await captureFallbackWorld({ models, world, instanceCode: INSTANCE_CODE });
+    const first = JSON.stringify(models.CyberiaMapAudioConf.docs);
+    await captureFallbackWorld({ models, world, instanceCode: INSTANCE_CODE });
+    expect(models.CyberiaMapAudioConf.docs.length).to.equal(AUDIO_CONFIG.maps.length);
+    expect(JSON.stringify(models.CyberiaMapAudioConf.docs)).to.equal(first);
+  });
+});

package/test/integration/app/cyberia/object-layer-item-selection.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { ObjectLayerEngine } from '../../../../src/projects/cyberia/object-layer.js';
+
+const select = (storedItemIds, requestedItemIds) =>
+  ObjectLayerEngine.selectStoredItemIds({ storedItemIds, requestedItemIds });
+
+describe('ol stored item selection', () => {
+  it('takes every stored item when the command gives no item-id', () => {
+    expect(select(['hatchet', 'sword'])).toEqual({ itemIds: ['hatchet', 'sword'], missingItemIds: [] });
+  });
+
+  it('keeps only the requested items that the collection holds', () => {
+    expect(select(['hatchet', 'sword'], ['sword', 'ghost'])).toEqual({
+      itemIds: ['sword'],
+      missingItemIds: ['ghost'],
+    });
+  });
+
+  it('removes blanks and duplicates from both sides', () => {
+    expect(select(['hatchet', 'hatchet', null, ' sword '], [' hatchet ', 'hatchet', ''])).toEqual({
+      itemIds: ['hatchet'],
+      missingItemIds: [],
+    });
+    expect(select([undefined, ''], [])).toEqual({ itemIds: [], missingItemIds: [] });
+  });
+});
+
+const rebuild = (options) => ObjectLayerEngine.selectAtlasRebuild(options);
+
+describe('ol atlas rebuild selection', () => {
+  it('rebuilds when --to-atlas-sprite-sheet is given, with or without a dimension', () => {
+    expect(rebuild({ toAtlasSpriteSheet: true })).toBe(true);
+    expect(rebuild({ toAtlasSpriteSheet: '2048' })).toBe(true);
+    expect(rebuild({ toAtlasSpriteSheet: true, instance: 'TEST' })).toBe(true);
+  });
+
+  it('treats a bare --upscale as the rebuild request', () => {
+    expect(rebuild({ upscale: 20 })).toBe(true);
+    expect(rebuild({ upscale: 20, instance: 'TEST' })).toBe(true);
+  });
+
+  it('keeps --upscale a modifier next to another action', () => {
+    expect(rebuild({ upscale: 20, import: true })).toBe(false);
+    expect(rebuild({ upscale: 20, minify: true })).toBe(false);
+    expect(rebuild({ upscale: 20, generate: true })).toBe(false);
+    expect(rebuild({ upscale: 20, importTypes: 'skin' })).toBe(false);
+    expect(rebuild({ upscale: 20, drop: true })).toBe(false);
+    expect(rebuild({ upscale: 20, showFrame: '08_0' })).toBe(false);
+    expect(rebuild({ upscale: 20, showAtlasSpriteSheet: true })).toBe(false);
+  });
+
+  it('stays out of the way when neither flag is given', () => {
+    expect(rebuild({})).toBe(false);
+    expect(rebuild({ minify: true, instance: 'TEST' })).toBe(false);
+  });
+});

package/test/integration/app/cyberia/object-layer-natural-key.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { DataQuery } from '../../../../src/server/storage/data-query.js';
+
+const byItem = (key) => DataQuery.naturalKeyFilter('data.item.id', key);
+const byCode = (key) => DataQuery.naturalKeyFilter('code', key);
+
+describe('natural key addressing', () => {
+  it('addresses an object layer by its item id', () => {
+    expect(byItem('anon')).toEqual({ 'data.item.id': 'anon' });
+    expect(byItem('wood-drop-1')).toEqual({ 'data.item.id': 'wood-drop-1' });
+  });
+
+  it('addresses an instance or a map by its code', () => {
+    expect(byCode('TEST')).toEqual({ code: 'TEST' });
+    expect(byCode('TEST-map-0')).toEqual({ code: 'TEST-map-0' });
+  });
+
+  it('matches either field when the key is shaped like a document id', () => {
+    const key = '6a8fcb760faca8157bde4210';
+    expect(byItem(key)).toEqual({ $or: [{ 'data.item.id': key }, { _id: key }] });
+  });
+
+  it('keeps a twelve-character item id out of the document id branch', () => {
+    expect(byItem('wood-drop-12')).toEqual({ 'data.item.id': 'wood-drop-12' });
+    expect(byItem('atlas_pistol')).toEqual({ 'data.item.id': 'atlas_pistol' });
+  });
+
+  it('treats a non-hex string of document id length as a natural key', () => {
+    const key = 'zzzzzzzzzzzzzzzzzzzzzzzz';
+    expect(byItem(key)).toEqual({ 'data.item.id': key });
+  });
+});

package/test/integration/app/cyberia/seed-audio.test.js

@@ -0,0 +1,275 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs-extra';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { DataBaseProviderService } from '../../../../src/db/DataBaseProvider.js';
+import { CyberiaAudioModel } from '../../../../src/api/cyberia-audio/cyberia-audio.model.js';
+import { CyberiaAudioService } from '../../../../src/api/cyberia-audio/cyberia-audio.service.js';
+import { CyberiaMapAudioConfModel } from '../../../../src/api/cyberia-map-audio-conf/cyberia-map-audio-conf.model.js';
+import { FileModel } from '../../../../src/api/file/file.model.js';
+import { FileService } from '../../../../src/api/file/file.service.js';
+import { getFallbackMapCodes } from '../../../../src/api/cyberia-instance/cyberia-fallback-world.js';
+import {
+  audioConfigForMaps, fallbackAudioConfig, hasAudioRenderer, loadAudioRenderer, prepareFallbackAudio,
+  seedFallbackAudio, seedInstanceAudio,
+} from '../../../../src/projects/cyberia/seed-audio.js';
+import {
+  DEFAULT_AUDIO_BANK, DEFAULT_AUDIO_BINDINGS, buildAudioEventBindings,
+} from '../../../../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
+import {
+  AUDIO_BUS_MUSIC, AUDIO_BUS_SFX, AUDIO_LOGIC_ID_BUSES, isCanonicalAudioLogicId,
+} from '../../../../src/client/components/cyberia/SharedDefaultsCyberia.js';
+
+// Producing WAV bytes needs the cyberia-audio renderer, which lives in a sibling repository this
+// one does not contain — so it is absent on a fresh checkout and in CI. The cases below that need
+// real bytes are skipped there; everything that checks a rule rather than a recording still runs.
+const itRecording = it.skipIf(!hasAudioRenderer());
+
+describe('fallback audio pipeline', () => {
+  let directory;
+  let recordsPath;
+  let audio;
+  let files;
+  let maps;
+  let instances;
+  const options = { host: 'audio-test', path: '/' };
+
+  beforeEach(() => {
+    directory = fs.mkdtempSync(path.join(os.tmpdir(), 'cyberia-seed-audio-'));
+    recordsPath = path.join(directory, 'records');
+    audio = new Map(); files = new Map(); maps = new Map(); instances = new Map();
+    const CyberiaInstanceModel = {
+      findOne: ({ code }) => ({
+        select: () => ({ lean: async () => (instances.has(code) ? { cyberiaMapCodes: instances.get(code) } : null) }),
+      }),
+    };
+    vi.spyOn(DataBaseProviderService, 'getModel').mockImplementation((name) => {
+      if (name.toLowerCase() === 'cyberiaaudio') return CyberiaAudioModel;
+      if (name.toLowerCase() === 'cyberiamapaudioconf') return CyberiaMapAudioConfModel;
+      if (name.toLowerCase() === 'file') return FileModel;
+      if (name.toLowerCase() === 'cyberiainstance') return CyberiaInstanceModel;
+      if (name === 'Document') return { findOne: async () => null };
+      if (name === 'User') return {};
+      throw new Error(`Unexpected model: ${name}`);
+    });
+    vi.spyOn(CyberiaAudioModel, 'findOne').mockImplementation(async ({ code }) => audio.get(code) ?? null);
+    vi.spyOn(CyberiaAudioModel, 'exists').mockImplementation(async ({ code }) => audio.has(code));
+    vi.spyOn(CyberiaAudioModel, 'findOneAndUpdate').mockImplementation(async ({ code }, { $set }) => {
+      const doc = new CyberiaAudioModel({ ...audio.get(code)?.toObject(), ...$set });
+      await doc.validate(); audio.set(code, doc); return doc;
+    });
+    vi.spyOn(FileModel, 'findOneAndUpdate').mockImplementation(async ({ _id }, { $set }) => {
+      const doc = new FileModel({ _id, ...$set });
+      await doc.validate(); files.set(String(_id), doc); return doc;
+    });
+    vi.spyOn(FileModel, 'findOne').mockImplementation(async ({ _id }) => files.get(String(_id)) ?? null);
+    vi.spyOn(FileModel, 'findByIdAndDelete').mockImplementation(async (id) => {
+      const doc = files.get(String(id)) ?? null;
+      files.delete(String(id));
+      return doc;
+    });
+    vi.spyOn(CyberiaMapAudioConfModel, 'findOne').mockImplementation(async ({ mapCode }) => maps.get(mapCode) ?? null);
+    vi.spyOn(CyberiaMapAudioConfModel.prototype, 'save').mockImplementation(async function () {
+      await this.validate(); maps.set(this.mapCode, this); return this;
+    });
+  });
+
+  afterEach(() => { vi.restoreAllMocks(); fs.removeSync(directory); });
+
+  itRecording('generates deterministic WAVs, seeds twice, and serves the same bytes through the generic file service', async () => {
+    const config = await prepareFallbackAudio({ recordsPath });
+    expect(config.maps.map(({ mapCode }) => mapCode)).toEqual(getFallbackMapCodes());
+    const digest = () => Object.fromEntries(config.assets.map((code) => [code,
+      createHash('sha256').update(fs.readFileSync(path.join(recordsPath, `${code}.wav`))).digest('hex'),
+    ]));
+    const hashes = digest();
+    await seedFallbackAudio({ recordsPath }, options);
+    const ids = [...audio.values()].map(({ fileId }) => String(fileId));
+    await prepareFallbackAudio({ recordsPath });
+    expect(digest()).toEqual(hashes);
+    await seedFallbackAudio({ recordsPath }, options);
+    // The vocabulary is the configuration's own asset list, so adding a cue never leaves a
+    // hard-coded count behind to correct.
+    expect(audio.size).toBe(config.assets.length);
+    expect(files.size).toBe(config.assets.length);
+    expect(maps.size).toBe(getFallbackMapCodes().length);
+    expect([...audio.values()].map(({ fileId }) => String(fileId))).toEqual(ids);
+    for (const map of maps.values()) {
+      expect(new Set(map.events.map(({ logicEventId }) => logicEventId)).size).toBe(config.events.length);
+      for (const event of map.events) expect(audio.has(event.audioCode)).toBe(true);
+    }
+    for (const code of config.assets) {
+      const fileId = String(audio.get(code).fileId);
+      const res = { set: vi.fn() };
+      const bytes = await FileService.get({ path: `/blob/${fileId}`, params: { id: fileId } }, res, options);
+      expect(bytes).toEqual(fs.readFileSync(path.join(recordsPath, `${code}.wav`)));
+      expect(res.set).toHaveBeenCalledWith('Content-Type', 'audio/wav');
+    }
+  }, 20000);
+
+  itRecording('converges on re-seed: a binding the bank no longer declares is dropped', async () => {
+    // The failure this prevents: a renamed cue leaves its old binding behind, the client asks the
+    // engine for an asset nothing declares, and the map keeps a dangling name forever.
+    await prepareFallbackAudio({ recordsPath });
+    await seedFallbackAudio({ recordsPath }, options);
+    const config = fallbackAudioConfig();
+    const [mapCode] = config.maps.map(({ mapCode: code }) => code);
+
+    const stale = maps.get(mapCode);
+    stale.events.push({ logicEventId: 'player-hit', audioCode: 'coin' });
+    expect(stale.events).toHaveLength(config.events.length + 1);
+
+    await seedFallbackAudio({ recordsPath }, options);
+    for (const map of maps.values()) {
+      expect(map.events).toHaveLength(config.events.length);
+      expect(map.events.some(({ logicEventId }) => logicEventId === 'player-hit')).toBe(false);
+      expect(map.events.map(({ logicEventId }) => logicEventId)).toEqual(
+        config.events.map(({ logicEventId }) => logicEventId),
+      );
+    }
+  }, 20000);
+
+  itRecording('reuses a file left by an interrupted metadata write and repairs a missing file', async () => {
+    await prepareFallbackAudio({ recordsPath });
+    const record = { wavPath: path.join(recordsPath, 'coin.wav'), manifestPath: path.join(recordsPath, 'coin.json') };
+    CyberiaAudioModel.findOneAndUpdate.mockRejectedValueOnce(new Error('interrupted'));
+    await expect(CyberiaAudioService.importRecord(record, options)).rejects.toThrow('interrupted');
+    expect(files.size).toBe(1);
+    const first = await CyberiaAudioService.importRecord(record, options);
+    expect(files.size).toBe(1);
+    files.clear();
+    const repaired = await CyberiaAudioService.importRecord(record, options);
+    expect(String(repaired.fileId)).toBe(String(first.fileId));
+    expect(files.size).toBe(1);
+  }, 15000);
+
+  itRecording('replaces the blob when a render changes, and leaves no orphan behind', async () => {
+    const { dispatch } = await loadAudioRenderer();
+    await prepareFallbackAudio({ recordsPath });
+    const record = { wavPath: path.join(recordsPath, 'coin.wav'), manifestPath: path.join(recordsPath, 'coin.json') };
+
+    const first = await CyberiaAudioService.importRecord(record, options);
+    expect(files.size).toBe(1);
+    // Unchanged bytes re-derive the same id: re-importing a bank must not churn File documents.
+    const again = await CyberiaAudioService.importRecord(record, options);
+    expect(String(again.fileId)).toBe(String(first.fileId));
+    expect(files.size).toBe(1);
+
+    // A changed render has to land on a new id — the client fetches and caches the WAV by
+    // fileId, so reusing it would serve the old sound forever.
+    await dispatch('sfx', 'coin', { sampleRate: 22050, volume: 0.5 }, { play: false, record: true, path: record.wavPath });
+    const changed = await CyberiaAudioService.importRecord(record, options);
+    expect(String(changed.fileId)).not.toBe(String(first.fileId));
+    // And the blob it replaced is gone rather than left for clean-fs to sweep.
+    expect(files.has(String(first.fileId))).toBe(false);
+    expect(files.size).toBe(1);
+    expect(String(audio.get('coin').fileId)).toBe(String(changed.fileId));
+  }, 20000);
+
+  itRecording('drops the blob with the asset it belongs to', async () => {
+    await prepareFallbackAudio({ recordsPath });
+    await CyberiaAudioService.importRecord(
+      { wavPath: path.join(recordsPath, 'coin.wav'), manifestPath: path.join(recordsPath, 'coin.json') },
+      options,
+    );
+    expect(files.size).toBe(1);
+    expect(await CyberiaAudioService.deleteBackingFiles([audio.get('coin')], options)).toBe(1);
+    expect(files.size).toBe(0);
+  }, 15000);
+
+  it('registers its File reference so the orphan sweep can see it', () => {
+    // `underpost db clean-fs` deletes every File no registered field points at. An unregistered
+    // fileId is not an untracked reference — it is a blob the sweep actively deletes.
+    const refs = fs.readJsonSync('./src/api/file/file.ref.json');
+    expect(refs.find(({ api }) => api === 'cyberia-audio')?.model).toEqual({ fileId: true });
+    for (const { api, model } of refs) {
+      for (const [field, tracked] of Object.entries(model)) {
+        expect(tracked, `${api}.${field} must be tracked`).toBe(true);
+      }
+    }
+  });
+
+  it('rejects malformed data before writing a file', async () => {
+    fs.ensureDirSync(recordsPath);
+    const wavPath = path.join(recordsPath, 'coin.wav');
+    const manifestPath = path.join(recordsPath, 'coin.json');
+    fs.writeFileSync(wavPath, 'RIFF');
+    fs.writeJsonSync(manifestPath, { id: 'coin', author: 'test', version: '1', duration: 0.5 });
+    await expect(CyberiaAudioService.importRecord({ wavPath, manifestPath }, options)).rejects.toThrow('Invalid WAV');
+    expect(files.size).toBe(0);
+  });
+
+  itRecording('scores every map of an instance alike, and converges on re-seed', async () => {
+    instances.set('nexus', ['nexus-hub', 'nexus-deep', 'nexus-vault', 'nexus-rim', 'nexus-gate']);
+    await prepareFallbackAudio({ recordsPath });
+    await seedInstanceAudio({ instanceCode: 'nexus', recordsPath }, options);
+
+    // One bed for the whole world: what a map sounds like at rest is the world's identity, and
+    // the events are what make a moment sound different.
+    const expected = audioConfigForMaps(instances.get('nexus'));
+    expect(expected.maps.map(({ defaultMusic }) => defaultMusic)).toEqual(Array(5).fill('exploration'));
+    expect([...maps.keys()]).toEqual(instances.get('nexus'));
+    for (const { mapCode, defaultMusic } of expected.maps) {
+      expect(maps.get(mapCode).defaultMusic).toBe(defaultMusic);
+      expect(maps.get(mapCode).events).toHaveLength(expected.events.length);
+    }
+
+    const stale = maps.get('nexus-hub');
+    stale.events.push({ logicEventId: 'player-hit', audioCode: 'coin' });
+    await seedInstanceAudio({ instanceCode: 'nexus', recordsPath }, options);
+    expect(maps.get('nexus-hub').events).toHaveLength(expected.events.length);
+    expect(maps.size).toBe(instances.get('nexus').length);
+  }, 20000);
+
+  it('refuses an instance it cannot score', async () => {
+    await expect(seedInstanceAudio({ instanceCode: 'absent', recordsPath }, options))
+      .rejects.toThrow('cyberia-instance not found for code="absent"');
+    instances.set('empty', []);
+    await expect(seedInstanceAudio({ instanceCode: 'empty', recordsPath }, options))
+      .rejects.toThrow('declares no maps');
+  });
+
+  it('sources its whole vocabulary from the centralized defaults', () => {
+    const config = fallbackAudioConfig();
+    // The seed declares nothing of its own: the bank, the bindings and the vocabulary they use
+    // all come from cyberia-server-defaults and SharedDefaultsCyberia.
+    expect(config.assets).toEqual(DEFAULT_AUDIO_BANK.map(({ code }) => code));
+    expect(config.events).toEqual(buildAudioEventBindings());
+    for (const { logicEventId, audioCode } of DEFAULT_AUDIO_BINDINGS) {
+      expect(isCanonicalAudioLogicId(logicEventId)).toBe(true);
+      expect(config.assets).toContain(audioCode);
+    }
+    // Routing is derived from the registry, never restated per binding.
+    for (const { logicEventId, settings } of config.events) {
+      expect(settings.bus).toBe(AUDIO_LOGIC_ID_BUSES[logicEventId] ?? AUDIO_BUS_SFX);
+      expect(settings.crossfadeMs > 0).toBe(settings.bus === AUDIO_BUS_MUSIC);
+    }
+  });
+
+  it('binds the portal charge as a bed and the jump as a one-shot', () => {
+    const config = fallbackAudioConfig();
+    const cooldown = config.events.find(({ logicEventId }) => logicEventId === 'portal-cooldown');
+    const portal = config.events.find(({ logicEventId }) => logicEventId === 'portal');
+    // The charge is held for as long as the player waits, so it loops; the jump sounds once.
+    expect(cooldown).toMatchObject({ audioCode: 'portal-cooldown', settings: { bus: AUDIO_BUS_MUSIC, loop: true } });
+    expect(portal).toMatchObject({ audioCode: 'portal', settings: { bus: AUDIO_BUS_SFX, loop: false } });
+  });
+
+  it('keeps the semantic skill vocabulary and makes bus routing a binding setting', () => {
+    const config = fallbackAudioConfig();
+    expect(config.events.find(({ logicEventId }) => logicEventId === 'projectile').audioCode).toBe('shoot');
+    // One impact cue for any collision, and the interface has a voice of its own.
+    expect(config.events.find(({ logicEventId }) => logicEventId === 'hit').audioCode).toBe('hit');
+    expect(config.events.find(({ logicEventId }) => logicEventId === 'ui-click').audioCode).toBe('ui-click');
+    expect(config.events.some(({ logicEventId }) => logicEventId === 'player-hit')).toBe(false);
+    expect(config.assets).toContain('hit');
+    expect(config.assets).not.toContain('player-hit');
+    expect(config.events.find(({ logicEventId }) => logicEventId === 'coin_drop_or_transaction').audioCode).toBe('coin');
+    expect(config.events.find(({ logicEventId }) => logicEventId === 'victory').settings.loop).toBe(false);
+    expect(new Set(config.maps.map(({ defaultMusic }) => defaultMusic))).toEqual(new Set(['exploration']));
+    for (const settings of [{ bus: 'MASTER' }, { volume: 2 }, { pan: -1 }, { pitch: 0 }, { crossfadeMs: Infinity }]) {
+      expect(new CyberiaMapAudioConfModel({ mapCode: 'test', settings }).validateSync()).toBeDefined();
+    }
+  });
+});

package/test/integration/infra/2-network/wireguard-cli.test.js

@@ -876,10 +876,12 @@ describe('edge host provisioning', () => {
     });
 
     it.skipIf(!shipsCyberiaPackageScript)(
-      'installs the deploy manifest before the CLI is used, and again on what the switch landed',
+      'installs the checkout manifest before the CLI is used, and the deploy manifest on what the switch landed',
       () => {
         // Regression: a node whose install no longer matched its manifest could not load its own
-        // CLI, so the first step of the sync died before the step that repairs the tree.
+        // CLI, so the first step of the sync died before the step that repairs the tree. The
+        // bootstrap installs the checkout's own manifest because that is the one matching the code
+        // already in the tree; the deploy manifest can only be installed once its switch lands it.
         const previousUser = process.env.GITHUB_USERNAME;
         const previousToken = process.env.GITHUB_TOKEN;
         process.env.GITHUB_USERNAME = 'fixture-org';
@@ -892,20 +894,25 @@ describe('edge host provisioning', () => {
           const commands = steps.map(({ command }) => command);
           const packageStep = 'bash ./deploy/dd-cyberia/package.sh';
 
-          expect(commands[0]).to.equal(packageStep);
-          expect(steps[0].halt, 'a tree predating the script must still reach the switch').to.not.equal(true);
+          expect(commands[0]).to.equal('git checkout -- package.json; npm install');
+          expect(steps[0].halt, 'a tree that cannot be restored must still reach the switch').to.not.equal(true);
           expect(commands).to.not.include('npm link --force');
           const last = commands.lastIndexOf(packageStep);
+          expect(last).to.equal(commands.indexOf(packageStep));
           expect(last).to.be.greaterThan(commands.findIndex((command) => command.includes('./engine-private')));
           expect(last).to.be.lessThan(commands.findIndex((command) => command.includes('underpost-event')));
           expect(steps[last].halt).to.equal(true);
 
-          // The monorepo belongs to no deploy, so it carries no package step at all.
-          expect(
-            UnderpostWireguard.API.syncCommands({ repoEngine: 'fixture-org/engine', nodeRole: 'control' }),
-          ).to.satisfy((monorepo) =>
-            monorepo.every(({ command }) => !command.includes('package.sh') && !/<[a-z-]+>/.test(command)),
+          // The monorepo belongs to no deploy, so its post-switch install falls back to the
+          // checkout's own manifest rather than being dropped.
+          const monorepo = UnderpostWireguard.API.syncCommands({
+            repoEngine: 'fixture-org/engine',
+            nodeRole: 'control',
+          }).map(({ command }) => command);
+          expect(monorepo.every((command) => !command.includes('package.sh') && !/<[a-z-]+>/.test(command))).to.equal(
+            true,
           );
+          expect(monorepo).to.include('npm install');
         } finally {
           if (previousUser === undefined) delete process.env.GITHUB_USERNAME;
           else process.env.GITHUB_USERNAME = previousUser;
@@ -915,6 +922,23 @@ describe('edge host provisioning', () => {
       },
     );
 
+    it('enters the CLI through Node, never through the link its own steps invalidate', () => {
+      // Regression: the global `underpost` is a symlink onto `bin/index.js` in the checkout the
+      // sync restores, so `run clean` rewrote that file's mode and every later step died on
+      // `Permission denied`.
+      const previous = process.env.GITHUB_USERNAME;
+      process.env.GITHUB_USERNAME = 'fixture-org';
+      try {
+        for (const nodeRole of ['control', 'worker', 'hub'])
+          expect(UnderpostWireguard.API.syncCommands({ nodeRole })).to.satisfy((steps) =>
+            steps.every(({ command }) => !/(^|[\s;&|])underpost\s/.test(command)),
+          );
+      } finally {
+        if (previous === undefined) delete process.env.GITHUB_USERNAME;
+        else process.env.GITHUB_USERNAME = previous;
+      }
+    });
+
     it('never writes a blank token onto a node', () => {
       const previous = process.env.GITHUB_TOKEN;
       delete process.env.GITHUB_TOKEN;