@scrabble-solver/scrabble-solver 2.16.7 → 2.17.0

package/src/solver-worker/dictionaries/revalidateDictionary.ts

@@ -0,0 +1,86 @@
+import { type Locale } from '@scrabble-solver/types';
+
+import { DICTIONARY_CACHE } from './constants';
+import { expirationManager } from './expirationManager';
+import { getDictionaryUrl } from './getDictionaryUrl';
+import { clearRevalidatedAt, readRevalidatedAt, writeRevalidatedAt } from './revalidatedAt';
+
+const REVALIDATION_INTERVAL = 60 * 60 * 1000;
+
+const requests: Partial<Record<Locale, Promise<void> | undefined>> = {};
+const resetWhileRevalidating = new Set<Locale>();
+
+export function revalidateDictionary(locale: Locale): Promise<void> {
+  const inFlight = requests[locale];
+
+  if (inFlight) {
+    return inFlight;
+  }
+
+  // Registered before the first await, so concurrent callers share this request.
+  const request = revalidateWhenStale(locale).finally(() => {
+    requests[locale] = undefined;
+  });
+
+  requests[locale] = request;
+  return request;
+}
+
+/**
+ * Lets the next access revalidate immediately - used when the cached dictionary
+ * is deleted, so its replacement is not stuck behind the throttle.
+ * A revalidation already in flight when this runs saw the deleted entry, so it
+ * must not arm the throttle when it finishes.
+ * Both in-memory guards are raised before the first await, so a caller that
+ * runs this straight after deleting the entry leaves no gap for a revalidation
+ * to slip into.
+ */
+export async function resetRevalidationThrottle(locale: Locale): Promise<void> {
+  resetWhileRevalidating.add(locale);
+  await clearRevalidatedAt(locale);
+}
+
+async function revalidateWhenStale(locale: Locale): Promise<void> {
+  if (Date.now() - (await readRevalidatedAt(locale)) < REVALIDATION_INTERVAL) {
+    return;
+  }
+
+  resetWhileRevalidating.delete(locale);
+  await revalidate(locale);
+
+  if (!resetWhileRevalidating.has(locale)) {
+    await writeRevalidatedAt(locale, Date.now());
+  }
+}
+
+/**
+ * `no-cache` revalidates against the server without letting the HTTP cache
+ * answer, while still allowing a 304 that keeps the multi-megabyte cached body
+ * untouched; only a real 200 rewrites it. `no-store` would look equivalent but
+ * makes the browser send `Cache-Control: no-cache`, which Next.js reads as an
+ * unconditional request and answers with the whole body every time.
+ */
+async function revalidate(locale: Locale): Promise<void> {
+  await expirationManager.expireEntries();
+
+  const url = getDictionaryUrl(locale);
+  const cache = await caches.open(DICTIONARY_CACHE);
+  const cached = await cache.match(url);
+  const etag = cached?.headers.get('etag');
+  const response = await fetch(url, {
+    cache: 'no-cache',
+    headers: etag ? { 'If-None-Match': etag } : {},
+  });
+
+  if (response.status === 304) {
+    await expirationManager.updateTimestamp(url);
+    return;
+  }
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  await cache.put(url, response);
+  await expirationManager.updateTimestamp(url);
+}

package/src/solver-worker/dictionaries/revalidatedAt.ts

@@ -0,0 +1,43 @@
+import { type Locale } from '@scrabble-solver/types';
+
+import { REVALIDATED_AT_CACHE } from './constants';
+import { getDictionaryUrl } from './getDictionaryUrl';
+
+const timestamps: Partial<Record<Locale, number>> = {};
+
+/**
+ * A dedicated worker is created per page, so a timestamp kept only in memory
+ * would let every navigation revalidate again. The Cache API is the only
+ * storage a worker shares with other tabs, so the throttle lives there and is
+ * read at most once per locale per worker.
+ */
+export async function readRevalidatedAt(locale: Locale): Promise<number> {
+  const known = timestamps[locale];
+
+  if (typeof known !== 'undefined') {
+    return known;
+  }
+
+  const persisted = await readPersistedRevalidatedAt(locale);
+  // A reset that landed while reading wins over the value it invalidated.
+  return (timestamps[locale] ??= persisted);
+}
+
+export async function writeRevalidatedAt(locale: Locale, timestamp: number): Promise<void> {
+  timestamps[locale] = timestamp;
+  const cache = await caches.open(REVALIDATED_AT_CACHE);
+  await cache.put(getDictionaryUrl(locale), new Response(String(timestamp)));
+}
+
+export async function clearRevalidatedAt(locale: Locale): Promise<void> {
+  timestamps[locale] = 0;
+  const cache = await caches.open(REVALIDATED_AT_CACHE);
+  await cache.delete(getDictionaryUrl(locale));
+}
+
+async function readPersistedRevalidatedAt(locale: Locale): Promise<number> {
+  const cache = await caches.open(REVALIDATED_AT_CACHE);
+  const response = await cache.match(getDictionaryUrl(locale));
+  const timestamp = Number(await response?.text());
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}

package/src/solver-worker/getGaddag.test.ts

@@ -0,0 +1,109 @@
+import { Gaddag } from '@kamilmielnik/gaddag';
+import { Locale } from '@scrabble-solver/types';
+import { describe, expect, it, mock } from 'bun:test';
+
+import type * as getGaddagModule from './getGaddag';
+
+let dictionary: Response | undefined;
+const deletedLocales: Locale[] = [];
+
+await mock.module('./dictionaries', () => ({
+  deleteDictionary: (locale: Locale) => {
+    deletedLocales.push(locale);
+    return Promise.resolve();
+  },
+  getDictionary: () => Promise.resolve(dictionary),
+}));
+
+const { getGaddag }: typeof getGaddagModule = await import('./getGaddag');
+
+describe('getGaddag', () => {
+  it('returns undefined when there is no cached dictionary', async () => {
+    dictionary = undefined;
+    expect(await getGaddag(Locale.EN_US)).toBeUndefined();
+  });
+
+  it('deserializes a cached dictionary', async () => {
+    dictionary = createDictionary(['scrabble', 'solver']);
+    const gaddag = await getGaddag(Locale.EN_US);
+
+    expect(gaddag?.has('scrabble')).toBe(true);
+    expect(gaddag?.has('trie')).toBe(false);
+  });
+
+  it('deletes a dictionary cached by an app version with an incompatible format', async () => {
+    dictionary = new Response('serialized trie from a previous app version');
+
+    expect(await getGaddag(Locale.PL_PL)).toBeUndefined();
+    expect(deletedLocales).toContain(Locale.PL_PL);
+  });
+
+  it('deletes a corrupted dictionary', async () => {
+    dictionary = new Response(Gaddag.fromArray(['scrabble']).serialize().subarray(0, 10));
+
+    expect(await getGaddag(Locale.FA_IR)).toBeUndefined();
+    expect(deletedLocales).toContain(Locale.FA_IR);
+  });
+
+  it('reuses the deserialized dictionary while the cached response is unchanged', async () => {
+    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
+    const first = await getGaddag(Locale.EN_GB);
+    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
+    const second = await getGaddag(Locale.EN_GB);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).toBe(first);
+  });
+
+  it('reuses the deserialized dictionary when a revalidation only refreshes the Date header', async () => {
+    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT', etag: '"v1"' });
+    const first = await getGaddag(Locale.FR_FR);
+    dictionary = createDictionary(['scrabble'], { date: 'Fri, 07 Aug 2026 00:00:00 GMT', etag: '"v1"' });
+    const second = await getGaddag(Locale.FR_FR);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).toBe(first);
+  });
+
+  it('picks up a dictionary another tab wrote into the shared cache', async () => {
+    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
+    const first = await getGaddag(Locale.TR_TR);
+    dictionary = createDictionary(['solver'], { etag: '"v2"' });
+    const second = await getGaddag(Locale.TR_TR);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).not.toBe(first);
+    expect(second?.has('solver')).toBe(true);
+  });
+
+  it('falls back to the Date header for responses without an ETag', async () => {
+    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT' });
+    const first = await getGaddag(Locale.DE_DE);
+    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT' });
+    const second = await getGaddag(Locale.DE_DE);
+    dictionary = createDictionary(['scrabble'], { date: 'Fri, 07 Aug 2026 00:00:00 GMT' });
+    const third = await getGaddag(Locale.DE_DE);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).toBe(first);
+    expect(third).not.toBe(first);
+    expect(third?.has('scrabble')).toBe(true);
+  });
+
+  it('memoizes each locale independently', async () => {
+    dictionary = createDictionary(['scrabble'], { etag: '"es"' });
+    const spanish = await getGaddag(Locale.ES_ES);
+    dictionary = createDictionary(['solver'], { etag: '"ro"' });
+    const romanian = await getGaddag(Locale.RO_RO);
+    dictionary = createDictionary(['scrabble'], { etag: '"es"' });
+    const spanishAgain = await getGaddag(Locale.ES_ES);
+
+    expect(spanish?.has('scrabble')).toBe(true);
+    expect(romanian?.has('solver')).toBe(true);
+    expect(spanishAgain).toBe(spanish);
+  });
+});
+
+function createDictionary(words: string[], headers: Record<string, string> = {}): Response {
+  return new Response(Gaddag.fromArray(words).serialize(), { headers });
+}

package/src/solver-worker/getGaddag.ts

@@ -0,0 +1,62 @@
+import { Gaddag } from '@kamilmielnik/gaddag';
+import { type Locale } from '@scrabble-solver/types';
+
+import { deleteDictionary, getDictionary } from './dictionaries';
+
+interface DeserializedDictionary {
+  gaddag: Gaddag;
+  version: string;
+}
+
+const deserializedDictionaries: Partial<Record<Locale, DeserializedDictionary>> = {};
+
+/**
+ * Returns undefined when there is no cached dictionary or when the cached
+ * dictionary cannot be deserialized (it was downloaded by an app version with
+ * an incompatible format). An undeserializable entry is deleted before
+ * returning, so the revalidation the caller triggers next downloads a fresh
+ * dictionary instead of getting a 304 for the broken bytes.
+ */
+export async function getGaddag(locale: Locale): Promise<Gaddag | undefined> {
+  const response = await getDictionary(locale);
+
+  if (typeof response === 'undefined') {
+    return undefined;
+  }
+
+  const version = readVersion(response);
+  const deserialized = deserializedDictionaries[locale];
+
+  if (deserialized && deserialized.version === version) {
+    return deserialized.gaddag;
+  }
+
+  try {
+    const gaddag = Gaddag.deserialize(new Uint8Array(await response.arrayBuffer()));
+
+    if (typeof version !== 'undefined') {
+      deserializedDictionaries[locale] = { gaddag, version };
+    }
+
+    return gaddag;
+  } catch {
+    delete deserializedDictionaries[locale];
+    await deleteDictionary(locale);
+    return undefined;
+  }
+}
+
+/**
+ * Read from the cached response rather than tracked in memory, so a dictionary
+ * another tab downloaded into the shared cache is picked up here too.
+ */
+function readVersion(response: Response): string | undefined {
+  const etag = response.headers.get('etag');
+
+  if (etag !== null) {
+    return etag;
+  }
+
+  const parts = ['date', 'content-length'].map((name) => response.headers.get(name) ?? '');
+  return parts.every((part) => part === '') ? undefined : parts.join('|');
+}

package/src/solver-worker/index.ts

@@ -0,0 +1 @@
+export { prefetchDictionary, solveLocally, verifyLocally } from './client';

package/src/solver-worker/index.worker.ts

@@ -0,0 +1,124 @@
+/// <reference lib="WebWorker" />
+
+import { getConfig } from '@scrabble-solver/configs';
+import { BLANK } from '@scrabble-solver/constants';
+import { solve } from '@scrabble-solver/solver';
+import { Board, type Locale, Tile } from '@scrabble-solver/types';
+
+import { type SolveRequestPayload, type VerifyRequestPayload } from '@/types';
+
+import { revalidateDictionary } from './dictionaries';
+import { getGaddag } from './getGaddag';
+import { type SolverWorkerRequest, type SolverWorkerResponse } from './messages';
+
+declare const self: DedicatedWorkerGlobalScope;
+
+/**
+ * Solves run synchronously on the single worker thread, so a burst of requests
+ * would queue stale solves ahead of the latest one.
+ */
+let latestSolveId = 0;
+
+self.addEventListener('message', ({ data }: MessageEvent<SolverWorkerRequest>) => {
+  if (data.type === 'solve') {
+    latestSolveId = data.id;
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    respond(data.id, () => handleSolve(data.id, data.payload));
+  } else if (data.type === 'verify') {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    respond(data.id, () => handleVerify(data.id, data.payload));
+  } else if (data.type === 'prefetch') {
+    prefetchDictionary(data.locale).catch(() => undefined);
+  }
+});
+
+async function handleSolve(id: number, payload: SolveRequestPayload): Promise<SolverWorkerResponse> {
+  const { board, characters, game, locale } = payload;
+  const gaddag = await getGaddag(locale);
+  revalidateInBackground(locale);
+
+  if (!gaddag) {
+    return { id, outcome: 'unavailable' };
+  }
+
+  await yieldToQueuedMessages();
+
+  if (latestSolveId !== id) {
+    return { id, outcome: 'superseded' };
+  }
+
+  const config = getConfig(game, locale);
+  const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
+  return { data: solve(gaddag, config, Board.fromJson(board), tiles), id, outcome: 'answered' };
+}
+
+async function handleVerify(
+  id: number,
+  { board: boardJson, locale }: VerifyRequestPayload,
+): Promise<SolverWorkerResponse> {
+  const gaddag = await getGaddag(locale);
+  revalidateInBackground(locale);
+
+  if (!gaddag) {
+    return { id, outcome: 'unavailable' };
+  }
+
+  const board = Board.fromJson(boardJson);
+  const words = board.getWords().sort((a, b) => a.localeCompare(b, locale));
+  const invalidWords: string[] = [];
+  const validWords: string[] = [];
+
+  for (const word of words) {
+    if (gaddag.has(word)) {
+      validWords.push(word);
+    } else {
+      invalidWords.push(word);
+    }
+  }
+
+  return { data: { invalidWords, validWords }, id, outcome: 'answered' };
+}
+
+/**
+ * Deserializes the dictionary ahead of the first solve, so it does not pay the
+ * cold-start cost. Warms even when revalidation fails (e.g. offline) - a
+ * previously cached dictionary can still be deserialized.
+ */
+async function prefetchDictionary(locale: Locale): Promise<void> {
+  try {
+    await revalidateDictionary(locale);
+  } catch {
+    // Solving falls back to the server until a later revalidation succeeds.
+  }
+
+  await getGaddag(locale);
+}
+
+/**
+ * Revalidation failures are expected (offline, server down) and must not
+ * surface as unhandled rejections - solving keeps using the cached dictionary
+ * until a later revalidation succeeds.
+ */
+function revalidateInBackground(locale: Locale): void {
+  revalidateDictionary(locale).catch(() => undefined);
+}
+
+async function respond(id: number, handle: () => Promise<SolverWorkerResponse>): Promise<void> {
+  try {
+    self.postMessage(await handle());
+  } catch {
+    self.postMessage({ id, outcome: 'unavailable' } satisfies SolverWorkerResponse);
+  }
+}
+
+/**
+ * Messages queued behind this handler dispatch only between macrotasks - a
+ * MessageChannel round-trip lets them register before an expensive solve.
+ */
+function yieldToQueuedMessages(): Promise<void> {
+  return new Promise((resolve) => {
+    const { port1, port2 } = new MessageChannel();
+    port1.onmessage = () => resolve();
+    port2.postMessage(null);
+  });
+}

package/src/solver-worker/messages.ts

@@ -0,0 +1,20 @@
+import { type Locale, type ResultJson } from '@scrabble-solver/types';
+
+import { type SolveRequestPayload, type VerifyRequestPayload } from '@/types';
+
+export interface VerifyResult {
+  invalidWords: string[];
+  validWords: string[];
+}
+
+export type SolverWorkerRequest =
+  | { id: number; type: 'prefetch'; locale: Locale }
+  | { id: number; type: 'solve'; payload: SolveRequestPayload }
+  | { id: number; type: 'verify'; payload: VerifyRequestPayload };
+
+export type SolverWorkerResponse =
+  | { id: number; outcome: 'answered'; data: ResultJson[] | VerifyResult }
+  /** No cached dictionary, or an internal error - the caller falls back to the server. */
+  | { id: number; outcome: 'unavailable' }
+  /** A newer solve replaced this one - the newer answer is the one worth waiting for. */
+  | { id: number; outcome: 'superseded' };

package/src/state/index.ts

@@ -12,4 +12,5 @@ export * from './solve';
 export * from './store';
 export * from './useTranslate';
 export * from './useTypedSelector';
+export * from './useTypedStore';
 export * from './verify';

package/src/state/sagas.ts

@@ -6,11 +6,12 @@
 import { type PayloadAction } from '@reduxjs/toolkit';
 import { hasConfig, languages } from '@scrabble-solver/configs';
 import { Board, type Locale, type Result } from '@scrabble-solver/types';
-import { call, delay, put, select, takeEvery, takeLatest } from 'redux-saga/effects';
+import { call, delay, put, select, spawn, takeEvery, takeLatest } from 'redux-saga/effects';
 
 import { LOCALE_FEATURES } from '@/i18n';
 import { memoize } from '@/lib';
 import { findWordDefinitions, solve, verify, visit } from '@/sdk';
+import { prefetchDictionary } from '@/solver-worker';
 
 import { initialize, reset } from './actions';
 import { boardSlice, selectBoard } from './board';
@@ -41,7 +42,7 @@ export function* rootSaga(): AnyGenerator {
   yield takeEvery(boardSlice.actions.changeCellValue.type, onCellValueChange);
   yield takeEvery([rackSlice.actions.changeCharacter.type, rackSlice.actions.changeCharacters.type], onRackValueChange);
   yield takeEvery(resultsSlice.actions.applyResult.type, onApplyResult);
-  yield takeEvery(resultsSlice.actions.changeResultCandidate.type, onResultCandidateChange);
+  yield takeLatest(resultsSlice.actions.changeResultCandidate.type, onResultCandidateChange);
   yield takeEvery(settingsSlice.actions.changeGame.type, onGameChange);
   yield takeEvery(settingsSlice.actions.changeLocale.type, onLocaleChange);
   yield takeLatest(dictionarySlice.actions.submit.type, onDictionarySubmit);
@@ -120,8 +121,11 @@ function* onDictionarySubmit(): AnyGenerator {
 
 function* onInitialize(): AnyGenerator {
   const board = yield select(selectBoard);
+  const locale = yield select(selectLocale);
 
-  yield call(visit);
+  yield spawn(prefetchDictionary, locale);
+  // Detached: offline, a failed visit would otherwise tear down the whole root saga.
+  yield spawn(visit);
 
   if (!board.isEmpty()) {
     yield* resetRack();
@@ -142,6 +146,8 @@ function* onReset(): AnyGenerator {
 }
 
 function* onLocaleChange({ payload: locale }: PayloadAction<Locale>): AnyGenerator {
+  yield spawn(prefetchDictionary, locale);
+
   const game = yield select(selectGame);
 
   if (!hasConfig(game, locale)) {
@@ -166,13 +172,17 @@ function* onLocaleChange({ payload: locale }: PayloadAction<Locale>): AnyGenerat
 }
 
 function* onResultCandidateChange({ payload: result }: PayloadAction<Result | null>): AnyGenerator {
-  if (result) {
-    const locale: Locale = yield select(selectLocale);
-    const uniqueWords = Array.from(new Set(result.words));
-    const input = uniqueWords.join(LOCALE_FEATURES[locale].separator);
-    yield put(dictionarySlice.actions.changeInput(input));
-    yield put(dictionarySlice.actions.submit());
+  if (!result) {
+    return;
   }
+
+  yield delay(SUBMIT_DELAY);
+
+  const locale: Locale = yield select(selectLocale);
+  const uniqueWords = Array.from(new Set(result.words));
+  const input = uniqueWords.join(LOCALE_FEATURES[locale].separator);
+  yield put(dictionarySlice.actions.changeInput(input));
+  yield put(dictionarySlice.actions.submit());
 }
 
 function* onSolve(): AnyGenerator {

package/src/state/useTypedStore.ts

@@ -0,0 +1,6 @@
+import { type Store } from '@reduxjs/toolkit';
+import { useStore } from 'react-redux';
+
+import type { RootState } from './types';
+
+export const useTypedStore = (): Store<RootState> => useStore<RootState>();

package/src/types/api.ts

@@ -1,9 +1,8 @@
-import { type BoardJson, type ConfigJson, type Game, type Locale } from '@scrabble-solver/types';
+import { type BoardJson, type Game, type Locale } from '@scrabble-solver/types';
 
 export interface SolveRequestPayload {
   board: BoardJson;
   characters: string[];
-  config: ConfigJson;
   game: Game;
   locale: Locale;
 }

package/tsconfig.json

@@ -7,6 +7,10 @@
     "isolatedModules": true,
     "jsx": "preserve",
     "lib": ["dom", "dom.iterable", "esnext"],
+    // Webpack bundles this package (import.meta worker URLs need an ES module
+    // target), unlike the nodenext library packages.
+    "module": "esnext",
+    "moduleResolution": "bundler",
     "noEmit": true,
     "paths": {
       "@/*": ["./src/*"]