@@ -233,17 +233,23 @@ afterEach(async () => {
 })
 
 describe('loaded rich editor lifecycle', () => {
-  it.each(['paste', 'drop'] as const)(
-    '%s uploads a standalone display-only image from another document',
-    async (method) => {
+  it.each([
+    { method: 'paste', caption: false },
+    { method: 'drop', caption: false },
+    { method: 'paste', caption: true },
+    { method: 'drop', caption: true },
+  ] as const)(
+    '$method uploads a display-only image from another document (caption: $caption)',
+    async ({ method, caption }) => {
       await render('before TARGET after')
       const editor = getEditor()
       await act(async () => editor.commands.setTextSelection({ from: 8, to: 14 }))
       if (method === 'drop')
         vi.spyOn(editor.view, 'posAtCoords').mockReturnValue({ pos: 8, inside: 0 })
       const src = '/api/workspaces/another-workspace/files/inline?fileId=another-image'
       const image = new File(['image'], 'image.png', { type: 'image/png' })
-      const html = `<img src="${window.location.origin}${src}">`
+      const img = `<img src="${window.location.origin}${src}" alt="Original" width="140">`
+      const html = caption ? `<p>Caption<a href="/destination">${img}</a></p><p>Tail</p>` : img
       uploadFile.mockResolvedValueOnce({ file: { url: '/api/files/view/uploaded-image' } })
       const event = new MouseEvent(method, { bubbles: true, cancelable: true })
       Object.defineProperty(event, method === 'paste' ? 'clipboardData' : 'dataTransfer', {
@@ -263,11 +269,19 @@ describe('loaded rich editor lifecycle', () => {
       })
       expect(editor.getMarkdown()).toContain('/api/files/view/uploaded-image')
       expect(editor.getMarkdown()).not.toContain('/inline?')
-      const storedSrc = editor.getJSON().content?.find((node) => node.type === 'image')?.attrs?.src
+      let storedSrc = ''
+      editor.state.doc.descendants((node) => {
+        if (node.type.name === 'image' || node.type.name === 'inlineImage')
+          storedSrc = node.attrs.src
+      })
       expect(extractEmbeddedFileRef(storedSrc)).toEqual({ fileId: 'uploaded-image' })
       expect(editor.state.doc.textContent).toBe(
-        method === 'paste' ? 'before  after' : 'before TARGET after'
+        `before ${caption ? 'CaptionTail' : ''}${method === 'paste' ? '' : 'TARGET'} after`
       )
+      expect(editor.view.dom.querySelector('img')?.getAttribute('alt')).toBe('Original')
+      expect(editor.getMarkdown()).toContain('width="140"')
+      if (caption)
+        expect(editor.view.dom.querySelector('a')?.getAttribute('href')).toBe('/destination')
     }
   )
 
 
@@ -82,6 +82,51 @@ async function submit(
 }
 
 describe('field upload completion boundary', () => {
+  it.each(['paste', 'drop'] as const)(
+    '%s uploads a non-portable image without losing its accompanying fragment',
+    async (method) => {
+      const pending = Promise.withResolvers<{ url: string; alt: string }>()
+      upload.mockReturnValueOnce(pending.promise)
+      await render()
+      const owner = editor()
+      const before = owner.getJSON()
+      await act(async () => owner.commands.setTextSelection({ from: 8, to: 14 }))
+      if (method === 'drop')
+        vi.spyOn(owner.view, 'posAtCoords').mockReturnValue({ pos: 8, inside: 0 })
+      const html =
+        '<p>Lead</p><h2>Caption</h2><p><a href="/destination"><img src="/api/workspaces/source/files/inline?fileId=image" alt="Original alt" width="123"></a><strong>Tail</strong><img src="/other.png" alt="Other"></p>'
+      const event = new MouseEvent(method, { bubbles: true, cancelable: true })
+      Object.defineProperty(event, method === 'paste' ? 'clipboardData' : 'dataTransfer', {
+        value: {
+          files: [new File(['image'], 'image.png', { type: 'image/png' })],
+          items: [],
+          types: ['Files', 'text/html'],
+          getData: (type: string) => (type === 'text/html' ? html : ''),
+        },
+      })
+      await act(async () => owner.view.dom.dispatchEvent(event))
+      expect(upload).toHaveBeenCalledOnce()
+      expect(owner.getJSON()).toEqual(before)
+      await act(async () => owner.commands.insertContentAt(1, 'prefix '))
+      await act(async () => pending.resolve({ url: '/api/files/view/uploaded', alt: 'New alt' }))
+      expect(owner.state.doc.textContent).toBe(
+        method === 'paste'
+          ? 'prefix before LeadCaptionTail after'
+          : 'prefix before LeadCaptionTailTARGET after'
+      )
+      expect(host.querySelector('h2')?.textContent).toBe('Caption')
+      expect(host.querySelector('strong')?.textContent).toBe('Tail')
+      expect(host.querySelector('a')?.getAttribute('href')).toBe('/destination')
+      expect(
+        Array.from(host.querySelectorAll('img')).map((image) => image.getAttribute('src'))
+      ).toEqual(['/api/files/view/uploaded', '/other.png'])
+      expect(host.querySelector('img')?.getAttribute('alt')).toBe('Original alt')
+      expect(owner.getMarkdown()).toContain('width="123"')
+      expect(owner.getMarkdown()).not.toContain('/inline?')
+      expect(() => owner.state.doc.check()).not.toThrow()
+    }
+  )
+
   it('replaces the selected range only after a pasted image finishes uploading', async () => {
     const pending = Promise.withResolvers<{ url: string; alt: string }>()
     upload.mockReturnValueOnce(pending.promise)
 
@@ -7,7 +7,9 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createMarkdownEditorExtensions } from '@/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/editor-extensions'
 import {
   extractImageFiles,
+  getImageFileFallback,
   normalizePastedImageSources,
+  resolveImageFileFallback,
   toSameOriginPath,
 } from '@/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/image-paste'
 
@@ -98,6 +100,42 @@ describe('normalizePastedImageSources', () => {
     }
   }
 
+  it.each([
+    'blob:https://editor.example/temporary-image',
+    '/api/workspaces/source/files/inline?fileId=image',
+    '/api/files/public/share/inline?fileId=image',
+  ])('resolves a bitmap for repeated non-portable images inside a complete fragment: %s', (src) => {
+    withEditor((editor, parse) => {
+      const html = (source: string) =>
+        `<h2>Heading <img src="${source}" width="120" alt="First"></h2><p><a href="/destination"><img src="${source}" width="240" alt="Second"></a>Caption<img src="/other.png"></p>`
+      const slice = parse(html(src))
+      const fallback = getImageFileFallback(slice, [imageFile()])
+      expect(fallback).not.toBeNull()
+      expect(fallback?.source).toBe(src)
+      expect(
+        resolveImageFileFallback(fallback!, '/api/files/view/uploaded').eq(
+          parse(html('/api/files/view/uploaded'))
+        )
+      ).toBe(true)
+      expect(editor.state.doc.textContent).toContain('Existing')
+    })
+  })
+
+  it('does not associate bitmap bytes with an ambiguous source or file ordering', () => {
+    withEditor((_editor, parse) => {
+      const twoSources = parse(
+        '<p><img src="blob:https://editor.example/a"><img src="blob:https://editor.example/b"></p>'
+      )
+      expect(getImageFileFallback(twoSources, [imageFile()])).toBeNull()
+      expect(
+        getImageFileFallback(twoSources, [imageFile('one.png'), imageFile('two.png')])
+      ).toBeNull()
+      expect(
+        getImageFileFallback(parse('<p>Caption<img src="/portable.png"></p>'), [imageFile()])
+      ).toBeNull()
+    })
+  })
+
   it('preserves the full fragment, image attributes, links and open boundaries', () => {
     withEditor((editor, parse) => {
       const html = (src: string) =>
 
@@ -17,14 +17,14 @@ function runtimeOrigin(): string {
   return typeof window === 'undefined' ? '' : window.location.origin
 }
 
-/** A native image copy can carry bytes for a display URL that cannot survive sharing or reload. */
-export function needsImageFileFallback(slice: Slice, files: readonly File[]): boolean {
-  if (files.length !== 1 || slice.content.childCount !== 1) return false
-  let node = slice.content.firstChild!
-  if (node.type.name === 'paragraph' && node.childCount === 1) node = node.firstChild!
-  if (!isImageNode(node) || typeof node.attrs.src !== 'string') return false
+export interface ImageFileFallback {
+  slice: Slice
+  source: string
+}
+
+function isNonPortableImageSource(src: string): boolean {
   try {
-    const url = new URL(node.attrs.src, runtimeOrigin() || 'http://placeholder')
+    const url = new URL(src, runtimeOrigin() || 'http://placeholder')
     return (
       url.protocol === 'blob:' ||
       /^\/api\/(?:workspaces\/[^/]+\/files|files\/public\/[^/]+)\/inline$/.test(url.pathname)
@@ -34,6 +34,30 @@ export function needsImageFileFallback(slice: Slice, files: readonly File[]): bo
   }
 }
 
+/** Associate a single attached bitmap with its source, without guessing a multi-file ordering. */
+export function getImageFileFallback(
+  slice: Slice,
+  files: readonly File[]
+): ImageFileFallback | null {
+  if (files.length !== 1) return null
+  const sources = new Set<string>()
+  slice.content.descendants((node) => {
+    if (
+      isImageNode(node) &&
+      typeof node.attrs.src === 'string' &&
+      isNonPortableImageSource(node.attrs.src)
+    ) {
+      sources.add(node.attrs.src)
+    }
+  })
+  return sources.size === 1 ? { slice, source: sources.values().next().value! } : null
+}
+
+/** Replace the uploaded image's source while retaining the original fragment and node attributes. */
+export function resolveImageFileFallback(fallback: ImageFileFallback, uploadedSrc: string): Slice {
+  return mapImageSources(fallback.slice, (src) => (src === fallback.source ? uploadedSrc : src))
+}
+
 /** Normalize native clipboard URLs against the actual page origin, never another host. */
 export function toSameOriginPath(src: string, origin = runtimeOrigin()): string | null {
   try {
@@ -70,14 +94,20 @@ export function normalizePastedImageSources(
     const path = toSameOriginPath(resolved, origin)
     if (path) sources.set(path, node.attrs.src)
   })
+  return mapImageSources(slice, (source) => {
+    const path = toSameOriginPath(source, origin)
+    return (path && (sources.get(path) ?? (extractEmbeddedFileRef(path) ? path : null))) || source
+  })
+}
+
+function mapImageSources(slice: Slice, map: (src: string) => string): Slice {
   let changed = false
   const normalize = (fragment: Fragment): Fragment => {
     const children: Node[] = []
     fragment.forEach((node) => {
       if (isImageNode(node) && typeof node.attrs.src === 'string') {
-        const path = toSameOriginPath(node.attrs.src, origin)
-        const src = path && (sources.get(path) ?? (extractEmbeddedFileRef(path) ? path : null))
-        if (src && src !== node.attrs.src) {
+        const src = map(node.attrs.src)
+        if (src !== node.attrs.src) {
           changed = true
           children.push(node.type.create({ ...node.attrs, src }, node.content, node.marks))
         } else children.push(node)
 
@@ -2,7 +2,8 @@
 import { Editor } from '@tiptap/core'
 import Collaboration from '@tiptap/extension-collaboration'
 import { undoDepth } from '@tiptap/pm/history'
-import { afterEach, describe, expect, it } from 'vitest'
+import { DOMParser } from '@tiptap/pm/model'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import * as Y from 'yjs'
 import { createMarkdownContentExtensions } from '@/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/extensions'
 import {
@@ -13,6 +14,7 @@ import {
   ImageUploadPlaceholders,
   removeImageUpload,
 } from '@/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/image-upload'
+import { createRichMarkdownPasteAdmission } from '@/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/paste-admission'
 
 let editor: Editor
 afterEach(() => editor?.destroy())
@@ -26,6 +28,33 @@ function mount(content = '<p>abcd</p>') {
 }
 
 describe('image upload anchors', () => {
+  it('rechecks the paste budget when an uploaded fragment completes after intervening edits', () => {
+    const rejected = vi.fn()
+    editor = new Editor({
+      extensions: [
+        ...createMarkdownContentExtensions(),
+        ImageUploadPlaceholders,
+        createRichMarkdownPasteAdmission({
+          maxResultBytes: 100,
+          maxResultCharacters: 100,
+          getCurrentText: () => editor.getMarkdown(),
+          onRejected: rejected,
+        }),
+      ],
+      content: '<p>Seed</p>',
+    })
+    const [id] = beginImageUploads(editor, { from: 5, to: 5 }, ['image'])
+    editor.commands.insertContentAt(1, 'x'.repeat(70))
+    const before = editor.getJSON()
+    const container = document.createElement('div')
+    container.innerHTML = '<p>Pasted caption <img src="/new.png"></p>'
+    const fragment = DOMParser.fromSchema(editor.schema).parseSlice(container)
+    expect(finishImageUpload(editor, id, '/new.png', 'image', fragment)).toBe(false)
+    expect(rejected).toHaveBeenCalledWith('paste')
+    expect(editor.getJSON()).toEqual(before)
+    expect(findImageUpload(editor, id)).toBeNull()
+  })
+
   it.each([false, true])(
     'safely cancels an anchor replaced by a peer update (unrelated paragraph=%s)',
     (unrelated) => {
 
@@ -156,29 +156,42 @@ export function removeImageUpload(editor: Editor, id: string): void {
 }
 
 /**
- * Commit one image at its surviving range. The first successful image replaces the captured content;
+ * Commit uploaded content at its surviving range. The first successful upload replaces the captured content;
  * its queued siblings become insertion anchors after it. Cancellation and failure never delete text.
  */
-export function finishImageUpload(editor: Editor, id: string, src: string, alt: string): boolean {
+export function finishImageUpload(
+  editor: Editor,
+  id: string,
+  src: string,
+  alt: string,
+  fragment?: Slice
+): boolean {
   if (editor.isDestroyed) return false
   const upload = uploadPlaceholderKey.getState(editor.state)?.uploads.get(id)
   if (!upload) return false
   if (!editor.isEditable) {
     removeImageUpload(editor, id)
     return false
   }
-  const inserted = editor
+  const ran = editor
     .chain()
-    .insertContentAt(
-      { from: upload.from, to: upload.to },
-      { type: imageTypeAt(editor.state.doc, upload.from), attrs: { src, alt } },
-      { updateSelection: false }
-    )
+    .command(({ tr, commands }) => {
+      if (fragment) {
+        tr.replaceRange(upload.from, upload.to, fragment).setMeta('uiEvent', 'paste')
+        return true
+      }
+      return commands.insertContentAt(
+        { from: upload.from, to: upload.to },
+        { type: imageTypeAt(editor.state.doc, upload.from), attrs: { src, alt } },
+        { updateSelection: false }
+      )
+    })
     .command(({ tr }) => {
       tr.setMeta(uploadPlaceholderKey, { complete: id } satisfies UploadPlaceholderAction)
       return true
     })
     .run()
+  const inserted = ran && findImageUpload(editor, id) === null
   if (!inserted) removeImageUpload(editor, id)
   return inserted
 }