dsh-offwork 1.1.0 → 1.1.2

package/tests/pet-video.test.mjs

@@ -0,0 +1,503 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createPetVideoMotion, petVideoAlphaSupported } from '../pet-video.js';
+
+const flush = async () => {
+  for (let i = 0; i < 5; i++) await Promise.resolve();
+};
+function fixture({ alpha = true, rejectPlay = false, idle = false, options = {} } = {}) {
+  const media = Object.assign(new EventTarget(), { matches: false });
+  const document = Object.assign(new EventTarget(), { hidden: false });
+  const videos = [],
+    timers = new Map(),
+    calls = [],
+    states = [];
+  let nextTimer = 0;
+  document.createElement = (tag) => {
+    if (tag === 'canvas')
+      return {
+        getContext: () => ({
+          drawImage() {},
+          getImageData: (x) => ({ data: [0, 0, 0, x === 1 || !alpha ? 255 : 0] }),
+        }),
+      };
+    const video = {
+      style: {},
+      paused: false,
+      duration: 5,
+      removed: false,
+      canPlayType: () => 'probably',
+      requestVideoFrameCallback(callback) {
+        queueMicrotask(callback);
+        return 1;
+      },
+      cancelVideoFrameCallback() {},
+      setAttribute() {},
+      removeAttribute(name) {
+        delete this[name];
+      },
+      pause() {
+        this.paused = true;
+      },
+      load() {
+        if (this.src === 'probe') queueMicrotask(() => this.onloadeddata?.());
+      },
+      play() {
+        return rejectPlay ? Promise.reject(new Error('blocked')) : Promise.resolve();
+      },
+      remove() {
+        this.removed = true;
+      },
+    };
+    videos.push(video);
+    return video;
+  };
+  const host = {
+    document,
+    matchMedia: () => media,
+    setTimeout(fn, ms) {
+      const id = ++nextTimer;
+      timers.set(id, { fn, ms });
+      return id;
+    },
+    clearTimeout(id) {
+      timers.delete(id);
+    },
+  };
+  const element = { dataset: {}, querySelector: () => ({ appendChild() {} }) };
+  const base = {
+    play(action) {
+      calls.push(action);
+      return true;
+    },
+    configure() {},
+    release() {
+      delete element.dataset.action;
+    },
+    drag() {
+      element.dataset.action = 'drag';
+    },
+    destroy() {
+      calls.push('destroy');
+    },
+  };
+  const motion = createPetVideoMotion(
+    element,
+    host,
+    base,
+    { greet: 'greet-data', celebrate: 'drink-data', ...(idle ? { idle: 'idle-data' } : {}) },
+    'probe',
+    { ...options, onStateChange: (state) => states.push(state) },
+  );
+  motion.configure({ enabled: true, resting: false });
+  return { host, document, media, element, base, motion, videos, timers, calls, states };
+}
+
+test('alpha support checks decoded pixels rather than trusting WebM codec support', async () => {
+  for (const alpha of [true, false]) {
+    const f = fixture({ alpha });
+    assert.equal(await petVideoAlphaSupported(f.host, 'probe'), alpha);
+    assert.equal(f.videos.length, 1);
+    assert.equal(f.videos[0].src, undefined);
+    assert.equal(f.timers.size, 0);
+    f.motion.destroy();
+  }
+});
+
+test('clips reveal only after playing; accepted drinking interrupts greeting and stale events cannot stop it', async () => {
+  const f = fixture();
+  f.motion.play('greet');
+  await flush();
+  const greet = f.videos.at(-1),
+    staleEnd = greet.onended;
+  assert.equal(f.element.dataset.videoPlaying, undefined);
+  greet.onplaying();
+  assert.equal(f.element.dataset.videoPlaying, 'true');
+  assert.equal(greet.muted, true);
+  assert.equal(greet.playsInline, true);
+  assert.equal(f.motion.play('greet'), false);
+  f.motion.play('celebrate');
+  await flush();
+  const drink = f.videos.at(-1);
+  assert.equal(greet.removed, false);
+  assert.equal(greet.paused, false);
+  assert.equal(f.element.dataset.action, 'greet');
+  assert.equal(f.element.dataset.videoLoading, 'celebrate');
+  assert.equal(drink.style.opacity, '0');
+  drink.onplaying();
+  assert.equal(greet.paused, true);
+  assert.equal(greet.style.opacity, '0');
+  await fireTimer(f, 150);
+  assert.equal(greet.removed, true);
+  staleEnd();
+  assert.equal(f.element.dataset.action, 'celebrate');
+  assert.equal(f.motion.play('greet'), false);
+  assert.equal(f.motion.play('look'), false);
+  drink.onended();
+  assert.equal(f.element.dataset.videoPlaying, undefined);
+  assert.equal(f.element.dataset.action, undefined);
+  await fireTimer(f, 150);
+  assert.equal(drink.removed, true);
+  f.motion.destroy();
+});
+
+test('motion changes and disposal cancel pending probes without late playback', async () => {
+  const f = fixture();
+  f.motion.play('greet');
+  f.motion.configure({ enabled: false, resting: false });
+  await flush();
+  assert.equal(f.videos.length, 1);
+  assert.equal(f.element.dataset.action, undefined);
+  f.motion.configure({ enabled: true, resting: false });
+  f.motion.play('greet');
+  await flush();
+  const oldPlaying = f.videos.at(-1).onplaying;
+  f.motion.destroy();
+  oldPlaying();
+  assert.equal(f.element.dataset.videoPlaying, undefined);
+  assert.equal(f.timers.size, 0);
+  assert.equal(f.motion.play('greet'), false);
+});
+
+test('background, reduced motion, quiet time and dragging stop media without replay', async () => {
+  const f = fixture();
+  await flush();
+  for (const kind of ['hidden', 'reduce', 'quiet', 'drag']) {
+    f.motion.configure({ enabled: true, resting: false });
+    f.motion.play('celebrate');
+    await flush();
+    const video = f.videos.at(-1);
+    video.onplaying();
+    if (kind === 'hidden') {
+      f.document.hidden = true;
+      f.document.dispatchEvent(new Event('visibilitychange'));
+    }
+    if (kind === 'reduce') {
+      f.media.matches = true;
+      f.media.dispatchEvent(new Event('change'));
+    }
+    if (kind === 'quiet') f.motion.configure({ enabled: true, resting: true });
+    if (kind === 'drag') f.motion.drag(10);
+    assert.equal(video.removed, true);
+    assert.equal(f.element.dataset.videoPlaying, undefined);
+    const count = f.videos.length;
+    f.document.hidden = false;
+    f.media.matches = false;
+    f.document.dispatchEvent(new Event('visibilitychange'));
+    f.media.dispatchEvent(new Event('change'));
+    f.motion.release(true);
+    await flush();
+    assert.equal(f.videos.length, count);
+  }
+  f.motion.destroy();
+});
+
+test('unsupported alpha, rejected playback and a stalled clip fall back without repeatedly loading bad media', async () => {
+  for (const options of [{ alpha: false }, { rejectPlay: true }, {}]) {
+    const f = fixture(options);
+    f.motion.play('greet');
+    await flush();
+    if (!options.alpha && options.alpha !== false && !options.rejectPlay) {
+      const watchdog = [...f.timers.values()].find((t) => t.ms === 9000);
+      watchdog.fn();
+      await flush();
+    }
+    assert.deepEqual(f.calls, ['greet']);
+    assert.equal(f.element.dataset.videoPlaying, undefined);
+    const count = f.videos.length;
+    f.motion.play('greet');
+    await flush();
+    assert.equal(f.videos.length, count);
+    assert.deepEqual(f.calls, ['greet', 'greet']);
+    f.motion.destroy();
+    assert.equal(f.timers.size, 0);
+  }
+});
+
+async function fireTimer(f, milliseconds) {
+  const found = [...f.timers].find(([, timer]) => timer.ms === milliseconds);
+  assert.ok(found, `Expected ${milliseconds}ms timer`);
+  f.timers.delete(found[0]);
+  found[1].fn();
+  await flush();
+}
+
+test('idle loops are interrupted by actions and resume once after action completion', async () => {
+  const f = fixture({ idle: true });
+  await flush();
+  const idle = f.videos.at(-1);
+  idle.onplaying();
+  assert.equal(idle.loop, true);
+  assert.equal(f.timers.size, 0);
+  assert.equal(f.motion.play('look'), false);
+  f.motion.play('greet');
+  await flush();
+  const greet = f.videos.at(-1);
+  greet.onplaying();
+  assert.equal(idle.paused, true);
+  await fireTimer(f, 150);
+  assert.equal(idle.removed, true);
+  assert.equal(greet.loop, false);
+  const oldEnd = greet.onended;
+  f.motion.play('celebrate');
+  await flush();
+  const drink = f.videos.at(-1);
+  drink.duration = 7.5;
+  drink.onplaying();
+  assert.ok([...f.timers.values()].some((t) => t.ms === 9500));
+  oldEnd();
+  assert.equal(f.element.dataset.action, 'celebrate');
+  drink.onended();
+  await fireTimer(f, 0);
+  assert.equal(f.videos.at(-1).src, 'idle-data');
+  assert.equal(f.videos.at(-1).loop, true);
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('returning from hidden or reduced-motion state starts idle rather than replaying an action', async () => {
+  const f = fixture({ idle: true });
+  await flush();
+  f.motion.play('greet');
+  await flush();
+  f.document.hidden = true;
+  f.document.dispatchEvent(new Event('visibilitychange'));
+  assert.equal(f.element.dataset.action, undefined);
+  f.document.hidden = false;
+  f.document.dispatchEvent(new Event('visibilitychange'));
+  await fireTimer(f, 0);
+  assert.equal(f.videos.at(-1).src, 'idle-data');
+  f.media.matches = true;
+  f.media.dispatchEvent(new Event('change'));
+  const count = f.videos.length;
+  f.motion.configure({ enabled: true, resting: false });
+  await flush();
+  assert.equal(f.videos.length, count);
+  f.media.matches = false;
+  f.media.dispatchEvent(new Event('change'));
+  await fireTimer(f, 0);
+  assert.equal(f.videos.at(-1).src, 'idle-data');
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('quiet state and a held drag suppress idle until they finish', async () => {
+  const f = fixture({ idle: true });
+  await flush();
+  f.motion.configure({ enabled: true, resting: true });
+  const count = f.videos.length;
+  await flush();
+  assert.equal(f.videos.length, count);
+  f.motion.play('greet');
+  await flush();
+  f.videos.at(-1).onended();
+  await flush();
+  assert.equal(f.element.dataset.action, undefined);
+  f.motion.configure({ enabled: true, resting: false });
+  await flush();
+  f.motion.drag(1);
+  const before = f.videos.length;
+  f.motion.configure({ enabled: true, resting: false });
+  await flush();
+  assert.equal(f.videos.length, before);
+  assert.equal(f.element.dataset.action, 'drag');
+  f.motion.release(false);
+  await fireTimer(f, 650);
+  assert.equal(f.videos.at(-1).src, 'idle-data');
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('a stalled idle clip fails closed without disabling usable action clips', async () => {
+  const f = fixture({ idle: true });
+  await flush();
+  const idle = f.videos.at(-1);
+  idle.onplaying();
+  idle.onwaiting();
+  await fireTimer(f, 4000);
+  assert.equal(idle.removed, true);
+  const count = f.videos.length;
+  f.motion.configure({ enabled: true, resting: false });
+  await flush();
+  assert.equal(f.videos.length, count);
+  f.motion.play('greet');
+  await flush();
+  const greet = f.videos.at(-1);
+  greet.onplaying();
+  greet.onended();
+  await flush();
+  assert.equal(f.element.dataset.action, undefined);
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('failed action fallback suspends idle during CSS feedback and then returns to idle', async () => {
+  const f = fixture({ idle: true });
+  await flush();
+  f.motion.play('greet');
+  await flush();
+  f.videos.at(-1).onerror();
+  assert.deepEqual(f.calls, ['greet']);
+  await fireTimer(f, 1400);
+  const idle = f.videos.at(-1);
+  idle.onplaying();
+  const count = f.videos.length;
+  f.motion.play('greet');
+  await flush();
+  assert.equal(idle.removed, true);
+  assert.equal(f.videos.length, count);
+  assert.deepEqual(f.calls, ['greet', 'greet']);
+  await fireTimer(f, 1400);
+  assert.equal(f.videos.at(-1).src, 'idle-data');
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('preview waits for explicit play, switches actions freely and never resumes idle automatically', async () => {
+  const f = fixture({
+    idle: true,
+    options: { autoIdle: false, fallback: false, interruptible: true },
+  });
+  await flush();
+  assert.equal(f.videos.length, 0);
+  f.motion.play('greet');
+  await flush();
+  const greet = f.videos.at(-1);
+  greet.onplaying();
+  const announcements = f.states.length;
+  greet.onplaying();
+  assert.equal(f.states.length, announcements);
+  greet.onended();
+  await flush();
+  assert.equal(f.states.at(-1).phase, 'idle');
+  assert.equal(f.videos.length, 2);
+  await fireTimer(f, 150);
+  f.motion.play('idle');
+  await flush();
+  f.videos.at(-1).onplaying();
+  f.motion.play('celebrate');
+  await flush();
+  f.videos.at(-1).onplaying();
+  assert.equal(f.motion.play('greet'), true);
+  await flush();
+  f.videos.at(-1).onplaying();
+  assert.equal(f.motion.play('idle'), true);
+  await flush();
+  f.videos.at(-1).onplaying();
+  assert.ok(f.videos.filter((v) => v.src && !v.removed).length <= 2);
+  f.motion.stop();
+  assert.equal(f.element.dataset.videoPlaying, undefined);
+  assert.equal(f.states.at(-1).phase, 'idle');
+  assert.deepEqual(f.calls, []);
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('preview cancellation ignores late probe and video callbacks', async () => {
+  const f = fixture({ options: { autoIdle: false, fallback: false, interruptible: true } });
+  f.motion.play('greet');
+  f.motion.stop();
+  await flush();
+  assert.equal(f.videos.length, 1);
+  assert.deepEqual(
+    f.states.map((s) => s.phase),
+    ['loading', 'idle'],
+  );
+  f.motion.play('greet');
+  await flush();
+  const late = f.videos.at(-1).onplaying;
+  f.motion.stop();
+  late();
+  assert.equal(f.states.at(-1).phase, 'idle');
+  const count = f.states.length;
+  f.motion.destroy();
+  late();
+  assert.equal(f.states.length, count);
+  assert.equal(f.timers.size, 0);
+});
+
+test('preview reports media failure without pretending to play and supports explicit retry', async () => {
+  const f = fixture({
+    rejectPlay: true,
+    options: { autoIdle: false, fallback: false, interruptible: true },
+  });
+  f.motion.play('greet');
+  await flush();
+  assert.equal(f.states.at(-1).phase, 'unavailable');
+  assert.deepEqual(f.calls, []);
+  const create = f.document.createElement;
+  f.document.createElement = (tag) => {
+    const node = create(tag);
+    if (tag === 'video') node.play = () => Promise.resolve();
+    return node;
+  };
+  assert.equal(f.motion.retry('greet'), true);
+  await flush();
+  f.videos.at(-1).onplaying();
+  assert.equal(f.states.at(-1).phase, 'playing');
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('preview distinguishes unsupported transparency from retryable resource failures', async () => {
+  const f = fixture({
+    alpha: false,
+    options: { autoIdle: false, fallback: false, interruptible: true },
+  });
+  f.motion.play('greet');
+  await flush();
+  assert.equal(f.states.at(-1).phase, 'unsupported');
+  assert.deepEqual(f.calls, []);
+  const count = f.videos.length;
+  f.motion.retry('greet');
+  await flush();
+  assert.equal(f.videos.length, count);
+  assert.equal(f.states.at(-1).phase, 'unsupported');
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('alpha detection waits for a readable frame rather than treating an empty canvas as unsupported', async () => {
+  const f = fixture();
+  const create = f.document.createElement;
+  let reads = 0;
+  f.document.createElement = (tag) => {
+    const node = create(tag);
+    if (tag === 'canvas')
+      node.getContext = () => ({
+        drawImage() {},
+        getImageData(x) {
+          reads++;
+          return { data: [0, 0, 0, reads <= 2 ? 0 : x === 1 ? 255 : 0] };
+        },
+      });
+    return node;
+  };
+  assert.equal(await petVideoAlphaSupported(f.host, 'probe'), true);
+  assert.ok(reads >= 4);
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});
+
+test('a probe timeout remains retryable instead of poisoning the browser capability cache', async () => {
+  const f = fixture();
+  const create = f.document.createElement;
+  f.document.createElement = (tag) => {
+    const node = create(tag);
+    if (tag === 'video') node.load = () => {};
+    if (tag === 'canvas')
+      node.getContext = () => ({
+        drawImage() {
+          throw new Error('no decoded frame');
+        },
+      });
+    return node;
+  };
+  const first = petVideoAlphaSupported(f.host, 'probe');
+  await fireTimer(f, 5000);
+  assert.equal(await first, null);
+  f.document.createElement = create;
+  assert.equal(await petVideoAlphaSupported(f.host, 'probe'), true);
+  f.motion.destroy();
+  assert.equal(f.timers.size, 0);
+});

package/tools/build.mjs

@@ -1,4 +1,5 @@
 import { readFile, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 
 const root = new URL('../', import.meta.url);
 const moduleNames = [
@@ -7,10 +8,14 @@ const moduleNames = [
   'ui-utils.js',
   'companion.js',
   'pet-view.js',
+  'pet-motion.js',
+  'pet-video.js',
+  'pet-reminder.js',
   'pet-interactions.js',
   'pet-surfaces.js',
   'hydration.js',
   'hydration-store.js',
+  'countdown.js',
 ];
 const [entry, ...modules] = await Promise.all(
   moduleNames.map((name) => readFile(new URL(name, root), 'utf8')),
@@ -24,7 +29,9 @@ if (entry.split(marker).length !== 2) {
 // The browser and Node.js tests execute the same calculation and store code.
 const pure = modules
   .map((source) =>
-    source.replace(/^import .* from '\.\/hydration\.js';\n/gm, '').replace(/^export /gm, ''),
+    source
+      .replace(/^import\s+\{[^}]+\}\s+from '\.\/(?:hydration|clock)\.js';\n/gm, '')
+      .replace(/^export /gm, ''),
   )
   .join('\n');
 const banner = '// Generated by tools/build.mjs; edit the source modules, not this file.\n';
@@ -32,7 +39,7 @@ const spriteMarker = '/* PET_SPRITES */';
 if (entry.split(spriteMarker).length !== 2) throw new Error('Expected one sprite marker');
 const sprites = Object.fromEntries(
   await Promise.all(
-    ['whale-dress', 'whale-ornate'].map(async (id) => {
+    ['whale-dress', 'whale-ornate', 'whale-actions', 'whale-ornate-actions'].map(async (id) => {
       const bytes = await readFile(new URL(`assets/characters/${id}.webp`, root));
       if (bytes.toString('ascii', 8, 12) !== 'WEBP' || bytes.length > 200000)
         throw new Error(`Invalid sprite: ${id}`);
@@ -40,19 +47,61 @@ const sprites = Object.fromEntries(
     }),
   ),
 );
+const clipMarker = '/* PET_CLIPS */';
+if (entry.split(clipMarker).length !== 2) throw new Error('Expected one clip marker');
+const mediaRoute = '/offwork-clock/media';
+const mediaAssets = {};
+async function clip(name, maximum, inline = false) {
+  const bytes = await readFile(new URL(`assets/animations/${name}.webm`, root));
+  if (bytes.length < 4 || bytes.readUInt32BE(0) !== 0x1a45dfa3 || bytes.length > maximum)
+    throw new Error(`Invalid or oversized WebM: ${name}`);
+  if (inline) return 'data:video/webm;base64,' + bytes.toString('base64');
+  const sha256 = createHash('sha256').update(bytes).digest('hex');
+  const key = `${sha256}/${name}.webm`;
+  mediaAssets[key] = { file: `assets/animations/${name}.webm`, size: bytes.length, sha256 };
+  return `${mediaRoute.slice(1)}/${key}`;
+}
+const [probe, greet, celebrate, ornateIdle, ornateGreet, ornateDrink] = await Promise.all([
+  clip('alpha-probe', 10000, true),
+  clip('whale-greet', 2000000),
+  clip('whale-drink', 2000000),
+  clip('ornate-idle', 2000000),
+  clip('ornate-greet', 2000000),
+  clip('ornate-drink', 2000000),
+]);
+const clips = {
+  probe,
+  models: {
+    'whale-actions': { greet, celebrate },
+    'whale-ornate-actions': { idle: ornateIdle, greet: ornateGreet, celebrate: ornateDrink },
+  },
+};
 const result =
   banner +
   entry
     .replace(marker, pure)
-    .replace(spriteMarker, `const PET_SPRITES = ${JSON.stringify(sprites)};`);
-const output = new URL('client.js', root);
-
-if (process.argv.includes('--check')) {
-  if ((await readFile(output, 'utf8')) !== result) {
-    throw new Error('Client artifact is stale. Run npm run build and commit client.js.');
-  }
-  console.log('Client artifact matches tested source');
-} else {
-  await writeFile(output, result);
-  console.log('Built client.js from one calculation source');
+    .replace(spriteMarker, () => `const PET_SPRITES = ${JSON.stringify(sprites)};`)
+    .replace(
+      clipMarker,
+      () =>
+        `const PET_CLIPS = ${JSON.stringify(clips)};\nPET_CLIPS.models = petClipUrls(PET_CLIPS.models, document.baseURI);`,
+    );
+const manifest =
+  banner +
+  `export const MEDIA_ROUTE = ${JSON.stringify(mediaRoute)};\nexport const MEDIA_ASSETS = Object.freeze(${JSON.stringify(Object.fromEntries(Object.entries(mediaAssets).sort()), null, 2)});\n`;
+const outputs = [
+  ['client.js', result],
+  ['media-manifest.js', manifest],
+];
+for (const [name, contents] of outputs) {
+  const output = new URL(name, root);
+  if (process.argv.includes('--check')) {
+    if ((await readFile(output, 'utf8')) !== contents)
+      throw new Error(`Generated artifact is stale: ${name}. Run npm run build.`);
+  } else await writeFile(output, contents);
 }
+console.log(
+  process.argv.includes('--check')
+    ? 'Client and media manifest match tested source'
+    : 'Built client and content-addressed media manifest',
+);

package/tools/check-package.mjs

@@ -16,6 +16,10 @@ assert.ok(pkg.engines?.dsh, 'Declare the supported Harness versions');
 assert.equal(pkg.dsh?.bundle?.patch, './cordis.patch.yml');
 assert.equal(pkg.dsh?.client?.platform, 'web');
 assert.match(await read('LICENSE'), /^MIT License/);
+assert.ok(
+  Buffer.byteLength(await read('client.js')) < 2000000,
+  'Keep the initial client below 2MB; character movies must remain on-demand resources',
+);
 
 // This check covers this project's patch; Harness composition remains the
 // authoritative check that the bundle can be installed in a real profile.
@@ -67,17 +71,32 @@ assert.equal(packed.version, pkg.version);
 for (const path of [
   'package.json',
   'index.js',
+  'media-server.js',
+  'media-manifest.js',
   'client.js',
   'companion.js',
   'pet-view.js',
+  'pet-motion.js',
+  'pet-video.js',
+  'pet-reminder.js',
   'pet-interactions.js',
   'pet-surfaces.js',
   'hydration.js',
   'hydration-store.js',
+  'countdown.js',
   'cordis.patch.yml',
   'icon.svg',
   'assets/characters/whale-dress.webp',
   'assets/characters/whale-ornate.webp',
+  'assets/characters/whale-actions.webp',
+  'assets/characters/whale-ornate-actions.webp',
+  'assets/animations/ornate-idle.webm',
+  'assets/animations/ornate-greet.webm',
+  'assets/animations/ornate-drink.webm',
+  'assets/animations/whale-greet.webm',
+  'assets/animations/whale-drink.webm',
+  'assets/animations/alpha-probe.webm',
+  'assets/animations/NOTICE.md',
   'assets/characters/NOTICE.md',
   'locale/zh.json',
   'locale/en.json',