scrabble-solver 2.18.10-alpha.2 → 2.19.0-alpha.0

package/packages/scrabble-solver/src/service-worker/appShell.test.ts

@@ -1,86 +0,0 @@
-import { afterAll, beforeEach, describe, expect, it } from 'bun:test';
-
-import { cacheAppShell, respondToNavigation } from './appShell';
-
-const entries = new Map<string, Response>();
-
-let respond: () => Promise<Response> = () => Promise.resolve(html('shell'));
-
-const globals = { caches: globalThis.caches, fetch: globalThis.fetch };
-
-Object.assign(globalThis, {
-  caches: createCacheStorage(entries),
-  fetch: () => respond(),
-});
-
-afterAll(() => {
-  Object.assign(globalThis, globals);
-});
-
-describe('respondToNavigation', () => {
-  beforeEach(() => {
-    entries.clear();
-    respond = () => Promise.resolve(html('shell'));
-  });
-
-  it('serves the network response while online', async () => {
-    await cacheAppShell();
-    respond = () => Promise.resolve(html('deployed shell'));
-    const response = await respondToNavigation({ request: navigation('/') });
-    expect(await response.text()).toEqual('deployed shell');
-  });
-
-  it('serves the shell cached on install when the network is gone', async () => {
-    await cacheAppShell();
-    respond = () => Promise.reject(new Error('offline'));
-    const response = await respondToNavigation({ request: navigation('/') });
-    expect(await response.text()).toEqual('shell');
-  });
-
-  it('serves the shell for any navigated path', async () => {
-    await cacheAppShell();
-    respond = () => Promise.reject(new Error('offline'));
-    const response = await respondToNavigation({ request: navigation('/not-found') });
-    expect(await response.text()).toEqual('shell');
-  });
-
-  /**
-   * The cached shell links to the chunks precached next to it, so a navigation
-   * must not replace it with HTML from a build this worker did not precache.
-   */
-  it('keeps the installed shell when a newer one is served from the network', async () => {
-    await cacheAppShell();
-    respond = () => Promise.resolve(html('deployed shell'));
-    await respondToNavigation({ request: navigation('/') });
-
-    respond = () => Promise.reject(new Error('offline'));
-    const response = await respondToNavigation({ request: navigation('/') });
-    expect(await response.text()).toEqual('shell');
-  });
-
-  it('rethrows when there is nothing to fall back on', async () => {
-    respond = () => Promise.reject(new Error('offline'));
-    const error = await respondToNavigation({ request: navigation('/') }).catch((reason: Error) => reason);
-    expect(error).toEqual(new Error('offline'));
-  });
-});
-
-function navigation(url: string): Request {
-  return new Request(new URL(url, 'https://scrabble-solver.org'));
-}
-
-function html(body: string): Response {
-  return new Response(body, { headers: { 'Content-Type': 'text/html; charset=utf-8' } });
-}
-
-function createCacheStorage(cacheEntries: Map<string, Response>): CacheStorage {
-  return {
-    open: (name: string) =>
-      Promise.resolve({
-        add: async (url: string) => {
-          cacheEntries.set(`${name} ${url}`, await globalThis.fetch(url));
-        },
-        match: (url: string) => Promise.resolve(cacheEntries.get(`${name} ${url}`)?.clone()),
-      }),
-  } as unknown as CacheStorage;
-}

package/packages/scrabble-solver/src/service-worker/appShell.ts

@@ -1,39 +0,0 @@
-import { NavigationRoute, registerRoute } from 'workbox-routing';
-
-const APP_SHELL_CACHE = 'app-shell';
-const APP_SHELL_URL = '/';
-
-/**
- * Caching the shell on install instead of on navigation pins it to the same build
- * as the chunks precached alongside it, and covers the first visit, whose
- * navigation happens before this worker controls the page.
- */
-export async function cacheAppShell(): Promise<void> {
-  const cache = await caches.open(APP_SHELL_CACHE);
-  await cache.add(APP_SHELL_URL);
-}
-
-export function routeNavigations(): void {
-  registerRoute(new NavigationRoute(respondToNavigation, { denylist: [/^\/api\//] }));
-}
-
-/**
- * A deploy has to reach online users on their next navigation (see the revalidation
- * headers in next.config.js), so the shell only stands in when the network is gone.
- * Solving keeps working from there, off the dictionary the solver worker holds in
- * the Cache API.
- */
-export async function respondToNavigation({ request }: { request: Request }): Promise<Response> {
-  try {
-    return await fetch(request);
-  } catch (error) {
-    const cache = await caches.open(APP_SHELL_CACHE);
-    const appShell = await cache.match(APP_SHELL_URL);
-
-    if (!appShell) {
-      throw error;
-    }
-
-    return appShell;
-  }
-}

package/packages/scrabble-solver/src/service-worker/index.ts

@@ -1,22 +0,0 @@
-/// <reference lib="WebWorker" />
-
-import { cleanupOutdatedCaches, precacheAndRoute } from 'workbox-precaching';
-
-import { cacheAppShell, routeNavigations } from './appShell';
-
-declare const self: ServiceWorkerGlobalScope;
-
-self.addEventListener('install', (event) => {
-  event.waitUntil(cacheAppShell());
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises
-  self.skipWaiting();
-});
-
-self.addEventListener('activate', () => {
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises
-  self.clients.claim();
-});
-
-cleanupOutdatedCaches();
-precacheAndRoute(self.__WB_MANIFEST);
-routeNavigations();

package/packages/scrabble-solver/src/serviceWorkerManager.ts

@@ -1,12 +0,0 @@
-import { waitForIdle } from '@/lib/waitForIdleOrFirstIntent';
-
-export const registerServiceWorker = async () => {
-  if (!globalThis.navigator || !('serviceWorker' in globalThis.navigator)) {
-    return;
-  }
-
-  // Registration waits for load+idle so the install's precache downloads never compete with page resources
-  await waitForIdle();
-  const { Workbox } = await import('workbox-window');
-  await new Workbox('/service-worker.js').register();
-};

package/packages/scrabble-solver/src/solver-worker/client.test.ts

@@ -1,158 +0,0 @@
-import { type ResultJson } from '@scrabble-solver/types';
-import { afterAll, beforeEach, describe, expect, it } from 'bun:test';
-
-import type * as clientModule from './client';
-import { type SolverWorkerRequest, type SolverWorkerResponse, type VerifyResult } from './messages';
-
-type Listener = (event: { data: SolverWorkerResponse }) => void;
-
-const posted: SolverWorkerRequest[] = [];
-let listeners: Listener[] = [];
-let errorListeners: (() => void)[] = [];
-let terminated = 0;
-let timeouts: (() => void)[] = [];
-
-class FakeWorker {
-  public postMessage(message: SolverWorkerRequest): void {
-    posted.push(message);
-  }
-
-  public addEventListener(type: string, listener: Listener & (() => void)): void {
-    if (type === 'message') {
-      listeners.push(listener);
-    } else {
-      errorListeners.push(listener);
-    }
-  }
-
-  public terminate(): void {
-    terminated += 1;
-  }
-}
-
-// The client reads these off the global scope on every call, so stubbing them
-// here is what makes the worker round-trip and its timeout observable.
-const globals = { caches: globalThis.caches, clearTimeout, setTimeout, Worker: globalThis.Worker };
-
-Object.assign(globalThis, {
-  caches: {},
-  clearTimeout: () => undefined,
-  setTimeout: (callback: () => void) => timeouts.push(callback),
-  Worker: FakeWorker,
-});
-
-afterAll(() => {
-  Object.assign(globalThis, globals);
-});
-
-const { prefetchDictionary, solveLocally, verifyLocally }: typeof clientModule = await import('./client');
-
-const solvePayload = { board: [], characters: [], game: 'scrabble', locale: 'en-US' } as never;
-const verifyPayload = { board: [], game: 'scrabble', locale: 'en-US' } as never;
-
-describe('solver worker client', () => {
-  beforeEach(() => {
-    posted.length = 0;
-    timeouts = [];
-  });
-
-  it('resolves a solve with the worker results', async () => {
-    const solve = solveLocally(solvePayload);
-    respond({ data: createResults('ab'), id: lastRequestId(), outcome: 'answered' });
-
-    expect(await solve).toEqual(createResults('ab'));
-  });
-
-  it('resolves to undefined when the worker cannot answer, so the caller falls back to the server', async () => {
-    const solve = solveLocally(solvePayload);
-    respond({ id: lastRequestId(), outcome: 'unavailable' });
-
-    expect(await solve).toBeUndefined();
-  });
-
-  it('answers a superseded solve with the newer solve results', async () => {
-    const stale = solveLocally(solvePayload);
-    const staleId = lastRequestId();
-    const latest = solveLocally(solvePayload);
-    const latestId = lastRequestId();
-
-    respond({ id: staleId, outcome: 'superseded' });
-    respond({ data: createResults('cd'), id: latestId, outcome: 'answered' });
-
-    expect(await stale).toEqual(createResults('cd'));
-    expect(await latest).toEqual(createResults('cd'));
-  });
-
-  it('resolves to undefined when the worker never answers', async () => {
-    const solve = solveLocally(solvePayload);
-    expect(timeouts).toHaveLength(1);
-    timeouts[0]();
-
-    expect(await solve).toBeUndefined();
-  });
-
-  it('ignores a late answer to a request that already timed out', async () => {
-    const solve = solveLocally(solvePayload);
-    const id = lastRequestId();
-    timeouts[0]();
-    respond({ data: createResults('ef'), id, outcome: 'answered' });
-
-    expect(await solve).toBeUndefined();
-  });
-
-  it('resolves a verify with the worker words', async () => {
-    const verify = verifyLocally(verifyPayload);
-    respond({ data: createVerifyResult(), id: lastRequestId(), outcome: 'answered' });
-
-    expect(await verify).toEqual(createVerifyResult());
-  });
-
-  it('does not wait for a prefetch to answer', () => {
-    prefetchDictionary('pl-PL' as never);
-
-    expect(posted[posted.length - 1].type).toBe('prefetch');
-    expect(timeouts).toHaveLength(0);
-  });
-
-  it('settles in-flight requests and discards the worker when it fails', async () => {
-    const solve = solveLocally(solvePayload);
-    const verify = verifyLocally(verifyPayload);
-    const failuresBefore = terminated;
-
-    for (const listener of errorListeners) {
-      listener();
-    }
-
-    expect(await solve).toBeUndefined();
-    expect(await verify).toBeUndefined();
-    expect(terminated).toBe(failuresBefore + 1);
-
-    listeners = [];
-    errorListeners = [];
-    const restarted = solveLocally(solvePayload);
-    respond({ data: createResults('gh'), id: lastRequestId(), outcome: 'answered' });
-
-    expect(await restarted).toEqual(createResults('gh'));
-  });
-});
-
-function respond(response: SolverWorkerResponse): void {
-  for (const listener of listeners) {
-    listener({ data: response });
-  }
-}
-
-function lastRequestId(): number {
-  return posted[posted.length - 1].id;
-}
-
-function createResults(word: string): ResultJson[] {
-  return [{ blankIndices: [], id: 0, isHorizontal: true, points: 1, tiles: word.split(''), x: 0, y: 0 }];
-}
-
-function createVerifyResult(): VerifyResult {
-  return {
-    invalidWords: [{ direction: 'horizontal', isValid: false, word: 'zz', x: 0, y: 0 }],
-    validWords: [{ direction: 'vertical', isValid: true, word: 'ab', x: 3, y: 5 }],
-  };
-}

package/packages/scrabble-solver/src/solver-worker/client.ts

@@ -1,106 +0,0 @@
-import { type Locale, type ResultJson } from '@scrabble-solver/types';
-
-import { type SolveRequestPayload, type VerifyRequestPayload } from '@/types';
-
-import { type SolverWorkerRequest, type SolverWorkerResponse, type VerifyResult } from './messages';
-
-/**
- * A worker that never answers - killed under memory pressure, or a message lost
- * with it - must not hold the UI in a loading state with no server fallback.
- */
-const REQUEST_TIMEOUT = 30 * 1000;
-
-interface PendingRequest {
-  resolve: (response: SolverWorkerResponse) => void;
-  timeout: ReturnType<typeof setTimeout>;
-}
-
-let worker: Worker | undefined;
-let nextId = 0;
-let latestSolveId = 0;
-let latestSolve: Promise<ResultJson[] | undefined> = Promise.resolve(undefined);
-const pending = new Map<number, PendingRequest>();
-
-export function solveLocally(payload: SolveRequestPayload): Promise<ResultJson[] | undefined> {
-  const id = ++nextId;
-  const solve = readSolveResponse(id, payload);
-  latestSolveId = id;
-  latestSolve = solve;
-  return solve;
-}
-
-export async function verifyLocally(payload: VerifyRequestPayload): Promise<VerifyResult | undefined> {
-  const response = await request({ id: ++nextId, type: 'verify', payload });
-  return response.outcome === 'answered' ? (response.data as VerifyResult) : undefined;
-}
-
-export function prefetchDictionary(locale: Locale): void {
-  getWorker()?.postMessage({ id: ++nextId, locale, type: 'prefetch' } satisfies SolverWorkerRequest);
-}
-
-async function readSolveResponse(id: number, payload: SolveRequestPayload): Promise<ResultJson[] | undefined> {
-  const response = await request({ id, type: 'solve', payload });
-
-  /**
-   * The worker skipped this solve for a newer one; answer with the newer result
-   * rather than an empty list a caller could render as "no moves found".
-   */
-  if (response.outcome === 'superseded' && id !== latestSolveId) {
-    return latestSolve;
-  }
-
-  return response.outcome === 'answered' ? (response.data as ResultJson[]) : undefined;
-}
-
-function request(message: SolverWorkerRequest): Promise<SolverWorkerResponse> {
-  const targetWorker = getWorker();
-
-  if (!targetWorker) {
-    return Promise.resolve({ id: message.id, outcome: 'unavailable' });
-  }
-
-  return new Promise((resolve) => {
-    const timeout = setTimeout(() => settle({ id: message.id, outcome: 'unavailable' }), REQUEST_TIMEOUT);
-    pending.set(message.id, { resolve, timeout });
-    targetWorker.postMessage(message);
-  });
-}
-
-function settle(response: SolverWorkerResponse): void {
-  const entry = pending.get(response.id);
-
-  if (!entry) {
-    return;
-  }
-
-  pending.delete(response.id);
-  clearTimeout(entry.timeout);
-  entry.resolve(response);
-}
-
-function getWorker(): Worker | undefined {
-  if (typeof Worker === 'undefined' || !('caches' in globalThis)) {
-    return undefined;
-  }
-
-  if (!worker) {
-    worker = new Worker(new URL('./index.worker.ts', import.meta.url));
-    worker.addEventListener('message', ({ data }: MessageEvent<SolverWorkerResponse>) => settle(data));
-    worker.addEventListener('error', handleWorkerFailure);
-  }
-
-  return worker;
-}
-
-/**
- * Settles every in-flight request as locally unanswerable - callers fall back
- * to the server - and discards the worker so the next call starts a fresh one.
- */
-function handleWorkerFailure(): void {
-  for (const id of pending.keys()) {
-    settle({ id, outcome: 'unavailable' });
-  }
-
-  worker?.terminate();
-  worker = undefined;
-}

package/packages/scrabble-solver/src/solver-worker/dictionaries/constants.ts

@@ -1,9 +0,0 @@
-export const DICTIONARY_CACHE = 'dictionary-api-cache';
-
-export const REVALIDATED_AT_CACHE = 'dictionary-revalidated-at';
-
-export const DAY = 24 * 60 * 60 * 1000;
-
-// Staleness is handled by conditional revalidation; expiration only cleans up
-// dictionaries of locales the user no longer plays.
-export const DICTIONARY_CACHE_MAX_AGE = 30 * DAY;

package/packages/scrabble-solver/src/solver-worker/dictionaries/expirationManager.ts

@@ -1,7 +0,0 @@
-import { CacheExpiration } from 'workbox-expiration';
-
-import { DICTIONARY_CACHE, DICTIONARY_CACHE_MAX_AGE } from './constants';
-
-export const expirationManager = new CacheExpiration(DICTIONARY_CACHE, {
-  maxAgeSeconds: DICTIONARY_CACHE_MAX_AGE / 1000,
-});

package/packages/scrabble-solver/src/solver-worker/dictionaries/getDictionary.ts

@@ -1,21 +0,0 @@
-import { type Locale } from '@scrabble-solver/types';
-
-import { DICTIONARY_CACHE } from './constants';
-import { getDictionaryUrl } from './getDictionaryUrl';
-import { resetRevalidationThrottle } from './revalidateDictionary';
-
-export async function getDictionary(locale: Locale): Promise<Response | undefined> {
-  const cache = await caches.open(DICTIONARY_CACHE);
-  return cache.match(getDictionaryUrl(locale));
-}
-
-export async function deleteDictionary(locale: Locale): Promise<void> {
-  const cache = await caches.open(DICTIONARY_CACHE);
-  await cache.delete(getDictionaryUrl(locale));
-  /**
-   * Reset last: resetting first leaves a window in which a revalidation starts,
-   * reads the doomed entry's ETag, takes the 304 it answers with, and arms the
-   * throttle against a dictionary this call is about to delete.
-   */
-  await resetRevalidationThrottle(locale);
-}

package/packages/scrabble-solver/src/solver-worker/dictionaries/getDictionaryUrl.ts

@@ -1,5 +0,0 @@
-import { type Locale } from '@scrabble-solver/types';
-
-export const getDictionaryUrl = (locale: Locale): string => {
-  return `/api/dictionary/${locale}`;
-};

package/packages/scrabble-solver/src/solver-worker/dictionaries/index.ts

@@ -1,2 +0,0 @@
-export { deleteDictionary, getDictionary } from './getDictionary';
-export { revalidateDictionary } from './revalidateDictionary';

package/packages/scrabble-solver/src/solver-worker/dictionaries/revalidateDictionary.test.ts

@@ -1,199 +0,0 @@
-import { Locale } from '@scrabble-solver/types';
-import { afterAll, beforeEach, describe, expect, it, mock } from 'bun:test';
-
-import { DICTIONARY_CACHE, REVALIDATED_AT_CACHE } from './constants';
-import type * as getDictionaryModule from './getDictionary';
-import { getDictionaryUrl } from './getDictionaryUrl';
-import type * as revalidateDictionaryModule from './revalidateDictionary';
-
-const HOUR = 60 * 60 * 1000;
-
-const fetchCalls: { cache: RequestCache | undefined; ifNoneMatch: string | undefined; url: string }[] = [];
-const updatedTimestamps: string[] = [];
-let respond: () => Promise<Response> = () => Promise.resolve(notModified());
-
-await mock.module('./expirationManager', () => ({
-  expirationManager: {
-    expireEntries: () => Promise.resolve(),
-    updateTimestamp: (url: string) => {
-      updatedTimestamps.push(url);
-      return Promise.resolve();
-    },
-  },
-}));
-
-const globals = { caches: globalThis.caches, fetch: globalThis.fetch };
-
-Object.assign(globalThis, {
-  caches: createCacheStorage(),
-  fetch: (url: string, { cache, headers }: RequestInit) => {
-    fetchCalls.push({ cache, ifNoneMatch: (headers as Record<string, string>)['If-None-Match'], url });
-    return respond();
-  },
-});
-
-afterAll(() => {
-  Object.assign(globalThis, globals);
-});
-
-const { resetRevalidationThrottle, revalidateDictionary }: typeof revalidateDictionaryModule =
-  await import('./revalidateDictionary');
-const { deleteDictionary }: typeof getDictionaryModule = await import('./getDictionary');
-
-describe('revalidateDictionary', () => {
-  beforeEach(() => {
-    fetchCalls.length = 0;
-    updatedTimestamps.length = 0;
-    respond = () => Promise.resolve(notModified());
-  });
-
-  /**
-   * `no-store` would look equivalent, but makes the browser send
-   * `Cache-Control: no-cache`, which Next.js answers with the whole body.
-   */
-  it('sends a conditional request the HTTP cache cannot answer', async () => {
-    const locale = await unthrottled(Locale.EN_US);
-    await cacheDictionary(locale, 'dictionary', '"v1"');
-    await revalidateDictionary(locale);
-    expect(fetchCalls).toEqual([{ cache: 'no-cache', ifNoneMatch: '"v1"', url: '/api/dictionary/en-US' }]);
-  });
-
-  it('keeps the cached body on 304', async () => {
-    const locale = await unthrottled(Locale.EN_GB);
-    await cacheDictionary(locale, 'dictionary', '"v1"');
-    await revalidateDictionary(locale);
-    expect(await readCachedDictionary(locale)).toBe('dictionary');
-    expect(updatedTimestamps).toEqual([getDictionaryUrl(locale)]);
-  });
-
-  it('replaces the cached body on 200', async () => {
-    const locale = await unthrottled(Locale.DE_DE);
-    await cacheDictionary(locale, 'old', '"v1"');
-    respond = () => Promise.resolve(new Response('new', { headers: { etag: '"v2"' } }));
-    await revalidateDictionary(locale);
-    expect(await readCachedDictionary(locale)).toBe('new');
-    expect(updatedTimestamps).toEqual([getDictionaryUrl(locale)]);
-  });
-
-  it('omits If-None-Match when nothing is cached', async () => {
-    const locale = await unthrottled(Locale.ES_ES);
-    respond = () => Promise.resolve(new Response('dictionary'));
-    await revalidateDictionary(locale);
-    expect(fetchCalls[0].ifNoneMatch).toBeUndefined();
-    expect(await readCachedDictionary(locale)).toBe('dictionary');
-  });
-
-  it('rejects a failed response without arming the throttle', async () => {
-    const locale = await unthrottled(Locale.FA_IR);
-    respond = () => Promise.resolve(new Response(null, { status: 503, statusText: 'Service Unavailable' }));
-    const failure = await revalidateDictionary(locale).catch((error: Error) => error.message);
-    expect(failure).toBe('HTTP 503: Service Unavailable');
-    respond = () => Promise.resolve(notModified());
-    await revalidateDictionary(locale);
-    expect(fetchCalls).toHaveLength(2);
-  });
-
-  it('revalidates at most once per interval', async () => {
-    const locale = await unthrottled(Locale.FR_FR);
-    await revalidateDictionary(locale);
-    await revalidateDictionary(locale);
-    expect(fetchCalls).toHaveLength(1);
-  });
-
-  it('shares one request between concurrent callers', async () => {
-    const locale = await unthrottled(Locale.EN_US);
-    await Promise.all([revalidateDictionary(locale), revalidateDictionary(locale), revalidateDictionary(locale)]);
-    expect(fetchCalls).toHaveLength(1);
-  });
-
-  it('persists the throttle, so a later page load can honour it', async () => {
-    const locale = await unthrottled(Locale.PL_PL);
-    await revalidateDictionary(locale);
-    expect(await readPersistedRevalidatedAt(locale)).toBeGreaterThan(Date.now() - HOUR);
-  });
-
-  /**
-   * This locale and the next are used nowhere else: the worker is created per
-   * page, so only a locale unseen in memory exercises a fresh page's read.
-   */
-  it('honours a throttle persisted by an earlier page load', async () => {
-    await persistRevalidatedAt(Locale.RO_RO, Date.now() - 1000);
-    await revalidateDictionary(Locale.RO_RO);
-    expect(fetchCalls).toHaveLength(0);
-  });
-
-  it('revalidates when a throttle persisted by an earlier page load has expired', async () => {
-    await persistRevalidatedAt(Locale.TR_TR, Date.now() - 2 * HOUR);
-    await revalidateDictionary(Locale.TR_TR);
-    expect(fetchCalls).toHaveLength(1);
-  });
-
-  it('lets the next access revalidate after the dictionary is deleted', async () => {
-    const locale = await unthrottled(Locale.DE_DE);
-    await revalidateDictionary(locale);
-    await revalidateDictionary(locale);
-    await deleteDictionary(locale);
-    await revalidateDictionary(locale);
-    expect(fetchCalls).toHaveLength(2);
-  });
-
-  it('does not arm the throttle when the dictionary is deleted mid-revalidation', async () => {
-    const locale = await unthrottled(Locale.EN_GB);
-    let release: (response: Response) => void = () => undefined;
-    respond = () => new Promise((resolve) => (release = resolve));
-    const revalidation = revalidateDictionary(locale);
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    await resetRevalidationThrottle(locale);
-    release(notModified());
-    await revalidation;
-    respond = () => Promise.resolve(notModified());
-    await revalidateDictionary(locale);
-    expect(fetchCalls).toHaveLength(2);
-  });
-});
-
-/** Throttle state outlives a test, so tests sharing a locale start it un-throttled. */
-async function unthrottled(locale: Locale): Promise<Locale> {
-  await resetRevalidationThrottle(locale);
-  return locale;
-}
-
-async function cacheDictionary(locale: Locale, body: string, etag: string): Promise<void> {
-  const cache = await caches.open(DICTIONARY_CACHE);
-  await cache.put(getDictionaryUrl(locale), new Response(body, { headers: { etag } }));
-}
-
-async function readCachedDictionary(locale: Locale): Promise<string | undefined> {
-  const cache = await caches.open(DICTIONARY_CACHE);
-  return (await cache.match(getDictionaryUrl(locale)))?.text();
-}
-
-async function persistRevalidatedAt(locale: Locale, timestamp: number): Promise<void> {
-  const cache = await caches.open(REVALIDATED_AT_CACHE);
-  await cache.put(getDictionaryUrl(locale), new Response(String(timestamp)));
-}
-
-async function readPersistedRevalidatedAt(locale: Locale): Promise<number> {
-  const cache = await caches.open(REVALIDATED_AT_CACHE);
-  return Number(await (await cache.match(getDictionaryUrl(locale)))?.text());
-}
-
-function notModified(): Response {
-  return new Response(null, { status: 304 });
-}
-
-function createCacheStorage(): CacheStorage {
-  const entries = new Map<string, Response>();
-
-  return {
-    open: (name: string) =>
-      Promise.resolve({
-        delete: (url: string) => Promise.resolve(entries.delete(`${name} ${url}`)),
-        match: (url: string) => Promise.resolve(entries.get(`${name} ${url}`)?.clone()),
-        put: (url: string, response: Response) => {
-          entries.set(`${name} ${url}`, response);
-          return Promise.resolve();
-        },
-      }),
-  } as unknown as CacheStorage;
-}