fix(core): invalidate searcher cache on collection mutation

_lastSearcher is keyed only on the query string, but token-search
bakes IDF weights at searcher construction. After setCollection,
add, remove, or removeAt the cached searcher can return stale
scoring for the same query.

Adds _invalidateSearcherCache called from every mutator. remove
only invalidates when something was actually removed.

Author: krisk

src/core/index.ts

@@ -122,6 +122,8 @@ export default class Fuse<T> {
         analyzer
       )
     }
+
+    this._invalidateSearcherCache()
   }
 
   add(doc: T): void {
@@ -145,6 +147,8 @@ export default class Fuse<T> {
         analyzer
       )
     }
+
+    this._invalidateSearcherCache()
   }
 
   remove(predicate: (doc: T, idx: number) => boolean = () => false): T[] {
@@ -167,6 +171,8 @@ export default class Fuse<T> {
       const toRemove = new Set(indicesToRemove)
       this._docs = this._docs.filter((_, i) => !toRemove.has(i))
       this._myIndex.removeAll(indicesToRemove)
+
+      this._invalidateSearcherCache()
     }
 
     return results
@@ -178,9 +184,15 @@ export default class Fuse<T> {
     }
     const doc = this._docs.splice(idx, 1)[0]
     this._myIndex.removeAt(idx)
+    this._invalidateSearcherCache()
     return doc
   }
 
+  _invalidateSearcherCache(): void {
+    this._lastQuery = null
+    this._lastSearcher = null
+  }
+
   getIndex(): FuseIndex<T> {
     return this._myIndex
   }

test/cache-invalidation.test.js

@@ -0,0 +1,82 @@
+// Verifies that _lastSearcher is invalidated on collection mutation.
+// Without the fix, token-search IDF weights stay frozen from construction,
+// so the same query against a mutated collection returns stale scoring.
+
+import { describe, test, expect } from 'vitest'
+
+process.env.EXTENDED_SEARCH_ENABLED = 'true'
+process.env.TOKEN_SEARCH_ENABLED = 'true'
+
+const { default: Fuse } = await import('../src/entry')
+
+describe('searcher cache invalidation on mutation', () => {
+  const options = {
+    keys: ['title'],
+    useTokenSearch: true,
+    includeScore: true
+  }
+
+  test('setCollection invalidates _lastSearcher', () => {
+    const fuse = new Fuse([{ title: 'apple' }, { title: 'banana' }], options)
+    fuse.search('apple')
+    expect(fuse._lastSearcher).not.toBeNull()
+
+    fuse.setCollection([{ title: 'cherry' }])
+    expect(fuse._lastSearcher).toBeNull()
+    expect(fuse._lastQuery).toBeNull()
+  })
+
+  test('add invalidates _lastSearcher', () => {
+    const fuse = new Fuse([{ title: 'apple' }], options)
+    fuse.search('apple')
+    expect(fuse._lastSearcher).not.toBeNull()
+
+    fuse.add({ title: 'banana' })
+    expect(fuse._lastSearcher).toBeNull()
+  })
+
+  test('remove invalidates _lastSearcher', () => {
+    const fuse = new Fuse(
+      [{ title: 'apple' }, { title: 'banana' }, { title: 'cherry' }],
+      options
+    )
+    fuse.search('apple')
+    expect(fuse._lastSearcher).not.toBeNull()
+
+    fuse.remove((doc) => doc.title === 'banana')
+    expect(fuse._lastSearcher).toBeNull()
+  })
+
+  test('remove with no matches does not invalidate', () => {
+    const fuse = new Fuse([{ title: 'apple' }], options)
+    fuse.search('apple')
+    const cached = fuse._lastSearcher
+
+    fuse.remove((doc) => doc.title === 'zebra')
+    expect(fuse._lastSearcher).toBe(cached)
+  })
+
+  test('removeAt invalidates _lastSearcher', () => {
+    const fuse = new Fuse([{ title: 'apple' }, { title: 'banana' }], options)
+    fuse.search('apple')
+    expect(fuse._lastSearcher).not.toBeNull()
+
+    fuse.removeAt(0)
+    expect(fuse._lastSearcher).toBeNull()
+  })
+
+  test('same query after add returns docs added post-construction', () => {
+    const fuse = new Fuse([{ title: 'foo bar' }], options)
+
+    // Prime cache with this query
+    const first = fuse.search('quux')
+    expect(first.length).toBe(0)
+
+    fuse.add({ title: 'quux quux' })
+
+    // Without invalidation, the cached searcher would run against stale state
+    const second = fuse.search('quux')
+    expect(second.length).toBe(1)
+    expect(second[0].item.title).toBe('quux quux')
+  })
+})