@@ -0,0 +1,3 @@
+https://github.com/WordPress/wordpress-develop/pull/13412
+
+* https://github.com/WordPress/gutenberg/pull/81947
@@ -1740,6 +1740,21 @@ public function finalize_item( WP_REST_Request $request ) {
 			$response_request['_fields'] = $request['_fields'];
 		}
 
+		/*
+		 * Re-read the post. The 'wp_generate_attachment_metadata' filter above
+		 * runs long after $post was fetched, and a callback that rewrites the
+		 * post row - an optimizer changing post_mime_type once it has
+		 * converted the file, say - would otherwise be missing from this
+		 * response. The editor stores the response as its copy of the record
+		 * rather than reading the attachment again, so a stale row here is
+		 * what it keeps. A callback that deleted the attachment instead leaves
+		 * nothing to respond with, so that is reported as the error it is.
+		 */
+		$post = $this->get_post( $attachment_id );
+		if ( is_wp_error( $post ) ) {
+			return $post;
+		}
+
 		return $this->prepare_item_for_response( $post, $response_request );
 	}
 
 
@@ -53,6 +53,7 @@
 -   Device Preview: Center the editor canvas with the canvas container's own flex alignment rather than the canvas's auto margins, which were conditional on the resize handles being active. Switching from the mobile or tablet preview back to desktop no longer expands the canvas from the left edge ([#81484](https://github.com/WordPress/gutenberg/pull/81484)).
 -   `PostSchedule`: Announce the new publish date to screen readers when the date is changed ([#81629](https://github.com/WordPress/gutenberg/pull/81629)).
 -   Start page/template pattern modals: Align the footer actions with the modal content's padding, so the footer no longer overflows the modal width ([#82021](https://github.com/WordPress/gutenberg/pull/82021)).
+-   Media: Store the attachment record returned by the `finalize` endpoint instead of refetching the attachment once a client-side upload completes. The finalize response is prepared after the sub-size metadata is written, so it already carries `media_details.sizes`; the refetch it replaces could be answered with the pre-finalize record - by an out-of-order response, or by a host cache keyed on the request URL - leaving the Image block without its Resolution control ([#81947](https://github.com/WordPress/gutenberg/pull/81947)).
 
 ### Internal
 
 
@@ -1,5 +1,6 @@
 import apiFetch from '@wordpress/api-fetch';
 import { transformAttachment } from '@wordpress/media-utils';
+import { receiveFinalizedAttachment } from '../media-upload/finalized-attachments';
 
 export default async function mediaFinalize( id, subSizes = [] ) {
 	const response = await apiFetch( {
@@ -8,7 +9,19 @@ export default async function mediaFinalize( id, subSizes = [] ) {
 		data: { sub_sizes: subSizes },
 	} );
 
+	if ( ! response ) {
+		return undefined;
+	}
+
+	// The finalize response is the attachment as prepared after its sub-size
+	// metadata was written, so it is the record the editor should be holding.
+	// Storing it here means the upload does not have to fetch the attachment
+	// again to pick the sizes up - a refetch that can be served the pre-finalize
+	// record either by an out-of-order response or by a host cache keyed on the
+	// request URL. See https://github.com/WordPress/gutenberg/issues/81844.
+	receiveFinalizedAttachment( response );
+
 	// Returning the post-finalize attachment lets callers refresh the block
 	// URL (via onChange) so it points at the scaled file and srcset matches.
-	return response ? transformAttachment( response ) : undefined;
+	return transformAttachment( response );
 }
@@ -1,11 +1,16 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import apiFetch from '@wordpress/api-fetch';
 import mediaFinalize from '..';
+import { receiveFinalizedAttachment } from '../../media-upload/finalized-attachments';
 
 vi.mock( import( '@wordpress/api-fetch' ), () => ( {
 	default: vi.fn(),
 } ) );
 
+vi.mock( import( '../../media-upload/finalized-attachments' ), () => ( {
+	receiveFinalizedAttachment: vi.fn(),
+} ) );
+
 const mockRestAttachment = {
 	id: 123,
 	alt_text: '',
@@ -81,4 +86,30 @@ describe( 'mediaFinalize', () => {
 
 		await expect( mediaFinalize( 456 ) ).rejects.toThrow( 'Network error' );
 	} );
+
+	it( 'should store the finalize response as the attachment record', async () => {
+		// The finalize response is the attachment as prepared after its
+		// sub-size metadata was written, so it is what the editor should hold.
+		// Receiving it here is what removes the need to fetch the attachment
+		// again just to pick the generated sizes up.
+		const finalized = {
+			...mockRestAttachment,
+			media_details: { sizes: { thumbnail: {} } },
+		};
+		apiFetch.mockResolvedValue( finalized );
+
+		await mediaFinalize( 123 );
+
+		// The untransformed record: core-data holds REST records, and
+		// transformAttachment renames fields for block consumers.
+		expect( receiveFinalizedAttachment ).toHaveBeenCalledWith( finalized );
+	} );
+
+	it( 'should store nothing when the response is empty', async () => {
+		apiFetch.mockResolvedValue( undefined );
+
+		await mediaFinalize( 123 );
+
+		expect( receiveFinalizedAttachment ).not.toHaveBeenCalled();
+	} );
 } );
@@ -0,0 +1,70 @@
+import { dispatch } from '@wordpress/data';
+import { store as coreDataStore } from '@wordpress/core-data';
+import type { Attachment } from '@wordpress/core-data';
+
+/**
+ * The queries the editor resolves an attachment record with.
+ *
+ * Blocks read the record either as `getEntityRecord( 'postType', 'attachment',
+ * id, { context: 'view' } )` or without a query at all, and resolution state is
+ * keyed on the exact arguments, so both have to be addressed.
+ */
+const ATTACHMENT_QUERIES = [ { context: 'view' }, undefined ];
+
+/**
+ * IDs of attachments whose finalized record has already been received.
+ *
+ * An entry is consumed by `mediaUploadOnSuccess`, which then has nothing left
+ * to refetch for that attachment.
+ */
+const finalized = new Set< number >();
+
+/**
+ * Stores the attachment record returned by the `finalize` endpoint.
+ *
+ * `finalize` is the server's commit point for a client-side upload: it writes
+ * the sub-size metadata collected from the sideloads and returns the attachment
+ * as prepared *after* that write, so its `media_details.sizes` is the finished
+ * set of generated sizes. Storing that response is what makes the editor's copy
+ * of the record current, so `mediaUploadOnSuccess` has nothing left to
+ * invalidate for it.
+ *
+ * The record is received under both queries the editor resolves attachments
+ * with. It is prepared in the `edit` context, which for an attachment carries
+ * every field the `view` context does plus a few edit-only ones, so it also
+ * satisfies a consumer reading the `view` record.
+ *
+ * @param record Attachment record as returned by the `finalize` endpoint.
+ */
+export function receiveFinalizedAttachment(
+	record: Partial< Attachment >
+): void {
+	if ( ! record?.id ) {
+		return;
+	}
+
+	const { receiveEntityRecords } = dispatch( coreDataStore );
+
+	for ( const query of ATTACHMENT_QUERIES ) {
+		/*
+		 * Passing the record on its own rather than in an array keeps this a
+		 * single-item receive, which leaves list queries (the media library,
+		 * the inserter's Media tab) untouched.
+		 */
+		receiveEntityRecords( 'postType', 'attachment', record, query );
+	}
+
+	finalized.add( record.id );
+}
+
+/**
+ * Reports whether a finalized record has been received for an attachment,
+ * forgetting it in the process.
+ *
+ * @param id Attachment ID.
+ *
+ * @return Whether the editor already holds the finalized record.
+ */
+export function consumeFinalizedAttachment( id: number ): boolean {
+	return finalized.delete( id );
+}
@@ -1,31 +1,39 @@
 import { dispatch } from '@wordpress/data';
 import { store as coreDataStore } from '@wordpress/core-data';
+import { consumeFinalizedAttachment } from './finalized-attachments';
 
 /**
- * Invalidates core-data entity records for uploaded attachments so that
- * blocks re-fetch updated data (e.g. `media_details.sizes` after
- * thumbnails have been generated via client-side media processing).
+ * Brings core-data's copy of an uploaded attachment up to date, so that blocks
+ * see the data the server produced after the upload itself (e.g.
+ * `media_details.sizes`, once the sub-sizes have been generated).
+ *
+ * A client-side upload ends with a `finalize` request whose response already
+ * carries the finished record, and that response has been stored by then, so
+ * there is nothing left to fetch. An upload the server processed on its own
+ * never goes through `finalize`, so its record is invalidated and refetched.
  *
  * @param {Object[]} attachments Array of attachment objects from the upload queue.
  */
 export default function mediaUploadOnSuccess( attachments ) {
 	const { invalidateResolution } = dispatch( coreDataStore );
 	for ( const attachment of attachments ) {
-		if ( attachment.id ) {
-			// Invalidate with and without the query argument, since
-			// resolution keys must exactly match the args used by
-			// each consumer's getEntityRecord() call.
-			invalidateResolution( 'getEntityRecord', [
-				'postType',
-				'attachment',
-				attachment.id,
-				{ context: 'view' },
-			] );
-			invalidateResolution( 'getEntityRecord', [
-				'postType',
-				'attachment',
-				attachment.id,
-			] );
+		if ( ! attachment.id || consumeFinalizedAttachment( attachment.id ) ) {
+			continue;
 		}
+
+		// Invalidate with and without the query argument, since
+		// resolution keys must exactly match the args used by
+		// each consumer's getEntityRecord() call.
+		invalidateResolution( 'getEntityRecord', [
+			'postType',
+			'attachment',
+			attachment.id,
+			{ context: 'view' },
+		] );
+		invalidateResolution( 'getEntityRecord', [
+			'postType',
+			'attachment',
+			attachment.id,
+		] );
 	}
 }
@@ -0,0 +1,114 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Mock } from 'vitest';
+import type { Attachment } from '@wordpress/core-data';
+import { dispatch } from '@wordpress/data';
+import {
+	receiveFinalizedAttachment,
+	consumeFinalizedAttachment,
+} from '../finalized-attachments';
+
+vi.mock( import( '@wordpress/data' ), () => ( {
+	dispatch: vi.fn(),
+} ) );
+
+vi.mock(
+	import( '@wordpress/core-data' ),
+	() =>
+		( {
+			store: 'core',
+		} ) as unknown as typeof import('@wordpress/core-data')
+);
+
+const receiveEntityRecords = vi.fn();
+
+describe( 'receiveFinalizedAttachment', () => {
+	beforeEach( () => {
+		vi.clearAllMocks();
+		( dispatch as unknown as Mock ).mockReturnValue( {
+			receiveEntityRecords,
+		} );
+	} );
+
+	afterEach( () => {
+		// Leave no entry behind for the next test.
+		consumeFinalizedAttachment( 123 );
+	} );
+
+	it( 'receives the record under both queries the editor resolves attachments with', () => {
+		const record: Partial< Attachment > = {
+			id: 123,
+			media_details: {
+				sizes: {
+					full: {
+						file: 'image.jpg',
+						width: 1024,
+						height: 768,
+						mime_type: 'image/jpeg',
+						source_url: 'https://example.com/image.jpg',
+					},
+				},
+			},
+		};
+
+		receiveFinalizedAttachment( record );
+
+		expect( receiveEntityRecords ).toHaveBeenCalledTimes( 2 );
+		expect( receiveEntityRecords ).toHaveBeenCalledWith(
+			'postType',
+			'attachment',
+			record,
+			{ context: 'view' }
+		);
+		expect( receiveEntityRecords ).toHaveBeenCalledWith(
+			'postType',
+			'attachment',
+			record,
+			undefined
+		);
+	} );
+
+	it( 'receives the record on its own, so list queries are left alone', () => {
+		// core-data only merges an item list into a query's results when the
+		// received items are an array; a lone record must stay a lone record.
+		receiveFinalizedAttachment( { id: 123 } );
+
+		for ( const call of receiveEntityRecords.mock.calls ) {
+			expect( Array.isArray( call[ 2 ] ) ).toBe( false );
+		}
+	} );
+
+	it( 'ignores a response without an ID', () => {
+		receiveFinalizedAttachment( {} );
+		receiveFinalizedAttachment(
+			undefined as unknown as Partial< Attachment >
+		);
+
+		expect( receiveEntityRecords ).not.toHaveBeenCalled();
+	} );
+} );
+
+describe( 'consumeFinalizedAttachment', () => {
+	beforeEach( () => {
+		vi.clearAllMocks();
+		( dispatch as unknown as Mock ).mockReturnValue( {
+			receiveEntityRecords,
+		} );
+	} );
+
+	it( 'reports an attachment whose finalized record was received', () => {
+		receiveFinalizedAttachment( { id: 456 } );
+
+		expect( consumeFinalizedAttachment( 456 ) ).toBe( true );
+	} );
+
+	it( 'reports an attachment that was never finalized', () => {
+		expect( consumeFinalizedAttachment( 789 ) ).toBe( false );
+	} );
+
+	it( 'forgets the attachment once consumed, so a later upload is not skipped', () => {
+		receiveFinalizedAttachment( { id: 456 } );
+
+		expect( consumeFinalizedAttachment( 456 ) ).toBe( true );
+		expect( consumeFinalizedAttachment( 456 ) ).toBe( false );
+	} );
+} );
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+https://github.com/WordPress/wordpress-develop/pull/13412`
	`2`	`+`
	`3`	`+* https://github.com/WordPress/gutenberg/pull/81947`