diff --git a/‎packages/core/ui/core/native-updates/native-updates.spec.ts‎
Lines changed: 76 additions & 1 deletion b/‎packages/core/ui/core/native-updates/native-updates.spec.ts‎
Lines changed: 76 additions & 1 deletion
diff --git a/‎packages/core/ui/core/properties/index.ts‎
Lines changed: 26 additions & 6 deletions b/‎packages/core/ui/core/properties/index.ts‎
Lines changed: 26 additions & 6 deletions
diff --git a/‎packages/core/ui/core/properties/native-updates-commit-cost.spec.ts‎
Lines changed: 101 additions & 0 deletions b/‎packages/core/ui/core/properties/native-updates-commit-cost.spec.ts‎
Lines changed: 101 additions & 0 deletions
@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 
 import { View } from '../view';
 import { Style } from '../../styling/style';
@@ -168,6 +168,81 @@ describe('commitNativeUpdates', () => {
 	});
 });
 
+describe('committing without a batch', () => {
+	it('builds no batch for a node whose class can neither order nor observe one', () => {
+		const plain: any = loaded(new TestView());
+		const ordered: any = loaded(new OrderedView());
+		const applyRemaining = vi.spyOn(NativeUpdateBatch.prototype, '_applyRemaining');
+
+		try {
+			plain._batchUpdate(() => {
+				plain.two = 'b';
+				plain.one = 'a';
+			});
+			NativeUpdates.batch(() => {
+				plain.one = 'c';
+			});
+			plain.callUnloaded();
+			plain.two = 'd';
+			plain.flushNativeUpdates({ force: true });
+			plain.callLoaded();
+
+			expect(log).toEqual(['two=b', 'one=a', 'one=c', 'two=d']);
+			expect(applyRemaining).not.toHaveBeenCalled();
+
+			log.length = 0;
+			ordered._batchUpdate(() => {
+				ordered.two = 'b';
+				ordered.one = 'a';
+			});
+
+			expect(log).toEqual(['commit', 'two=b', 'one=a']);
+			expect(applyRemaining).toHaveBeenCalledTimes(1);
+		} finally {
+			applyRemaining.mockRestore();
+		}
+	});
+
+	it('sweeps a mount in the same order the batch path does', () => {
+		function mounted(view: any): string[] {
+			log.length = 0;
+			view.two = 'b';
+			view.style.three = 'c';
+			view.one = 'a';
+			view._setupUI({});
+			view.callLoaded();
+
+			return log.filter((entry) => entry !== 'commit');
+		}
+
+		const withoutBatch = mounted(new TestView());
+		const withBatch = mounted(new OrderedView());
+
+		expect(withoutBatch).toEqual(['two=b', 'one=a', 'three=c']);
+		expect(withBatch).toEqual(withoutBatch);
+	});
+
+	it('sweeps a dirty set in the same order the batch path does', () => {
+		function reloaded(view: any): string[] {
+			loaded(view);
+			view.callUnloaded();
+			view.two = 'b';
+			view.style.three = 'c';
+			view.one = 'a';
+			log.length = 0;
+			view.callLoaded();
+
+			return log.filter((entry) => entry !== 'commit');
+		}
+
+		const withoutBatch = reloaded(new TestView());
+		const withBatch = reloaded(new OrderedView());
+
+		expect(withoutBatch).toEqual(['two=b', 'three=c', 'one=a']);
+		expect(withBatch).toEqual(withoutBatch);
+	});
+});
+
 describe('the batch', () => {
 	function commitOf(view: TestView): NativeUpdateBatch {
 		return view.commits[view.commits.length - 1];
 
@@ -1554,7 +1554,24 @@ function applyNativeUpdate(batch: NativeUpdateBatch, entry: NativeUpdateEntry):
  * `ViewBase.flushNativeUpdates` to push what is pending.
  */
 export const initNativeView = profile('"properties".initNativeView', function initNativeView(view: ViewBase): void {
-	const isMount = view._suspendedUpdates === undefined;
+	const dirty = view._suspendedUpdates;
+	const isMount = dirty === undefined;
+
+	if (view._pendingInvalidations === undefined && view.commitNativeUpdates === defaultCommitNativeUpdates) {
+		// Nothing on this node can reach a batch, so the sweep runs straight off the dirty set,
+		// which is dropped first as on the batch path.
+		view._suspendedUpdates = {};
+		view._pendingPrevious = undefined;
+
+		if (isMount) {
+			applyAllNativeSetters(view);
+		} else {
+			applyDirtyNativeSetters(view, dirty);
+		}
+
+		return;
+	}
+
 	const batch = new NativeUpdateBatch(view, isMount, collectNativeUpdateEntries(view, isMount), view._pendingPrevious, applyNativeUpdate);
 
 	// Dropped before the commit runs so that a write made from a handler queues against a fresh set.
@@ -1612,15 +1629,18 @@ function applyMountedNativeSetter(view: ViewBase, property: PropertyInterface):
  * @deprecated Superseded by `ViewBase.commitNativeUpdates`, which applies the same dirty set
  * through a `NativeUpdateBatch` the class can reorder.
  */
-export function applyPendingNativeSetters(view: ViewBase): void {
+function applyDirtyNativeSetters(view: ViewBase, dirty: ViewBase['_suspendedUpdates']): void {
 	// TODO: Check what happens if a view was suspended and its value was reset, or set back to default!
-	const suspendedUpdates = view._suspendedUpdates;
-	for (const propertyName in suspendedUpdates) {
-		if (!HAS_OWN.call(suspendedUpdates, propertyName)) continue;
-		applyPendingNativeSetter(view, <PropertyInterface>suspendedUpdates[propertyName]);
+	for (const propertyName in dirty) {
+		if (!HAS_OWN.call(dirty, propertyName)) continue;
+		applyPendingNativeSetter(view, <PropertyInterface>dirty[propertyName]);
 	}
 }
 
+export function applyPendingNativeSetters(view: ViewBase): void {
+	applyDirtyNativeSetters(view, view._suspendedUpdates);
+}
+
 /**
  * @deprecated Superseded by `ViewBase.commitNativeUpdates` with a batch whose `isMount` is set.
  */
 
@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+
+import { View } from '../view';
+import { Property } from './index';
+
+/**
+ * What a commit costs per node, where the batch is built. The numbers are printed rather than
+ * asserted - the assertion is only that every pending value arrived.
+ */
+const COMMIT_PROPERTIES = 8;
+const RELOAD_PROPERTIES = 4;
+
+let calls = 0;
+
+class TestView extends View {
+	createNativeView(): Object {
+		return {};
+	}
+
+	public _addViewToNativeVisualTree(): boolean {
+		return true;
+	}
+}
+
+const propertyNames: string[] = [];
+for (let i = 0; i < COMMIT_PROPERTIES; i++) {
+	const property = new Property<TestView, number>({ name: `commit${i}`, defaultValue: -1 });
+	property.register(TestView);
+	(TestView.prototype as any)[property.setNative] = function () {
+		calls++;
+	};
+	propertyNames.push(property.name);
+}
+
+function write(view: any, count: number, value: number): void {
+	for (let i = 0; i < count; i++) {
+		view[propertyNames[i]] = value;
+	}
+}
+
+function loadedView(): any {
+	const view: any = new TestView();
+	view._setupUI({});
+	view.callLoaded();
+
+	return view;
+}
+
+function measure(label: string, iterations: number, unit: string, callsEach: number, run: (iterations: number) => void): void {
+	run(Math.max(1, Math.round(iterations / 10)));
+
+	calls = 0;
+	const started = performance.now();
+	run(iterations);
+	const elapsed = performance.now() - started;
+
+	console.log(`commit ${label}: ${iterations} ${unit} in ${elapsed.toFixed(1)}ms (${((elapsed * 1000) / iterations).toFixed(2)}us each)`);
+	expect(calls).toBe(callsEach * iterations);
+}
+
+describe('commit cost', () => {
+	it('loads views carrying pending properties', () => {
+		measure('load', 2000, 'views', COMMIT_PROPERTIES, (iterations) => {
+			for (let i = 0; i < iterations; i++) {
+				const view: any = new TestView();
+				write(view, COMMIT_PROPERTIES, i);
+				view._setupUI({});
+				view.callLoaded();
+			}
+		});
+	});
+
+	it('reloads views written to while unloaded', () => {
+		const views: any[] = [];
+		for (let i = 0; i < 2200; i++) {
+			views.push(loadedView());
+		}
+		let next = 0;
+
+		measure('reload', 2000, 'views', RELOAD_PROPERTIES, (iterations) => {
+			for (let i = 0; i < iterations; i++) {
+				const view = views[next++ % views.length];
+				view.callUnloaded();
+				write(view, RELOAD_PROPERTIES, i);
+				view.callLoaded();
+			}
+		});
+	});
+
+	it('commits batched writes on a live view', () => {
+		const view = loadedView();
+
+		measure('_batchUpdate', 5000, 'batches', COMMIT_PROPERTIES, (iterations) => {
+			for (let i = 0; i < iterations; i++) {
+				view._batchUpdate(() => {
+					write(view, COMMIT_PROPERTIES, i);
+				});
+			}
+		});
+	});
+});