fix(search): local index rejects FTS syntax in live search queries (#983)

* fix(search): reject FTS syntax chars in local index live search queries

FTS5 treats `=` and similar characters as query syntax, so tokens like
1=2 produced unrelated prefix hits. Skip FTS for unsafe tokens instead.

* docs: CHANGELOG for local index FTS syntax query fix (PR #983)

* fix(search): reject syntax junk in server search3 and live search race

Share FTS-safe token guard with search3; skip network invoke for ** and
similar queries; show empty dropdown without misleading source badge.

* fix(search): allow censorship stars in queries, reject wildcard-only tokens

Block ** and **** but keep ***Flawless-style title searches working
in local FTS and search3.

src/utils/library/liveSearchLocal.test.ts

@@ -3,6 +3,7 @@ import { onInvoke } from '@/test/mocks/tauri';
 import type { SearchResults } from '../../api/subsonicTypes';
 import { useAuthStore } from '@/store/authStore';
 import {
+  liveSearchQueryRejected,
   liveSearchQueryTooShort,
   mergeLiveSearchResults,
   runLocalLiveSearch,
@@ -92,6 +93,16 @@ describe('runLocalLiveSearch', () => {
   });
 });
 
+describe('liveSearchQueryRejected', () => {
+  it('rejects syntax junk and single-character queries', () => {
+    expect(liveSearchQueryRejected('**')).toBe(true);
+    expect(liveSearchQueryRejected('1=2')).toBe(true);
+    expect(liveSearchQueryRejected('а')).toBe(true);
+    expect(liveSearchQueryRejected('ab')).toBe(false);
+    expect(liveSearchQueryRejected('metallica')).toBe(false);
+  });
+});
+
 describe('liveSearchQueryTooShort', () => {
   it('treats one grapheme as too short', () => {
     expect(liveSearchQueryTooShort('а')).toBe(true);

src/utils/library/liveSearchLocal.ts

@@ -14,6 +14,7 @@ import {
   trackToSong,
 } from './advancedSearchLocal';
 import { logLibrarySearch, timed } from './libraryDevLog';
+import { searchQueryIsFtsSafe } from './searchQueryFtsSafe';
 
 export const LIVE_SEARCH_DEBOUNCE_LOCAL_MS = 200;
 export const LIVE_SEARCH_DEBOUNCE_NETWORK_MS = 300;
@@ -45,6 +46,14 @@ export function liveSearchQueryTooShort(query: string): boolean {
   return !q || queryGraphemeCount(q) < LOCAL_FTS_MIN_QUERY_CHARS;
 }
 
+/** Skip local FTS and search3 when the query would only produce junk wildcard hits. */
+export function liveSearchQueryRejected(query: string): boolean {
+  const q = query.trim();
+  if (!q) return true;
+  if (liveSearchQueryTooShort(q)) return true;
+  return !searchQueryIsFtsSafe(q);
+}
+
 export type LiveSearchStaleCheck = () => boolean;
 
 export interface LiveSearchRunContext {
@@ -61,7 +70,7 @@ export async function runLocalLiveSearch(
 ): Promise<SearchResults | null> {
   if (!serverId || ctx.isStale()) return null;
   const q = query.trim();
-  if (liveSearchQueryTooShort(q)) return null;
+  if (liveSearchQueryRejected(q)) return null;
   const t0 = performance.now();
   try {
     const { result: resp, ms: invokeMs } = await timed(() =>
@@ -131,7 +140,7 @@ export async function runNetworkLiveSearch(
   signal?: AbortSignal,
 ): Promise<SearchResults | null> {
   const q = query.trim();
-  if (liveSearchQueryTooShort(q)) return null;
+  if (liveSearchQueryRejected(q)) return null;
   try {
     return await search(q, {
       signal,

src/utils/library/searchQueryFtsSafe.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { searchQueryIsFtsSafe, searchTokenIsFtsSafe } from './searchQueryFtsSafe';
+
+describe('searchQueryIsFtsSafe', () => {
+  it('rejects equals and wildcard-only junk queries', () => {
+    expect(searchQueryIsFtsSafe('1=2')).toBe(false);
+    expect(searchQueryIsFtsSafe('**')).toBe(false);
+    expect(searchQueryIsFtsSafe('***')).toBe(false);
+    expect(searchQueryIsFtsSafe('****')).toBe(false);
+    expect(searchQueryIsFtsSafe('M=c')).toBe(false);
+    expect(searchQueryIsFtsSafe('V()>P')).toBe(false);
+  });
+
+  it('accepts normal search terms and censorship stars in titles', () => {
+    expect(searchQueryIsFtsSafe('metallica')).toBe(true);
+    expect(searchQueryIsFtsSafe('love supreme')).toBe(true);
+    expect(searchQueryIsFtsSafe('25')).toBe(true);
+    expect(searchQueryIsFtsSafe('AC/DC')).toBe(true);
+    expect(searchQueryIsFtsSafe('***Flawless')).toBe(true);
+    expect(searchQueryIsFtsSafe('B********')).toBe(true);
+    expect(searchQueryIsFtsSafe('F**k This Industry')).toBe(true);
+  });
+
+  it('rejects when any token is unsafe', () => {
+    expect(searchQueryIsFtsSafe('dark side')).toBe(true);
+    expect(searchQueryIsFtsSafe('dark = side')).toBe(false);
+  });
+});
+
+describe('searchTokenIsFtsSafe', () => {
+  it('requires at least one letter or digit', () => {
+    expect(searchTokenIsFtsSafe('***')).toBe(false);
+    expect(searchTokenIsFtsSafe('!!!')).toBe(false);
+  });
+});

src/utils/library/searchQueryFtsSafe.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared guard for local FTS and Subsonic search3.
+ * - Wildcard-only tokens (`**`, `****`) match everything on search3 / FTS5.
+ * - `=` and other query syntax break quoted FTS tokens (`1=2` → junk hits).
+ * - Asterisks in real tags (`***Flawless`, `B********`) stay searchable.
+ */
+
+/** FTS5 / search3 syntax — not `*` (censorship stars in titles are valid). */
+const FTS_QUERY_SYNTAX_CHARS = new Set(['=', ':', '(', ')', '^', '<', '>', '%', '|', '\\']);
+
+function isWildcardOnlyToken(token: string): boolean {
+  return token.length > 0 && [...token].every(ch => ch === '*');
+}
+
+export function searchTokenIsFtsSafe(token: string): boolean {
+  const t = token.trim();
+  if (!t || isWildcardOnlyToken(t)) return false;
+  if ([...t].some(ch => FTS_QUERY_SYNTAX_CHARS.has(ch))) return false;
+  return [...t].some(ch => /\p{L}|\p{N}/u.test(ch) || ch.charCodeAt(0) >= 0x80);
+}
+
+/** Every whitespace token must be safe — mirrors `fts_safe_whitespace_tokens` in Rust. */
+export function searchQueryIsFtsSafe(query: string): boolean {
+  const tokens = query.trim().split(/\s+/).filter(Boolean);
+  return tokens.length > 0 && tokens.every(searchTokenIsFtsSafe);
+}