@open-mercato/search 0.7.0 → 0.7.1-develop.7103.1.41ff100d93

package/src/__tests__/token-strategy-entity-exclusion.test.ts

@@ -0,0 +1,99 @@
+import { TokenSearchStrategy } from '../strategies/token.strategy'
+
+/**
+ * Coverage for `OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY` on the read path (#5046).
+ *
+ * The exclusion is read-side by design and the writer deliberately ignores the flag:
+ * `search_tokens` doubles as the encrypted-column lookup index, so the People and Companies list
+ * search resolves ids through the very `customers:customer_entity` rows this flag hides from
+ * search results. Dropping them write-side would turn that list search into a silent empty page.
+ * These tests therefore pin the SQL predicate the strategy issues, never the writer's behavior —
+ * `packages/core/src/modules/query_index/__tests__/search-entity-policy.test.ts` is the other half
+ * of the pair and asserts the writer emits byte-identical rows in both flag states.
+ */
+
+const CUSTOMER_ENTITY = 'customers:customer_entity'
+const PERSON_PROFILE = 'customers:customer_person_profile'
+
+type RecordedWhere = [string, string, unknown]
+
+function createMockDb() {
+  const wheres: RecordedWhere[] = []
+  const builder: Record<string, unknown> = {
+    select: jest.fn(() => builder),
+    where: jest.fn((column: unknown, op?: unknown, value?: unknown) => {
+      if (typeof column === 'string' && typeof op === 'string') wheres.push([column, op, value])
+      return builder
+    }),
+    groupBy: jest.fn(() => builder),
+    having: jest.fn(() => builder),
+    orderBy: jest.fn(() => builder),
+    limit: jest.fn(() => builder),
+    execute: jest.fn().mockResolvedValue([]),
+  }
+  const db = { selectFrom: jest.fn(() => builder) }
+  return { db, wheres, builder }
+}
+
+const entityTypePredicates = (wheres: RecordedWhere[]) => wheres.filter(([column]) => column === 'entity_type')
+
+const originalFlag = process.env.OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY
+
+afterEach(() => {
+  if (originalFlag === undefined) delete process.env.OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY
+  else process.env.OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY = originalFlag
+})
+
+describe('TokenSearchStrategy excludes base customer entities by default', () => {
+  it('adds a NOT IN predicate when the caller requests no specific entity types', async () => {
+    delete process.env.OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY
+    const { db, wheres } = createMockDb()
+    const strategy = new TokenSearchStrategy(db as never)
+
+    await strategy.search('ada lovelace', { tenantId: 'tenant-1' })
+
+    expect(entityTypePredicates(wheres)).toEqual([['entity_type', 'not in', [CUSTOMER_ENTITY]]])
+  })
+
+  it('drops the excluded type from an explicit entityTypes filter and keeps the rest', async () => {
+    delete process.env.OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY
+    const { db, wheres } = createMockDb()
+    const strategy = new TokenSearchStrategy(db as never)
+
+    await strategy.search('ada lovelace', {
+      tenantId: 'tenant-1',
+      entityTypes: [CUSTOMER_ENTITY, PERSON_PROFILE],
+    })
+
+    expect(entityTypePredicates(wheres)).toEqual([['entity_type', 'in', [PERSON_PROFILE]]])
+  })
+
+  it('returns no results — and issues no query — when only excluded types were requested', async () => {
+    delete process.env.OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY
+    const { db } = createMockDb()
+    const strategy = new TokenSearchStrategy(db as never)
+
+    const results = await strategy.search('ada lovelace', {
+      tenantId: 'tenant-1',
+      entityTypes: [CUSTOMER_ENTITY],
+    })
+
+    expect(results).toEqual([])
+    expect(db.selectFrom).not.toHaveBeenCalled()
+  })
+
+  it('leaves the query untouched when the flag re-enables base customer entities', async () => {
+    process.env.OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY = 'true'
+    const { db, wheres } = createMockDb()
+    const strategy = new TokenSearchStrategy(db as never)
+
+    await strategy.search('ada lovelace', { tenantId: 'tenant-1' })
+    expect(entityTypePredicates(wheres)).toEqual([])
+
+    await strategy.search('ada lovelace', {
+      tenantId: 'tenant-1',
+      entityTypes: [CUSTOMER_ENTITY, PERSON_PROFILE],
+    })
+    expect(entityTypePredicates(wheres)).toEqual([['entity_type', 'in', [CUSTOMER_ENTITY, PERSON_PROFILE]]])
+  })
+})

package/src/__tests__/workers.test.ts

@@ -451,6 +451,7 @@ describe('Fulltext Index Worker', () => {
   const mockSearchIndexer = {
     getEntityConfig: jest.fn().mockReturnValue(null),
     indexRecordById: jest.fn().mockResolvedValue({ action: 'indexed', created: true }),
+    indexRecordsById: jest.fn().mockResolvedValue({ indexed: 0, skipped: 0 }),
   }
 
   const mockEm = {
@@ -471,6 +472,7 @@ describe('Fulltext Index Worker', () => {
     ;(hasActiveReindexProgress as jest.Mock).mockResolvedValue(true)
     mockFulltextStrategy.isAvailable.mockResolvedValue(true)
     mockSearchIndexer.indexRecordById.mockResolvedValue({ action: 'indexed', created: true })
+    mockSearchIndexer.indexRecordsById.mockResolvedValue({ indexed: 0, skipped: 0 })
   })
 
   it('should skip job with missing tenantId', async () => {
@@ -486,12 +488,13 @@ describe('Fulltext Index Worker', () => {
     expect(mockFulltextStrategy.bulkIndex).not.toHaveBeenCalled()
   })
 
-  it('should index records via searchIndexer when jobType is batch-index', async () => {
+  it('should index the whole batch in a single indexRecordsById call when jobType is batch-index', async () => {
     // Use minimal record format (just entityId + recordId)
     const records = [
       { entityId: 'test:entity', recordId: 'rec-1' },
       { entityId: 'test:entity', recordId: 'rec-2' },
     ]
+    mockSearchIndexer.indexRecordsById.mockResolvedValueOnce({ indexed: 2, skipped: 0 })
     const job = createMockJob<FulltextIndexJobPayload>({
       jobType: 'batch-index',
       tenantId: 'tenant-123',
@@ -501,26 +504,22 @@ describe('Fulltext Index Worker', () => {
 
     await handleFulltextIndexJob(job, ctx, mockContainer)
 
-    // Verify indexRecordById was called for each record
-    expect(mockSearchIndexer.indexRecordById).toHaveBeenCalledTimes(2)
-    expect(mockSearchIndexer.indexRecordById).toHaveBeenCalledWith({
-      entityId: 'test:entity',
-      recordId: 'rec-1',
-      tenantId: 'tenant-123',
-      organizationId: undefined,
-    })
-    expect(mockSearchIndexer.indexRecordById).toHaveBeenCalledWith({
-      entityId: 'test:entity',
-      recordId: 'rec-2',
+    // Verify the whole batch is written through exactly one indexRecordsById
+    // call, not one indexRecordById call per record.
+    expect(mockSearchIndexer.indexRecordsById).toHaveBeenCalledTimes(1)
+    expect(mockSearchIndexer.indexRecordsById).toHaveBeenCalledWith({
+      items: [
+        { entityId: 'test:entity', recordId: 'rec-1' },
+        { entityId: 'test:entity', recordId: 'rec-2' },
+      ],
       tenantId: 'tenant-123',
       organizationId: undefined,
     })
+    expect(mockSearchIndexer.indexRecordById).not.toHaveBeenCalled()
   })
 
   it('counts handled fulltext batch records as processed so progress can complete', async () => {
-    mockSearchIndexer.indexRecordById
-      .mockResolvedValueOnce({ action: 'skipped' })
-      .mockResolvedValueOnce({ action: 'skipped' })
+    mockSearchIndexer.indexRecordsById.mockResolvedValueOnce({ indexed: 0, skipped: 2 })
     const records = [
       { entityId: 'test:entity', recordId: 'rec-1' },
       { entityId: 'test:entity', recordId: 'rec-2' },
@@ -543,7 +542,7 @@ describe('Fulltext Index Worker', () => {
 
     await handleFulltextIndexJob(job, createMockJobContext(), containerWithProgress)
 
-    expect(mockSearchIndexer.indexRecordById).toHaveBeenCalledTimes(2)
+    expect(mockSearchIndexer.indexRecordsById).toHaveBeenCalledTimes(1)
     expect(updateReindexProgress).toHaveBeenCalledWith(mockDb, 'tenant-123', 'fulltext', 2, 'org-456')
     expect(incrementReindexProgress).toHaveBeenCalledWith(
       expect.objectContaining({ type: 'fulltext', tenantId: 'tenant-123', delta: 2 }),
@@ -551,6 +550,36 @@ describe('Fulltext Index Worker', () => {
     expect(clearReindexLock).toHaveBeenCalledWith(mockDb, 'tenant-123', 'fulltext', 'org-456')
   })
 
+  it('re-throws a failed fulltext batch write without advancing reindex progress so the queue retries it', async () => {
+    mockSearchIndexer.indexRecordsById.mockRejectedValueOnce(new Error('meilisearch unavailable'))
+    const records = [
+      { entityId: 'test:entity', recordId: 'rec-1' },
+      { entityId: 'test:entity', recordId: 'rec-2' },
+    ]
+    const containerWithProgress: HandlerContext = {
+      resolve: jest.fn((name: string) => {
+        if (name === 'searchStrategies') return [mockFulltextStrategy]
+        if (name === 'em') return mockEm
+        if (name === 'searchIndexer') return mockSearchIndexer
+        if (name === 'progressService') return { id: 'progress' }
+        throw new Error(`Unknown service: ${name}`)
+      }) as HandlerContext['resolve'],
+    }
+    const job = createMockJob<FulltextIndexJobPayload>({
+      jobType: 'batch-index',
+      tenantId: 'tenant-123',
+      organizationId: 'org-456',
+      records,
+    })
+
+    await expect(
+      handleFulltextIndexJob(job, createMockJobContext(), containerWithProgress),
+    ).rejects.toThrow('meilisearch unavailable')
+
+    expect(updateReindexProgress).not.toHaveBeenCalled()
+    expect(incrementReindexProgress).not.toHaveBeenCalled()
+  })
+
   it('clears an orphaned fulltext reindex lock instead of recreating it when no progress job is active', async () => {
     ;(hasActiveReindexProgress as jest.Mock).mockResolvedValueOnce(false)
     const records = [{ entityId: 'test:entity', recordId: 'rec-1' }]
@@ -572,7 +601,7 @@ describe('Fulltext Index Worker', () => {
 
     await handleFulltextIndexJob(job, createMockJobContext(), containerWithProgress)
 
-    expect(mockSearchIndexer.indexRecordById).toHaveBeenCalledTimes(1)
+    expect(mockSearchIndexer.indexRecordsById).toHaveBeenCalledTimes(1)
     expect(updateReindexProgress).not.toHaveBeenCalled()
     expect(incrementReindexProgress).not.toHaveBeenCalled()
     expect(clearReindexLock).toHaveBeenCalledWith(mockDb, 'tenant-123', 'fulltext', 'org-456')

package/src/indexer/search-indexer.ts

@@ -33,6 +33,15 @@ export type IndexRecordParams = {
   customFields?: Record<string, unknown>
 }
 
+/**
+ * Parameters for indexing a batch of records by id in a single bulk write.
+ */
+export type IndexRecordsByIdParams = {
+  items: Array<{ entityId: EntityId; recordId: string }>
+  tenantId: string
+  organizationId?: string | null
+}
+
 /**
  * Parameters for deleting a record from the search index.
  */
@@ -342,6 +351,81 @@ export class SearchIndexer {
     }
   }
 
+  /**
+   * Index a batch of records by id in a single bulk write.
+   * Unlike calling indexRecordById() in a loop, this loads each record fresh
+   * (same as indexRecordById) but flushes the whole batch through a single
+   * searchService.bulkIndex() call. Strategies that implement bulkIndex then
+   * collapse the batch into one write; strategies without it still write per
+   * record, at the bounded concurrency SearchService applies.
+   */
+  async indexRecordsById(params: IndexRecordsByIdParams): Promise<{ indexed: number; skipped: number }> {
+    const { items, tenantId, organizationId } = params
+    if (!this.queryEngine || items.length === 0) {
+      return { indexed: 0, skipped: items.length }
+    }
+
+    const recordIdsByEntity = new Map<EntityId, string[]>()
+    for (const item of items) {
+      const list = recordIdsByEntity.get(item.entityId) ?? []
+      list.push(item.recordId)
+      recordIdsByEntity.set(item.entityId, list)
+    }
+
+    const allRecords: IndexableRecord[] = []
+    let skipped = 0
+
+    for (const [entityId, recordIds] of recordIdsByEntity) {
+      const config = this.entityConfigMap.get(entityId)
+      if (!config || config.enabled === false) {
+        skipped += recordIds.length
+        continue
+      }
+
+      for (const recordId of recordIds) {
+        try {
+          const result = await this.queryEngine.query(entityId, {
+            tenantId,
+            organizationId: organizationId ?? undefined,
+            filters: { id: recordId },
+            includeCustomFields: true,
+            page: { page: 1, pageSize: 1 },
+            skipAutoReindex: true,
+          })
+
+          const record = result.items[0] as Record<string, unknown> | undefined
+          if (!record) {
+            skipped++
+            continue
+          }
+
+          const { records: built, dropped } = await this.buildIndexableRecords(
+            entityId,
+            tenantId,
+            organizationId ?? null,
+            [record],
+            config,
+          )
+          skipped += dropped
+          allRecords.push(...built)
+        } catch (error) {
+          skipped++
+          searchError('SearchIndexer', 'Failed to load record for batch indexing', {
+            entityId,
+            recordId,
+            error: error instanceof Error ? error.message : error,
+          })
+        }
+      }
+    }
+
+    if (allRecords.length > 0) {
+      await this.searchService.bulkIndex(allRecords)
+    }
+
+    return { indexed: allRecords.length, skipped }
+  }
+
   /**
    * Delete a record from the search index.
    */

package/src/lib/presenter-enricher.ts

@@ -104,6 +104,95 @@ 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.
@@ -285,7 +374,7 @@ export function createPresenterEnricher(
     }
 
     // Enrich results with computed presenter, URL, and links
-    return results.map((result) => {
+    const enrichedResults = results.map((result) => {
       if (!shouldEnrich(result)) return result
       const key = `${result.entityId}:${result.recordId}`
       const enriched = enrichmentMap.get(key)
@@ -297,5 +386,7 @@ export function createPresenterEnricher(
         links: enriched.links ?? result.links,
       }
     })
+
+    return mergeLinkedDuplicateResults(enrichedResults)
   }
 }

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

@@ -1,12 +1,75 @@
-import { expect, test } from '@playwright/test'
+import { expect, test, type APIRequestContext } 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 GlobalSearchResponse = { strategiesEnabled?: 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[] }
 
 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
@@ -71,4 +134,129 @@ 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)
+      }
+    }
+  })
 })