feat: SF cache persistence attempt

Author: ashtonanderson

next.config.js

@@ -28,6 +28,15 @@ module.exports = withTM({
   },
   async headers() {
     return [
+      {
+        source: '/stockfish/:path*',
+        headers: [
+          {
+            key: 'Cache-Control',
+            value: 'public, max-age=31536000, immutable',
+          },
+        ],
+      },
       {
         source: '/(.*)',
         headers: [

src/lib/engine/stockfish.ts

@@ -2,6 +2,7 @@ import { Chess } from 'chess.ts'
 import { cpToWinrate } from 'src/lib'
 import StockfishWeb from 'lila-stockfish-web'
 import { StockfishEvaluation } from 'src/types'
+import StockfishModelStorage from './stockfishStorage'
 
 class Engine {
   private fen: string
@@ -339,6 +340,25 @@ const sharedWasmMemory = (lo: number, hi = 32767): WebAssembly.Memory => {
   }
 }
 
+const loadNnueModel = async (
+  url: string,
+  storage: StockfishModelStorage,
+): Promise<ArrayBuffer> => {
+  const cachedBuffer = await storage.getModel(url)
+  if (cachedBuffer) {
+    return cachedBuffer
+  }
+
+  const response = await fetch(url, { cache: 'force-cache' })
+  if (!response.ok) {
+    throw new Error(`Failed to fetch Stockfish NNUE model: ${url}`)
+  }
+
+  const buffer = await response.arrayBuffer()
+  await storage.storeModel(url, buffer)
+  return buffer
+}
+
 const setupStockfish = (): Promise<StockfishWeb> => {
   return new Promise<StockfishWeb>((resolve, reject) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -351,16 +371,19 @@ const setupStockfish = (): Promise<StockfishWeb> => {
         })
         .then(async (instance: StockfishWeb) => {
           // Load NNUE models before resolving
+          const storage = new StockfishModelStorage()
+          await storage.requestPersistentStorage()
+
           Promise.all([
-            fetch(`/stockfish/${instance.getRecommendedNnue(0)}`),
-            fetch(`/stockfish/${instance.getRecommendedNnue(1)}`),
+            loadNnueModel(
+              `/stockfish/${instance.getRecommendedNnue(0)}`,
+              storage,
+            ),
+            loadNnueModel(
+              `/stockfish/${instance.getRecommendedNnue(1)}`,
+              storage,
+            ),
           ])
-            .then((responses) => {
-              return Promise.all([
-                responses[0].arrayBuffer(),
-                responses[1].arrayBuffer(),
-              ])
-            })
             .then((buffers) => {
               instance.setNnueBuffer(new Uint8Array(buffers[0]), 0)
               instance.setNnueBuffer(new Uint8Array(buffers[1]), 1)

src/lib/engine/stockfishStorage.ts

@@ -0,0 +1,103 @@
+interface NnueStorage {
+  id: string
+  data: Blob
+  timestamp: number
+  size: number
+}
+
+export class StockfishModelStorage {
+  private dbName = 'StockfishModels'
+  private storeName = 'nnue'
+  private version = 1
+  private db: IDBDatabase | null = null
+
+  private get supported(): boolean {
+    return typeof indexedDB !== 'undefined'
+  }
+
+  async requestPersistentStorage(): Promise<boolean> {
+    try {
+      if (typeof navigator === 'undefined') return false
+      if ('storage' in navigator && 'persist' in navigator.storage) {
+        return await navigator.storage.persist()
+      }
+      return false
+    } catch (error) {
+      console.warn('Failed to request persistent storage for Stockfish:', error)
+      return false
+    }
+  }
+
+  async openDB(): Promise<IDBDatabase | null> {
+    if (!this.supported) return null
+    if (this.db) return this.db
+
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.version)
+
+      request.onerror = () => reject(request.error)
+      request.onsuccess = () => {
+        this.db = request.result
+        resolve(request.result)
+      }
+
+      request.onupgradeneeded = (event) => {
+        const db = (event.target as IDBOpenDBRequest).result
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: 'id' })
+        }
+      }
+    })
+  }
+
+  async getModel(url: string): Promise<ArrayBuffer | null> {
+    try {
+      const db = await this.openDB()
+      if (!db) return null
+
+      const transaction = db.transaction([this.storeName], 'readonly')
+      const store = transaction.objectStore(this.storeName)
+
+      const modelData = await new Promise<NnueStorage | null>(
+        (resolve, reject) => {
+          const request = store.get(url)
+          request.onsuccess = () => resolve(request.result || null)
+          request.onerror = () => reject(request.error)
+        },
+      )
+
+      if (!modelData) return null
+      return modelData.data.arrayBuffer()
+    } catch (error) {
+      console.warn('Failed to read Stockfish cache:', error)
+      return null
+    }
+  }
+
+  async storeModel(url: string, buffer: ArrayBuffer): Promise<void> {
+    try {
+      const db = await this.openDB()
+      if (!db) return
+
+      const transaction = db.transaction([this.storeName], 'readwrite')
+      const store = transaction.objectStore(this.storeName)
+
+      const modelData: NnueStorage = {
+        id: url,
+        data: new Blob([buffer]),
+        timestamp: Date.now(),
+        size: buffer.byteLength,
+      }
+
+      await new Promise<void>((resolve, reject) => {
+        const request = store.put(modelData)
+        request.onsuccess = () => resolve()
+        request.onerror = () => reject(request.error)
+      })
+    } catch (error) {
+      console.warn('Failed to store Stockfish cache:', error)
+    }
+  }
+}
+
+export default StockfishModelStorage