dsh-hyperframes 0.9.1 → 0.9.3

package/skills/media-use/audio/scripts/lib/sfx.mjs

@@ -1,21 +1,26 @@
-// sfx.mjs — sound effects for the media audio engine. Provider-gated (NOT a
-// per-cue merge): the decision is made once, by whether HeyGen is configured —
-// mirroring how TTS and BGM degrade.
-//
-//   HeyGen credential present  →  retrieve EVERY cue from HeyGen's audio library
-//        (/v3/audio/sounds, type=sound_effects, min_score=0.4). The bundled
-//        library is NOT consulted.
-//   HeyGen credential absent   →  resolve cues against the bundled 21-file
-//        library (assets/sfx/manifest.json), copying matched files into the
-//        project. Offline, deterministic, free.
+// sfx.mjs — sound effects for the media audio engine. Each cue is searched on
+// Openverse (CC0 / CC BY only, see openverse.mjs). A cue Openverse cannot answer,
+// and every cue after Openverse is unreachable or rate limited, resolves against
+// the bundled 21-file library (assets/sfx/manifest.json) instead.
 //
 // A cue that matches nothing is skipped (recorded as an anomaly); SFX never
 // blocks a render. Every cue sits at volume ~0.35, under voice + BGM.
 
 import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { downloadTo, searchSounds } from "./heygen.mjs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { downloadTo } from "./heygen.mjs";
+import { OpenverseUnavailableError, searchOpenverseSfx, writeSfxCredit } from "./openverse.mjs";
+import { latestRecordFor } from "../../../scripts/lib/manifest.mjs";
+import { agentWritePath } from "./media-record.mjs";
 
+export const BUNDLED_SFX_DIR = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "assets",
+  "sfx",
+);
 const SFX_VOLUME = 0.35;
 const slug = (s) =>
   s
@@ -25,12 +30,42 @@ const slug = (s) =>
     .slice(0, 40) || "x";
 const r3 = (x) => Number(x.toFixed(3));
 
+// Lookups by manifest key, file basename, and slug of either, so a cue can name
+// "whoosh", "whoosh.mp3", or "ui click" (→ slug match). { error } when unusable.
+function loadBundledLibrary(sfxLibDir) {
+  const manifestPath = join(sfxLibDir, "manifest.json");
+  if (!existsSync(manifestPath)) return { error: `no bundled SFX library at ${sfxLibDir}` };
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch (e) {
+    return { error: `bundled SFX manifest parse failed (${e.message})` };
+  }
+  const byKey = new Map();
+  for (const [key, entry] of Object.entries(manifest)) {
+    if (!entry?.file || !isFinite(entry.duration)) continue;
+    const rec = { key, file: entry.file, duration: entry.duration };
+    byKey.set(key, rec);
+    byKey.set(entry.file, rec);
+    byKey.set(slug(key), rec);
+    byKey.set(slug(entry.file.replace(/\.\w+$/, "")), rec);
+  }
+  return { byKey };
+}
+
 // cues: [{ id, name }] (id = the line/frame/scene the cue fires in). Returns
-// { sfx: [{ id, name, file, source, offset_s, duration_s, volume }], anomalies }.
-export async function resolveSfx({ cues, heygenOK, headers, hyperframesDir, sfxLibDir }) {
+// { sfx: [{ id, name, file, source, offset_s, duration_s, volume, license?, credit? }], anomalies }.
+export async function resolveSfx({ cues, hyperframesDir, sfxLibDir = BUNDLED_SFX_DIR }) {
   const sfx = [];
   const anomalies = [];
   const destDir = join(hyperframesDir, "assets", "sfx");
+  // Each effect's file this run: one effect named twice gets one file, and two effects never share one.
+  const fileFor = new Map();
+  const taken = () => new Set(fileFor.values());
+  // One Openverse sound per effect name this run, so a repeated cue costs no second request.
+  const openverseFor = new Map();
+  let openverseDown = false;
+  let library;
 
   // Dedupe identical (id,name) cues — the same effect named twice in one line
   // downloads/copies once.
@@ -42,94 +77,82 @@ export async function resolveSfx({ cues, heygenOK, headers, hyperframesDir, sfxL
     return true;
   });
 
-  if (heygenOK) {
-    for (const { id, name } of uniq) {
+  async function fromOpenverse({ id, name }) {
+    const key = `openverse:${slug(name)}`;
+    let entry = openverseFor.get(key);
+    if (!entry) {
+      const sound = await searchOpenverseSfx(name);
+      if (!sound) return null;
+      const file = agentWritePath(hyperframesDir, `assets/sfx/${slug(name)}${sound.ext}`, {
+        anomalies,
+        taken: taken(),
+      });
       try {
-        // SFX hits score low (~0.5–0.67), below the API's default 0.7 which
-        // silently drops most named cues — floor to 0.4. (BGM/music score high
-        // and keep the default.)
-        const results = await searchSounds(name, "sound_effects", headers, {
-          limit: 3,
-          minScore: 0.4,
-        });
-        if (!results.length) {
-          anomalies.push(`sfx "${name}" (id ${id}): no HeyGen match — skipped`);
-          continue;
-        }
-        const top = results[0];
-        const file = `assets/sfx/${slug(name)}.mp3`;
-        await downloadTo(top.audio_url, join(hyperframesDir, file));
-        sfx.push({
-          id,
-          name,
-          file,
-          source: "heygen",
-          offset_s: 0,
-          duration_s: typeof top.duration === "number" ? r3(top.duration) : 1.0,
-          volume: SFX_VOLUME,
-        });
+        await downloadTo(sound.url, join(hyperframesDir, file));
       } catch (e) {
-        anomalies.push(`sfx "${name}" (id ${id}): retrieval failed — ${e.message}`);
+        anomalies.push(`sfx "${name}" (id ${id}): Openverse download failed — ${e.message}`);
+        return null;
       }
+      fileFor.set(key, file);
+      writeSfxCredit(join(destDir, "CREDITS.md"), file, sound);
+      entry = {
+        file,
+        source: "openverse",
+        duration_s: r3(sound.durationS),
+        license: sound.license,
+        credit: sound.credit,
+      };
+      openverseFor.set(key, entry);
     }
-    return { sfx, anomalies };
+    return { id, name, ...entry, offset_s: 0, volume: SFX_VOLUME };
   }
 
-  // ── offline: bundled library ──
-  const manifestPath = join(sfxLibDir, "manifest.json");
-  if (!existsSync(manifestPath)) {
-    if (uniq.length)
-      anomalies.push(`no HeyGen credential and no SFX library at ${sfxLibDir} — all cues dropped`);
-    return { sfx, anomalies };
-  }
-  let manifest;
-  try {
-    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-  } catch (e) {
-    anomalies.push(`SFX manifest parse failed (${e.message}) — all cues dropped`);
-    return { sfx, anomalies };
-  }
-  // Build lookups: by manifest key, by file basename, and by slug of either, so
-  // a cue can name "whoosh", "whoosh.mp3", or "ui click" (→ slug match).
-  const byKey = new Map();
-  for (const [key, entry] of Object.entries(manifest)) {
-    if (!entry?.file || !isFinite(entry.duration)) continue;
-    const rec = { key, file: entry.file, duration: entry.duration };
-    byKey.set(key, rec);
-    byKey.set(entry.file, rec);
-    byKey.set(slug(key), rec);
-    byKey.set(slug(entry.file.replace(/\.\w+$/, "")), rec);
-  }
-  mkdirSync(destDir, { recursive: true });
-  for (const { id, name } of uniq) {
+  function fromBundled({ id, name }) {
+    library ??= loadBundledLibrary(sfxLibDir);
+    if (library.error) {
+      anomalies.push(`sfx "${name}" (id ${id}): ${library.error} — skipped`);
+      return null;
+    }
+    const { byKey } = library;
     const hit = byKey.get(name) ?? byKey.get(slug(name));
     if (!hit) {
       const known = [...new Set([...byKey.values()].map((v) => v.key))].slice(0, 8).join(", ");
       anomalies.push(
         `sfx "${name}" (id ${id}): not in bundled library — skipped (have: ${known}…)`,
       );
-      continue;
+      return null;
     }
+    mkdirSync(destDir, { recursive: true });
     const src = join(sfxLibDir, hit.file);
-    const destRel = `assets/sfx/${hit.file}`;
+    const bytes = existsSync(src) ? readFileSync(src) : null;
+    const isLibraryCopy = (rel) =>
+      bytes &&
+      existsSync(join(hyperframesDir, rel)) &&
+      readFileSync(join(hyperframesDir, rel)).equals(bytes);
+    const destRel =
+      fileFor.get(hit.file) ??
+      agentWritePath(hyperframesDir, `assets/sfx/${hit.file}`, {
+        anomalies,
+        taken: taken(),
+        // An unrecorded copy of the library file is one an engine run made before the manifest had it.
+        reusable: (rel) => !latestRecordFor(hyperframesDir, rel) && isLibraryCopy(rel),
+      });
     const dest = join(hyperframesDir, destRel);
-    // The bundled library may be incomplete: some installs of the skill ship
-    // manifest.json without the actual mp3s. Pushing an sfx entry that points at
-    // a file we never copied produces a dangling reference that silently drops
-    // downstream ("not on disk"). Surface it as a loud anomaly and skip the cue
-    // instead, so the audio_meta never references a missing file.
-    if (!existsSync(dest)) {
-      if (!existsSync(src)) {
-        anomalies.push(
-          `sfx "${name}" (id ${id}): bundled file ${hit.file} missing from the offline ` +
-            `library (${sfxLibDir}) — skipped. Reinstall the media-use skill to ` +
-            `restore assets/sfx/*.mp3, or configure a HeyGen credential for retrieval.`,
-        );
-        continue;
-      }
-      copyFileSync(src, dest);
-    }
-    sfx.push({
+    // Some installs of the skill ship manifest.json without the mp3s. An entry
+    // pointing at a file we never copied would silently drop downstream, so
+    // skip the cue with a loud anomaly instead.
+    if (bytes) {
+      if (!isLibraryCopy(destRel)) copyFileSync(src, dest);
+    } else if (!existsSync(dest)) {
+      anomalies.push(
+        `sfx "${name}" (id ${id}): bundled file ${hit.file} missing from the offline ` +
+          `library (${sfxLibDir}) — skipped. Reinstall the media-use skill to ` +
+          `restore assets/sfx/*.mp3.`,
+      );
+      return null;
+    } // else the engine's earlier copy at dest stands in for the file this install lacks
+    fileFor.set(hit.file, destRel);
+    return {
       id,
       name,
       file: destRel,
@@ -137,7 +160,37 @@ export async function resolveSfx({ cues, heygenOK, headers, hyperframesDir, sfxL
       offset_s: 0,
       duration_s: r3(hit.duration),
       volume: SFX_VOLUME,
-    });
+    };
+  }
+
+  for (const cue of uniq) {
+    let entry = null;
+    if (!openverseDown) {
+      try {
+        entry = await fromOpenverse(cue);
+      } catch (e) {
+        if (!(e instanceof OpenverseUnavailableError)) throw e;
+        openverseDown = true;
+        anomalies.push(`${e.message}: the remaining SFX cues use the bundled library`);
+      }
+    }
+    entry ??= fromBundled(cue);
+    if (entry) sfx.push(entry);
   }
   return { sfx, anomalies };
 }
+
+/**
+ * One sound effect for `query`, saved under the project's assets/sfx/ (the entry point for hosts).
+ * { sound: { file, source, duration_s, license?, credit? } | null, anomalies }.
+ */
+export async function findSoundEffect(query, { hyperframesDir, sfxLibDir = BUNDLED_SFX_DIR }) {
+  const { sfx, anomalies } = await resolveSfx({
+    cues: [{ id: "1", name: query }],
+    hyperframesDir,
+    sfxLibDir,
+  });
+  if (!sfx.length) return { sound: null, anomalies };
+  const { file, source, duration_s, license, credit } = sfx[0];
+  return { sound: { file, source, duration_s, ...(license && { license, credit }) }, anomalies };
+}

package/skills/media-use/audio/scripts/lib/sfx.test.mjs

@@ -1,11 +1,21 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { resolveSfx } from "./sfx.mjs";
+import { appendRecord } from "../../../scripts/lib/manifest.mjs";
+import { BUNDLED_SFX_DIR, findSoundEffect, resolveSfx } from "./sfx.mjs";
 
-// Offline (no HeyGen) SFX resolution: the bundled library may ship manifest.json
+// No real network: each test serves Openverse's answers; by default it is unreachable.
+const offline = async () => {
+  throw new TypeError("fetch failed");
+};
+let serve = offline;
+const UNREACHABLE =
+  "Openverse unreachable (fetch failed): the remaining SFX cues use the bundled library";
+globalThis.fetch = (url, init) => serve(String(url), init);
+
+// Offline SFX resolution: the bundled library may ship manifest.json
 // without the actual mp3s. The old code copied only when the source existed but
 // pushed the sfx entry unconditionally — producing a dangling reference that
 // silently dropped downstream ("not on disk"). These tests lock in the loud
@@ -36,7 +46,6 @@ test("offline: copies and references a present bundled file", async () => {
     writeFileSync(join(libDir, "whoosh.mp3"), "ID3-fake-bytes");
     const { sfx, anomalies } = await resolveSfx({
       cues: [{ id: "s1", name: "whoosh" }],
-      heygenOK: false,
       hyperframesDir: projDir,
       sfxLibDir: libDir,
     });
@@ -44,7 +53,7 @@ test("offline: copies and references a present bundled file", async () => {
     assert.equal(sfx[0].file, "assets/sfx/whoosh.mp3");
     assert.equal(sfx[0].source, "local");
     assert.ok(existsSync(join(projDir, "assets/sfx/whoosh.mp3")), "mp3 copied into project");
-    assert.equal(anomalies.length, 0);
+    assert.deepEqual(anomalies, [UNREACHABLE]);
   });
 });
 
@@ -57,13 +66,266 @@ test("offline: a matched-but-missing bundled file yields an anomaly and NO dangl
     );
     const { sfx, anomalies } = await resolveSfx({
       cues: [{ id: "s1", name: "whoosh" }],
-      heygenOK: false,
       hyperframesDir: projDir,
       sfxLibDir: libDir,
     });
     assert.equal(sfx.length, 0, "no dangling entry for a file that was never copied");
-    assert.equal(anomalies.length, 1);
-    assert.match(anomalies[0], /missing from the offline library/);
+    assert.equal(anomalies.length, 2);
+    assert.match(anomalies[1], /missing from the offline library/);
     assert.ok(!existsSync(join(projDir, "assets/sfx/whoosh.mp3")), "nothing copied");
   });
 });
+
+const whooshLibrary = (libDir, withFile) => {
+  writeFileSync(
+    join(libDir, "manifest.json"),
+    JSON.stringify({ whoosh: { file: "whoosh.mp3", duration: 0.8 } }),
+  );
+  if (withFile) writeFileSync(join(libDir, "whoosh.mp3"), "ID3-library-bytes");
+};
+const record = (projDir, source) =>
+  appendRecord(projDir, { id: "sfx_001", type: "sfx", path: "assets/sfx/whoosh.mp3", source });
+const bundledOnly = (libDir, projDir) =>
+  resolveSfx({
+    cues: [{ id: "s1", name: "whoosh" }],
+    hyperframesDir: projDir,
+    sfxLibDir: libDir,
+  });
+
+test("offline: the engine's earlier copy stands in for a library file this install lacks", async () => {
+  await withDirs(async ({ libDir, projDir }) => {
+    whooshLibrary(libDir, false);
+    mkdirSync(join(projDir, "assets/sfx"), { recursive: true });
+    writeFileSync(join(projDir, "assets/sfx/whoosh.mp3"), "engine copy");
+    record(projDir, "bundled");
+
+    const { sfx, anomalies } = await bundledOnly(libDir, projDir);
+
+    assert.deepEqual(
+      sfx.map(({ file }) => file),
+      ["assets/sfx/whoosh.mp3"],
+    );
+    assert.deepEqual(anomalies, [UNREACHABLE]);
+  });
+});
+
+test("offline: a person's file with the library's bytes stays theirs once recorded as their own", async () => {
+  await withDirs(async ({ libDir, projDir }) => {
+    whooshLibrary(libDir, true);
+    mkdirSync(join(projDir, "assets/sfx"), { recursive: true });
+    writeFileSync(join(projDir, "assets/sfx/whoosh.mp3"), "ID3-library-bytes");
+    record(projDir, "existing");
+
+    const { sfx } = await bundledOnly(libDir, projDir);
+
+    assert.deepEqual(
+      sfx.map(({ file }) => file),
+      ["assets/sfx/whoosh-2.mp3"],
+    );
+    assert.equal(readFileSync(join(projDir, "assets/sfx/whoosh.mp3"), "utf8"), "ID3-library-bytes");
+  });
+});
+
+const libraryWith = (libDir, names) => {
+  const manifest = {};
+  for (const name of names) {
+    manifest[name] = { file: `${name}.mp3`, duration: 0.5 };
+    writeFileSync(join(libDir, `${name}.mp3`), `library ${name}`);
+  }
+  writeFileSync(join(libDir, "manifest.json"), JSON.stringify(manifest));
+};
+const sound = (overrides = {}) => ({
+  id: "ov-1",
+  title: "Swoosh",
+  creator: "Ana",
+  license: "by",
+  foreign_landing_url: "https://freesound.org/s/1",
+  url: "https://cdn.freesound.test/swoosh.mp3",
+  filetype: "mp3",
+  duration: 820,
+  attribution: '"Swoosh" by Ana is licensed under CC BY 4.0.',
+  ...overrides,
+});
+// Openverse stand-in: `answer(query)` gives a search response; any other URL is the sound file.
+function openverse(answer) {
+  const searches = [];
+  serve = async (url) => {
+    const query = new URL(url).searchParams.get("q");
+    if (!url.startsWith("https://api.openverse.org/")) return new Response(`bytes of ${url}`);
+    searches.push(query);
+    return answer(query);
+  };
+  return searches;
+}
+const run = (libDir, projDir, names) =>
+  resolveSfx({
+    cues: names.map((name, index) => ({ id: String(index + 1), name })),
+    hyperframesDir: projDir,
+    sfxLibDir: libDir,
+  });
+
+test("openverse: each cue gets the best licensed sound, with its licence and credit", async () => {
+  await withDirs(async ({ libDir, projDir }) => {
+    libraryWith(libDir, ["whoosh"]);
+    openverse(() => Response.json({ results: [sound()] }));
+    try {
+      const { sfx, anomalies } = await run(libDir, projDir, ["whoosh"]);
+      assert.deepEqual(sfx, [
+        {
+          id: "1",
+          name: "whoosh",
+          file: "assets/sfx/whoosh.mp3",
+          source: "openverse",
+          duration_s: 0.82,
+          license: "by",
+          credit: '"Swoosh" by Ana is licensed under CC BY 4.0.',
+          offset_s: 0,
+          volume: 0.35,
+        },
+      ]);
+      assert.deepEqual(anomalies, []);
+      assert.equal(
+        readFileSync(join(projDir, "assets/sfx/whoosh.mp3"), "utf8"),
+        "bytes of https://cdn.freesound.test/swoosh.mp3",
+      );
+      assert.match(
+        readFileSync(join(projDir, "assets/sfx/CREDITS.md"), "utf8"),
+        /- `assets\/sfx\/whoosh\.mp3`: "Swoosh" by Ana is licensed under CC BY 4\.0\. Source: https:\/\/freesound\.org\/s\/1/,
+      );
+    } finally {
+      serve = offline;
+    }
+  });
+});
+
+test("openverse: a rate limit sends this and every later cue to the bundled library, asking once", async () => {
+  await withDirs(async ({ libDir, projDir }) => {
+    libraryWith(libDir, ["whoosh", "pop"]);
+    const searches = openverse(() => new Response("slow down", { status: 429 }));
+    try {
+      const { sfx, anomalies } = await run(libDir, projDir, ["whoosh", "pop"]);
+      assert.deepEqual(searches, ["whoosh"]);
+      assert.deepEqual(
+        sfx.map(({ file, source }) => [file, source]),
+        [
+          ["assets/sfx/whoosh.mp3", "local"],
+          ["assets/sfx/pop.mp3", "local"],
+        ],
+      );
+      assert.equal(readFileSync(join(projDir, "assets/sfx/pop.mp3"), "utf8"), "library pop");
+      assert.deepEqual(anomalies, [
+        "Openverse rate limit reached (HTTP 429): the remaining SFX cues use the bundled library",
+      ]);
+    } finally {
+      serve = offline;
+    }
+  });
+});
+
+test("openverse: a cue with no licensed match falls back to the bundled library alone", async () => {
+  await withDirs(async ({ libDir, projDir }) => {
+    libraryWith(libDir, ["pop"]);
+    const searches = openverse((query) =>
+      Response.json({ results: query === "pop" ? [sound({ license: "by-nc" })] : [sound()] }),
+    );
+    try {
+      const { sfx } = await run(libDir, projDir, ["pop", "swoosh"]);
+      assert.deepEqual(searches, ["pop", "swoosh"]);
+      assert.deepEqual(
+        sfx.map(({ file, source }) => [file, source]),
+        [
+          ["assets/sfx/pop.mp3", "local"],
+          ["assets/sfx/swoosh.mp3", "openverse"],
+        ],
+      );
+    } finally {
+      serve = offline;
+    }
+  });
+});
+
+test("openverse: a failed download falls back to the bundled file with an anomaly", async () => {
+  await withDirs(async ({ libDir, projDir }) => {
+    libraryWith(libDir, ["whoosh"]);
+    serve = async (url) =>
+      url.startsWith("https://api.openverse.org/")
+        ? Response.json({ results: [sound()] })
+        : new Response("gone", { status: 404 });
+    try {
+      const { sfx, anomalies } = await run(libDir, projDir, ["whoosh"]);
+      assert.deepEqual(
+        sfx.map(({ file, source }) => [file, source]),
+        [["assets/sfx/whoosh.mp3", "local"]],
+      );
+      assert.match(anomalies[0], /Openverse download failed — download HTTP 404/);
+    } finally {
+      serve = offline;
+    }
+  });
+});
+
+test("openverse: one effect named in two lines is searched and downloaded once", async () => {
+  await withDirs(async ({ libDir, projDir }) => {
+    libraryWith(libDir, []);
+    const searches = openverse(() => Response.json({ results: [sound({ license: "cc0" })] }));
+    try {
+      const { sfx } = await run(libDir, projDir, ["whoosh", "whoosh"]);
+      assert.deepEqual(searches, ["whoosh"]);
+      assert.deepEqual(
+        sfx.map(({ id, file }) => [id, file]),
+        [
+          ["1", "assets/sfx/whoosh.mp3"],
+          ["2", "assets/sfx/whoosh.mp3"],
+        ],
+      );
+      assert.equal(
+        existsSync(join(projDir, "assets/sfx/CREDITS.md")),
+        false,
+        "CC0 needs no credit",
+      );
+    } finally {
+      serve = offline;
+    }
+  });
+});
+
+test("findSoundEffect: a host gets the saved file, licence, credit and duration for one query", async () => {
+  await withDirs(async ({ projDir }) => {
+    const searches = openverse(() => Response.json({ results: [sound()] }));
+    try {
+      assert.deepEqual(await findSoundEffect("whoosh", { hyperframesDir: projDir }), {
+        sound: {
+          file: "assets/sfx/whoosh.mp3",
+          source: "openverse",
+          duration_s: 0.82,
+          license: "by",
+          credit: '"Swoosh" by Ana is licensed under CC BY 4.0.',
+        },
+        anomalies: [],
+      });
+      assert.deepEqual(searches, ["whoosh"]);
+    } finally {
+      serve = offline;
+    }
+  });
+});
+
+test("findSoundEffect: offline, the skill's own bundled library answers", async () => {
+  await withDirs(async ({ projDir }) => {
+    const { sound, anomalies } = await findSoundEffect("whoosh", { hyperframesDir: projDir });
+    assert.deepEqual(sound, {
+      file: "assets/sfx/whoosh.mp3",
+      source: "local",
+      duration_s: sound.duration_s,
+    });
+    assert.deepEqual(
+      readFileSync(join(projDir, sound.file)),
+      readFileSync(join(BUNDLED_SFX_DIR, "whoosh.mp3")),
+    );
+    assert.deepEqual(anomalies, [UNREACHABLE]);
+    assert.equal(
+      (await findSoundEffect("no such sound at all", { hyperframesDir: projDir })).sound,
+      null,
+    );
+  });
+});