diff --git a/src/afo-register/application/AfoRegisterService.test.ts b/src/afo-register/application/AfoRegisterService.test.ts
new file mode 100644
index 000000000..a600d3398
--- /dev/null
+++ b/src/afo-register/application/AfoRegisterService.test.ts
@@ -0,0 +1,63 @@
+import { testDelegation, TestData } from 'test-support/utils'
+import AfoRegisterRepository from 'afo-register/infrastructure/AfoRegisterRepository'
+import AfoRegisterRecord, {
+  AfoRegisterRecordSuggestion,
+} from 'afo-register/domain/Record'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import { stringify } from 'query-string'
+
+jest.mock('afo-register/infrastructure/AfoRegisterRepository')
+const afoRegisterRepository = new (AfoRegisterRepository as jest.Mock)()
+
+const afoRegisterService = new AfoRegisterService(afoRegisterRepository)
+
+const resultStub = {
+  afoNumber: 'AfO 1',
+  page: '2',
+  text: 'some text',
+  textNumber: '5',
+  discussedBy: '',
+  discussedByNotes: '',
+  linesDiscussed: '',
+  fragmentNumbers: undefined,
+}
+
+const suggestionResultStub = {
+  text: 'some text',
+  textNumbers: undefined,
+}
+
+const query = { afoNumber: resultStub.afoNumber, page: resultStub.page }
+const entry = new AfoRegisterRecord(resultStub)
+const suggestionEntry = new AfoRegisterRecordSuggestion(suggestionResultStub)
+
+const testData: TestData<AfoRegisterService>[] = [
+  new TestData(
+    'search',
+    [stringify(query)],
+    afoRegisterRepository.search,
+    [entry],
+    [stringify(query), undefined],
+    Promise.resolve([entry])
+  ),
+  new TestData(
+    'searchTextsAndNumbers',
+    [['text1', 'number1']],
+    afoRegisterRepository.searchTextsAndNumbers,
+    [entry],
+    [['text1', 'number1']],
+    Promise.resolve([entry])
+  ),
+  new TestData(
+    'searchSuggestions',
+    ['suggestion query'],
+    afoRegisterRepository.searchSuggestions,
+    [suggestionEntry],
+    ['suggestion query'],
+    Promise.resolve([suggestionEntry])
+  ),
+]
+
+describe('AfoRegisterService', () => {
+  testDelegation(afoRegisterService, testData)
+})
diff --git a/src/afo-register/application/AfoRegisterService.ts b/src/afo-register/application/AfoRegisterService.ts
new file mode 100644
index 000000000..4ee326ec1
--- /dev/null
+++ b/src/afo-register/application/AfoRegisterService.ts
@@ -0,0 +1,40 @@
+import Promise from 'bluebird'
+import AfoRegisterRecord, {
+  AfoRegisterRecordSuggestion,
+} from 'afo-register/domain/Record'
+import AfoRegisterRepository from 'afo-register/infrastructure/AfoRegisterRepository'
+import FragmentService from 'fragmentarium/application/FragmentService'
+
+export interface afoRegisterSearch {
+  search(query: string): Promise<readonly AfoRegisterRecord[]>
+  searchSuggestions(
+    query: string
+  ): Promise<readonly AfoRegisterRecordSuggestion[]>
+}
+
+export default class AfoRegisterService implements afoRegisterSearch {
+  private readonly afoRegisterRepository: AfoRegisterRepository
+
+  constructor(afoRegisterRepository: AfoRegisterRepository) {
+    this.afoRegisterRepository = afoRegisterRepository
+  }
+
+  search(
+    query: string,
+    fragmentService?: FragmentService
+  ): Promise<readonly AfoRegisterRecord[]> {
+    return this.afoRegisterRepository.search(query, fragmentService)
+  }
+
+  searchTextsAndNumbers(
+    query: readonly string[]
+  ): Promise<readonly AfoRegisterRecord[]> {
+    return this.afoRegisterRepository.searchTextsAndNumbers(query)
+  }
+
+  searchSuggestions(
+    query: string
+  ): Promise<readonly AfoRegisterRecordSuggestion[]> {
+    return this.afoRegisterRepository.searchSuggestions(query)
+  }
+}
diff --git a/src/afo-register/domain/Record.test.ts b/src/afo-register/domain/Record.test.ts
new file mode 100644
index 000000000..8aa3728df
--- /dev/null
+++ b/src/afo-register/domain/Record.test.ts
@@ -0,0 +1,48 @@
+import AfoRegisterRecord from 'afo-register/domain/Record'
+
+describe('AfoRegisterRecord', () => {
+  const mockRecord = {
+    afoNumber: '123',
+    page: '456',
+    text: 'Sample text',
+    textNumber: '789',
+    linesDiscussed: 'Some lines',
+    discussedBy: 'John Doe',
+    discussedByNotes: 'Notes by John',
+    fragmentNumbers: ['BM777'],
+  }
+
+  describe('constructor', () => {
+    describe('constructor', () => {
+      it('should initialize properties correctly', () => {
+        const record = new AfoRegisterRecord(mockRecord)
+        expect(record.afoNumber).toEqual('123')
+        expect(record.page).toEqual('456')
+        expect(record.text).toEqual('Sample text')
+        expect(record.textNumber).toEqual('789')
+        expect(record.linesDiscussed).toEqual('Some lines')
+        expect(record.discussedBy).toEqual('John Doe')
+        expect(record.discussedByNotes).toEqual('Notes by John')
+      })
+    })
+  })
+
+  describe('Converts to Markdown string', () => {
+    it('Returns the correct markdown string with fragments', () => {
+      const record = new AfoRegisterRecord(mockRecord)
+      const result = record.toMarkdownString()
+      expect(result).toEqual(
+        'Sample text 789 ([BM777](/fragmentarium/BM777)), Some lines: John Doe Notes by John<small class="text-black-50 ml-3">[123, 456]</small>'
+      )
+    })
+
+    it('Handles sup tags correctly', () => {
+      const recordWithSup = new AfoRegisterRecord({
+        ...mockRecord,
+        text: 'Sample^text^',
+      })
+      const result = recordWithSup.toMarkdownString()
+      expect(result).toContain('<sup>text</sup>')
+    })
+  })
+})
diff --git a/src/afo-register/domain/Record.ts b/src/afo-register/domain/Record.ts
new file mode 100644
index 000000000..4f1027a44
--- /dev/null
+++ b/src/afo-register/domain/Record.ts
@@ -0,0 +1,113 @@
+import produce, { Draft, immerable } from 'immer'
+
+interface RecordData {
+  readonly afoNumber: string
+  readonly page: string
+  readonly text: string
+  readonly textNumber: string
+  readonly linesDiscussed?: string
+  readonly discussedBy?: string
+  readonly discussedByNotes?: string
+  readonly fragmentNumbers?: string[]
+}
+
+export class AfoRegisterRecordSuggestion {
+  [immerable] = true
+
+  readonly text: string
+  readonly textNumbers?: string[]
+
+  constructor({
+    text,
+    textNumbers,
+  }: {
+    readonly text: string
+    readonly textNumbers?: string[]
+  }) {
+    this.text = text
+    this.textNumbers = textNumbers
+  }
+}
+
+export default class AfoRegisterRecord {
+  [immerable] = true
+
+  readonly afoNumber: string
+  readonly page: string
+  readonly text: string
+  readonly textNumber: string
+  readonly linesDiscussed?: string
+  readonly discussedBy?: string
+  readonly discussedByNotes?: string
+  readonly fragmentNumbers?: string[]
+
+  constructor({
+    afoNumber,
+    page,
+    text,
+    textNumber,
+    linesDiscussed,
+    discussedBy,
+    discussedByNotes,
+    fragmentNumbers,
+  }: RecordData) {
+    this.afoNumber = afoNumber
+    this.page = page
+    this.text = text
+    this.textNumber = textNumber
+    this.linesDiscussed = linesDiscussed
+    this.discussedBy = discussedBy
+    this.discussedByNotes = discussedByNotes
+    this.fragmentNumbers = fragmentNumbers
+  }
+
+  toMarkdownString(): string {
+    const textNumber = this.textNumberToMarkdownString()
+    const fragments = this.fragmentsToMarkdownString()
+    const linesDiscussed = this.linesDiscussedToMarkdownString()
+    const discussedBy = this.discussedByToMarkdownString()
+    const discussedByNotes = this.discussedByNotesToMarkdownString()
+    const footnote = this.footnotesToMarkdownString()
+    const result = `${this.text}${textNumber}${fragments}${linesDiscussed}${discussedBy}${discussedByNotes}${footnote}`
+    return result.replace(/\^([^^]+)\^/g, '<sup>$1</sup>')
+  }
+
+  setFragmentNumbers(fragmentNumbers: string[]): AfoRegisterRecord {
+    return produce(this, (draft: Draft<AfoRegisterRecord>) => {
+      draft.fragmentNumbers = fragmentNumbers
+    })
+  }
+
+  private textNumberToMarkdownString(): string {
+    return `${this.textNumber ? ` ${this.textNumber}` : ''}`
+  }
+
+  private fragmentsToMarkdownString(): string {
+    if (!this.fragmentNumbers || this.fragmentNumbers?.length < 1) {
+      return ''
+    }
+    const fragmentsString = this.fragmentNumbers
+      .map(
+        (fragmentNumber) =>
+          `[${fragmentNumber}](/fragmentarium/${fragmentNumber})`
+      )
+      .join(', ')
+    return ` (${fragmentsString})`
+  }
+
+  private linesDiscussedToMarkdownString(): string {
+    return this.linesDiscussed ? `, ${this.linesDiscussed}` : ''
+  }
+
+  private discussedByToMarkdownString(): string {
+    return this.discussedBy ? `: ${this.discussedBy}` : ''
+  }
+
+  private discussedByNotesToMarkdownString(): string {
+    return this.discussedByNotes ? ` ${this.discussedByNotes}` : ''
+  }
+
+  private footnotesToMarkdownString(): string {
+    return `<small class="text-black-50 ml-3">[${this.afoNumber}, ${this.page}]</small>`
+  }
+}
diff --git a/src/afo-register/infrastructure/AfoRegisterRepository.test.ts b/src/afo-register/infrastructure/AfoRegisterRepository.test.ts
new file mode 100644
index 000000000..f7cbbab0f
--- /dev/null
+++ b/src/afo-register/infrastructure/AfoRegisterRepository.test.ts
@@ -0,0 +1,190 @@
+import { testDelegation, TestData } from 'test-support/utils'
+import AfoRegisterRepository from 'afo-register/infrastructure/AfoRegisterRepository'
+import AfoRegisterRecord, {
+  AfoRegisterRecordSuggestion,
+} from 'afo-register/domain/Record'
+import { stringify } from 'query-string'
+import ApiClient from 'http/ApiClient'
+import Bluebird from 'bluebird'
+import FragmentService from 'fragmentarium/application/FragmentService'
+import { QueryItem } from 'query/QueryResult'
+
+jest.mock('http/ApiClient')
+jest.mock('fragmentarium/application/FragmentService')
+
+const apiClient = new (ApiClient as jest.Mock<jest.Mocked<ApiClient>>)()
+const fragmentService = new (FragmentService as jest.Mock<
+  jest.Mocked<FragmentService>
+>)()
+const afoRegisterRepository = new AfoRegisterRepository(apiClient)
+
+const resultStub = {
+  afoNumber: 'AfO 1',
+  page: '2',
+  text: 'some text',
+  textNumber: '5',
+  discussedBy: '',
+  discussedByNotes: '',
+  linesDiscussed: '',
+}
+
+const query = { afoNumber: resultStub.afoNumber, page: resultStub.page }
+const entry = new AfoRegisterRecord(resultStub)
+const suggestionEntry = new AfoRegisterRecordSuggestion({
+  text: 'some text',
+  textNumbers: undefined,
+})
+
+const testData: TestData<AfoRegisterRepository>[] = [
+  new TestData(
+    'search',
+    [
+      stringify({
+        afoNumber: 'AfO 1',
+        page: '2',
+      }),
+    ],
+    apiClient.fetchJson,
+    [entry],
+    [`/afo-register?${stringify(query)}`, false],
+    Promise.resolve([resultStub])
+  ),
+  new TestData(
+    'searchTextsAndNumbers',
+    [['text1', 'number1']],
+    apiClient.postJson,
+    [entry],
+    ['/afo-register/texts-numbers', ['text1', 'number1'], false],
+    Promise.resolve([resultStub])
+  ),
+  new TestData(
+    'searchSuggestions',
+    ['suggestion query'],
+    apiClient.fetchJson,
+    [suggestionEntry],
+    ['/afo-register/suggestions?text_query=suggestion query', false],
+    Promise.resolve([resultStub])
+  ),
+]
+describe('afoRegisterService', () =>
+  testDelegation(afoRegisterRepository, testData))
+
+describe('AfoRegisterRepository - search', () => {
+  it('handles search without fragmentService', async () => {
+    apiClient.fetchJson.mockReturnValue(Bluebird.resolve([entry]))
+    const response = await afoRegisterRepository.search(stringify(query))
+    expect(response).toEqual([entry])
+    expect(apiClient.fetchJson).toHaveBeenCalledWith(
+      `/afo-register?${stringify(query)}`,
+      false
+    )
+  })
+
+  it('handles different query strings', async () => {
+    const query2 = { afoNumber: 'AfO 2', page: '3' }
+    const entry2 = new AfoRegisterRecord({
+      text: 'Some text',
+      textNumber: '22',
+      afoNumber: 'AfO 2',
+      page: '3',
+    })
+    apiClient.fetchJson.mockResolvedValueOnce([resultStub, entry2])
+    const response = await afoRegisterRepository.search(stringify(query2))
+    expect(response).toEqual([entry, entry2])
+  })
+
+  it('handles empty response', async () => {
+    apiClient.fetchJson.mockResolvedValueOnce([])
+    const response = await afoRegisterRepository.search(stringify(query))
+    expect(response).toEqual([])
+  })
+
+  it('handles API errors', async () => {
+    apiClient.fetchJson.mockRejectedValueOnce(new Error('API Error'))
+    await expect(
+      afoRegisterRepository.search(stringify(query))
+    ).rejects.toThrow('API Error')
+  })
+})
+
+describe('AfoRegisterRepository - searchTextsAndNumbers', () => {
+  it('handles various text and number combinations', async () => {
+    const query2 = ['text2', 'number2']
+    const entry2 = new AfoRegisterRecord({
+      ...resultStub,
+      text: 'text2',
+      textNumber: 'number2',
+    })
+    apiClient.postJson.mockResolvedValueOnce([resultStub, entry2])
+    const response = await afoRegisterRepository.searchTextsAndNumbers(query2)
+    expect(response).toEqual([entry, entry2])
+  })
+
+  it('handles empty response', async () => {
+    apiClient.postJson.mockResolvedValueOnce([])
+    const response = await afoRegisterRepository.searchTextsAndNumbers([
+      'text1',
+      'number1',
+    ])
+    expect(response).toEqual([])
+  })
+
+  it('handles API errors', async () => {
+    apiClient.postJson.mockRejectedValueOnce(new Error('API Error'))
+    await expect(
+      afoRegisterRepository.searchTextsAndNumbers(['text1', 'number1'])
+    ).rejects.toThrow('API Error')
+  })
+})
+
+describe('AfoRegisterRepository - searchSuggestions', () => {
+  it('handles different query strings', async () => {
+    const query2 = 'different suggestion query'
+    const suggestionEntry2 = new AfoRegisterRecordSuggestion({
+      ...resultStub,
+      text: 'different text',
+    })
+    apiClient.fetchJson.mockResolvedValueOnce([resultStub, suggestionEntry2])
+    const response = await afoRegisterRepository.searchSuggestions(query2)
+    expect(response).toEqual([suggestionEntry, suggestionEntry2])
+  })
+
+  it('handles empty response', async () => {
+    apiClient.fetchJson.mockResolvedValueOnce([])
+    const response = await afoRegisterRepository.searchSuggestions(
+      'suggestion query'
+    )
+    expect(response).toEqual([])
+  })
+
+  it('handles API errors', async () => {
+    apiClient.fetchJson.mockRejectedValueOnce(new Error('API Error'))
+    await expect(
+      afoRegisterRepository.searchSuggestions('suggestion query')
+    ).rejects.toThrow('API Error')
+  })
+})
+
+describe('AfoRegisterRepository - search with fragmentService', () => {
+  it('injects fragment references when fragmentService is provided', async () => {
+    const modifiedEntry = { ...entry, fragmentNumbers: ['Frag1', 'Frag2'] }
+    fragmentService.query.mockReturnValueOnce(
+      Bluebird.resolve({
+        items: [
+          { museumNumber: 'Frag1' },
+          { museumNumber: 'Frag2' },
+        ] as QueryItem[],
+        matchCountTotal: 2,
+      })
+    )
+    apiClient.fetchJson.mockResolvedValueOnce([resultStub])
+    const response = await afoRegisterRepository.search(
+      stringify(query),
+      fragmentService
+    )
+    expect(response).toEqual([modifiedEntry])
+    expect(fragmentService.query).toHaveBeenCalledWith({
+      traditionalReferences: entry.text + ' ' + entry.textNumber,
+    })
+  })
+})
diff --git a/src/afo-register/infrastructure/AfoRegisterRepository.ts b/src/afo-register/infrastructure/AfoRegisterRepository.ts
new file mode 100644
index 000000000..f3e5b24e9
--- /dev/null
+++ b/src/afo-register/infrastructure/AfoRegisterRepository.ts
@@ -0,0 +1,70 @@
+import AfoRegisterRecord, {
+  AfoRegisterRecordSuggestion,
+} from 'afo-register/domain/Record'
+import Promise from 'bluebird'
+import FragmentService from 'fragmentarium/application/FragmentService'
+import ApiClient from 'http/ApiClient'
+
+function createAfoRegisterRecord(data): AfoRegisterRecord {
+  return new AfoRegisterRecord(data)
+}
+
+function createAfoRegisterRecordSuggestion(data): AfoRegisterRecordSuggestion {
+  return new AfoRegisterRecordSuggestion(data)
+}
+
+function injectFragmentReferecesToRecord(
+  record: AfoRegisterRecord,
+  fragmentService: FragmentService
+): Promise<AfoRegisterRecord> {
+  const { text, textNumber } = record
+  return fragmentService
+    .query({ traditionalReferences: text + ' ' + textNumber })
+    .then((queryResult) => {
+      return record.setFragmentNumbers(
+        queryResult.items.map((item) => item.museumNumber)
+      )
+    })
+}
+
+export default class AfoRegisterRepository {
+  private readonly apiClient: ApiClient
+
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient
+  }
+
+  search(
+    query: string,
+    fragmentService?: FragmentService
+  ): Promise<AfoRegisterRecord[]> {
+    return this.apiClient
+      .fetchJson(`/afo-register?${query}`, false)
+      .then((result) => result.map(createAfoRegisterRecord))
+      .then((records) => {
+        if (fragmentService) {
+          return Promise.all(
+            records.map((record) =>
+              injectFragmentReferecesToRecord(record, fragmentService)
+            )
+          )
+        } else {
+          return records
+        }
+      })
+  }
+
+  searchTextsAndNumbers(
+    query: readonly string[]
+  ): Promise<AfoRegisterRecord[]> {
+    return this.apiClient
+      .postJson(`/afo-register/texts-numbers`, query, false)
+      .then((result) => result.map(createAfoRegisterRecord))
+  }
+
+  searchSuggestions(query: string): Promise<AfoRegisterRecordSuggestion[]> {
+    return this.apiClient
+      .fetchJson(`/afo-register/suggestions?text_query=${query}`, false)
+      .then((result) => result.map(createAfoRegisterRecordSuggestion))
+  }
+}
diff --git a/src/afo-register/ui/AfoRegisterDisplay.test.tsx b/src/afo-register/ui/AfoRegisterDisplay.test.tsx
new file mode 100644
index 000000000..238c95bfc
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterDisplay.test.tsx
@@ -0,0 +1,57 @@
+import React from 'react'
+import { act, render, screen, waitFor } from '@testing-library/react'
+import {
+  AfoRegisterRecordDisplay,
+  AfoRegisterRecordsListDisplay,
+} from './AfoRegisterDisplay'
+import { afoRegisterRecordFactory } from 'test-support/afo-register-fixtures'
+import { waitForSpinnerToBeRemoved } from 'test-support/waitForSpinnerToBeRemoved'
+
+const mockRecord = afoRegisterRecordFactory.build()
+const anotherMockRecord = afoRegisterRecordFactory.build()
+
+describe('AfoRegisterRecordDisplay', () => {
+  it('renders correctly', async () => {
+    await act(async () => {
+      render(
+        <div data-testid="item">
+          <AfoRegisterRecordDisplay record={mockRecord} index={0} />
+        </div>
+      )
+      await waitForSpinnerToBeRemoved(screen)
+      await waitFor(() => {
+        const { text, textNumber } = mockRecord
+        const item = screen.getByTestId('item')
+        expect(item).toHaveTextContent(text)
+        expect(item).toHaveTextContent(textNumber)
+      })
+    })
+  })
+})
+
+describe('AfoRegisterRecordsListDisplay', () => {
+  it('displays no records message when empty', () => {
+    render(<AfoRegisterRecordsListDisplay records={[]} />)
+    expect(screen.getByText('No records found')).toBeInTheDocument()
+  })
+
+  it('renders records correctly', async () => {
+    await act(async () => {
+      render(
+        <AfoRegisterRecordsListDisplay
+          records={[mockRecord, anotherMockRecord]}
+        />
+      )
+      await waitForSpinnerToBeRemoved(screen)
+      await waitFor(() => {
+        expect(screen.getAllByRole('listitem').length).toBe(2)
+        screen.getAllByRole('listitem').forEach((item, index) => {
+          expect(item).toHaveClass('afo-register-records__list-item')
+          const { text, textNumber } = [mockRecord, anotherMockRecord][index]
+          expect(item).toHaveTextContent(text)
+          expect(item).toHaveTextContent(textNumber)
+        })
+      })
+    })
+  })
+})
diff --git a/src/afo-register/ui/AfoRegisterDisplay.tsx b/src/afo-register/ui/AfoRegisterDisplay.tsx
new file mode 100644
index 000000000..54630ee4f
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterDisplay.tsx
@@ -0,0 +1,39 @@
+import React from 'react'
+import AfoRegisterRecord from 'afo-register/domain/Record'
+import MarkdownAndHtmlToHtml from 'common/MarkdownAndHtmlToHtml'
+
+export function AfoRegisterRecordDisplay({
+  record,
+  index,
+}: {
+  record: AfoRegisterRecord
+  index: string | number
+}): JSX.Element {
+  return (
+    <MarkdownAndHtmlToHtml
+      key={`md-${index}`}
+      markdownAndHtml={record.toMarkdownString()}
+      className="afo-register-record"
+    />
+  )
+}
+
+export function AfoRegisterRecordsListDisplay({
+  records,
+  ...props
+}: {
+  records: readonly AfoRegisterRecord[]
+} & React.OlHTMLAttributes<HTMLOListElement>): JSX.Element {
+  if (records.length < 1) {
+    return <p>No records found</p>
+  }
+  return (
+    <ol {...props}>
+      {records.map((record, index) => (
+        <li key={`li-${index}`} className="afo-register-records__list-item">
+          <AfoRegisterRecordDisplay record={record} index={index} />
+        </li>
+      ))}
+    </ol>
+  )
+}
diff --git a/src/afo-register/ui/AfoRegisterFragmentRecords.test.tsx b/src/afo-register/ui/AfoRegisterFragmentRecords.test.tsx
new file mode 100644
index 000000000..6487b2f01
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterFragmentRecords.test.tsx
@@ -0,0 +1,43 @@
+import React from 'react'
+import { render, waitFor, screen, act } from '@testing-library/react'
+import AfoRegisterFragmentRecords from './AfoRegisterFragmentRecords'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import { fragmentFactory } from 'test-support/fragment-fixtures'
+import { afoRegisterRecordFactory } from 'test-support/afo-register-fixtures'
+
+jest.mock('afo-register/application/AfoRegisterService')
+
+describe('AfoRegisterFragmentRecords', () => {
+  const mockRecords = [
+    afoRegisterRecordFactory.build(),
+    afoRegisterRecordFactory.build(),
+  ]
+
+  it('fetches records and displays them', async () => {
+    const mockService = new (AfoRegisterService as jest.Mock<
+      jest.Mocked<AfoRegisterService>
+    >)()
+    mockService.searchTextsAndNumbers.mockResolvedValue(mockRecords)
+
+    const fragment = fragmentFactory.build({
+      traditionalReferences: mockRecords.map(
+        (record) => record.text + ' ' + record.textNumber
+      ),
+    })
+    await act(async () => {
+      render(
+        <AfoRegisterFragmentRecords
+          afoRegisterService={mockService}
+          fragment={fragment}
+        />
+      )
+    })
+    await waitFor(() => {
+      mockRecords.forEach(async (record) => {
+        expect(
+          await screen.findByText(record.text + ' ' + record.textNumber)
+        ).toBeInTheDocument()
+      })
+    })
+  })
+})
diff --git a/src/afo-register/ui/AfoRegisterFragmentRecords.tsx b/src/afo-register/ui/AfoRegisterFragmentRecords.tsx
new file mode 100644
index 000000000..758d84224
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterFragmentRecords.tsx
@@ -0,0 +1,41 @@
+import React from 'react'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import { Fragment } from 'fragmentarium/domain/fragment'
+import withData from 'http/withData'
+import AfoRegisterRecord from 'afo-register/domain/Record'
+import _ from 'lodash'
+import { AfoRegisterRecordsListDisplay } from './AfoRegisterDisplay'
+
+function AfoRegisterFragmentRecords({
+  data,
+}: {
+  data: { records: readonly AfoRegisterRecord[] }
+}): JSX.Element {
+  return (
+    <AfoRegisterRecordsListDisplay
+      records={data.records}
+      className="AfORegisterRecordsInFragment"
+    />
+  )
+}
+
+export default withData<
+  unknown,
+  {
+    afoRegisterService: AfoRegisterService
+    fragment: Fragment
+  },
+  { records: readonly AfoRegisterRecord[] }
+>(
+  AfoRegisterFragmentRecords,
+  (props) => {
+    return props.afoRegisterService
+      .searchTextsAndNumbers(props.fragment.traditionalReferences)
+      .then((records) => ({ records }))
+  },
+  {
+    watch: (props) => [...props.fragment.traditionalReferences],
+    filter: (props) => !_.isEmpty(props.fragment.traditionalReferences),
+    defaultData: () => ({ records: [] }),
+  }
+)
diff --git a/src/afo-register/ui/AfoRegisterSearch.test.tsx b/src/afo-register/ui/AfoRegisterSearch.test.tsx
new file mode 100644
index 000000000..582a02b5f
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterSearch.test.tsx
@@ -0,0 +1,68 @@
+import React from 'react'
+import { render, screen, waitFor, act } from '@testing-library/react'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import AfoRegisterSearch from 'afo-register/ui/AfoRegisterSearch'
+import { waitForSpinnerToBeRemoved } from 'test-support/waitForSpinnerToBeRemoved'
+import FragmentService from 'fragmentarium/application/FragmentService'
+import Bluebird from 'bluebird'
+import { afoRegisterRecordFactory } from 'test-support/afo-register-fixtures'
+
+jest.mock('afo-register/application/AfoRegisterService')
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useHistory: jest.fn(),
+}))
+
+const afoRegisterService = new (AfoRegisterService as jest.Mock<
+  jest.Mocked<AfoRegisterService>
+>)()
+
+const fragmentService = new (FragmentService as jest.Mock<
+  jest.Mocked<FragmentService>
+>)()
+
+describe('AfO Register search display', () => {
+  const mockQuery = { text: 'testText', textNumber: 'testNumber' }
+  let record
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    record = afoRegisterRecordFactory.build()
+  })
+
+  it('renders correctly with initial state', async () => {
+    afoRegisterService.search.mockReturnValue(Bluebird.resolve([record]))
+    await act(async () => {
+      render(
+        <AfoRegisterSearch
+          query={mockQuery}
+          afoRegisterService={afoRegisterService}
+          fragmentService={fragmentService}
+        />
+      )
+      await waitForSpinnerToBeRemoved(screen)
+      await waitFor(() => {
+        const item = screen.getByRole('listitem')
+        expect(item).toBeVisible()
+        expect(item).toHaveTextContent(record.text)
+      })
+    })
+  })
+
+  it('renders correctly with empty result', async () => {
+    afoRegisterService.search.mockReturnValue(Bluebird.resolve([]))
+    await act(async () => {
+      render(
+        <AfoRegisterSearch
+          query={mockQuery}
+          afoRegisterService={afoRegisterService}
+          fragmentService={fragmentService}
+        />
+      )
+      await waitForSpinnerToBeRemoved(screen)
+      await waitFor(() => {
+        expect(screen.getByText('No records found')).toBeVisible()
+      })
+    })
+  })
+})
diff --git a/src/afo-register/ui/AfoRegisterSearch.tsx b/src/afo-register/ui/AfoRegisterSearch.tsx
new file mode 100644
index 000000000..5f612b0f9
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterSearch.tsx
@@ -0,0 +1,58 @@
+import React from 'react'
+import _ from 'lodash'
+
+import withData from 'http/withData'
+
+import AfoRegisterRecord from 'afo-register/domain/Record'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import { LiteratureRedirectBox } from 'common/LiteratureRedirectBox'
+import { AfoRegisterQuery } from './AfoRegisterSearchForm'
+import { stringify } from 'query-string'
+import { AfoRegisterRecordsListDisplay } from './AfoRegisterDisplay'
+import FragmentService from 'fragmentarium/application/FragmentService'
+
+export const AfoRegisterRedirectBox = (
+  <LiteratureRedirectBox
+    authors="Hirsch, H.; Hunger, H.; Jursa, M.; Weszeli, M.; et al."
+    book="Archiv für Orientforschung (Register Assyriologie)"
+    notelink=""
+    subtitle="25 (1974/1977) – 54 (2021)"
+    note="By permission from the AfO Redaktion"
+    link="https://orientalistik.univie.ac.at/publikationen/afo/register/"
+    icon="pointer__hover my-2 fas fa-external-link-square-alt"
+  />
+)
+
+function AfoRegisterSearch({ data }: { data: readonly AfoRegisterRecord[] }) {
+  return (
+    <>
+      <AfoRegisterRecordsListDisplay
+        records={data}
+        className="afoRegisterSearchResults"
+      />
+      {data.length > 0 && AfoRegisterRedirectBox}
+    </>
+  )
+}
+
+export default withData<
+  unknown,
+  {
+    afoRegisterService: AfoRegisterService
+    fragmentService: FragmentService
+    query: AfoRegisterQuery
+  },
+  readonly AfoRegisterRecord[]
+>(
+  AfoRegisterSearch,
+  (props) =>
+    props.afoRegisterService.search(
+      stringify(props.query),
+      props.fragmentService
+    ),
+  {
+    watch: (props) => [props.query],
+    filter: (props) => !_.isEmpty(props.query),
+    defaultData: () => [],
+  }
+)
diff --git a/src/afo-register/ui/AfoRegisterSearchForm.test.tsx b/src/afo-register/ui/AfoRegisterSearchForm.test.tsx
new file mode 100644
index 000000000..d447f592e
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterSearchForm.test.tsx
@@ -0,0 +1,148 @@
+import React from 'react'
+import { render, fireEvent, waitFor, screen, act } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import AfoRegisterSearchForm from './AfoRegisterSearchForm'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import { Router } from 'react-router-dom'
+import { createMemoryHistory } from 'history'
+import Bluebird from 'bluebird'
+import { AfoRegisterRecordSuggestion } from 'afo-register/domain/Record'
+
+jest.mock('afo-register/application/AfoRegisterService')
+jest.mock('fragmentarium/application/FragmentService')
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useHistory: () => ({
+    push: jest.fn(),
+  }),
+}))
+
+async function renderWithRouter(
+  children: JSX.Element,
+  path?: string
+): Promise<void> {
+  const history = createMemoryHistory()
+  path && history.push(path)
+  await act(async () => {
+    render(<Router history={history}>{children}</Router>)
+  })
+}
+
+describe('AfoRegisterSearch Component Tests', () => {
+  let afoRegisterServiceMock
+
+  beforeEach(() => {
+    afoRegisterServiceMock = new (AfoRegisterService as jest.Mock<
+      jest.Mocked<AfoRegisterService>
+    >)()
+    afoRegisterServiceMock.searchSuggestions.mockReturnValue(
+      Bluebird.resolve([
+        new AfoRegisterRecordSuggestion({
+          text: 'Sample text',
+          textNumbers: ['1', '2', '3', '4'],
+        }),
+      ])
+    )
+  })
+
+  const mockQueryProp = {
+    text: 'Sample Text',
+    textNumber: '1',
+  }
+
+  test('renders without crashing', async () => {
+    await renderWithRouter(
+      <AfoRegisterSearchForm
+        queryProp={mockQueryProp}
+        afoRegisterService={afoRegisterServiceMock}
+      />
+    )
+    await waitFor(() => {
+      expect(screen.getByPlaceholderText('Number')).toBeInTheDocument()
+    })
+  })
+
+  test('handles form submission correctly', async () => {
+    const historyMock = { push: jest.fn() }
+    jest
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      .spyOn(require('react-router-dom'), 'useHistory')
+      .mockReturnValue(historyMock)
+
+    await renderWithRouter(
+      <AfoRegisterSearchForm
+        queryProp={mockQueryProp}
+        afoRegisterService={afoRegisterServiceMock}
+      />
+    )
+
+    const submitButton = screen.getByRole('button', { name: /search/i })
+
+    userEvent.click(submitButton)
+
+    await waitFor(() => {
+      const expectedUrl = '?text=Sample%20Text&textNumber=1'
+      expect(historyMock.push).toHaveBeenCalledWith(expectedUrl)
+    })
+  })
+
+  test('updates state on input change', async () => {
+    await renderWithRouter(
+      <AfoRegisterSearchForm
+        queryProp={mockQueryProp}
+        afoRegisterService={afoRegisterServiceMock}
+      />
+    )
+    const textNumberInput = screen.getByPlaceholderText('Number')
+
+    fireEvent.change(textNumberInput, { target: { value: '456' } })
+
+    await waitFor(() => {
+      expect(expect(screen.getByDisplayValue('456')).toBeInTheDocument())
+    })
+  })
+
+  test('fetchTextNumberOptions updates options correctly', async () => {
+    afoRegisterServiceMock.searchSuggestions.mockReturnValue(
+      Bluebird.resolve([
+        new AfoRegisterRecordSuggestion({
+          text: 'Test',
+          textNumbers: ['111', '222'],
+        }),
+      ])
+    )
+    await renderWithRouter(
+      <AfoRegisterSearchForm
+        queryProp={{ text: 'Test', textNumber: '' }}
+        afoRegisterService={afoRegisterServiceMock}
+      />
+    )
+    await act(async () => {
+      const exactSwitch = screen.getByLabelText('Exact number')
+      userEvent.click(exactSwitch)
+    })
+    await act(async () => {
+      const numberInput = screen.getByLabelText('select-text-number')
+      userEvent.click(numberInput)
+    })
+    await waitFor(() => {
+      expect(screen.getByText('—')).toBeInTheDocument()
+      expect(screen.getByText('111')).toBeInTheDocument()
+      expect(screen.getByText('222')).toBeInTheDocument()
+    })
+  })
+
+  test('handles condition when textNumber is not set', async () => {
+    const queryProp = { text: 'Some text', textNumber: '' }
+
+    await renderWithRouter(
+      <AfoRegisterSearchForm
+        queryProp={queryProp}
+        afoRegisterService={afoRegisterServiceMock}
+      />
+    )
+    await waitFor(() => {
+      expect(screen.getByPlaceholderText('Number')).toHaveValue('')
+    })
+  })
+})
diff --git a/src/afo-register/ui/AfoRegisterSearchForm.tsx b/src/afo-register/ui/AfoRegisterSearchForm.tsx
new file mode 100644
index 000000000..dc5dc9f0f
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterSearchForm.tsx
@@ -0,0 +1,263 @@
+import React, { useEffect, useState } from 'react'
+import { stringify } from 'query-string'
+import _ from 'lodash'
+import { Form, Button, Row, Col } from 'react-bootstrap'
+import { RouteComponentProps, withRouter, useHistory } from 'react-router-dom'
+import { AfoRegisterRecordSuggestion } from 'afo-register/domain/Record'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import Select from 'react-select'
+import Promise from 'bluebird'
+import AfoRegisterTextSelect from 'afo-register/ui/AfoRegisterTextSelect'
+
+export type AfoRegisterQuery = { text: string; textNumber: string }
+
+interface TextNumberOption {
+  label: string
+  value: string
+}
+
+type FormProps = {
+  queryProp: AfoRegisterQuery
+  afoRegisterService: AfoRegisterService
+} & RouteComponentProps
+
+interface TextOrPublicationSelectProps {
+  query: AfoRegisterQuery
+  setQuery: React.Dispatch<React.SetStateAction<AfoRegisterQuery>>
+  searchTextSuggestions: (
+    text: string
+  ) => Promise<readonly AfoRegisterRecordSuggestion[]>
+  textNumberOptions: TextNumberOption[]
+  setTextNumberOptions: React.Dispatch<React.SetStateAction<TextNumberOption[]>>
+}
+
+function updateQuery(queryProp: AfoRegisterQuery): AfoRegisterQuery {
+  return {
+    ...queryProp,
+    textNumber: _.trim(queryProp.textNumber, '"'),
+  }
+}
+
+async function fetchTextNumberOptions(
+  query: AfoRegisterQuery,
+  textNumberOptions: TextNumberOption[],
+  setTextNumberOptions: React.Dispatch<
+    React.SetStateAction<TextNumberOption[]>
+  >,
+  afoRegisterService: AfoRegisterService
+): Promise<void> {
+  const suggestions = await searchTextSuggestions(
+    query.text,
+    afoRegisterService
+  )
+  const suggestion = suggestions.find(
+    (suggestion) => suggestion.text === query.text
+  )
+  if (
+    suggestion &&
+    suggestion.textNumbers &&
+    textNumberOptions.length !== suggestion.textNumbers.length + 1
+  ) {
+    loadTextNumberOptions(suggestion.textNumbers, setTextNumberOptions)
+  }
+}
+
+function loadTextNumberOptions(
+  textNumbers: string[] = [],
+  setTextNumberOptions: React.Dispatch<React.SetStateAction<TextNumberOption[]>>
+): void {
+  setTextNumberOptions([
+    { label: '—', value: '' },
+    ...textNumbers.map(makeTextNumberOption).filter((option) => option.label),
+  ])
+}
+
+function makeTextNumberOption(textNumber: string): TextNumberOption {
+  return { label: textNumber, value: textNumber }
+}
+
+function searchTextSuggestions(
+  queryText: string,
+  afoRegisterService: AfoRegisterService
+): Promise<readonly AfoRegisterRecordSuggestion[]> {
+  if (queryText.replace(/\s/g, '').length > 1) {
+    return afoRegisterService.searchSuggestions(queryText)
+  }
+  return Promise.resolve([])
+}
+
+function makeTextSelectValue(
+  query: AfoRegisterQuery,
+  textNumberOptions: TextNumberOption[]
+): AfoRegisterRecordSuggestion | null {
+  return query.text
+    ? new AfoRegisterRecordSuggestion({
+        text: query.text,
+        textNumbers: textNumberOptions.map((option) => option.value),
+      })
+    : null
+}
+
+function AfoRegisterSearch({ queryProp, afoRegisterService }: FormProps) {
+  const [query, setQuery] = useState<AfoRegisterQuery>(updateQuery(queryProp))
+  const [textNumberOptions, setTextNumberOptions] = useState<
+    Array<{ label: string; value: string }>
+  >([makeTextNumberOption(queryProp.textNumber)])
+  const [isTextNumberSelect, setIsTextNumberSelect] = useState<boolean>(
+    !!queryProp.textNumber &&
+      queryProp.textNumber.length === query.textNumber.length + 2
+  )
+  const history = useHistory()
+
+  useEffect(() => {
+    if (query.text) {
+      fetchTextNumberOptions(
+        query,
+        textNumberOptions,
+        setTextNumberOptions,
+        afoRegisterService
+      )
+    }
+  }, [query, textNumberOptions, setTextNumberOptions, afoRegisterService])
+
+  function submit(event) {
+    event.preventDefault()
+    const _query = { ...query }
+    if (isTextNumberSelect) {
+      _query.textNumber = `"${query.textNumber}"`
+    }
+    history.push(`?${stringify(_query)}`)
+  }
+
+  return (
+    <Form onSubmit={submit}>
+      <Form.Group
+        controlId={_.uniqueId('AfoRegisterSearch-')}
+        style={{ width: '100%' }}
+      >
+        <Row>
+          <Col sm={8}>
+            <TextOrPublicationSelect
+              query={query}
+              setQuery={setQuery}
+              searchTextSuggestions={(text: string) =>
+                searchTextSuggestions(text, afoRegisterService)
+              }
+              textNumberOptions={textNumberOptions}
+              setTextNumberOptions={setTextNumberOptions}
+            />
+          </Col>
+          <Col sm={4}>
+            <TextNumberField
+              query={query}
+              setQuery={setQuery}
+              textNumberOptions={textNumberOptions}
+              isTextNumberSelect={isTextNumberSelect}
+            />
+          </Col>
+        </Row>
+        <Row style={{ paddingTop: '10px' }}>
+          <Col sm={8}>
+            <Button type="submit" variant="primary">
+              Search
+            </Button>
+          </Col>
+          <Col sm={4}>
+            <TextNumberExactSwitch
+              isTextNumberSelect={isTextNumberSelect}
+              setIsTextNumberSelect={setIsTextNumberSelect}
+            />
+          </Col>
+        </Row>
+      </Form.Group>
+    </Form>
+  )
+}
+
+function TextOrPublicationSelect({
+  query,
+  setQuery,
+  searchTextSuggestions,
+  textNumberOptions,
+  setTextNumberOptions,
+}: TextOrPublicationSelectProps): JSX.Element {
+  return (
+    <AfoRegisterTextSelect
+      ariaLabel={'Select text'}
+      value={makeTextSelectValue(query, textNumberOptions)}
+      onChange={(suggestion) => {
+        loadTextNumberOptions(
+          suggestion.textNumbers || [],
+          setTextNumberOptions
+        )
+        setQuery({ text: suggestion.text, textNumber: '' })
+      }}
+      searchSuggestions={searchTextSuggestions}
+      isClearable={true}
+    />
+  )
+}
+
+interface TextNumberFieldProps {
+  query: AfoRegisterQuery
+  setQuery: React.Dispatch<React.SetStateAction<AfoRegisterQuery>>
+  textNumberOptions: TextNumberOption[]
+  isTextNumberSelect: boolean
+}
+
+function TextNumberField({
+  query,
+  setQuery,
+  textNumberOptions,
+  isTextNumberSelect,
+}: TextNumberFieldProps): JSX.Element {
+  return isTextNumberSelect ? (
+    <Select
+      aria-label="select-text-number"
+      placeholder={'Number'}
+      options={textNumberOptions}
+      onChange={(option) => {
+        if (option) {
+          setQuery({ ...query, textNumber: option.value })
+        }
+      }}
+      isSearchable={true}
+      value={
+        query.textNumber
+          ? { value: query.textNumber, label: query.textNumber }
+          : null
+      }
+    />
+  ) : (
+    <Form.Control
+      aria-label="input-text-number"
+      placeholder="Number"
+      value={query.textNumber}
+      onChange={(event) => {
+        setQuery({ ...query, textNumber: event.target.value })
+      }}
+    />
+  )
+}
+
+interface TextNumberExactSwitchProps {
+  isTextNumberSelect: boolean
+  setIsTextNumberSelect: React.Dispatch<React.SetStateAction<boolean>>
+}
+
+function TextNumberExactSwitch({
+  isTextNumberSelect,
+  setIsTextNumberSelect,
+}: TextNumberExactSwitchProps): JSX.Element {
+  return (
+    <Form.Switch
+      className="settings__switch"
+      label={'Exact number'}
+      id={_.uniqueId('text-number-field-toggle-')}
+      onChange={() => setIsTextNumberSelect(!isTextNumberSelect)}
+      checked={isTextNumberSelect}
+    />
+  )
+}
+
+export default withRouter(AfoRegisterSearch)
diff --git a/src/afo-register/ui/AfoRegisterSearchPage.tsx b/src/afo-register/ui/AfoRegisterSearchPage.tsx
new file mode 100644
index 000000000..e0879741e
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterSearchPage.tsx
@@ -0,0 +1,66 @@
+import React from 'react'
+import { parse } from 'query-string'
+import { RouteComponentProps } from 'react-router-dom'
+import AfoRegisterSearch from 'afo-register/ui/AfoRegisterSearch'
+import AfoRegisterSearchForm, {
+  AfoRegisterQuery,
+} from 'afo-register/ui/AfoRegisterSearchForm'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import FragmentService from 'fragmentarium/application/FragmentService'
+import { Markdown } from 'common/Markdown'
+
+function getAfoRegisterQueryFromLocation(
+  location: RouteComponentProps['location']
+): AfoRegisterQuery {
+  const query = parse(location.search) as AfoRegisterQuery
+  if (!query) {
+    return { text: '', textNumber: '' }
+  }
+  const { text, textNumber } = query
+  return { text: text ?? '', textNumber: textNumber ?? '' }
+}
+
+function AfoRegisterIntroduction(): JSX.Element {
+  return (
+    <Markdown
+      className="AfoRegister__introduction"
+      text="The [AfO Register](https://orientalistik.univie.ac.at/publikationen/afo/register/) (Archiv für Orientforschung: Register für Assyriologie), 
+        hosted by the Department of Near Eastern Studies of the University of Vienna, is an essential bibliographic catalogue for Assyriology. 
+        Starting with Volume 25 (1974-1977), it has published a comprehensive bibliography of new Assyriological literature and an index in most volumes, 
+        categorized by subject areas, Akkadian and Sumerian words, texts, and passages. 
+        With the kind permission of the department, the register was digitized and made searchable by the eBL team, 
+        enhancing its accessibility for researchers, students, and enthusiasts interested in the history and culture of Ancient Mesopotamia."
+    />
+  )
+}
+
+export default function AfoRegisterSearchPage({
+  afoRegisterService,
+  fragmentService,
+  location,
+}: {
+  afoRegisterService: AfoRegisterService
+  fragmentService: FragmentService
+} & RouteComponentProps): JSX.Element {
+  const query = getAfoRegisterQueryFromLocation(location)
+  return (
+    <>
+      <AfoRegisterIntroduction />
+      <div className="AfoRegister__search">
+        <AfoRegisterSearchForm
+          queryProp={query}
+          afoRegisterService={afoRegisterService}
+        />
+      </div>
+      <div className="AfoRegister__search_results">
+        {!!query.text && (
+          <AfoRegisterSearch
+            query={query}
+            afoRegisterService={afoRegisterService}
+            fragmentService={fragmentService}
+          />
+        )}
+      </div>
+    </>
+  )
+}
diff --git a/src/afo-register/ui/AfoRegisterTextSelect.test.tsx b/src/afo-register/ui/AfoRegisterTextSelect.test.tsx
new file mode 100644
index 000000000..5b68b344f
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterTextSelect.test.tsx
@@ -0,0 +1,59 @@
+import React from 'react'
+import { render, screen, fireEvent, waitFor, act } from '@testing-library/react'
+import AfoRegisterTextSelect from './AfoRegisterTextSelect'
+import userEvent from '@testing-library/user-event'
+import { AfoRegisterRecordSuggestion } from 'afo-register/domain/Record'
+import Bluebird from 'bluebird'
+
+describe('AfoRegisterTextSelect', () => {
+  const mockSearchSuggestions = jest.fn()
+  const mockOnChange = jest.fn()
+  const defaultProps = {
+    ariaLabel: 'test-select',
+    value: null,
+    searchSuggestions: mockSearchSuggestions,
+    onChange: mockOnChange,
+    isClearable: true,
+  }
+
+  it('renders without crashing', () => {
+    render(<AfoRegisterTextSelect {...defaultProps} />)
+    expect(screen.getByLabelText('test-select')).toBeInTheDocument()
+  })
+
+  it('updates selection when props change', async () => {
+    const newValue = new AfoRegisterRecordSuggestion({
+      text: 'Some text option',
+      textNumbers: ['4', '5', '6'],
+    })
+    await act(async () => {
+      const { rerender } = render(<AfoRegisterTextSelect {...defaultProps} />)
+      rerender(<AfoRegisterTextSelect {...defaultProps} value={newValue} />)
+    })
+    await waitFor(() => {
+      expect(screen.getByText(newValue.text)).toBeInTheDocument()
+    })
+  })
+
+  it('calls onChange when an option is selected', async () => {
+    const options = [
+      { text: 'Text option 1', textNumbers: ['1'] },
+      { text: 'Text option 2', textNumbers: ['2'] },
+    ]
+    mockSearchSuggestions.mockReturnValue(Bluebird.resolve(options))
+    await act(async () => {
+      render(<AfoRegisterTextSelect {...defaultProps} />)
+      userEvent.type(screen.getByLabelText('test-select'), 'Option')
+      await waitFor(() => {
+        const option = screen.getByText(options[0].text)
+        fireEvent.click(option)
+      })
+    })
+    await waitFor(() => {
+      expect(mockOnChange).toHaveBeenCalledWith({
+        text: options[0].text,
+        textNumbers: options[0].textNumbers,
+      })
+    })
+  })
+})
diff --git a/src/afo-register/ui/AfoRegisterTextSelect.tsx b/src/afo-register/ui/AfoRegisterTextSelect.tsx
new file mode 100644
index 000000000..31f40ac20
--- /dev/null
+++ b/src/afo-register/ui/AfoRegisterTextSelect.tsx
@@ -0,0 +1,108 @@
+import React, { useEffect, useState } from 'react'
+import { AfoRegisterRecordSuggestion } from 'afo-register/domain/Record'
+import { usePrevious } from 'common/usePrevious'
+import { ValueType } from 'react-select'
+import AsyncSelect from 'react-select/async'
+import { Markdown } from 'common/Markdown'
+
+interface SelectProps {
+  ariaLabel: string
+  value: AfoRegisterRecordSuggestion | null
+  searchSuggestions: (
+    query: string
+  ) => Promise<readonly AfoRegisterRecordSuggestion[]>
+  onChange: (event: AfoRegisterRecordSuggestion) => void
+  isClearable: boolean
+}
+
+interface TextSuggestionOption {
+  value: string
+  label: string | JSX.Element
+  entry: AfoRegisterRecordSuggestion
+}
+
+const collator = new Intl.Collator([], { numeric: true })
+function sorter(a: string, b: string, inputValue: string) {
+  const removeSpecialChars = /[*^]/g
+  const cleanedA = a.replace(removeSpecialChars, '')
+  const cleanedB = b.replace(removeSpecialChars, '')
+  const regex = new RegExp(`^${inputValue}`, 'i')
+  const startsWithQueryA = regex.test(cleanedA)
+  const startsWithQueryB = regex.test(cleanedB)
+  if (startsWithQueryA === startsWithQueryB) {
+    return collator.compare(cleanedA, cleanedB)
+  }
+  return startsWithQueryA ? -1 : 1
+}
+
+function createOption(
+  recordSuggestion: AfoRegisterRecordSuggestion
+): TextSuggestionOption {
+  return {
+    value: recordSuggestion.text,
+    label: recordSuggestion.text,
+    entry: recordSuggestion,
+  }
+}
+
+export default function AfoRegisterTextSelect({
+  ariaLabel,
+  value,
+  searchSuggestions,
+  onChange,
+  isClearable,
+}: SelectProps): JSX.Element {
+  const [
+    selectedOption,
+    setSelectedOption,
+  ] = useState<TextSuggestionOption | null>(value ? createOption(value) : null)
+  const prevValue = usePrevious(value)
+
+  useEffect(() => {
+    if (value && value !== prevValue) {
+      setSelectedOption(createOption(value))
+    }
+  }, [value, prevValue])
+
+  const loadOptions = (
+    inputValue: string,
+    callback: (options: TextSuggestionOption[]) => void
+  ) => {
+    searchSuggestions(inputValue).then((entries) => {
+      const options = entries
+        .map(createOption)
+        .filter((option) => option !== null) as TextSuggestionOption[]
+      options.sort((a, b) => sorter(a.value, b.value, inputValue))
+      callback(options)
+    })
+  }
+
+  const handleChange = (
+    selectedOption: ValueType<TextSuggestionOption, false>
+  ) => {
+    if (selectedOption) {
+      setSelectedOption(selectedOption)
+      onChange(selectedOption.entry)
+    } else {
+      setSelectedOption(null)
+      onChange(new AfoRegisterRecordSuggestion({ text: '', textNumbers: [] }))
+    }
+  }
+
+  function formatOptionLabel(option: TextSuggestionOption): JSX.Element {
+    return <Markdown text={option.label as string} />
+  }
+
+  return (
+    <AsyncSelect
+      isClearable={isClearable}
+      aria-label={ariaLabel}
+      placeholder="Text or Publication"
+      cacheOptions
+      loadOptions={loadOptions}
+      onChange={handleChange}
+      value={selectedOption}
+      formatOptionLabel={formatOptionLabel}
+    />
+  )
+}
diff --git a/src/bibliography/infrastructure/BibliographyRepository.test.ts b/src/bibliography/infrastructure/BibliographyRepository.test.ts
index 7c70fcacc..3e937eeb1 100644
--- a/src/bibliography/infrastructure/BibliographyRepository.test.ts
+++ b/src/bibliography/infrastructure/BibliographyRepository.test.ts
@@ -8,7 +8,7 @@ jest.mock('http/ApiClient')
 
 const apiClient = new (ApiClient as jest.Mock<jest.Mocked<ApiClient>>)()
 
-const wordRepository = new BibliographyRepository(apiClient)
+const bibliographyRepository = new BibliographyRepository(apiClient)
 const query = 'Bor Ger 1998 The Qualifications'
 const id = 'RN 2020'
 const resultStub = {
@@ -60,4 +60,4 @@ const testData: TestData<BibliographyRepository>[] = [
 ]
 
 describe('BibliographyRepository', () =>
-  testDelegation(wordRepository, testData))
+  testDelegation(bibliographyRepository, testData))
diff --git a/src/bibliography/ui/Bibliography.css b/src/bibliography/ui/Bibliography.css
index 9a3927ad4..afaab7f86 100644
--- a/src/bibliography/ui/Bibliography.css
+++ b/src/bibliography/ui/Bibliography.css
@@ -2,3 +2,16 @@
   margin: 0 auto 2em;
   max-width: 32em;
 }
+
+.AfoRegister__search {
+  margin: 0 auto 2em;
+  max-width: 38em;
+}
+
+.BibliographyReferences__introduction,
+.AfoRegister__introduction,
+.AfoRegister__search_results {
+  text-align: justify;
+  padding: 0 4em;
+  padding-bottom: 20px;
+}
diff --git a/src/bibliography/ui/Bibliography.test.tsx b/src/bibliography/ui/Bibliography.test.tsx
index 78fd6076d..4218431a4 100644
--- a/src/bibliography/ui/Bibliography.test.tsx
+++ b/src/bibliography/ui/Bibliography.test.tsx
@@ -1,5 +1,5 @@
 import React from 'react'
-import { render, screen } from '@testing-library/react'
+import { act, render, screen } from '@testing-library/react'
 import { MemoryRouter, withRouter } from 'react-router-dom'
 import Promise from 'bluebird'
 import SessionContext from 'auth/SessionContext'
@@ -12,6 +12,8 @@ const BibliographyWithRouter = withRouter(Bibliography)
 
 let entries: BibliographyEntry[]
 let bibliographyService
+let afoRegisterService
+let fragmentService
 let session
 
 beforeEach(() => {
@@ -19,21 +21,33 @@ beforeEach(() => {
   bibliographyService = {
     search: jest.fn(),
   }
+  afoRegisterService = {
+    search: jest.fn(),
+  }
+  fragmentService = {
+    query: jest.fn(),
+  }
   session = {
     isAllowedToReadBibliography: jest.fn(),
     isAllowedToWriteBibliography: (): boolean => false,
   }
 })
 
-describe('Searching bibliography', () => {
+describe('Searching bibliography and AfO Register', () => {
   beforeEach(() => {
     session.isAllowedToReadBibliography.mockReturnValue(true)
-    bibliographyService.search.mockReturnValueOnce(Promise.resolve(entries))
+    bibliographyService.search.mockReturnValue(Promise.resolve(entries))
+    afoRegisterService.search.mockReturnValue(Promise.resolve([]))
+    fragmentService.query.mockReturnValue(Promise.resolve([]))
   })
 
   it('displays result on successfull query', async () => {
-    renderDictionary('/bibliography?query=Borger')
-
+    await act(async () => {
+      await renderBibliography(
+        '/bibliography/references?query=Borger',
+        'references'
+      )
+    })
     expect(
       await screen.findByText(createAuthorRegExp(entries[0]))
     ).toBeInTheDocument()
@@ -41,34 +55,62 @@ describe('Searching bibliography', () => {
   })
 
   it('fills in search form query', async () => {
-    renderDictionary('/bibliography?query=Borger')
+    await act(async () => {
+      renderBibliography('/bibliography/references?query=Borger', 'references')
+    })
 
-    expect(await screen.findByLabelText('Query')).toHaveValue('Borger')
+    expect(await screen.findByLabelText('Bibliography-Query')).toHaveValue(
+      'Borger'
+    )
   })
 
   it('displays empty search if no query', async () => {
-    renderDictionary('/bibliography')
+    await act(async () => {
+      renderBibliography('/bibliography/references', 'references')
+    })
 
-    expect(await screen.findByLabelText('Query')).toHaveValue('')
+    expect(await screen.findByLabelText('Bibliography-Query')).toHaveValue('')
+  })
+
+  it('Displays a message if user is not logged in', async () => {
+    session.isAllowedToReadBibliography.mockReturnValueOnce(false)
+    await act(async () => {
+      renderBibliography('/bibliography/references', 'references')
+    })
+    expect(
+      screen.getByText('Please log in to browse the Bibliography.')
+    ).toBeInTheDocument()
   })
-})
 
-it('Displays a message if user is not logged in', async () => {
-  session.isAllowedToReadBibliography.mockReturnValueOnce(false)
+  function renderBibliography(
+    path: string,
+    activeTab: 'references' | 'afo-register'
+  ): void {
+    render(
+      <MemoryRouter initialEntries={[path]}>
+        <SessionContext.Provider value={session}>
+          <BibliographyWithRouter
+            bibliographyService={bibliographyService}
+            afoRegisterService={afoRegisterService}
+            fragmentService={fragmentService}
+            activeTab={activeTab}
+          />
+        </SessionContext.Provider>
+      </MemoryRouter>
+    )
+  }
 
-  renderDictionary('/bibliography')
+  it('renders content based on session state', () => {
+    session.isAllowedToReadBibliography.mockReturnValue(false)
+    renderBibliography('/bibliography/references', 'references')
 
-  expect(
-    screen.getByText('Please log in to browse the Bibliography.')
-  ).toBeInTheDocument()
-})
+    expect(
+      screen.getByText('Please log in to browse the Bibliography.')
+    ).toBeInTheDocument()
+  })
 
-function renderDictionary(path: string): void {
-  render(
-    <MemoryRouter initialEntries={[path]}>
-      <SessionContext.Provider value={session}>
-        <BibliographyWithRouter bibliographyService={bibliographyService} />
-      </SessionContext.Provider>
-    </MemoryRouter>
-  )
-}
+  it('handles URL queries correctly', () => {
+    renderBibliography('/bibliography/references?query=TestQuery', 'references')
+    expect(screen.getByLabelText('Bibliography-Query')).toHaveValue('TestQuery')
+  })
+})
diff --git a/src/bibliography/ui/Bibliography.tsx b/src/bibliography/ui/Bibliography.tsx
index 4104753db..46d5870f3 100644
--- a/src/bibliography/ui/Bibliography.tsx
+++ b/src/bibliography/ui/Bibliography.tsx
@@ -1,7 +1,7 @@
 import React from 'react'
 import { parse } from 'query-string'
 import { LinkContainer } from 'react-router-bootstrap'
-import { Button } from 'react-bootstrap'
+import { Button, Tab, Tabs } from 'react-bootstrap'
 import _ from 'lodash'
 
 import AppContent from 'common/AppContent'
@@ -10,9 +10,14 @@ import BibliographySearch from './BibliographySearch'
 import SessionContext from 'auth/SessionContext'
 
 import './Bibliography.css'
-import { SectionCrumb } from 'common/Breadcrumbs'
+import { TextCrumb } from 'common/Breadcrumbs'
 import { Session } from 'auth/Session'
-import { RouteComponentProps } from 'react-router-dom'
+import { RouteComponentProps, useHistory } from 'react-router-dom'
+import BibliographyService from 'bibliography/application/BibliographyService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import AfoRegisterSearchPage from 'afo-register/ui/AfoRegisterSearchPage'
+import { Markdown } from 'common/Markdown'
+import FragmentService from 'fragmentarium/application/FragmentService'
 
 function CreateButton({ session }: { session: Session }): JSX.Element {
   return (
@@ -27,31 +32,114 @@ function CreateButton({ session }: { session: Session }): JSX.Element {
   )
 }
 
+function getReferencesQueryFromLocation(
+  location: RouteComponentProps['location']
+): string {
+  const rawQuery = parse(location.search).query || ''
+  return _.isArray(rawQuery) ? rawQuery.join('') : rawQuery
+}
+
+function BibliographyReferencesIntroduction(): JSX.Element {
+  return (
+    <Markdown
+      className="BibliographyReferences__introduction"
+      text="The electronic Babylonian Library (eBL) features a comprehensive collection of 
+        bibliography references related to Babylonian literature and cuneiform studies in general. 
+        These references have been meticulously gathered and are readily accessible 
+        through a dedicated search function on the eBL platform. 
+        This robust bibliographic repository serves as a valuable resource for researchers, scholars, 
+        and anyone interested in the study of ancient Mesopotamian texts."
+    />
+  )
+}
+
+function BibliographyReferences({
+  bibliographyService,
+  location,
+}: {
+  bibliographyService: BibliographyService
+} & RouteComponentProps): JSX.Element {
+  const query = getReferencesQueryFromLocation(location)
+  return (
+    <>
+      <BibliographyReferencesIntroduction />
+      <div className="Bibliography__search">
+        <BibliographySearchForm query={query} />
+      </div>
+      <BibliographySearch
+        query={query}
+        bibliographyService={bibliographyService}
+      />
+    </>
+  )
+}
+
 export default function Bibliography({
   bibliographyService,
+  afoRegisterService,
+  fragmentService,
   location,
+  activeTab,
+  ...props
 }: {
-  bibliographyService
+  bibliographyService: BibliographyService
+  afoRegisterService: AfoRegisterService
+  fragmentService: FragmentService
+  activeTab: 'references' | 'afo-register'
 } & RouteComponentProps): JSX.Element {
-  const rawQuery = parse(location.search).query || ''
-  const query = _.isArray(rawQuery) ? rawQuery.join('') : rawQuery
+  const history = useHistory()
   return (
     <SessionContext.Consumer>
       {(session: Session): JSX.Element => (
         <AppContent
-          crumbs={[new SectionCrumb('Bibliography')]}
-          actions={<CreateButton session={session} />}
+          crumbs={[
+            new TextCrumb('Bibliography'),
+            new TextCrumb(
+              { 'afo-register': 'AfO Register', references: 'References' }[
+                activeTab
+              ]
+            ),
+          ]}
+          actions={
+            activeTab === 'references' && <CreateButton session={session} />
+          }
         >
           {session.isAllowedToReadBibliography() ? (
-            <>
-              <div className="Bibliography__search">
-                <BibliographySearchForm query={query} />
-              </div>
-              <BibliographySearch
-                query={query}
-                bibliographyService={bibliographyService}
-              />
-            </>
+            <Tabs
+              activeKey={activeTab}
+              onSelect={(eventKey) => {
+                if (eventKey !== activeTab) {
+                  history.push(`${eventKey}`)
+                }
+              }}
+              id={_.uniqueId('Bibliography-')}
+            >
+              <Tab
+                eventKey={'afo-register'}
+                title={'AfO Register'}
+                key={'afo-register'}
+                style={{ paddingTop: '20px' }}
+              >
+                <AfoRegisterSearchPage
+                  afoRegisterService={afoRegisterService}
+                  fragmentService={fragmentService}
+                  location={location}
+                  {...props}
+                />
+              </Tab>
+              <Tab
+                eventKey={'references'}
+                title={'References'}
+                key={'references'}
+                style={{ paddingTop: '20px' }}
+              >
+                <BibliographyReferences
+                  bibliographyService={bibliographyService}
+                  location={location}
+                  {...props}
+                />
+              </Tab>
+            </Tabs>
           ) : (
             <p>Please log in to browse the Bibliography.</p>
           )}
diff --git a/src/bibliography/ui/BibliographySearch.tsx b/src/bibliography/ui/BibliographySearch.tsx
index 31ea8f42d..1b3778baf 100644
--- a/src/bibliography/ui/BibliographySearch.tsx
+++ b/src/bibliography/ui/BibliographySearch.tsx
@@ -2,12 +2,12 @@ import React from 'react'
 import { Link } from 'react-router-dom'
 import _ from 'lodash'
 import { Parser } from 'html-to-react'
-import Promise from 'bluebird'
 
 import withData from 'http/withData'
 
 import './BibliographySearch.css'
 import BibliographyEntry from 'bibliography/domain/BibliographyEntry'
+import BibliographyService from 'bibliography/application/BibliographyService'
 
 function BibliographySearch({ data }: { data: readonly BibliographyEntry[] }) {
   const parser = new Parser()
@@ -16,7 +16,7 @@ function BibliographySearch({ data }: { data: readonly BibliographyEntry[] }) {
       {data.map((entry) => (
         <li key={entry.id} className="BibliographySearch__entry">
           <Link
-            to={`/bibliography/${encodeURIComponent(entry.id)}`}
+            to={`/bibliography/references/${encodeURIComponent(entry.id)}`}
             className="BibliographySearch__edit"
           >
             <i className="fas fa-edit" />
@@ -31,7 +31,7 @@ function BibliographySearch({ data }: { data: readonly BibliographyEntry[] }) {
 export default withData<
   unknown,
   {
-    bibliographyService: { search(query: string): Promise<BibliographyEntry[]> }
+    bibliographyService: BibliographyService
     query: string
   },
   readonly BibliographyEntry[]
diff --git a/src/bibliography/ui/BibliographySearchForm.tsx b/src/bibliography/ui/BibliographySearchForm.tsx
index 50cf144dd..8267fd222 100644
--- a/src/bibliography/ui/BibliographySearchForm.tsx
+++ b/src/bibliography/ui/BibliographySearchForm.tsx
@@ -29,7 +29,7 @@ class BibliographySearch extends Component<Props, { query: string }> {
         <Form.Group as={Row} controlId={this.id}>
           <Col sm={8}>
             <FormControl
-              aria-label="Query"
+              aria-label="Bibliography-Query"
               type="text"
               value={this.state.query}
               placeholder="Author Year Title / Container-Title-Short Collection-Number"
diff --git a/src/dictionary/ui/display/WordDisplay.tsx b/src/dictionary/ui/display/WordDisplay.tsx
index 3adfa8bad..24f16b67f 100644
--- a/src/dictionary/ui/display/WordDisplay.tsx
+++ b/src/dictionary/ui/display/WordDisplay.tsx
@@ -19,6 +19,7 @@ import WordTitle from 'dictionary/ui/display/WordTitle'
 import FragmentLemmaLines from '../search/FragmentLemmaLines'
 import FragmentService from 'fragmentarium/application/FragmentService'
 import { HeadTags } from 'router/head'
+import { AfoRegisterRedirectBox } from 'afo-register/ui/AfoRegisterSearch'
 
 const Heading = ({
   number,
@@ -111,15 +112,7 @@ function WordDisplay({
   const akkadischeGlossareUndIndices = word.akkadischeGlossareUndIndices ? (
     <Fragment key="AkkadischeGlossareUndIndices">
       <AGI AkkadischeGlossareUndIndices={word.akkadischeGlossareUndIndices} />
-      <LiteratureRedirectBox
-        authors="Hirsch, H.; Hunger, H.; Jursa, M.; Weszeli, M.; et al."
-        book="Archiv für Orientforschung (Register Assyriologie)"
-        notelink=""
-        subtitle="25 (1974/1977) – 54 (2021)"
-        note="By permission from the AfO Redaktion"
-        link="https://orientalistik.univie.ac.at/publikationen/afo/register/"
-        icon="pointer__hover my-2 fas fa-external-link-square-alt"
-      />{' '}
+      {AfoRegisterRedirectBox}{' '}
       <LiteratureRedirectBox
         authors="Sommerfeld, W."
         book="Akkadische Glossare und Indizes"
diff --git a/src/fragmentarium/domain/Fragment.test.ts b/src/fragmentarium/domain/Fragment.test.ts
index 9e49857ea..ad052b92c 100644
--- a/src/fragmentarium/domain/Fragment.test.ts
+++ b/src/fragmentarium/domain/Fragment.test.ts
@@ -99,6 +99,7 @@ const config: Parameters<typeof Fragment['create']>[0] = {
       pages: [3, 208],
     },
   ],
+  traditionalReferences: [],
   atf: '$ (atf)',
   hasPhoto: true,
   genres: Genres.fromJson([
diff --git a/src/fragmentarium/domain/FragmentDtos.ts b/src/fragmentarium/domain/FragmentDtos.ts
index 7245913e1..e72bdb9ee 100644
--- a/src/fragmentarium/domain/FragmentDtos.ts
+++ b/src/fragmentarium/domain/FragmentDtos.ts
@@ -51,6 +51,8 @@ interface UncuratedReferenceDto {
   pages: readonly number[]
 }
 
+type TraditionalReference = string
+
 type RecordEntryDto = Pick<RecordEntry, 'user' | 'date' | 'type'>
 
 type FolioDto = Pick<Folio, 'name' | 'number'>
@@ -98,6 +100,7 @@ export default interface FragmentDto {
   notes: Notes
   references: readonly ReferenceDto[]
   uncuratedReferences: readonly UncuratedReferenceDto[] | null
+  traditionalReferences: readonly TraditionalReference[]
   atf: string
   hasPhoto: boolean
   genres: readonly GenreDto[]
diff --git a/src/fragmentarium/domain/fragment.ts b/src/fragmentarium/domain/fragment.ts
index fb4a956ed..dfb5ca58e 100644
--- a/src/fragmentarium/domain/fragment.ts
+++ b/src/fragmentarium/domain/fragment.ts
@@ -95,6 +95,7 @@ export class Fragment {
     readonly museum: Museum,
     readonly references: ReadonlyArray<Reference>,
     readonly uncuratedReferences: ReadonlyArray<UncuratedReference> | null,
+    readonly traditionalReferences: readonly string[],
     readonly atf: string,
     readonly hasPhoto: boolean,
     readonly genres: Genres,
@@ -124,6 +125,7 @@ export class Fragment {
     museum,
     references,
     uncuratedReferences,
+    traditionalReferences,
     atf,
     hasPhoto,
     genres,
@@ -151,6 +153,7 @@ export class Fragment {
     museum: Museum
     references: ReadonlyArray<Reference>
     uncuratedReferences?: ReadonlyArray<UncuratedReference> | null
+    traditionalReferences: readonly string[]
     atf: string
     hasPhoto: boolean
     genres: Genres
@@ -179,6 +182,7 @@ export class Fragment {
       museum,
       references,
       uncuratedReferences ?? null,
+      traditionalReferences,
       atf,
       hasPhoto,
       genres,
diff --git a/src/fragmentarium/infrastructure/FragmentRepository.ts b/src/fragmentarium/infrastructure/FragmentRepository.ts
index 8e3502476..a6038ef48 100644
--- a/src/fragmentarium/infrastructure/FragmentRepository.ts
+++ b/src/fragmentarium/infrastructure/FragmentRepository.ts
@@ -96,6 +96,7 @@ function createFragment(dto: FragmentDto): Fragment {
     text: createTransliteration(dto.text),
     references: dto.references.map(createReference),
     uncuratedReferences: dto.uncuratedReferences,
+    traditionalReferences: dto.traditionalReferences,
     genres: Genres.fromJson(dto.genres),
     script: createScript(dto.script),
     projects: dto.projects.map(createResearchProject),
diff --git a/src/fragmentarium/ui/fragment/CuneiformFragment.test.tsx b/src/fragmentarium/ui/fragment/CuneiformFragment.test.tsx
index 8284b1cfc..340aa76aa 100644
--- a/src/fragmentarium/ui/fragment/CuneiformFragment.test.tsx
+++ b/src/fragmentarium/ui/fragment/CuneiformFragment.test.tsx
@@ -19,11 +19,13 @@ import {
 } from 'test-support/fragment-fixtures'
 import { Fragment } from 'fragmentarium/domain/fragment'
 import { FindspotService } from 'fragmentarium/application/FindspotService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 
 jest.mock('dictionary/application/WordService')
 jest.mock('fragmentarium/application/FindspotService')
 jest.mock('fragmentarium/application/FragmentService')
 jest.mock('fragmentarium/application/FragmentSearchService')
+jest.mock('afo-register/application/AfoRegisterService')
 jest.mock('auth/Session')
 
 let fragment: Fragment
@@ -32,6 +34,7 @@ let fragmentService: jest.Mocked<FragmentService>
 let fragmentSearchService: jest.Mocked<FragmentSearchService>
 let wordService: jest.Mocked<WordService>
 let findspotService: jest.Mocked<FindspotService>
+let afoRegisterService: jest.Mocked<AfoRegisterService>
 let session: jest.Mocked<Session>
 let updatedFragment: Fragment
 
@@ -99,6 +102,7 @@ beforeEach(async () => {
           fragmentSearchService={fragmentSearchService}
           wordService={wordService}
           findspotService={findspotService}
+          afoRegisterService={afoRegisterService}
           activeLine=""
         />
       </SessionContext.Provider>
diff --git a/src/fragmentarium/ui/fragment/CuneiformFragment.tsx b/src/fragmentarium/ui/fragment/CuneiformFragment.tsx
index 3f34c7157..5c3c79db7 100644
--- a/src/fragmentarium/ui/fragment/CuneiformFragment.tsx
+++ b/src/fragmentarium/ui/fragment/CuneiformFragment.tsx
@@ -25,6 +25,7 @@ import ErrorBoundary from 'common/ErrorBoundary'
 import ArchaeologyEditor from 'fragmentarium/ui/fragment/ArchaeologyEditor'
 import { ArchaeologyDto } from 'fragmentarium/domain/archaeology'
 import { FindspotService } from 'fragmentarium/application/FindspotService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 
 const ContentSection: FunctionComponent = ({
   children,
@@ -178,6 +179,7 @@ type CuneiformFragmentProps = {
   fragment: Fragment
   fragmentService: FragmentService
   fragmentSearchService: FragmentSearchService
+  afoRegisterService: AfoRegisterService
   wordService: WordService
   findspotService: FindspotService
   activeFolio: Folio | null
@@ -191,6 +193,7 @@ const CuneiformFragment: FunctionComponent<CuneiformFragmentProps> = ({
   fragment,
   fragmentService,
   fragmentSearchService,
+  afoRegisterService,
   wordService,
   findspotService,
   activeFolio,
@@ -208,6 +211,7 @@ const CuneiformFragment: FunctionComponent<CuneiformFragmentProps> = ({
             <Info
               fragment={fragment}
               fragmentService={fragmentService}
+              afoRegisterService={afoRegisterService}
               onSave={onSave}
             />
           </ErrorBoundary>
@@ -251,6 +255,7 @@ type ControllerProps = {
   fragment: Fragment
   fragmentService: FragmentService
   fragmentSearchService: FragmentSearchService
+  afoRegisterService: AfoRegisterService
   wordService: WordService
   findspotService: FindspotService
   activeFolio?: Folio | null
@@ -261,6 +266,7 @@ const CuneiformFragmentController: FunctionComponent<ControllerProps> = ({
   fragment,
   fragmentService,
   fragmentSearchService,
+  afoRegisterService,
   wordService,
   findspotService,
   activeFolio = null,
@@ -297,6 +303,7 @@ const CuneiformFragmentController: FunctionComponent<ControllerProps> = ({
         fragment={currentFragment}
         fragmentService={fragmentService}
         fragmentSearchService={fragmentSearchService}
+        afoRegisterService={afoRegisterService}
         wordService={wordService}
         findspotService={findspotService}
         activeFolio={activeFolio}
diff --git a/src/fragmentarium/ui/fragment/FragmentView.test.tsx b/src/fragmentarium/ui/fragment/FragmentView.test.tsx
index 3876db562..837099d8b 100644
--- a/src/fragmentarium/ui/fragment/FragmentView.test.tsx
+++ b/src/fragmentarium/ui/fragment/FragmentView.test.tsx
@@ -25,11 +25,13 @@ import Folio from 'fragmentarium/domain/Folio'
 import { helmetContext } from 'router/head'
 import { HelmetProvider } from 'react-helmet-async'
 import { FindspotService } from 'fragmentarium/application/FindspotService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 
 jest.mock('dictionary/application/WordService')
 jest.mock('fragmentarium/application/FindspotService')
 jest.mock('fragmentarium/application/FragmentService')
 jest.mock('fragmentarium/application/FragmentSearchService')
+jest.mock('afo-register/application/AfoRegisterService')
 
 const message = 'message'
 const fragmentNumber = 'K,K.1'
@@ -38,6 +40,7 @@ let fragmentService: jest.Mocked<FragmentService>
 let fragmentSearchService: jest.Mocked<FragmentSearchService>
 let wordService: jest.Mocked<WordService>
 let findspotService: jest.Mocked<FindspotService>
+let afoRegisterService: jest.Mocked<AfoRegisterService>
 let session
 let container: HTMLElement
 
@@ -61,6 +64,7 @@ function renderFragmentView(
               fragmentSearchService={fragmentSearchService}
               wordService={wordService}
               findspotService={findspotService}
+              afoRegisterService={afoRegisterService}
               activeLine=""
               session={session}
             />
diff --git a/src/fragmentarium/ui/fragment/FragmentView.tsx b/src/fragmentarium/ui/fragment/FragmentView.tsx
index 2241d5dfb..27bac7a42 100644
--- a/src/fragmentarium/ui/fragment/FragmentView.tsx
+++ b/src/fragmentarium/ui/fragment/FragmentView.tsx
@@ -18,6 +18,7 @@ import FragmentSearchService from 'fragmentarium/application/FragmentSearchServi
 import { Session } from 'auth/Session'
 import { HeadTags } from 'router/head'
 import { FindspotService } from 'fragmentarium/application/FindspotService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 
 function TagSignsButton({
   number,
@@ -41,6 +42,7 @@ type Props = {
   fragmentSearchService: FragmentSearchService
   wordService: WordService
   findspotService: FindspotService
+  afoRegisterService: AfoRegisterService
   number: string
   folioName: string | null
   folioNumber: string | null
@@ -65,6 +67,7 @@ function FragmentView({
   fragment,
   fragmentService,
   fragmentSearchService,
+  afoRegisterService,
   wordService,
   findspotService,
   number,
@@ -111,6 +114,7 @@ function FragmentView({
         activeFolio={activeFolio}
         tab={tab}
         activeLine={activeLine}
+        afoRegisterService={afoRegisterService}
       />
     </AppContent>
   )
diff --git a/src/fragmentarium/ui/info/Info.tsx b/src/fragmentarium/ui/info/Info.tsx
index e70177581..af004b979 100644
--- a/src/fragmentarium/ui/info/Info.tsx
+++ b/src/fragmentarium/ui/info/Info.tsx
@@ -4,27 +4,36 @@ import Details from 'fragmentarium/ui/info/Details'
 import Record from 'fragmentarium/ui/info/Record'
 import ExternalResources from 'fragmentarium/ui/info/ExternalResources'
 import UncuratedReferences from 'fragmentarium/ui/info/UncuratedReferences'
-import { Fragment, UncuratedReference } from 'fragmentarium/domain/fragment'
+import {
+  Fragment,
+  Script,
+  UncuratedReference,
+} from 'fragmentarium/domain/fragment'
+import { Genres } from 'fragmentarium/domain/Genres'
 import FragmentService from 'fragmentarium/application/FragmentService'
 import { ReferencesHelp } from 'bibliography/ui/ReferencesHelp'
 import './info.sass'
 import { ProjectList } from 'fragmentarium/ui/info/ResearchProjects'
 import _ from 'lodash'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import AfoRegisterFragmentRecords from 'afo-register/ui/AfoRegisterFragmentRecords'
 
 interface Props {
   fragment: Fragment
   fragmentService: FragmentService
+  afoRegisterService: AfoRegisterService
   onSave: (fragment: Promise<Fragment>) => void
 }
 
 export default function Info({
   fragment,
   fragmentService,
+  afoRegisterService,
   onSave,
 }: Props): JSX.Element {
-  const updateGenres = (genres) =>
+  const updateGenres = (genres: Genres) =>
     onSave(fragmentService.updateGenres(fragment.number, genres))
-  const updateScript = (script) =>
+  const updateScript = (script: Script) =>
     fragmentService.updateScript(fragment.number, script)
   const updateDate = (date) => fragmentService.updateDate(fragment.number, date)
   const updateDatesInText = (datesInText) =>
@@ -54,6 +63,13 @@ export default function Info({
           />
         )}
       </section>
+      <section>
+        <h3>AfO Register</h3>
+        <AfoRegisterFragmentRecords
+          afoRegisterService={afoRegisterService}
+          fragment={fragment}
+        />
+      </section>
       {!_.isEmpty(fragment.projects) && (
         <section>
           <h3>Projects</h3>
diff --git a/src/fragmentarium/ui/info/info.sass b/src/fragmentarium/ui/info/info.sass
index 8e05bb59c..85b4eaad8 100644
--- a/src/fragmentarium/ui/info/info.sass
+++ b/src/fragmentarium/ui/info/info.sass
@@ -4,3 +4,9 @@
       &__header
             display: flex
             align-items: baseline
+
+ol.AfORegisterRecordsInFragment
+      padding-left: 15px
+
+      li small.text-black-50.ml-3
+            display: none
\ No newline at end of file
diff --git a/src/http/ApiClient.ts b/src/http/ApiClient.ts
index 6f6fb51f6..d8fe37329 100644
--- a/src/http/ApiClient.ts
+++ b/src/http/ApiClient.ts
@@ -140,8 +140,8 @@ export default class ApiClient {
     )
   }
 
-  postJson(path: string, body: unknown): Bluebird<any> {
-    return this.fetch(path, true, createOptions(body, 'POST')).then(
+  postJson(path: string, body: unknown, authenticate = true): Bluebird<any> {
+    return this.fetch(path, authenticate, createOptions(body, 'POST')).then(
       deserializeJson
     )
   }
diff --git a/src/index.tsx b/src/index.tsx
index 3a7265f76..e34a43d9f 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -23,9 +23,10 @@ import { Auth0Provider } from 'auth/react-auth0-spa'
 import { scopeString, useAuthentication } from 'auth/Auth'
 import SignService from 'signs/application/SignService'
 import SignRepository from 'signs/infrastructure/SignRepository'
-
-import './index.sass'
+import AfoRegisterRepository from 'afo-register/infrastructure/AfoRegisterRepository'
 import MarkupService from 'markup/application/MarkupService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import './index.sass'
 import { FindspotService } from 'fragmentarium/application/FindspotService'
 import { ApiFindspotRepository } from 'fragmentarium/infrastructure/FindspotRepository'
 
@@ -55,6 +56,7 @@ function InjectedApp(): JSX.Element {
   const fragmentRepository = new FragmentRepository(apiClient)
   const imageRepository = new ApiImageRepository(apiClient)
   const bibliographyRepository = new BibliographyRepository(apiClient)
+  const afoRegisterRepository = new AfoRegisterRepository(apiClient)
   const findspotRepository = new ApiFindspotRepository(apiClient)
 
   const bibliographyService = new BibliographyService(bibliographyRepository)
@@ -74,6 +76,7 @@ function InjectedApp(): JSX.Element {
   )
   const signService = new SignService(signsRepository)
   const markupService = new MarkupService(apiClient, bibliographyService)
+  const afoRegisterService = new AfoRegisterService(afoRegisterRepository)
   const findspotService = new FindspotService(findspotRepository)
   return (
     <App
@@ -84,6 +87,7 @@ function InjectedApp(): JSX.Element {
       bibliographyService={bibliographyService}
       textService={textService}
       markupService={markupService}
+      afoRegisterService={afoRegisterService}
       findspotService={findspotService}
     />
   )
diff --git a/src/query/FragmentQuery.ts b/src/query/FragmentQuery.ts
index e966f64ee..9e2d629cf 100644
--- a/src/query/FragmentQuery.ts
+++ b/src/query/FragmentQuery.ts
@@ -18,5 +18,6 @@ export type FragmentQuery = Partial<{
   scriptPeriod: PeriodString
   scriptPeriodModifier: PeriodModifierString
   genre: string
+  traditionalReferences: string
   project: keyof typeof ResearchProjects | null
 }>
diff --git a/src/router/bibliographyRoutes.tsx b/src/router/bibliographyRoutes.tsx
index 2c3b58ca1..12a377f1b 100644
--- a/src/router/bibliographyRoutes.tsx
+++ b/src/router/bibliographyRoutes.tsx
@@ -1,24 +1,30 @@
 import React, { ReactNode } from 'react'
-import { Route } from 'react-router-dom'
+import { Redirect, Route } from 'react-router-dom'
 import Bibliography from 'bibliography/ui/Bibliography'
 import BibliographyEditor from 'bibliography/ui/BibliographyEditor'
 import BibliographyService from 'bibliography/application/BibliographyService'
 import { BibliographySlugs, sitemapDefaults } from 'router/sitemap'
 import { HeadTagsService } from 'router/head'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
+import FragmentService from 'fragmentarium/application/FragmentService'
 
 export default function BibliographyRoutes({
   sitemap,
   bibliographyService,
+  afoRegisterService,
+  fragmentService,
   bibliographySlugs,
 }: {
   sitemap: boolean
   bibliographyService: BibliographyService
+  afoRegisterService: AfoRegisterService
+  fragmentService: FragmentService
   bibliographySlugs?: BibliographySlugs
 }): JSX.Element[] {
   return [
     <Route
       key="BibliographyViewerAndEditor"
-      path="/bibliography/:id"
+      path="/bibliography/references/:id"
       render={(props): ReactNode => (
         <HeadTagsService
           title="Bibliography entry: eBL"
@@ -47,17 +53,48 @@ export default function BibliographyRoutes({
       )}
     />,
     <Route
-      key="Bibliography"
-      path="/bibliography"
+      key="Bibliography references search"
+      path="/bibliography/references"
       render={(props): ReactNode => (
         <HeadTagsService
-          title="Bibliography: eBL"
-          description="Bibliography search in the electronic Babylonian Library (eBL)."
+          title="Bibliography References: eBL"
+          description="Bibliography references search in the electronic Babylonian Library (eBL)."
         >
-          <Bibliography bibliographyService={bibliographyService} {...props} />
+          <Bibliography
+            bibliographyService={bibliographyService}
+            afoRegisterService={afoRegisterService}
+            fragmentService={fragmentService}
+            {...props}
+            activeTab={'references'}
+          />
         </HeadTagsService>
       )}
       {...(sitemap && sitemapDefaults)}
     />,
+    <Route
+      key="Bibliography AfO Register search"
+      path="/bibliography/afo-register"
+      render={(props): ReactNode => (
+        <HeadTagsService
+          title="Bibliography AfO Register: eBL"
+          description="AfO Register search in the electronic Babylonian Library (eBL)."
+        >
+          <Bibliography
+            bibliographyService={bibliographyService}
+            afoRegisterService={afoRegisterService}
+            fragmentService={fragmentService}
+            {...props}
+            activeTab={'afo-register'}
+          />
+        </HeadTagsService>
+      )}
+      {...(sitemap && sitemapDefaults)}
+    />,
+    <Redirect
+      from="/bibliography"
+      to="/bibliography/afo-register"
+      key="bibliography-root-redirect"
+      strict={true}
+    />,
   ]
 }
diff --git a/src/router/fragmentariumRoutes.tsx b/src/router/fragmentariumRoutes.tsx
index de8e1fe6d..5ee436e67 100644
--- a/src/router/fragmentariumRoutes.tsx
+++ b/src/router/fragmentariumRoutes.tsx
@@ -21,6 +21,7 @@ import { FragmentSlugs, sitemapDefaults } from 'router/sitemap'
 import { HeadTagsService } from 'router/head'
 import BibliographyService from 'bibliography/application/BibliographyService'
 import { FindspotService } from 'fragmentarium/application/FindspotService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 
 function parseStringParam(location: Location, param: string): string | null {
   const value = parse(location.search)[param]
@@ -54,6 +55,7 @@ export default function FragmentariumRoutes({
   sitemap,
   fragmentService,
   fragmentSearchService,
+  afoRegisterService,
   textService,
   wordService,
   findspotService,
@@ -67,6 +69,7 @@ export default function FragmentariumRoutes({
   textService: TextService
   wordService: WordService
   findspotService: FindspotService
+  afoRegisterService: AfoRegisterService
   signService: SignService
   bibliographyService: BibliographyService
   fragmentSlugs?: FragmentSlugs
@@ -138,6 +141,7 @@ export default function FragmentariumRoutes({
                 fragmentSearchService={fragmentSearchService}
                 wordService={wordService}
                 findspotService={findspotService}
+                afoRegisterService={afoRegisterService}
                 session={session}
                 {...parseFragmentParams(match, location)}
               />
diff --git a/src/router/router.tsx b/src/router/router.tsx
index 6d2837a7a..b4694ac8d 100644
--- a/src/router/router.tsx
+++ b/src/router/router.tsx
@@ -10,6 +10,7 @@ import BibliographyService from 'bibliography/application/BibliographyService'
 import TextService from 'corpus/application/TextService'
 import MarkupService from 'markup/application/MarkupService'
 import SignService from 'signs/application/SignService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 
 import BibliographyRoutes from 'router/bibliographyRoutes'
 import CorpusRoutes from 'router/corpusRoutes'
@@ -32,6 +33,7 @@ export interface Services {
   textService: TextService
   signService: SignService
   markupService: MarkupService
+  afoRegisterService: AfoRegisterService
   findspotService: FindspotService
 }
 
diff --git a/src/router/sitemap.test.tsx b/src/router/sitemap.test.tsx
index 94b9dc6c6..289a6ce6c 100644
--- a/src/router/sitemap.test.tsx
+++ b/src/router/sitemap.test.tsx
@@ -7,6 +7,7 @@ import FragmentService from 'fragmentarium/application/FragmentService'
 import FragmentSearchService from 'fragmentarium/application/FragmentSearchService'
 import TextService from 'corpus/application/TextService'
 import MarkupService from 'markup/application/MarkupService'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 import Bluebird from 'bluebird'
 import { Services } from './router'
 import { saveAs } from 'file-saver'
@@ -47,6 +48,10 @@ beforeEach(() => {
     jest.Mocked<MarkupService>
   >)()
 
+  const afoRegisterService = new (AfoRegisterService as jest.Mock<
+    jest.Mocked<AfoRegisterService>
+  >)()
+
   signService.listAllSigns.mockReturnValue(Bluebird.resolve(['a2']))
   bibliographyService.listAllBibliography.mockReturnValue(
     Bluebird.resolve(['ref1'])
@@ -71,6 +76,7 @@ beforeEach(() => {
     fragmentSearchService: fragmentSearchService,
     textService: textService,
     markupService: markupService,
+    afoRegisterService: afoRegisterService,
   }
 })
 
diff --git a/src/test-support/AppDriver.tsx b/src/test-support/AppDriver.tsx
index 282fb959b..a58ff68ed 100644
--- a/src/test-support/AppDriver.tsx
+++ b/src/test-support/AppDriver.tsx
@@ -28,6 +28,8 @@ import { eblNameProperty, AuthenticationContext } from 'auth/Auth'
 import SignRepository from 'signs/infrastructure/SignRepository'
 import SignService from 'signs/application/SignService'
 import MarkupService from 'markup/application/MarkupService'
+import AfoRegisterRepository from 'afo-register/infrastructure/AfoRegisterRepository'
+import AfoRegisterService from 'afo-register/application/AfoRegisterService'
 import { FindspotService } from 'fragmentarium/application/FindspotService'
 import { ApiFindspotRepository } from 'fragmentarium/infrastructure/FindspotRepository'
 
@@ -54,8 +56,10 @@ function createApp(api): JSX.Element {
     bibliographyService
   )
   const signsRepository = new SignRepository(api)
+  const afoRegisterRepository = new AfoRegisterRepository(api)
   const signService = new SignService(signsRepository)
   const markupService = new MarkupService(api, bibliographyService)
+  const afoRegisterService = new AfoRegisterService(afoRegisterRepository)
   const findspotService = new FindspotService(findspotRepository)
   return (
     <App
@@ -66,6 +70,7 @@ function createApp(api): JSX.Element {
       bibliographyService={bibliographyService}
       textService={textService}
       markupService={markupService}
+      afoRegisterService={afoRegisterService}
       findspotService={findspotService}
     />
   )
diff --git a/src/test-support/afo-register-fixtures.ts b/src/test-support/afo-register-fixtures.ts
new file mode 100644
index 000000000..3544782c5
--- /dev/null
+++ b/src/test-support/afo-register-fixtures.ts
@@ -0,0 +1,72 @@
+import { Factory } from 'fishery'
+import Chance from 'chance'
+import AfoRegisterRecord, {
+  AfoRegisterRecordSuggestion,
+} from 'afo-register/domain/Record'
+
+const chance = new Chance()
+const PUBLICATIONS = [
+  'StOr',
+  'Al.T.',
+  'OECT',
+  'VS',
+  'STT',
+  'CCT',
+  'CM',
+  'CST',
+  'SAAB',
+]
+
+const getRandomPublication = (): string => chance.pickone(PUBLICATIONS)
+
+const getAfoNumber = (): string => `AfO ${chance.integer({ min: 10, max: 52 })}`
+
+const getPage = (): string => `${chance.integer({ min: 1, max: 700 })}`
+
+const getText = (): string =>
+  `${getRandomPublication()}, ${chance.integer({ min: 1, max: 40 })}`
+
+const getTextNumber = (): string =>
+  `Nr. ${chance.integer({ min: 1, max: 300 })}`
+
+const getTextNumbers = (): string[] =>
+  Array.from({ length: chance.integer({ min: 1, max: 15 }) }, getTextNumber)
+
+const getLinesDiscussed = (): string =>
+  `${chance.integer({ min: 1, max: 40 })}f.`
+
+const getDiscussedBy = (): string =>
+  `${chance.last()}, ${getRandomPublication()}, ${chance.integer({
+    min: 1,
+    max: 40,
+  })}, ${chance.integer({ min: 1, max: 50 })}`
+
+const getFragmentNumber = (): string[] =>
+  Array.from(
+    { length: chance.integer({ min: 0, max: 5 }) },
+    () => `${chance.word()}.${chance.natural()}`
+  )
+
+export const afoRegisterRecordFactory = Factory.define<AfoRegisterRecord>(
+  () =>
+    new AfoRegisterRecord({
+      afoNumber: getAfoNumber(),
+      page: getPage(),
+      text: getText(),
+      textNumber: getTextNumber(),
+      linesDiscussed: getLinesDiscussed(),
+      discussedBy: getDiscussedBy(),
+      discussedByNotes: chance.sentence(),
+      fragmentNumbers: getFragmentNumber(),
+    })
+)
+
+export const afoRegisterRecordSuggestionFactory = Factory.define<
+  AfoRegisterRecordSuggestion
+>(
+  () =>
+    new AfoRegisterRecordSuggestion({
+      text: getText(),
+      textNumbers: getTextNumbers().sort(),
+    })
+)
diff --git a/src/test-support/fragment-fixtures.ts b/src/test-support/fragment-fixtures.ts
index 4ec4dab54..728a4259e 100644
--- a/src/test-support/fragment-fixtures.ts
+++ b/src/test-support/fragment-fixtures.ts
@@ -266,6 +266,7 @@ export const fragmentFactory = Factory.define<Fragment>(
       associations.references ??
         referenceFactory.buildList(2, {}, { transient: { chance } }),
       associations.uncuratedReferences ?? null,
+      [],
       '',
       chance.bool(),
       associations.genres ??
diff --git a/src/test-support/test-fragment.ts b/src/test-support/test-fragment.ts
index 4aaf82c1a..04c8f06a5 100644
--- a/src/test-support/test-fragment.ts
+++ b/src/test-support/test-fragment.ts
@@ -388,6 +388,7 @@ export const fragmentDto: FragmentDto = {
     },
   ],
   uncuratedReferences: null,
+  traditionalReferences: [],
   atf:
     '10. sal/: š[im {gu}[...].GA\n10. ::/sal ši]m\n10. šim | šim\n10. ...+ku {KA.G[A} ... ....ku x',
   hasPhoto: true,
@@ -490,6 +491,7 @@ export const fragment = new Fragment(
     ),
   ],
   null,
+  [],
   '10. sal/: š[im {gu}[...].GA\n10. ::/sal ši]m\n10. šim | šim\n10. ...+ku {KA.G[A} ... ....ku x',
   true,
   Genres.fromJson([
diff --git a/src/test-support/utils.ts b/src/test-support/utils.ts
index c84593fa6..759d91170 100644
--- a/src/test-support/utils.ts
+++ b/src/test-support/utils.ts
@@ -162,7 +162,8 @@ export function testDelegation<S>(
 
       it('Returns', async () => {
         if (result instanceof Bluebird || result instanceof Promise) {
-          await expect(result).resolves.toEqual(expectedResult)
+          const resolvedResult = await result
+          await expect(resolvedResult).toEqual(expectedResult)
         } else {
           expect(result).toEqual(expectedResult)
         }