@open-mercato/search 0.6.8-develop.7100.1.fbf66fca35 → 0.7.0

package/src/lib/presenter-enricher.ts

@@ -104,95 +104,6 @@ type EnrichmentResult = {
   links?: SearchResultLink[]
 }
 
-function primaryNavigationHref(result: SearchResult): string | null {
-  if (typeof result.url === 'string' && result.url.trim().length > 0) {
-    return result.url.trim()
-  }
-  const primaryLink = result.links?.find((link) => link.kind === 'primary' && link.href.trim().length > 0)
-  return primaryLink?.href.trim() ?? null
-}
-
-function directNavigationRecordId(href: string): string | null {
-  try {
-    const url = new URL(href, 'http://search.local')
-    if (url.search || url.hash) return null
-    const segments = url.pathname.split('/').filter(Boolean)
-    const lastSegment = segments.at(-1)
-    return lastSegment ? decodeURIComponent(lastSegment) : null
-  } catch {
-    return null
-  }
-}
-
-function presenterTitle(result: SearchResult): string | null {
-  const title = result.presenter?.title?.trim()
-  return title?.length ? title : null
-}
-
-function resultScopeKey(result: SearchResult, recordId: string): string {
-  return `${result.organizationId ?? ''}:${recordId}`
-}
-
-function mergeResultMetadata(
-  targetMetadata: SearchResult['metadata'],
-  linkedMetadata: SearchResult['metadata'],
-): SearchResult['metadata'] {
-  if (!targetMetadata && !linkedMetadata) return undefined
-  return {
-    ...targetMetadata,
-    ...linkedMetadata,
-  }
-}
-
-function mergeLinkedDuplicateResults(results: SearchResult[]): SearchResult[] {
-  const indexesByRecord = new Map<string, number[]>()
-  for (let index = 0; index < results.length; index += 1) {
-    const result = results[index]
-    const key = resultScopeKey(result, result.recordId)
-    const indexes = indexesByRecord.get(key) ?? []
-    indexes.push(index)
-    indexesByRecord.set(key, indexes)
-  }
-
-  const replacements = new Map<number, SearchResult>()
-  const removedIndexes = new Set<number>()
-
-  for (let index = 0; index < results.length; index += 1) {
-    const linkedResult = results[index]
-    const href = primaryNavigationHref(linkedResult)
-    const targetRecordId = href ? directNavigationRecordId(href) : null
-    if (!targetRecordId || targetRecordId === linkedResult.recordId) continue
-
-    const targetIndexes = (indexesByRecord.get(resultScopeKey(linkedResult, targetRecordId)) ?? [])
-      .filter((candidateIndex) => candidateIndex !== index && !removedIndexes.has(candidateIndex))
-    if (targetIndexes.length !== 1) continue
-
-    const targetIndex = targetIndexes[0]
-    const targetResult = replacements.get(targetIndex) ?? results[targetIndex]
-    if (primaryNavigationHref(targetResult)) continue
-
-    const linkedTitle = presenterTitle(linkedResult)
-    const targetTitle = presenterTitle(targetResult)
-    if (!linkedTitle || linkedTitle !== targetTitle) continue
-
-    replacements.set(targetIndex, {
-      ...targetResult,
-      score: Math.max(targetResult.score, linkedResult.score),
-      source: linkedResult.score > targetResult.score ? linkedResult.source : targetResult.source,
-      presenter: linkedResult.presenter ?? targetResult.presenter,
-      url: linkedResult.url ?? targetResult.url,
-      links: linkedResult.links ?? targetResult.links,
-      metadata: mergeResultMetadata(targetResult.metadata, linkedResult.metadata),
-    })
-    removedIndexes.add(index)
-  }
-
-  return results
-    .map((result, index) => replacements.get(index) ?? result)
-    .filter((_, index) => !removedIndexes.has(index))
-    .sort((left, right) => right.score - left.score)
-}
-
 /**
  * Compute presenter, URL, and links for a single doc using config or fallback.
  * Returns presenter (null if cannot be computed), and optionally URL/links from config.
@@ -374,7 +285,7 @@ export function createPresenterEnricher(
     }
 
     // Enrich results with computed presenter, URL, and links
-    const enrichedResults = results.map((result) => {
+    return results.map((result) => {
       if (!shouldEnrich(result)) return result
       const key = `${result.entityId}:${result.recordId}`
       const enriched = enrichmentMap.get(key)
@@ -386,7 +297,5 @@ export function createPresenterEnricher(
         links: enriched.links ?? result.links,
       }
     })
-
-    return mergeLinkedDuplicateResults(enrichedResults)
   }
 }

package/src/modules/search/__integration__/TC-SEARCH-006.spec.ts

@@ -1,75 +1,12 @@
-import { expect, test, type APIRequestContext } from '@playwright/test'
+import { expect, test } from '@playwright/test'
 import { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'
 import { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'
-import {
-  createCompanyFixture,
-  createPersonFixture,
-  deleteEntityIfExists,
-} from '@open-mercato/core/helpers/integration/crmFixtures'
 
 type GlobalSearchSettings = { enabledStrategies?: string[] }
 type GlobalSearchUpdate = { ok?: boolean; enabledStrategies?: string[] }
-type SearchResultItem = {
-  entityId?: string
-  recordId?: string
-  presenter?: { title?: string } | null
-  url?: string | null
-}
-type GlobalSearchResponse = { strategiesEnabled?: string[]; results?: SearchResultItem[] }
-type SearchQueryResult = { ok: boolean; status: number; results: SearchResultItem[] }
+type GlobalSearchResponse = { strategiesEnabled?: string[] }
 
 const DEFAULT_STRATEGIES = ['fulltext', 'vector', 'tokens']
-const CUSTOMER_ENTITY = 'customers:customer_entity'
-const PERSON_PROFILE = 'customers:customer_person_profile'
-const COMPANY_PROFILE = 'customers:customer_company_profile'
-
-function presenterTitle(result: SearchResultItem): string | null {
-  const title = result.presenter?.title
-  return typeof title === 'string' && title.trim().length > 0 ? title.trim() : null
-}
-
-async function searchResults(
-  request: APIRequestContext,
-  token: string,
-  path: string,
-): Promise<SearchQueryResult> {
-  const response = await apiRequest(request, 'GET', path, { token })
-  if (!response.ok()) return { ok: false, status: response.status(), results: [] }
-  const body = (await readJsonSafe<GlobalSearchResponse>(response)) ?? {}
-  return {
-    ok: true,
-    status: response.status(),
-    results: Array.isArray(body.results) ? body.results : [],
-  }
-}
-
-function customerSearchPath(query: string, entityType: string): string {
-  const params = new URLSearchParams({
-    q: query,
-    limit: '20',
-    strategies: 'tokens',
-    entityTypes: entityType,
-  })
-  return `/api/search/search?${params.toString()}`
-}
-
-function globalSearchPath(query: string): string {
-  const params = new URLSearchParams({ q: query, limit: '20' })
-  return `/api/search/search/global?${params.toString()}`
-}
-
-/**
- * A profile result navigates to the customer's v2 detail page, whose path segment is the base
- * customer entity id — not the profile's own `recordId`. So this asserts the shape of a direct
- * detail link (prefix + one non-empty id segment, no query string or anchor) rather than
- * equality with `recordId`.
- */
-function hasCanonicalNavigation(result: SearchResultItem, expectedPrefix: string): boolean {
-  if (typeof result.url !== 'string') return false
-  if (!result.url.startsWith(`${expectedPrefix}/`)) return false
-  const target = result.url.slice(expectedPrefix.length + 1)
-  return target.length > 0 && !/[/?#]/.test(target)
-}
 
 /**
  * TC-SEARCH-006: global (Cmd+K) search honors the saved strategy config over a
@@ -134,129 +71,4 @@ test.describe('TC-SEARCH-006: global search honors saved strategy config over UR
       }
     }
   })
-
-  test('returns one navigable profile result per customer and no base-entity duplicate', async ({ request }) => {
-    test.slow()
-    test.setTimeout(120_000)
-
-    const stamp = Date.now()
-    const personName = `QASRCH006P${stamp}`
-    const companyName = `QASRCH006C${stamp}`
-    let token: string | null = null
-    let originalStrategies: string[] | null = DEFAULT_STRATEGIES
-    let personId: string | null = null
-    let companyId: string | null = null
-    let personGlobalResults: SearchResultItem[] = []
-    let companyGlobalResults: SearchResultItem[] = []
-
-    try {
-      token = await getAuthToken(request, 'admin')
-
-      const currentRes = await apiRequest(request, 'GET', '/api/search/settings/global-search', { token })
-      expect(currentRes.ok(), 'GET global-search settings should succeed').toBeTruthy()
-      const current = (await readJsonSafe<GlobalSearchSettings>(currentRes)) ?? {}
-      originalStrategies =
-        Array.isArray(current.enabledStrategies) && current.enabledStrategies.length > 0
-          ? current.enabledStrategies
-          : DEFAULT_STRATEGIES
-
-      const updateRes = await apiRequest(request, 'POST', '/api/search/settings/global-search', {
-        token,
-        data: { enabledStrategies: ['tokens'] },
-      })
-      expect(updateRes.status(), 'POST global-search settings should return 200').toBe(200)
-
-      personId = await createPersonFixture(request, token, {
-        firstName: 'QA',
-        lastName: `Search 006 ${stamp}`,
-        displayName: personName,
-      })
-      companyId = await createCompanyFixture(request, token, companyName)
-
-      await expect
-        .poll(
-          async () => {
-            const [personEntity, personProfile, companyEntity, companyProfile, personGlobal, companyGlobal] =
-              await Promise.all([
-                searchResults(request, token!, customerSearchPath(personName, CUSTOMER_ENTITY)),
-                searchResults(request, token!, customerSearchPath(personName, PERSON_PROFILE)),
-                searchResults(request, token!, customerSearchPath(companyName, CUSTOMER_ENTITY)),
-                searchResults(request, token!, customerSearchPath(companyName, COMPANY_PROFILE)),
-                searchResults(request, token!, globalSearchPath(personName)),
-                searchResults(request, token!, globalSearchPath(companyName)),
-              ])
-
-            const queries = [
-              ['person-entity', personEntity],
-              ['person-profile', personProfile],
-              ['company-entity', companyEntity],
-              ['company-profile', companyProfile],
-              ['person-global', personGlobal],
-              ['company-global', companyGlobal],
-            ] as const
-            const failedQuery = queries.find(([, result]) => !result.ok)
-            if (failedQuery) return `${failedQuery[0]}:status:${failedQuery[1].status}`
-
-            const indexedQueries = [
-              ['person-profile', personProfile.results, personName, PERSON_PROFILE],
-              ['company-profile', companyProfile.results, companyName, COMPANY_PROFILE],
-            ] as const
-            for (const [label, results, expectedTitle, expectedEntityId] of indexedQueries) {
-              const matches = results.filter(
-                (result) => presenterTitle(result) === expectedTitle && result.entityId === expectedEntityId,
-              )
-              if (matches.length === 0) return `${label}:matches:0`
-            }
-
-            // Under the default OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY=false the token strategy
-            // refuses to return base customer rows, so an explicit query for that entity type is
-            // empty even though the same customers' profiles are already indexed above. (The rows
-            // themselves stay in search_tokens — the list-search id lookup still needs them.)
-            const baseEntityQueries = [
-              ['person-entity', personEntity.results, personName],
-              ['company-entity', companyEntity.results, companyName],
-            ] as const
-            for (const [label, results, expectedTitle] of baseEntityQueries) {
-              const matches = results.filter((result) => presenterTitle(result) === expectedTitle)
-              if (matches.length !== 0) return `${label}:matches:${matches.length}`
-            }
-
-            personGlobalResults = personGlobal.results.filter((result) => presenterTitle(result) === personName)
-            companyGlobalResults = companyGlobal.results.filter((result) => presenterTitle(result) === companyName)
-            if (personGlobalResults.length !== 1) return `person-global:matches:${personGlobalResults.length}`
-            if (companyGlobalResults.length !== 1) return `company-global:matches:${companyGlobalResults.length}`
-            if (personGlobalResults[0]?.entityId !== PERSON_PROFILE) {
-              return `person-global:entity:${personGlobalResults[0]?.entityId ?? 'missing'}`
-            }
-            if (companyGlobalResults[0]?.entityId !== COMPANY_PROFILE) {
-              return `company-global:entity:${companyGlobalResults[0]?.entityId ?? 'missing'}`
-            }
-            if (!hasCanonicalNavigation(personGlobalResults[0], '/backend/customers/people-v2')) {
-              return `person-global:navigation:${personGlobalResults[0]?.url ?? 'missing'}`
-            }
-            if (!hasCanonicalNavigation(companyGlobalResults[0], '/backend/customers/companies-v2')) {
-              return `company-global:navigation:${companyGlobalResults[0]?.url ?? 'missing'}`
-            }
-
-            return 'ready'
-          },
-          { timeout: 10_000 },
-        )
-        .toBe('ready')
-
-      expect(personGlobalResults).toHaveLength(1)
-      expect(personGlobalResults[0]?.entityId).toBe(PERSON_PROFILE)
-      expect(companyGlobalResults).toHaveLength(1)
-      expect(companyGlobalResults[0]?.entityId).toBe(COMPANY_PROFILE)
-    } finally {
-      await deleteEntityIfExists(request, token, '/api/customers/people', personId)
-      await deleteEntityIfExists(request, token, '/api/customers/companies', companyId)
-      if (token && originalStrategies) {
-        await apiRequest(request, 'POST', '/api/search/settings/global-search', {
-          token,
-          data: { enabledStrategies: originalStrategies },
-        }).catch(() => undefined)
-      }
-    }
-  })
 })

package/src/modules/search/api/__tests__/global-search.routes.test.ts

@@ -198,113 +198,6 @@ describe('GET /api/search/search/global presenter localization', () => {
       expect(result.links?.[0]?.label).toBe('Otwórz osobę')
     }
   })
-
-  // Covers OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY=true, where base customer rows are tokenized and
-  // the route can therefore receive both halves of a pair. Under the default the token strategy
-  // never returns the base rows at all (see token-strategy-entity-exclusion.test.ts); the strategy
-  // here is a stub that yields them regardless, so this pins the merge itself.
-  it('merges a customer entity and profile pair into one navigable result when both are indexed', async () => {
-    const rows = [
-      {
-        entity_type: 'customers:customer_entity',
-        entity_id: 'person-entity',
-        doc: { id: 'person-entity', display_name: 'Ada Lovelace', kind: 'person' },
-      },
-      {
-        entity_type: 'customers:customer_person_profile',
-        entity_id: 'person-profile',
-        doc: { id: 'person-profile', entity_id: 'person-entity', display_name: 'Ada Lovelace' },
-      },
-      {
-        entity_type: 'customers:customer_entity',
-        entity_id: 'company-entity',
-        doc: { id: 'company-entity', display_name: 'Analytical Engines', kind: 'company' },
-      },
-      {
-        entity_type: 'customers:customer_company_profile',
-        entity_id: 'company-profile',
-        doc: { id: 'company-profile', entity_id: 'company-entity', display_name: 'Analytical Engines' },
-      },
-      {
-        entity_type: 'orders:order',
-        entity_id: 'order-1',
-        doc: { id: 'order-1', title: 'Order 1' },
-      },
-    ]
-    const personEntityId = 'customers:customer_person_profile' as EntityId
-    const companyEntityId = 'customers:customer_company_profile' as EntityId
-    const configMap = new Map<EntityId, SearchEntityConfig>([
-      [personEntityId, {
-        entityId: personEntityId,
-        formatResult: async (context) => ({ title: String(context.record.display_name) }),
-        resolveUrl: async (context) => `/backend/customers/people-v2/${String(context.record.entity_id)}`,
-      }],
-      [companyEntityId, {
-        entityId: companyEntityId,
-        formatResult: async (context) => ({ title: String(context.record.display_name) }),
-        resolveUrl: async (context) => `/backend/customers/companies-v2/${String(context.record.entity_id)}`,
-      }],
-    ])
-    const scoresByRecordId: Record<string, number> = {
-      'person-profile': 0.95,
-      'company-profile': 0.85,
-      'order-1': 0.5,
-      'person-entity': 0.2,
-      'company-entity': 0.1,
-    }
-    const results: SearchResult[] = rows
-      .map((row) => ({
-        entityId: row.entity_type as EntityId,
-        recordId: row.entity_id,
-        organizationId: 'org-1',
-        score: scoresByRecordId[row.entity_id] ?? 0,
-        source: 'tokens' as const,
-      }))
-      .sort((left, right) => right.score - left.score)
-    const strategy: SearchStrategy = {
-      id: 'tokens',
-      name: 'tokens',
-      priority: 10,
-      isAvailable: async () => true,
-      ensureReady: async () => undefined,
-      search: async () => results,
-      index: async () => undefined,
-      delete: async () => undefined,
-    }
-    const searchService = new SearchService({
-      strategies: [strategy],
-      defaultStrategies: ['tokens'],
-      presenterEnricher: createPresenterEnricher(createDatabase(rows), configMap),
-    })
-    mockCreateRequestContainer.mockResolvedValue(
-      createContainer(searchService, configMap, { features: ['search.global'], isSuperAdmin: true }),
-    )
-
-    const response = await GET(new Request('http://localhost/api/search/search/global?q=customer'))
-    const body = await response.json() as { results: SearchResult[] }
-
-    expect(response.status).toBe(200)
-    expect(body.results).toEqual([
-      expect.objectContaining({
-        entityId: 'customers:customer_entity',
-        recordId: 'person-entity',
-        presenter: expect.objectContaining({ title: 'Ada Lovelace' }),
-        url: '/backend/customers/people-v2/person-entity',
-      }),
-      expect.objectContaining({
-        entityId: 'customers:customer_entity',
-        recordId: 'company-entity',
-        presenter: expect.objectContaining({ title: 'Analytical Engines' }),
-        url: '/backend/customers/companies-v2/company-entity',
-      }),
-      expect.objectContaining({
-        entityId: 'orders:order',
-        recordId: 'order-1',
-      }),
-    ])
-    expect(body.results[0]?.score).toBeGreaterThan(body.results[1]?.score ?? 0)
-    expect(body.results[1]?.score).toBeGreaterThan(body.results[2]?.score ?? 0)
-  })
 })
 
 describe('GET /api/search/search/global per-entity access control', () => {

package/src/modules/search/lib/entity-access.ts

@@ -1,6 +1,132 @@
+import type { SearchEntityConfig } from '@open-mercato/shared/modules/search'
+import { authorizeFeatures } from '@open-mercato/shared/security/featurePolicy'
+
 /**
- * Re-export shared entity-access helpers so existing imports keep working.
- * The canonical implementation lives in @open-mercato/shared to be reusable
- * from ai-assistant without introducing a search↔ai-assistant dependency cycle.
+ * Minimal shape of the `searchIndexer` DI service consumed by per-entity ACL
+ * resolution. Kept structural so callers and tests can pass a plain object
+ * instead of constructing a full `SearchIndexer`.
  */
-export * from '@open-mercato/shared/lib/search/entityAccess'
+export type SearchEntityConfigLookup = {
+  getEntityConfig: (entityId: string) => SearchEntityConfig | undefined
+  getAllEntityConfigs: () => SearchEntityConfig[]
+}
+
+export type SearchEntityAccessSubject = {
+  grantedFeatures: readonly string[]
+  isSuperAdmin?: boolean
+}
+
+export type SearchEntityDenyReason =
+  /** No module declares this entity in a `search.ts` config. */
+  | 'unconfigured'
+  /** The entity is configured for search but declares no `aclFeatures`. */
+  | 'no-acl-features'
+  /** The caller does not hold the entity's declared view feature(s). */
+  | 'insufficient-features'
+
+export type SearchEntityAccessOptions = {
+  /**
+   * Called once per denied entity type. Exists so a silent drop is diagnosable:
+   * results disappearing because a module forgot to declare `aclFeatures` looks
+   * identical, from the palette, to results that simply did not match.
+   */
+  onDeny?: (entityId: string, reason: SearchEntityDenyReason) => void
+}
+
+/**
+ * Decide whether a caller may see results for one entity type.
+ *
+ * The single `search.global` gate on the palette only says "this user may use
+ * global search"; it says nothing about which records they may read. Each entity
+ * declares the owning module's view feature(s) in `aclFeatures`, and those are
+ * what actually authorize the read — the same rule the `search_get` /
+ * `search_aggregate` AI tools already apply.
+ *
+ * Fails closed: an entity that is not registered for search, or that declares no
+ * `aclFeatures`, is never exposed to a non-superadmin caller.
+ */
+export function canReadSearchEntity(
+  entityId: string,
+  lookup: SearchEntityConfigLookup,
+  subject: SearchEntityAccessSubject,
+  options: SearchEntityAccessOptions = {},
+): boolean {
+  if (subject.isSuperAdmin) return true
+
+  const config = lookup.getEntityConfig(entityId)
+  if (!config) {
+    options.onDeny?.(entityId, 'unconfigured')
+    return false
+  }
+
+  const required = config.aclFeatures
+  if (!required || required.length === 0) {
+    options.onDeny?.(entityId, 'no-acl-features')
+    return false
+  }
+
+  const allowed = authorizeFeatures(required, {
+    grantedFeatures: subject.grantedFeatures,
+    unrestricted: false,
+  })
+  if (!allowed) options.onDeny?.(entityId, 'insufficient-features')
+  return allowed
+}
+
+/**
+ * The entity types this caller may read, narrowed to `requestedEntityTypes` when
+ * the caller asked for specific ones.
+ *
+ * Restricting the query up front is what keeps `limit` meaningful. Filtering only
+ * after the search would spend the whole result budget on records the caller
+ * cannot see: an employee granted just `customers.people.view` would get the top
+ * 50 hits across every entity type, then watch most of them be dropped, and the
+ * palette would look empty even with hundreds of matching people behind it.
+ *
+ * Returns `undefined` when no restriction applies (superadmin with no explicit
+ * request), and an empty array when nothing is readable — callers should
+ * short-circuit on that rather than pass it down as "no filter".
+ */
+export function resolveReadableEntityTypes(
+  lookup: SearchEntityConfigLookup,
+  subject: SearchEntityAccessSubject,
+  requestedEntityTypes?: string[],
+): string[] | undefined {
+  if (subject.isSuperAdmin) return requestedEntityTypes
+
+  const readable = lookup
+    .getAllEntityConfigs()
+    .filter((config) => config.enabled !== false)
+    .map((config) => config.entityId)
+    .filter((entityId) => canReadSearchEntity(entityId, lookup, subject))
+
+  if (!requestedEntityTypes) return readable
+  const requested = new Set(requestedEntityTypes)
+  return readable.filter((entityId) => requested.has(entityId))
+}
+
+/**
+ * Drop the results whose entity type the caller is not allowed to read.
+ *
+ * Filtering happens server-side so an under-privileged caller never receives the
+ * presenter title, subtitle or deep link of a record they cannot open. Decisions
+ * are memoized per entity type because a single response commonly mixes dozens of
+ * results across a handful of types.
+ */
+export function filterSearchResultsByEntityAccess<T extends { entityId: string }>(
+  results: readonly T[],
+  lookup: SearchEntityConfigLookup,
+  subject: SearchEntityAccessSubject,
+  options: SearchEntityAccessOptions = {},
+): T[] {
+  if (subject.isSuperAdmin) return [...results]
+
+  const decisions = new Map<string, boolean>()
+  return results.filter((result) => {
+    const cached = decisions.get(result.entityId)
+    if (cached !== undefined) return cached
+    const allowed = canReadSearchEntity(result.entityId, lookup, subject, options)
+    decisions.set(result.entityId, allowed)
+    return allowed
+  })
+}

package/src/modules/search/workers/fulltext-index.worker.ts

@@ -78,9 +78,8 @@ async function advanceFulltextReindexProgress(params: {
  * This handler processes single record indexing, batch indexing, deletion, and purge
  * operations for the fulltext search strategy.
  *
- * Single-record jobs load fresh data via searchIndexer.indexRecordById(). Batch jobs load
- * fresh data per record via searchIndexer.indexRecordsById(), which flushes the whole batch
- * through a single bulk write instead of one write per record.
+ * All indexing operations (single and batch) use searchIndexer.indexRecordById() to load
+ * fresh data, ensuring consistency with the vector worker pattern.
  *
  * @param job - The queued job containing payload
  * @param jobCtx - Queue job context with job ID and attempt info
@@ -203,7 +202,7 @@ export async function handleFulltextIndexJob(
       return
     }
 
-    // ========== BATCH-INDEX: Load fresh data, write the whole batch in one call ==========
+    // ========== BATCH-INDEX: Use searchIndexer.indexRecordById() for fresh data ==========
     if (jobType === 'batch-index') {
       const { records, organizationId } = job.payload
       if (!records || records.length === 0) {
@@ -217,13 +216,30 @@ export async function handleFulltextIndexJob(
         throw new Error('searchIndexer not available for batch indexing')
       }
 
-      // Load and index the whole batch through a single bulk write instead of
-      // one indexRecordById() call per record.
-      const { indexed: successCount, skipped: skippedCount } = await searchIndexer.indexRecordsById({
-        items: records.map(({ entityId, recordId }) => ({ entityId: entityId as EntityId, recordId })),
-        tenantId,
-        organizationId,
-      })
+      // Process each record using indexRecordById (same pattern as vector worker)
+      let successCount = 0
+      let failCount = 0
+
+      for (const { entityId, recordId } of records) {
+        try {
+          const result = await searchIndexer.indexRecordById({
+            entityId: entityId as EntityId,
+            recordId,
+            tenantId,
+            organizationId,
+          })
+          if (result.action === 'indexed') {
+            successCount++
+          }
+        } catch (error) {
+          failCount++
+          searchDebugWarn('fulltext-index.worker', 'Failed to index record in batch', {
+            entityId,
+            recordId,
+            error: error instanceof Error ? error.message : error,
+          })
+        }
+      }
 
       await advanceFulltextReindexProgress({
         db,
@@ -239,7 +255,7 @@ export async function handleFulltextIndexJob(
         tenantId,
         requestedCount: records.length,
         successCount,
-        skippedCount,
+        failCount,
       })
 
       await recordIndexerLog(
@@ -249,7 +265,7 @@ export async function handleFulltextIndexJob(
           handler: 'worker:fulltext:batch-index',
           message: `Indexed ${successCount}/${records.length} records to fulltext`,
           tenantId,
-          details: { jobId: jobCtx.jobId, requestedCount: records.length, successCount, skippedCount },
+          details: { jobId: jobCtx.jobId, requestedCount: records.length, successCount, failCount },
         },
       )
       return