@open-mercato/shared 0.6.7-develop.6860.1.f796b22e80 → 0.6.7

package/src/lib/query/engine.ts

@@ -12,13 +12,6 @@ import {
   type ResolvedJoin,
 } from './join-utils'
 import { resolveSearchConfig } from '../search/config'
-import {
-  createSearchTokenAvailability,
-  isSearchFilterOp,
-  type SearchTokenAvailability,
-  type SearchTokenProbeDb,
-  type SearchTokenProbeQueryBuilder,
-} from '../search/availability'
 import { tokenizeText } from '../search/tokenize'
 import { runBeforeQueryPipeline, runAfterQueryPipeline, type QueryExtensionContext } from './query-extension-runner'
 import {
@@ -27,7 +20,6 @@ import {
   type CustomFieldDefinitionRow,
   type ResolvedCustomFieldDefinitions,
 } from '../crud/custom-field-definition-index'
-import { warnOnCiphertextLikeFallback } from './ciphertext-search-warning'
 import { resolveEncryptedSortFields, resolveEncryptedSortMaxRows, sortRowsInMemory } from './encrypted-sort'
 import { mapWithConcurrency } from './bounded-decrypt'
 import { createLogger } from '../logger'
@@ -214,8 +206,8 @@ function computeCustomFieldScore(cfg: Record<string, unknown>, kind: string, ent
  */
 export class BasicQueryEngine implements QueryEngine {
   private columnCache = new Map<string, boolean>()
+  private tableCache = new Map<string, boolean>()
   private searchAliasSeq = 0
-  private searchAvailabilityInstance: SearchTokenAvailability | null = null
 
   constructor(
     private em: EntityManager,
@@ -238,22 +230,6 @@ export class BasicQueryEngine implements QueryEngine {
     throw new Error('BasicQueryEngine requires an EntityManager exposing getKysely() (MikroORM v7)')
   }
 
-  private searchAvailability(): SearchTokenAvailability {
-    if (!this.searchAvailabilityInstance) {
-      this.searchAvailabilityInstance = createSearchTokenAvailability({
-        getDb: () => this.getDb() as unknown as SearchTokenProbeDb,
-        getConfig: resolveSearchConfig,
-        applyOrganizationScope: (query, column, scope) => this.applyOrganizationScope(
-          query as unknown as AnyBuilder,
-          column,
-          scope,
-        ) as unknown as SearchTokenProbeQueryBuilder,
-        logDebug: (event, payload) => this.logSearchDebug(event, payload),
-      })
-    }
-    return this.searchAvailabilityInstance
-  }
-
   async query<T = any>(entity: EntityId, opts: QueryOptions = {}): Promise<QueryResult<T>> {
     // --- UMES query extension: before-query pipeline ---
     const ext = opts.extensions
@@ -317,20 +293,17 @@ export class BasicQueryEngine implements QueryEngine {
     const { baseFilters, joinFilters } = partitionFilters(table, normalizedFilters, joinMap)
     const cfFilters = normalizedFilters.filter((filter) => String(filter.field).startsWith('cf:'))
     const searchConfig = resolveSearchConfig()
-    const searchFilters = [...baseFilters, ...cfFilters].filter((filter) => isSearchFilterOp(filter.op))
     // Callers that opt out of automatic tenant/org scoping own the full
     // visibility predicate. Search-token filtering has its own tenant/org
     // guards, so it must be disabled on this direct-query path as documented
     // by QueryOptions.omitAutomaticTenantOrgScope.
-    const searchEnabled = !skipAutoScope && await this.searchAvailability().staticEnabled()
-    // Probe `search_tokens` only when this query actually searches (#4723): every consumer of
-    // `searchActive` sits behind a like/ilike guard, so on a plain list load the answer is never
-    // read — and the probe is a `LIMIT 1` the planner can resolve as a seq scan over a large
-    // `search_tokens`. The join path below already probes lazily for the same reason.
-    const hasSearchTokens = searchEnabled && searchFilters.length
-      ? await this.searchAvailability().hasTokens(String(entity), opts.tenantId ?? null, orgScope)
+    const searchEnabled = !skipAutoScope && searchConfig.enabled && await this.tableExists('search_tokens')
+    const hasSearchTokens = searchEnabled
+      ? await this.hasSearchTokens(String(entity), opts.tenantId ?? null, orgScope)
       : false
     const searchActive = searchEnabled && hasSearchTokens
+    const joinSearchAvailability = new Map<string, boolean>()
+    const searchFilters = [...baseFilters, ...cfFilters].filter((filter) => filter.op === 'like' || filter.op === 'ilike')
     if (searchFilters.length) {
       const fields = searchFilters.map((filter) => String(filter.field))
       this.logSearchDebug('search:init', {
@@ -360,45 +333,6 @@ export class BasicQueryEngine implements QueryEngine {
           organizationScope: orgScope,
         })
       }
-      const fallbackFields = searchFilters
-        .filter((filter) => !searchActive || typeof filter.value !== 'string' || tokenizeText(filter.value, searchConfig).hashes.length === 0)
-        .map((filter) => String(filter.field))
-      if (fallbackFields.length) {
-        await warnOnCiphertextLikeFallback({
-          entity: String(entity),
-          fields: fallbackFields,
-          tenantId: opts.tenantId ?? null,
-          // `searchEnabled` also folds in the missing-table and
-          // omitAutomaticTenantOrgScope cases, which are "no usable tokens"
-          // rather than "the operator switched search off".
-          reason: searchActive
-            ? 'no-indexable-tokens'
-            : searchConfig.enabled ? 'no-search-tokens' : 'search-disabled',
-          service: this.getEncryptionService(),
-        })
-      }
-    }
-    for (const [alias, joinedFilters] of joinFilters) {
-      const filters = joinedFilters.filter((entry) => entry.op === 'like' || entry.op === 'ilike')
-      if (!filters.length) continue
-      const join = joinMap.get(alias)
-      if (!join?.entityId) continue
-      const hasJoinedTokens = searchEnabled
-        ? await this.searchAvailability().hasTokens(join.entityId, opts.tenantId ?? null, orgScope)
-        : false
-      const fallbackFields = filters
-        .filter((filter) => !hasJoinedTokens || typeof filter.value !== 'string' || tokenizeText(filter.value, searchConfig).hashes.length === 0)
-        .map((filter) => filter.column)
-      if (!fallbackFields.length) continue
-      await warnOnCiphertextLikeFallback({
-        entity: join.entityId,
-        fields: fallbackFields,
-        tenantId: opts.tenantId ?? null,
-        reason: hasJoinedTokens
-          ? 'no-indexable-tokens'
-          : searchConfig.enabled ? 'no-search-tokens' : 'search-disabled',
-        service: this.getEncryptionService(),
-      })
     }
     const recordIdColumn = qualify('id')
 
@@ -462,7 +396,11 @@ export class BasicQueryEngine implements QueryEngine {
       if (!['like', 'ilike'].includes(filter.op)) return { applied: false, builder }
       if (typeof filter.value !== 'string' || filter.value.trim().length === 0) return { applied: false, builder }
 
-      const searchAvailable = await this.searchAvailability().hasTokens(join.entityId, opts.tenantId ?? null, orgScope)
+      let searchAvailable = joinSearchAvailability.get(join.entityId)
+      if (searchAvailable === undefined) {
+        searchAvailable = await this.hasSearchTokens(join.entityId, opts.tenantId ?? null, orgScope)
+        joinSearchAvailability.set(join.entityId, searchAvailable)
+      }
       if (!searchAvailable) return { applied: false, builder }
 
       const tokens = tokenizeText(String(filter.value), searchConfig)
@@ -533,8 +471,8 @@ export class BasicQueryEngine implements QueryEngine {
     // today's complete selection (base fields + CF projections + extension joins).
     // `projection: 'sortKeys'` selects only `id` + the sort columns — the slim phase-1
     // candidate scan used when `requiresPlaintextSort`. Re-running the WHERE/JOIN logic
-    // twice is cheap: every `columnExists` check is memoized on `this.columnCache`,
-    // so the second pass hits no extra DB calls.
+    // twice is cheap: every `columnExists`/`tableExists` check is memoized on
+    // `this.columnCache`/`this.tableCache`, so the second pass hits no extra DB calls.
     const buildQuery = async (projection: 'full' | 'sortKeys'): Promise<BuiltQuery> => {
       const isSortKeysProjection = projection === 'sortKeys'
       let q: AnyBuilder = db.selectFrom(table as any)
@@ -1198,6 +1136,51 @@ export class BasicQueryEngine implements QueryEngine {
     return present
   }
 
+  private async tableExists(table: string): Promise<boolean> {
+    if (this.tableCache.has(table)) return this.tableCache.get(table) ?? false
+    const db = this.getDb()
+    const exists = await db
+      .selectFrom('information_schema.tables' as any)
+      .select(sql<number>`1`.as('one'))
+      .where('table_name' as any, '=', table)
+      .limit(1)
+      .executeTakeFirst()
+    const present = !!exists
+    this.tableCache.set(table, present)
+    return present
+  }
+
+  private async hasSearchTokens(
+    entity: string,
+    tenantId: string | null,
+    orgScope?: { ids: string[]; includeNull: boolean } | null
+  ): Promise<boolean> {
+    try {
+      const db = this.getDb()
+      let query: AnyBuilder = db
+        .selectFrom('search_tokens' as any)
+        .select(sql<number>`1`.as('one'))
+        .where('entity_type' as any, '=', entity)
+        .limit(1)
+      if (tenantId !== undefined) {
+        query = query.where(sql<boolean>`tenant_id is not distinct from ${tenantId}`)
+      }
+      if (orgScope) {
+        query = this.applyOrganizationScope(query, 'search_tokens.organization_id', orgScope)
+      }
+      const row = await query.executeTakeFirst()
+      return !!row
+    } catch (err) {
+      this.logSearchDebug('search:has-tokens-error', {
+        entity,
+        tenantId,
+        organizationScope: orgScope,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return false
+    }
+  }
+
   private applySearchTokens(
     q: AnyBuilder,
     opts: {

package/src/lib/query/types.ts

@@ -108,10 +108,11 @@ export type QueryOptions = {
    * and MUST fail closed when the authenticated principal lacks a resolvable tenant/org, otherwise
    * queries return cross-tenant rows.
    *
-   * When this flag is set, the hybrid query engine delegates to the basic engine. The basic engine
-   * still applies `cf:*` filters/sorts, but `search_tokens` fulltext filtering, the JSONB index read
-   * path, and the vector-search branch are BYPASSED. Only use this on entities whose scoping does
-   * not match the standard `organization_id = X AND tenant_id = Y` shape.
+   * When this flag is set, the hybrid query engine delegates to the basic engine, which means
+   * custom-field (`cf:*`) filters/sorts, `search_tokens` fulltext filtering, and vector-search
+   * branches are BYPASSED. Only use this on entities whose scoping does not match the standard
+   * `organization_id = X AND tenant_id = Y` shape and which do not rely on custom-field/search
+   * features.
    */
   omitAutomaticTenantOrgScope?: boolean
   // Soft-delete behavior: when false (default), rows with non-null deleted_at

package/src/lib/redis/__tests__/connection.test.ts

@@ -5,11 +5,9 @@ describe('parseRedisUrl', () => {
     expect(parseRedisUrl('rediss://:secret@example.cache.amazonaws.com:6379/2')).toEqual({
       host: 'example.cache.amazonaws.com',
       port: 6379,
-      username: undefined,
       password: 'secret',
       db: 2,
       tls: {},
-      family: undefined,
     })
   })
 
@@ -17,23 +15,9 @@ describe('parseRedisUrl', () => {
     expect(parseRedisUrl('redis://:secret@localhost:6379/0')).toEqual({
       host: 'localhost',
       port: 6379,
-      username: undefined,
       password: 'secret',
       db: 0,
       tls: undefined,
-      family: undefined,
-    })
-  })
-
-  it('preserves ACL credentials and supported address-family options', () => {
-    expect(parseRedisUrl('rediss://app%2Duser:p%40ss@example.com:6380/4?family=6')).toEqual({
-      host: 'example.com',
-      port: 6380,
-      username: 'app-user',
-      password: 'p@ss',
-      db: 4,
-      tls: {},
-      family: 6,
     })
   })
 })

package/src/lib/redis/connection.ts

@@ -21,11 +21,9 @@ const logger = createLogger('shared').child({ component: 'redis' })
 export type ParsedRedisConnection = {
   host: string
   port: number
-  username?: string
   password?: string
   db?: number
   tls?: Record<string, unknown>
-  family?: number
 }
 
 /**
@@ -61,8 +59,12 @@ export function getRedisUrlOrThrow(prefix?: string): string {
 }
 
 /**
- * Parse a redis:// URL into structured connection options suitable for
- * BullMQ and ioredis.
+ * Parse a redis:// URL into a {host, port, password, db} object
+ * suitable for BullMQ / ioredis structured connection options.
+ *
+ * @deprecated Prefer passing the full URL via `{ url: getRedisUrl(...) }` to
+ * BullMQ/ioredis — this preserves rediss://, username, database, and query
+ * params that structured parsing may lose. Kept for backward compatibility.
  */
 export function parseRedisUrl(url: string): ParsedRedisConnection {
   try {
@@ -70,17 +72,12 @@ export function parseRedisUrl(url: string): ParsedRedisConnection {
     const dbStr = parsed.pathname ? parsed.pathname.slice(1) : ''
     const dbParsed = dbStr !== '' ? parseInt(dbStr, 10) : NaN
     const db = Number.isNaN(dbParsed) ? undefined : dbParsed
-    const familyValue = parsed.searchParams.get('family')
-    const familyParsed = familyValue !== null ? parseInt(familyValue, 10) : NaN
-    const family = [0, 4, 6].includes(familyParsed) ? familyParsed : undefined
     return {
       host: parsed.hostname || 'localhost',
       port: parseInt(parsed.port, 10) || 6379,
-      username: parsed.username ? decodeURIComponent(parsed.username) : undefined,
-      password: parsed.password ? decodeURIComponent(parsed.password) : undefined,
+      password: parsed.password || undefined,
       db,
       tls: parsed.protocol === 'rediss:' ? {} : undefined,
-      family,
     }
   } catch {
     const safeUrl = url.replace(/\/\/[^:]*:[^@]*@/, '//<redacted>@')

package/src/lib/search/__tests__/config.test.ts

@@ -1,12 +1,7 @@
 import {
-  DEFAULT_SEARCH_MAX_FIELD_CHARS,
-  DEFAULT_SEARCH_MAX_TOKENS_PER_FIELD,
-  DEFAULT_SEARCH_MAX_TOKENS_PER_RECORD,
   DEFAULT_SEARCH_MIN_TOKEN_LENGTH,
-  isSearchFieldBlocklisted,
   resolveSearchConfig,
   resolveSearchMinTokenLength,
-  resolveSearchTokenLimits,
 } from '../config'
 
 describe('resolveSearchMinTokenLength', () => {
@@ -45,175 +40,3 @@ describe('resolveSearchMinTokenLength', () => {
     expect(resolveSearchConfig().minTokenLength).toBe(resolveSearchMinTokenLength())
   })
 })
-
-describe('OM_SEARCH_FIELD_BLOCKLIST parsing', () => {
-  const originalValue = process.env.OM_SEARCH_FIELD_BLOCKLIST
-
-  afterEach(() => {
-    if (originalValue === undefined) {
-      delete process.env.OM_SEARCH_FIELD_BLOCKLIST
-    } else {
-      process.env.OM_SEARCH_FIELD_BLOCKLIST = originalValue
-    }
-  })
-
-  it('always includes the built-in defaults', () => {
-    delete process.env.OM_SEARCH_FIELD_BLOCKLIST
-    const config = resolveSearchConfig()
-    expect(config.blocklistedFields).toEqual(expect.arrayContaining(['password', 'token', 'secret', 'hash']))
-    expect(config.entityBlocklistedFields).toEqual({})
-  })
-
-  it('treats an unprefixed entry as global and lowercases it', () => {
-    process.env.OM_SEARCH_FIELD_BLOCKLIST = ' Body , body '
-    const config = resolveSearchConfig()
-    expect(config.blocklistedFields.filter((entry) => entry === 'body')).toHaveLength(1)
-    expect(config.entityBlocklistedFields).toEqual({})
-  })
-
-  it('routes an entityType@field entry into the per-entity map only', () => {
-    process.env.OM_SEARCH_FIELD_BLOCKLIST = 'customers:customer_interaction@body'
-    const config = resolveSearchConfig()
-    expect(config.blocklistedFields).not.toContain('body')
-    expect(config.entityBlocklistedFields).toEqual({ 'customers:customer_interaction': ['body'] })
-  })
-
-  it('groups several fields under the same entity type', () => {
-    process.env.OM_SEARCH_FIELD_BLOCKLIST = 'customers:customer_interaction@body,customers:customer_interaction@subject'
-    expect(resolveSearchConfig().entityBlocklistedFields).toEqual({
-      'customers:customer_interaction': ['body', 'subject'],
-    })
-  })
-
-  it('ignores entries whose field part is empty', () => {
-    process.env.OM_SEARCH_FIELD_BLOCKLIST = 'customers:customer_interaction@,@,body'
-    const config = resolveSearchConfig()
-    expect(config.blocklistedFields).toContain('body')
-    expect(config.entityBlocklistedFields).toEqual({})
-  })
-
-  it('treats a leading separator as a global entry', () => {
-    process.env.OM_SEARCH_FIELD_BLOCKLIST = '@body'
-    const config = resolveSearchConfig()
-    expect(config.blocklistedFields).toContain('body')
-    expect(config.entityBlocklistedFields).toEqual({})
-  })
-
-  it('stores entity types that collide with inherited object keys as own entries', () => {
-    process.env.OM_SEARCH_FIELD_BLOCKLIST = 'constructor@body,toString@summary,__proto__@notes'
-    const config = resolveSearchConfig()
-
-    expect(Object.getPrototypeOf(config.entityBlocklistedFields)).toBeNull()
-    expect(config.entityBlocklistedFields?.['constructor']).toEqual(['body'])
-    expect(config.entityBlocklistedFields?.['tostring']).toEqual(['summary'])
-    expect(config.entityBlocklistedFields?.['__proto__']).toEqual(['notes'])
-    expect(isSearchFieldBlocklisted('body', 'constructor', config)).toBe(true)
-    expect(isSearchFieldBlocklisted('summary', 'toString', config)).toBe(true)
-    expect(isSearchFieldBlocklisted('notes', '__proto__', config)).toBe(true)
-  })
-})
-
-describe('search token limits', () => {
-  const variableNames = [
-    'OM_SEARCH_MAX_FIELD_CHARS',
-    'OM_SEARCH_MAX_TOKENS_PER_FIELD',
-    'OM_SEARCH_MAX_TOKENS_PER_RECORD',
-  ] as const
-  const originalValues = Object.fromEntries(variableNames.map((name) => [name, process.env[name]]))
-
-  afterEach(() => {
-    for (const name of variableNames) {
-      const original = originalValues[name]
-      if (original === undefined) delete process.env[name]
-      else process.env[name] = original
-    }
-  })
-
-  it('uses safe defaults when limits are unset', () => {
-    for (const name of variableNames) delete process.env[name]
-
-    expect(resolveSearchTokenLimits(resolveSearchConfig())).toEqual({
-      maxFieldChars: DEFAULT_SEARCH_MAX_FIELD_CHARS,
-      maxTokensPerField: DEFAULT_SEARCH_MAX_TOKENS_PER_FIELD,
-      maxTokensPerRecord: DEFAULT_SEARCH_MAX_TOKENS_PER_RECORD,
-    })
-  })
-
-  it('accepts zero to disable individual limits', () => {
-    for (const name of variableNames) process.env[name] = '0'
-
-    expect(resolveSearchTokenLimits(resolveSearchConfig())).toEqual({
-      maxFieldChars: 0,
-      maxTokensPerField: 0,
-      maxTokensPerRecord: 0,
-    })
-  })
-
-  it('normalizes invalid custom config values to defaults', () => {
-    expect(resolveSearchTokenLimits({
-      enabled: true,
-      minTokenLength: 3,
-      enablePartials: true,
-      hashAlgorithm: 'sha256',
-      storeRawTokens: false,
-      blocklistedFields: [],
-      maxFieldChars: Number.NaN,
-      maxTokensPerField: -1,
-      maxTokensPerRecord: 4.8,
-    })).toEqual({
-      maxFieldChars: DEFAULT_SEARCH_MAX_FIELD_CHARS,
-      maxTokensPerField: DEFAULT_SEARCH_MAX_TOKENS_PER_FIELD,
-      maxTokensPerRecord: 4,
-    })
-  })
-})
-
-describe('isSearchFieldBlocklisted', () => {
-  const baseConfig = {
-    enabled: true,
-    minTokenLength: 3,
-    enablePartials: true,
-    hashAlgorithm: 'sha256' as const,
-    storeRawTokens: false,
-  }
-
-  it('matches global entries by substring for any entity type', () => {
-    const config = { ...baseConfig, blocklistedFields: ['password'], entityBlocklistedFields: {} }
-    expect(isSearchFieldBlocklisted('password_hash', 'customers:person', config)).toBe(true)
-    expect(isSearchFieldBlocklisted('password_hash', null, config)).toBe(true)
-    expect(isSearchFieldBlocklisted('display_name', 'customers:person', config)).toBe(false)
-  })
-
-  it('applies an entity-scoped entry only to its own entity type', () => {
-    const config = {
-      ...baseConfig,
-      blocklistedFields: [],
-      entityBlocklistedFields: { 'customers:customer_interaction': ['body'] },
-    }
-    expect(isSearchFieldBlocklisted('body', 'customers:customer_interaction', config)).toBe(true)
-    expect(isSearchFieldBlocklisted('body', 'customers:person', config)).toBe(false)
-    expect(isSearchFieldBlocklisted('body', null, config)).toBe(false)
-  })
-
-  it('compares entity types case-insensitively', () => {
-    const config = {
-      ...baseConfig,
-      blocklistedFields: [],
-      entityBlocklistedFields: { 'customers:customer_interaction': ['body'] },
-    }
-    expect(isSearchFieldBlocklisted('BODY', ' Customers:Customer_Interaction ', config)).toBe(true)
-  })
-
-  it('ignores inherited Object.prototype keys when looking up an entity type', () => {
-    const config = { ...baseConfig, blocklistedFields: [], entityBlocklistedFields: {} }
-    expect(isSearchFieldBlocklisted('body', 'constructor', config)).toBe(false)
-    expect(isSearchFieldBlocklisted('body', 'toString', config)).toBe(false)
-    expect(isSearchFieldBlocklisted('body', '__proto__', config)).toBe(false)
-  })
-
-  it('tolerates a config without the per-entity map', () => {
-    const config = { ...baseConfig, blocklistedFields: ['secret'] }
-    expect(isSearchFieldBlocklisted('client_secret', 'customers:person', config)).toBe(true)
-    expect(isSearchFieldBlocklisted('body', 'customers:person', config)).toBe(false)
-  })
-})

package/src/lib/search/config.ts

@@ -1,6 +1,5 @@
 import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
 import { parseNumberWithDefault } from '@open-mercato/shared/lib/number'
-import { parseCommaSeparatedList } from '@open-mercato/shared/lib/string'
 
 export type SearchConfig = {
   enabled: boolean
@@ -9,27 +8,12 @@ export type SearchConfig = {
   hashAlgorithm: 'sha256' | 'sha1' | 'md5'
   storeRawTokens: boolean
   blocklistedFields: string[]
-  entityBlocklistedFields?: Record<string, string[]>
-  maxFieldChars?: number
-  maxTokensPerField?: number
-  maxTokensPerRecord?: number
 }
 
 export const DEFAULT_SEARCH_MIN_TOKEN_LENGTH = 3
-export const DEFAULT_SEARCH_MAX_FIELD_CHARS = 20_000
-export const DEFAULT_SEARCH_MAX_TOKENS_PER_FIELD = 5_000
-export const DEFAULT_SEARCH_MAX_TOKENS_PER_RECORD = 20_000
-
-export type SearchTokenLimits = {
-  maxFieldChars: number
-  maxTokensPerField: number
-  maxTokensPerRecord: number
-}
 
 const DEFAULT_BLOCKLIST = ['password', 'token', 'secret', 'hash']
 
-const ENTITY_BLOCKLIST_SEPARATOR = '@'
-
 function parseBoolean(raw: string | undefined, fallback: boolean): boolean {
   return parseBooleanWithDefault(raw, fallback)
 }
@@ -38,19 +22,6 @@ function parseNumber(raw: string | undefined, fallback: number, min = 1): number
   return parseNumberWithDefault(raw, fallback, { integer: true, min })
 }
 
-export function resolveSearchTokenLimits(config: SearchConfig): SearchTokenLimits {
-  const resolveLimit = (value: number | undefined, fallback: number): number => {
-    if (value === undefined) return fallback
-    if (!Number.isFinite(value) || value < 0) return fallback
-    return Math.trunc(value)
-  }
-  return {
-    maxFieldChars: resolveLimit(config.maxFieldChars, DEFAULT_SEARCH_MAX_FIELD_CHARS),
-    maxTokensPerField: resolveLimit(config.maxTokensPerField, DEFAULT_SEARCH_MAX_TOKENS_PER_FIELD),
-    maxTokensPerRecord: resolveLimit(config.maxTokensPerRecord, DEFAULT_SEARCH_MAX_TOKENS_PER_RECORD),
-  }
-}
-
 function parseHashAlgorithm(raw: string | undefined): 'sha256' | 'sha1' | 'md5' {
   const value = (raw ?? '').trim().toLowerCase()
   if (value === 'sha1') return 'sha1'
@@ -58,93 +29,24 @@ function parseHashAlgorithm(raw: string | undefined): 'sha256' | 'sha1' | 'md5'
   return 'sha256'
 }
 
-/**
- * Parses `OM_SEARCH_FIELD_BLOCKLIST` into a global list plus per-entity-type lists.
- *
- * Why: a deployment often needs to keep one large free-text column out of the token
- * index (e-mail bodies on `customers:customer_interaction`) while still indexing the
- * same-named column elsewhere. A flat global list cannot express that.
- *
- * How to apply: entries are comma-separated; an entry may carry an optional
- * `entityType@` prefix — `body` blocks the field everywhere, while
- * `customers:customer_interaction@body` blocks it only for that entity type. Entries
- * whose field part is empty are ignored so malformed env input cannot break indexing.
- */
-function parseFieldBlocklist(raw: string | undefined): {
-  global: string[]
-  byEntity: Record<string, string[]>
-} {
-  const global: string[] = []
-  const byEntity = new Map<string, string[]>()
-
-  for (const rawEntry of parseCommaSeparatedList(raw)) {
-    const entry = rawEntry.toLowerCase()
-    const separatorIndex = entry.indexOf(ENTITY_BLOCKLIST_SEPARATOR)
-    const entityType = separatorIndex >= 0 ? entry.slice(0, separatorIndex).trim() : ''
-    const field = separatorIndex >= 0 ? entry.slice(separatorIndex + 1).trim() : entry
-    if (!field.length) continue
-
-    if (!entityType.length) {
-      if (!global.includes(field)) global.push(field)
-      continue
-    }
-
-    const scoped = byEntity.get(entityType) ?? []
-    if (!scoped.includes(field)) scoped.push(field)
-    byEntity.set(entityType, scoped)
-  }
-
-  for (const fallback of DEFAULT_BLOCKLIST) {
-    if (!global.includes(fallback)) global.push(fallback)
-  }
-
-  const scopedBlocklist = Object.create(null) as Record<string, string[]>
-  for (const [entityType, fields] of byEntity) scopedBlocklist[entityType] = fields
-
-  return { global, byEntity: scopedBlocklist }
-}
-
 export function resolveSearchConfig(): SearchConfig {
-  const blocklist = parseFieldBlocklist(process.env.OM_SEARCH_FIELD_BLOCKLIST)
   return {
     enabled: parseBoolean(process.env.OM_SEARCH_ENABLED, true),
     minTokenLength: resolveSearchMinTokenLength(),
     enablePartials: parseBoolean(process.env.OM_SEARCH_ENABLE_PARTIAL, true),
     hashAlgorithm: parseHashAlgorithm(process.env.OM_SEARCH_HASH_ALGO),
     storeRawTokens: parseBoolean(process.env.OM_SEARCH_STORE_RAW_TOKENS, false),
-    blocklistedFields: blocklist.global,
-    entityBlocklistedFields: blocklist.byEntity,
-    maxFieldChars: parseNumber(process.env.OM_SEARCH_MAX_FIELD_CHARS, DEFAULT_SEARCH_MAX_FIELD_CHARS, 0),
-    maxTokensPerField: parseNumber(process.env.OM_SEARCH_MAX_TOKENS_PER_FIELD, DEFAULT_SEARCH_MAX_TOKENS_PER_FIELD, 0),
-    maxTokensPerRecord: parseNumber(process.env.OM_SEARCH_MAX_TOKENS_PER_RECORD, DEFAULT_SEARCH_MAX_TOKENS_PER_RECORD, 0),
+    blocklistedFields: (process.env.OM_SEARCH_FIELD_BLOCKLIST ?? '')
+      .split(',')
+      .map((entry) => entry.trim())
+      .filter((entry) => entry.length > 0)
+      .filter((value, index, arr) => arr.indexOf(value) === index)
+      .map((entry) => entry.toLowerCase())
+      .concat(DEFAULT_BLOCKLIST)
+      .filter((value, index, arr) => arr.indexOf(value) === index),
   }
 }
 
-/**
- * Single matcher for "should this field be kept out of the search index?".
- *
- * Why: the per-field token path and the `search_text` aggregate previously each
- * decided this on their own, and the aggregate simply never consulted the config —
- * so a blocklisted column's text came back into the index under the aggregate's
- * field name (#4624). Both paths now share this function so they cannot drift.
- *
- * How to apply: pass the document's field name and the entity type being indexed;
- * `entityType` may be omitted when unknown, in which case only global entries apply.
- * Matching keeps the historical substring semantics (`fieldName.includes(pattern)`).
- */
-export function isSearchFieldBlocklisted(
-  field: string,
-  entityType: string | null | undefined,
-  config: SearchConfig,
-): boolean {
-  const lower = field.toLowerCase()
-  if (config.blocklistedFields.some((blocked) => lower.includes(blocked))) return true
-  if (!entityType) return false
-  const scoped = config.entityBlocklistedFields?.[entityType.trim().toLowerCase()]
-  if (!Array.isArray(scoped) || !scoped.length) return false
-  return scoped.some((blocked) => lower.includes(blocked))
-}
-
 /**
  * Browser-safe accessor for the minimum search token length.
  *