@airalogy/aimd-renderer 2.6.0 → 2.8.0

package/src/__tests__/renderer.test.ts

@@ -1,4 +1,7 @@
-import { describe, expect, it } from 'vitest'
+import { existsSync, readFileSync } from 'node:fs'
+import { mount } from '@vue/test-utils'
+import { h } from 'vue'
+import { describe, expect, it, vi } from 'vitest'
 
 import { resolveQuizPreviewOptions } from '../common/quiz-preview'
 import {
@@ -9,8 +12,18 @@ import {
   createRenderer,
 } from '../common/processor'
 import { getFinalIndent, parseFieldTag } from '../index'
+import {
+  createReadonlyRecordRenderContext,
+  normalizeRecordRenderValue,
+  renderReadonlyRecordToVue,
+} from '../vue/readonly-record-renderer'
 import { createCodeBlockRenderer, createStepCardRenderer } from '../vue/vue-renderer'
 
+const rendererStylesPath = existsSync('src/styles/katex.css')
+  ? 'src/styles/katex.css'
+  : 'packages/npm/aimd-renderer/src/styles/katex.css'
+const rendererStyles = readFileSync(rendererStylesPath, 'utf8')
+
 function findVNodeByType(node: any, expectedType: string): any | null {
   if (!node || typeof node !== 'object') {
     return null
@@ -36,6 +49,37 @@ function findVNodeByType(node: any, expectedType: string): any | null {
   return null
 }
 
+function findVNodeByClass(node: any, expectedClass: string): any | null {
+  if (!node || typeof node !== 'object') {
+    return null
+  }
+
+  const className = node.props?.class
+  const classes = Array.isArray(className)
+    ? className
+    : typeof className === 'string'
+      ? className.split(/\s+/)
+      : []
+  if (classes.includes(expectedClass)) {
+    return node
+  }
+
+  const children = Array.isArray(node.children)
+    ? node.children
+    : Array.isArray(node.component?.subTree?.children)
+      ? node.component.subTree.children
+      : []
+
+  for (const child of children) {
+    const match = findVNodeByClass(child, expectedClass)
+    if (match) {
+      return match
+    }
+  }
+
+  return null
+}
+
 function collectVNodeText(node: any): string {
   if (node == null) {
     return ''
@@ -194,12 +238,183 @@ describe('renderToHtmlSync', () => {
     expect(html).toContain('Hello')
   })
 
+  it('renders CriticMarkup review marks to semantic HTML', () => {
+    const { html } = renderToHtmlSync('Add {++new++}, delete {--old--}, replace {~~old~>new~~}, comment {>>check units<<}, highlight {==important==}.')
+
+    expect(html).toContain('<ins class="aimd-critic aimd-critic--addition"')
+    expect(html).toContain('data-critic-kind="addition"')
+    expect(html).toContain('<del class="aimd-critic aimd-critic--deletion"')
+    expect(html).toContain('data-critic-kind="deletion"')
+    expect(html).toContain('<span class="aimd-critic aimd-critic--substitution"')
+    expect(html).toContain('aimd-critic--substitution-old')
+    expect(html).toContain('aimd-critic--substitution-new')
+    expect(html).toContain('<span class="aimd-critic aimd-critic--comment"')
+    expect(html).toContain('check units')
+    expect(html).toContain('<mark class="aimd-critic aimd-critic--highlight"')
+    expect(html).toContain('important')
+    expect(html).not.toContain('{++new++}')
+    expect(html).not.toContain('{--old--}')
+    expect(html).not.toContain('{~~old~>new~~}')
+    expect(html).not.toContain('{>>check units<<}')
+    expect(html).not.toContain('{==important==}')
+  })
+
+  it('does not parse CriticMarkup inside inline code', () => {
+    const { html } = renderToHtmlSync('Literal `{++not a mark++}` and `{~~old~>new~~}` remain code.')
+
+    expect(html).toContain('<code>{++not a mark++}</code>')
+    expect(html).toContain('<code>{~~old~>new~~}</code>')
+    expect(html).not.toContain('aimd-critic--addition')
+    expect(html).not.toContain('aimd-critic--substitution')
+  })
+
   it('renders AIMD var fields', () => {
     const { html, fields } = renderToHtmlSync('{{var|temperature}}')
     expect(fields.var).toContain('temperature')
     expect(html).toContain('temperature')
   })
 
+  it('resolves figure asset URLs during HTML rendering', () => {
+    const seenContexts: Array<{ src: string, kind: string, id?: string, title?: string }> = []
+    const { html } = renderToHtmlSync([
+      '```fig',
+      'id: workflow_diagram',
+      'src: files/workflow-diagram.svg',
+      'title: Workflow Diagram',
+      '```',
+    ].join('\n'), {
+      resolveAssetUrl: (src, context) => {
+        seenContexts.push({ src, ...context })
+        return `/assets/${src.split('/').pop()}`
+      },
+    })
+
+    expect(seenContexts).toEqual([{
+      src: 'files/workflow-diagram.svg',
+      kind: 'fig',
+      id: 'workflow_diagram',
+      title: 'Workflow Diagram',
+    }])
+    expect(html).toContain('src="/assets/workflow-diagram.svg"')
+  })
+
+  it('renders internal references without route-breaking bare hash hrefs', () => {
+    const { html } = renderToHtmlSync([
+      'As shown in {{ref_fig|workflow_diagram}}, follow {{ref_step|prepare_sample}}.',
+      '',
+      '```fig',
+      'id: workflow_diagram',
+      'src: files/workflow-diagram.svg',
+      'title: Workflow Diagram',
+      '```',
+      '',
+      '{{step|prepare_sample}}',
+    ].join('\n'))
+
+    expect(html).not.toContain('href="#fig-workflow_diagram"')
+    expect(html).not.toContain('href="#step-prepare_sample"')
+    expect(html).toContain('<span class="aimd-ref aimd-ref--fig"')
+    expect(html).toContain('data-aimd-ref-target="workflow_diagram"')
+    expect(html).toContain('data-aimd-ref-kind="fig"')
+    expect(html).toContain('<span class="aimd-ref aimd-ref--step"')
+    expect(html).toContain('data-aimd-ref-target="prepare_sample"')
+    expect(html).toContain('data-aimd-ref-kind="step"')
+  })
+
+  it('styles rendered figures as attached image-caption blocks', () => {
+    expect(rendererStyles).toMatch(/\.aimd-figure \{[\s\S]*?width: fit-content;/)
+    expect(rendererStyles).toMatch(/\.aimd-figure \{[\s\S]*?overflow: hidden;/)
+    expect(rendererStyles).not.toContain('box-shadow: 0 10px 28px')
+    expect(rendererStyles).toMatch(/\.aimd-figure__caption \{[\s\S]*?border-top: 1px solid #d8e2ef;/)
+    expect(rendererStyles).toMatch(/\.aimd-figure__legend \{[\s\S]*?margin: 4px 0 0;/)
+  })
+
+  it('styles citation popovers as selectable hoverable content', () => {
+    expect(rendererStyles).toContain('.aimd-cite__popover')
+    expect(rendererStyles).not.toContain('.aimd-cite__ref::after')
+    expect(rendererStyles).toMatch(/\.aimd-cite__popover \{[\s\S]*?pointer-events: none;/)
+    expect(rendererStyles).toMatch(/\.aimd-cite__popover \{[\s\S]*?user-select: text;/)
+    expect(rendererStyles).toMatch(/\.aimd-cite__popover::before \{[\s\S]*?height: 10px;/)
+    expect(rendererStyles).toMatch(/\.aimd-cite__ref:hover \.aimd-cite__popover,[\s\S]*?pointer-events: auto;/)
+  })
+
+  it('styles internal references as focusable route-safe targets', () => {
+    expect(rendererStyles).toMatch(/\.aimd-ref\[data-aimd-ref-target\] \{[\s\S]*?cursor: pointer;/)
+    expect(rendererStyles).toMatch(/\.aimd-ref\[data-aimd-ref-target\]:focus-visible \{[\s\S]*?outline: 2px solid rgba\(25, 118, 210, 0\.36\);/)
+  })
+
+  it('renders citation markers with reference tooltips and refs blocks', () => {
+    const content = [
+      'Cite the method {{cite|yang2025airalogyaiempowereduniversaldata, doe2024protocol}}.',
+      '',
+      '```refs',
+      '@misc{yang2025airalogyaiempowereduniversaldata,',
+      '      title={Airalogy: AI-empowered universal data digitization for research automation},',
+      '      author={Zijie Yang and Qiji Zhou and Fang Guo and Sijie Zhang and Yexun Xi and Jinglei Nie and Yudian Zhu and Liping Huang and Chou Wu and Yonghe Xia and Xiaoyu Ma and Yingming Pu and Panzhong Lu and Junshu Pan and Mingtao Chen and Tiannan Guo and Yanmei Dou and Hongyu Chen and Anping Zeng and Jiaxing Huang and Tian Xu and Yue Zhang},',
+      '      year={2025},',
+      '      eprint={2506.18586},',
+      '      archivePrefix={arXiv},',
+      '      primaryClass={cs.AI},',
+      '      url={https://arxiv.org/abs/2506.18586},',
+      '}',
+      '',
+      '@misc{doe2024protocol,',
+      '  title = "Protocol Notes",',
+      '  author = "Doe, Jane",',
+      '  year = "2024",',
+      '  url = "https://example.com/protocol"',
+      '}',
+      '```',
+    ].join('\n')
+
+    const { html, fields } = renderToHtmlSync(content)
+
+    expect(fields.cite).toEqual(['yang2025airalogyaiempowereduniversaldata', 'doe2024protocol'])
+    expect(fields.refs?.[0]).toMatchObject({
+      id: 'yang2025airalogyaiempowereduniversaldata',
+      entry_type: 'misc',
+      title: 'Airalogy: AI-empowered universal data digitization for research automation',
+      url: 'https://arxiv.org/abs/2506.18586',
+    })
+    expect(fields.refs?.[1]).toMatchObject({
+      id: 'doe2024protocol',
+      url: 'https://example.com/protocol',
+    })
+    expect(html).not.toContain('href="#ref-yang2025airalogyaiempowereduniversaldata"')
+    expect(html).not.toContain('href="#ref-doe2024protocol"')
+    expect(html).toContain('role="doc-noteref"')
+    expect(html).toContain('data-aimd-ref-id="yang2025airalogyaiempowereduniversaldata"')
+    expect(html).toContain('data-aimd-ref-summary="Zijie Yang')
+    expect(html).toContain('data-aimd-citation-labels="1,2"')
+    expect(html).toContain('<span class="aimd-cite__label">1</span>')
+    expect(html).toContain('<span class="aimd-cite__label">2</span>')
+    expect(html).toContain('<span class="aimd-cite__popover" role="tooltip">Zijie Yang')
+    expect(html).not.toContain('<span class="aimd-cite__label">yang2025airalogyaiempowereduniversaldata</span>')
+    expect(html).toContain('<section class="aimd-refs"')
+    expect(html).toContain('id="ref-yang2025airalogyaiempowereduniversaldata"')
+    expect(html).toContain('Airalogy: AI-empowered universal data digitization for research automation')
+    expect(html).toContain('href="https://arxiv.org/abs/2506.18586"')
+    expect(html).toContain('href="https://example.com/protocol"')
+  })
+
+  it('moves refs blocks to the end of the rendered document', () => {
+    const content = [
+      '```refs',
+      '@misc{doe2024protocol,',
+      '  title = "Protocol Notes",',
+      '  author = "Doe, Jane",',
+      '  year = "2024"',
+      '}',
+      '```',
+      '',
+      'The body continues after the refs declaration.',
+    ].join('\n')
+
+    const { html } = renderToHtmlSync(content)
+
+    expect(html.indexOf('<p>The body continues after the refs declaration.</p>')).toBeLessThan(html.indexOf('<section class="aimd-refs"'))
+  })
+
   it('renders AIMD var field display metadata', () => {
     const { html, fields } = renderToHtmlSync('{{var|record_date: str, title="Record date", description="ISO date", examples=["2026-05-26", "2026-05-27"]}}')
     expect(fields.var_definitions?.[0]?.title).toBe('Record date')
@@ -405,6 +620,120 @@ describe('renderToHtmlSync', () => {
 })
 
 describe('renderToVue', () => {
+  it('renders references as Vue nodes', async () => {
+    const { nodes } = await renderToVue(
+      [
+        'Cite {{cite|yang2025airalogyaiempowereduniversaldata}}.',
+        '',
+        '```refs',
+        '@misc{yang2025airalogyaiempowereduniversaldata,',
+        '      title={Airalogy: AI-empowered universal data digitization for research automation},',
+        '      author={Zijie Yang and Qiji Zhou and Fang Guo and Sijie Zhang and Yexun Xi and Jinglei Nie and Yudian Zhu and Liping Huang and Chou Wu and Yonghe Xia and Xiaoyu Ma and Yingming Pu and Panzhong Lu and Junshu Pan and Mingtao Chen and Tiannan Guo and Yanmei Dou and Hongyu Chen and Anping Zeng and Jiaxing Huang and Tian Xu and Yue Zhang},',
+        '      year={2025},',
+        '      eprint={2506.18586},',
+        '      archivePrefix={arXiv},',
+        '      primaryClass={cs.AI},',
+        '      url={https://arxiv.org/abs/2506.18586},',
+        '}',
+        '```',
+      ].join('\n'),
+    )
+
+    const refsNode = nodes
+      .map(node => findVNodeByType(node, 'section'))
+      .find(Boolean) as any
+    const citeNode = nodes
+      .map(node => findVNodeByClass(node, 'aimd-cite'))
+      .find(Boolean) as any
+
+    expect(refsNode).toBeTruthy()
+    expect(refsNode.props.class).toBe('aimd-refs')
+    expect(refsNode.props.id).toBe('refs')
+    expect(citeNode).toBeTruthy()
+    const citeRefNode = findVNodeByClass(citeNode, 'aimd-cite__ref') as any
+    const citeLabelNode = findVNodeByClass(citeNode, 'aimd-cite__label') as any
+    const citePopoverNode = findVNodeByClass(citeNode, 'aimd-cite__popover') as any
+    expect(citeRefNode.type).toBe('span')
+    expect(citeRefNode.props.href).toBeUndefined()
+    expect(citeRefNode.props['data-aimd-ref-summary']).toContain('Airalogy: AI-empowered universal data digitization for research automation')
+    expect(collectVNodeText(citeLabelNode).trim()).toBe('1')
+    expect(citePopoverNode.type).toBe('span')
+    expect(citePopoverNode.props.role).toBe('tooltip')
+    expect(collectVNodeText(citePopoverNode)).toContain('Airalogy: AI-empowered universal data digitization for research automation')
+    expect(collectVNodeText(nodes)).toContain('References')
+    expect(collectVNodeText(nodes)).toContain('Airalogy: AI-empowered universal data digitization for research automation')
+    expect(collectVNodeText(citeNode)).not.toContain('yang2025airalogyaiempowereduniversaldata')
+  })
+
+  it('resolves figure asset URLs during Vue rendering', async () => {
+    const { nodes } = await renderToVue([
+      '```fig',
+      'id: workflow_diagram',
+      'src: files/workflow-diagram.svg',
+      'title: Workflow Diagram',
+      '```',
+    ].join('\n'), {
+      resolveAssetUrl: (src, context) => {
+        expect(context).toMatchObject({
+          kind: 'fig',
+          id: 'workflow_diagram',
+          title: 'Workflow Diagram',
+        })
+        return `/assets/${src.split('/').pop()}`
+      },
+    })
+
+    const img = findVNodeByType({ children: nodes }, 'img') as any
+    expect(img).toBeTruthy()
+    expect(img.props.src).toBe('/assets/workflow-diagram.svg')
+  })
+
+  it('renders Vue figure references as route-safe internal markers', async () => {
+    const { nodes } = await renderToVue([
+      'As shown in {{ref_fig|workflow_diagram}}.',
+      '',
+      '```fig',
+      'id: workflow_diagram',
+      'src: files/workflow-diagram.svg',
+      'title: Workflow Diagram',
+      '```',
+    ].join('\n'))
+
+    const figRefNode = findVNodeByClass({ children: nodes }, 'aimd-ref--fig') as any
+    expect(figRefNode).toBeTruthy()
+    expect(figRefNode.type).toBe('span')
+    expect(figRefNode.props.href).toBeUndefined()
+    expect(figRefNode.props['data-aimd-ref-target']).toBe('workflow_diagram')
+    expect(figRefNode.props['data-aimd-ref-kind']).toBe('fig')
+    expect(figRefNode.props.tabindex).toBe(0)
+  })
+
+  it('moves refs Vue nodes to the end of the rendered document', async () => {
+    const { nodes } = await renderToVue(
+      [
+        '```refs',
+        '@misc{doe2024protocol,',
+        '  title = "Protocol Notes",',
+        '  author = "Doe, Jane",',
+        '  year = "2024"',
+        '}',
+        '```',
+        '',
+        'The body continues after the refs declaration.',
+      ].join('\n'),
+    )
+
+    const rootChildren = Array.isArray((nodes[0] as any)?.children)
+      ? (nodes[0] as any).children
+      : nodes
+    const refsIndex = rootChildren.findIndex((node: any) => Boolean(findVNodeByClass(node, 'aimd-refs')))
+    const bodyIndex = rootChildren.findIndex((node: any) => collectVNodeText(node).includes('The body continues after the refs declaration.'))
+
+    expect(bodyIndex).toBeGreaterThanOrEqual(0)
+    expect(refsIndex).toBeGreaterThanOrEqual(0)
+    expect(bodyIndex).toBeLessThan(refsIndex)
+  })
+
   it('renders code blocks with line numbers and wrapping classes', async () => {
     const { nodes } = await renderToVue(
       '```json\n{\n  "model":"qwen3.6-flash","enable_search":true\n}\n```',
@@ -543,6 +872,212 @@ describe('renderToVue', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// readonly record rendering
+// ---------------------------------------------------------------------------
+
+describe('readonly record rendering', () => {
+  it('normalizes bare record data and full record payload wrappers', () => {
+    expect(normalizeRecordRenderValue({
+      var: { sample_id: { value: 'S-001' } },
+      step: { prepare: { checked: true } },
+      var_table: {
+        samples: [{ sample_id: 'S-001' }],
+      },
+    })).toEqual({
+      var: { sample_id: { value: 'S-001' } },
+      step: { prepare: { checked: true } },
+      check: {},
+      quiz: {},
+      var_table: {
+        samples: [{ sample_id: 'S-001' }],
+      },
+    })
+
+    expect(normalizeRecordRenderValue({
+      record_id: 'rec-001',
+      data: {
+        var: { sample_id: 'S-002' },
+        quiz: { qc: ['A', 'B'] },
+      },
+    })).toEqual({
+      var: { sample_id: 'S-002' },
+      var_table: {},
+      step: {},
+      check: {},
+      quiz: { qc: ['A', 'B'] },
+    })
+  })
+
+  it('creates an edit-mode readonly render context for record-backed documents', () => {
+    const context = createReadonlyRecordRenderContext(
+      { data: { var: { sample_id: 'S-003' } } },
+      { quizPreview: { showAnswers: true } },
+    )
+
+    expect(context.mode).toBe('edit')
+    expect(context.readonly).toBe(true)
+    expect(context.quizPreview).toEqual({ showAnswers: true })
+    expect(context.value?.var.sample_id).toBe('S-003')
+  })
+
+  it('renders record values into AIMD fields without enabling input editing', async () => {
+    const { nodes } = await renderReadonlyRecordToVue(
+      [
+        'Sample {{var|sample_id: str}}',
+        '',
+        '{{check|prepared}} Prepared.',
+      ].join('\n'),
+      {
+        data: {
+          var: { sample_id: { value: 'S-004' } },
+          check: { prepared: { checked: true } },
+        },
+      },
+      {
+        groupCheckBodies: true,
+      },
+    )
+
+    expect(collectVNodeText(nodes)).toContain('S-004')
+    expect(collectVNodeText(nodes)).not.toContain('sample_id')
+    const input = findVNodeByType({ children: nodes }, 'input') as any
+    expect(input).toBeTruthy()
+    expect(input.props.checked).toBe(true)
+    expect(input.props.disabled).toBe(true)
+  })
+
+  it('shows readable missing labels only when record values are absent', async () => {
+    const { nodes } = await renderReadonlyRecordToVue(
+      'Sample {{var|sample_id: str, title="Sample ID"}}',
+      {
+        data: {
+          var: {},
+        },
+      },
+    )
+
+    expect(collectVNodeText(nodes)).toContain('Missing')
+    expect(collectVNodeText(nodes)).toContain('Sample ID')
+    const missing = findVNodeByType({ children: nodes }, 'span') as any
+    expect(missing.props.title).toContain('data.var.sample_id')
+  })
+
+  it('renders file-backed image fields with resolved assets', async () => {
+    const { nodes } = await renderReadonlyRecordToVue(
+      'Site photo: {{var|site_photo: FileIdPNG}}',
+      {
+        data: {
+          var: {
+            site_photo: 'airalogy.id.file.site-photo.png',
+          },
+        },
+      },
+      {
+        resolveAsset: context => context.fileId === 'airalogy.id.file.site-photo.png'
+          ? {
+              url: 'blob:site-photo',
+              filename: 'site-photo.png',
+              mimeType: 'image/png',
+            }
+          : null,
+      },
+    )
+
+    const img = findVNodeByType({ children: nodes }, 'img') as any
+    expect(img).toBeTruthy()
+    expect(img.props.src).toBe('blob:site-photo')
+    expect(img.props.alt).toBe('site-photo.png')
+  })
+
+  it('renders manifest-resolved file fields even when the protocol did not declare FileId type', async () => {
+    const { nodes } = await renderReadonlyRecordToVue(
+      'Attachment: {{var|sample_file}}',
+      {
+        data: {
+          var: {
+            sample_file: 'airalogy.id.file.sample-note.txt',
+          },
+        },
+      },
+      {
+        resolveAsset: context => context.fieldPath === 'data.var.sample_file'
+          ? {
+              href: 'blob:sample-note',
+              filename: 'sample-note.txt',
+              mimeType: 'text/plain',
+            }
+          : null,
+      },
+    )
+
+    const link = findVNodeByType({ children: nodes }, 'a') as any
+    expect(link).toBeTruthy()
+    expect(link.props.href).toBe('blob:sample-note')
+    expect(collectVNodeText(link)).toContain('sample-note.txt')
+  })
+
+  it('resolves markdown image elements through readonly record assets', async () => {
+    const { nodes } = await renderReadonlyRecordToVue(
+      '![Calibration chart](airalogy.id.file.chart.svg)',
+      { data: { var: {} } },
+      {
+        resolveAsset: context => context.fileId === 'airalogy.id.file.chart.svg'
+          ? {
+              url: 'blob:chart',
+              filename: 'chart.svg',
+              mimeType: 'image/svg+xml',
+            }
+          : null,
+      },
+    )
+
+    const img = findVNodeByType({ children: nodes }, 'img') as any
+    expect(img).toBeTruthy()
+    expect(img.props.src).toBe('blob:chart')
+    expect(img.props.alt).toBe('Calibration chart')
+  })
+
+  it('renders AiralogyMarkdown record values through the AIMD Vue renderer', async () => {
+    const { nodes } = await renderReadonlyRecordToVue(
+      'Report:\n\n{{var|report: AiralogyMarkdown}}',
+      {
+        data: {
+          var: {
+            report: [
+              '# Finding',
+              '',
+              '![Chart](airalogy.id.file.chart.svg)',
+              '',
+              'Nested token: {{var|nested: str, title="Nested value"}}',
+            ].join('\n'),
+          },
+        },
+      },
+      {
+        resolveAsset: context => context.fileId === 'airalogy.id.file.chart.svg'
+          ? {
+              url: 'blob:chart',
+              filename: 'chart.svg',
+              mimeType: 'image/svg+xml',
+            }
+          : null,
+      },
+    )
+
+    const wrapper = mount({
+      render: () => h('div', nodes),
+    })
+
+    await vi.waitFor(() => {
+      expect(wrapper.find('.aimd-record-field--markdown h1').text()).toBe('Finding')
+      expect(wrapper.find('.aimd-record-field--markdown img').attributes('src')).toBe('blob:chart')
+    })
+    expect(wrapper.find('.aimd-record-field--markdown').text()).toContain('Nested value')
+    wrapper.unmount()
+  })
+})
+
 // ---------------------------------------------------------------------------
 // createRenderer
 // ---------------------------------------------------------------------------

package/src/common/assetUrls.ts

@@ -0,0 +1,22 @@
+export interface AimdAssetUrlResolveContext {
+  kind: "fig"
+  id?: string
+  title?: string
+}
+
+export type AimdAssetUrlResolver = (
+  src: string,
+  context: AimdAssetUrlResolveContext,
+) => string | null | undefined
+
+export function resolveAimdAssetUrl(
+  src: string | undefined,
+  resolver: AimdAssetUrlResolver | undefined,
+  context: AimdAssetUrlResolveContext,
+): string | undefined {
+  if (!src || !resolver) {
+    return src
+  }
+
+  return resolver(src, context) || src
+}