@open-mercato/search 0.6.8-develop.7072.1.19c2a8bbe0 → 0.6.8-develop.7077.1.94f1126c13

package/src/__tests__/presenter-enricher.test.ts

@@ -190,4 +190,238 @@ describe('createPresenterEnricher', () => {
     const [enriched] = await enrich(results, 'tenant-1', null)
     expect(enriched.presenter?.title).toBe('Stored')
   })
+
+  it('merges person and company profile hits into their matching customer entities', async () => {
+    mockedDecryptIndexDocForSearch.mockImplementation(async (_entityId, doc) => doc)
+
+    const rows: IndexRow[] = [
+      {
+        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' },
+      },
+    ]
+    const personConfig = createConfig({
+      entityId: 'customers:customer_person_profile' as EntityId,
+      formatResult: async (context) => ({ title: String(context.record.display_name) }),
+      resolveUrl: async (context) => `/backend/customers/people-v2/${String(context.record.entity_id)}`,
+    })
+    const companyConfig = createConfig({
+      entityId: 'customers:customer_company_profile' as EntityId,
+      formatResult: async (context) => ({ title: String(context.record.display_name) }),
+      resolveUrl: async (context) => `/backend/customers/companies-v2/${String(context.record.entity_id)}`,
+    })
+    const enrich = createPresenterEnricher(
+      createKyselyMock(rows),
+      new Map([
+        [personConfig.entityId, personConfig],
+        [companyConfig.entityId, companyConfig],
+      ]),
+    )
+
+    const enriched = await enrich([
+      createResult({
+        entityId: 'customers:customer_entity' as EntityId,
+        recordId: 'person-entity',
+        presenter: undefined,
+        score: 0.9,
+      }),
+      createResult({
+        entityId: 'customers:customer_person_profile' as EntityId,
+        recordId: 'person-profile',
+        presenter: undefined,
+        score: 0.8,
+      }),
+      createResult({
+        entityId: 'customers:customer_entity' as EntityId,
+        recordId: 'company-entity',
+        presenter: undefined,
+        score: 0.7,
+      }),
+      createResult({
+        entityId: 'customers:customer_company_profile' as EntityId,
+        recordId: 'company-profile',
+        presenter: undefined,
+        score: 0.6,
+      }),
+    ], 'tenant-1', null)
+
+    expect(enriched).toEqual([
+      expect.objectContaining({
+        entityId: 'customers:customer_entity',
+        recordId: 'person-entity',
+        presenter: { title: 'Ada Lovelace' },
+        url: '/backend/customers/people-v2/person-entity',
+      }),
+      expect.objectContaining({
+        entityId: 'customers:customer_entity',
+        recordId: 'company-entity',
+        presenter: { title: 'Analytical Engines' },
+        url: '/backend/customers/companies-v2/company-entity',
+      }),
+    ])
+  })
+
+  it('re-sorts merged results when linked profiles outrank their customer entities', async () => {
+    mockedDecryptIndexDocForSearch.mockImplementation(async (_entityId, doc) => doc)
+
+    const rows: IndexRow[] = [
+      {
+        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' },
+      },
+    ]
+    const personConfig = createConfig({
+      entityId: 'customers:customer_person_profile' as EntityId,
+      formatResult: async (context) => ({ title: String(context.record.display_name) }),
+      resolveUrl: async (context) => `/backend/customers/people-v2/${String(context.record.entity_id)}`,
+    })
+    const companyConfig = createConfig({
+      entityId: 'customers:customer_company_profile' as EntityId,
+      formatResult: async (context) => ({ title: String(context.record.display_name) }),
+      resolveUrl: async (context) => `/backend/customers/companies-v2/${String(context.record.entity_id)}`,
+    })
+    const enrich = createPresenterEnricher(
+      createKyselyMock(rows),
+      new Map([
+        [personConfig.entityId, personConfig],
+        [companyConfig.entityId, companyConfig],
+      ]),
+    )
+
+    const enriched = await enrich([
+      createResult({
+        entityId: 'customers:customer_person_profile' as EntityId,
+        recordId: 'person-profile',
+        organizationId: 'org-1',
+        presenter: undefined,
+        score: 0.95,
+        source: 'fulltext',
+      }),
+      createResult({
+        entityId: 'customers:customer_company_profile' as EntityId,
+        recordId: 'company-profile',
+        organizationId: 'org-1',
+        presenter: undefined,
+        score: 0.85,
+        source: 'fulltext',
+      }),
+      createResult({
+        entityId: 'orders:order' as EntityId,
+        recordId: 'order-1',
+        organizationId: 'org-1',
+        presenter: { title: 'Order 1' },
+        url: '/backend/sales/orders/order-1',
+        score: 0.5,
+      }),
+      createResult({
+        entityId: 'customers:customer_entity' as EntityId,
+        recordId: 'person-entity',
+        organizationId: 'org-1',
+        presenter: undefined,
+        score: 0.2,
+      }),
+      createResult({
+        entityId: 'customers:customer_entity' as EntityId,
+        recordId: 'company-entity',
+        organizationId: 'org-1',
+        presenter: undefined,
+        score: 0.1,
+      }),
+    ], 'tenant-1', 'org-1')
+
+    expect(enriched).toEqual([
+      expect.objectContaining({
+        entityId: 'customers:customer_entity',
+        recordId: 'person-entity',
+        score: 0.95,
+        url: '/backend/customers/people-v2/person-entity',
+      }),
+      expect.objectContaining({
+        entityId: 'customers:customer_entity',
+        recordId: 'company-entity',
+        score: 0.85,
+        url: '/backend/customers/companies-v2/company-entity',
+      }),
+      expect.objectContaining({
+        entityId: 'orders:order',
+        recordId: 'order-1',
+        score: 0.5,
+      }),
+    ])
+  })
+
+  it('keeps linked content hits when their navigation includes a page anchor', async () => {
+    mockedDecryptIndexDocForSearch.mockImplementation(async (_entityId, doc) => doc)
+
+    const entityId = 'person-entity'
+    const rows: IndexRow[] = [
+      {
+        entity_type: 'customers:customer_entity',
+        entity_id: entityId,
+        doc: { id: entityId, display_name: 'Ada Lovelace' },
+      },
+      {
+        entity_type: 'customers:customer_comment',
+        entity_id: 'comment-1',
+        doc: { id: 'comment-1', body: 'Ada Lovelace', entity_id: entityId },
+      },
+    ]
+    const commentConfig = createConfig({
+      entityId: 'customers:customer_comment' as EntityId,
+      formatResult: async () => ({ title: 'Ada Lovelace' }),
+      resolveUrl: async () => `/backend/customers/people-v2/${entityId}#notes`,
+    })
+    const enrich = createPresenterEnricher(
+      createKyselyMock(rows),
+      new Map([[commentConfig.entityId, commentConfig]]),
+    )
+
+    const enriched = await enrich([
+      createResult({
+        entityId: 'customers:customer_entity' as EntityId,
+        recordId: entityId,
+        presenter: undefined,
+      }),
+      createResult({
+        entityId: 'customers:customer_comment' as EntityId,
+        recordId: 'comment-1',
+        presenter: undefined,
+      }),
+    ], 'tenant-1', null)
+
+    expect(enriched).toHaveLength(2)
+    expect(enriched[1]?.url).toBe(`/backend/customers/people-v2/${entityId}#notes`)
+  })
 })

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/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)
+      }
+    }
+  })
 })