diff --git a/apps/benchmarks/scripts/run-presentation-demo-probe.mts b/apps/benchmarks/scripts/run-presentation-demo-probe.mts
index 672935e0..606ad547 100644
--- a/apps/benchmarks/scripts/run-presentation-demo-probe.mts
+++ b/apps/benchmarks/scripts/run-presentation-demo-probe.mts
@@ -37,7 +37,7 @@ try {
   });
   page.on('pageerror', (error) => consoleProblems.push(`pageerror: ${error.message}`));
   await page.goto(
-    `http://127.0.0.1:${String(address.port)}/presentation?mode=benchmark&technique=mtsdf&backend=webgpu&delivery=baked&dpr=1&font=inter&workload=off-axis-3d`,
+    `http://127.0.0.1:${String(address.port)}/presentation?mode=benchmark&technique=mtsdf&backend=webgpu&delivery=baked&dpr=2&font=inter&workload=off-axis-3d`,
     { waitUntil: 'domcontentloaded' },
   );
 
diff --git a/apps/benchmarks/scripts/run-presentation-workload-probe.mts b/apps/benchmarks/scripts/run-presentation-workload-probe.mts
index ff0e2b35..ee685237 100644
--- a/apps/benchmarks/scripts/run-presentation-workload-probe.mts
+++ b/apps/benchmarks/scripts/run-presentation-workload-probe.mts
@@ -66,7 +66,7 @@ const presentationSamplePeriodMs = 300;
 let browser: Browser | undefined;
 try {
   browser = await launchProjectChromium({
-    headless: false,
+    headless: true,
     args: ['--enable-gpu', '--ignore-gpu-blocklist', '--enable-unsafe-webgpu'],
   });
   const page = await browser.newPage({ viewport: { width: 1_280, height: 720 } });
@@ -77,7 +77,7 @@ try {
   });
   page.on('pageerror', (error) => consoleProblems.push(`pageerror: ${error.message}`));
   await page.goto(
-    `http://127.0.0.1:${String(address.port)}/presentation?mode=benchmark&technique=${technique}&backend=webgpu&delivery=baked&dpr=1&font=inter&workload=text-ladder`,
+    `http://127.0.0.1:${String(address.port)}/presentation?mode=benchmark&technique=${technique}&backend=webgpu&delivery=baked&dpr=2&font=inter&workload=text-ladder`,
     { waitUntil: 'domcontentloaded' },
   );
   const workloadControl = page.getByLabel('Live workload', { exact: true });
@@ -95,9 +95,58 @@ try {
     );
   });
   await page.evaluate(() => {
-    const scope = globalThis as typeof globalThis & { presentationProbeCanvas: Element | undefined };
-    scope.presentationProbeCanvas =
-      document.querySelector('canvas[data-configured-renderer-active="true"]') ?? undefined;
+    const canvas = document.querySelector<HTMLCanvasElement>('canvas[data-configured-renderer-active="true"]');
+    const scope = globalThis as typeof globalThis & {
+      presentationProbeCanvas: HTMLCanvasElement | undefined;
+      presentationProbeCanvasEvidence: CanvasEvidence | undefined;
+      presentationProbeCanvasEvents: string[];
+      presentationProbeInputEvents: string[];
+    };
+    scope.presentationProbeCanvas = canvas ?? undefined;
+    if (canvas === null) {
+      scope.presentationProbeCanvasEvidence = undefined;
+    } else {
+      const bounds = canvas.getBoundingClientRect();
+      scope.presentationProbeCanvasEvidence = {
+        backingHeight: canvas.height,
+        backingWidth: canvas.width,
+        connected: canvas.isConnected,
+        cssHeight: bounds.height,
+        cssWidth: bounds.width,
+      };
+    }
+    scope.presentationProbeCanvasEvents = [];
+    scope.presentationProbeInputEvents = [];
+    document.addEventListener(
+      'click',
+      (event) => {
+        const target = event.target instanceof Element ? event.target : undefined;
+        scope.presentationProbeInputEvents.push(
+          `${performance.now().toFixed(1)}ms click ${target?.getAttribute('aria-label') ?? target?.textContent?.trim().slice(0, 80) ?? 'unknown'}`,
+        );
+      },
+      { capture: true },
+    );
+    if (canvas !== null) {
+      new MutationObserver((records) => {
+        for (const record of records) {
+          scope.presentationProbeCanvasEvents.push(
+            `${performance.now().toFixed(1)}ms attribute ${record.attributeName ?? 'unknown'} ${record.oldValue ?? 'null'} -> ${canvas.getAttribute(record.attributeName ?? '') ?? 'null'}`,
+          );
+        }
+      }).observe(canvas, { attributeFilter: ['height', 'width'], attributeOldValue: true, attributes: true });
+      new ResizeObserver(() => {
+        const bounds = canvas.getBoundingClientRect();
+        scope.presentationProbeCanvasEvents.push(
+          `${performance.now().toFixed(1)}ms css ${String(bounds.width)}x${String(bounds.height)}`,
+        );
+      }).observe(canvas);
+      new MutationObserver(() => {
+        if (!canvas.isConnected) {
+          scope.presentationProbeCanvasEvents.push(`${performance.now().toFixed(1)}ms disconnected`);
+        }
+      }).observe(document.documentElement, { childList: true, subtree: true });
+    }
   });
 
   for (const workload of workloads) {
@@ -139,6 +188,37 @@ try {
       throw new Error(`${workload.id} did not retain exactly one configured renderer`);
     }
   }
+  if (technique === 'bitmap') {
+    const dprMenu = page.getByRole('button', { name: 'Device pixel ratio: 2×', exact: true });
+    await dprMenu.click();
+    await page
+      .getByRole('button', { name: '1×', exact: true })
+      .evaluate((element) => (element as HTMLButtonElement).click());
+    await page.waitForFunction(() => new URLSearchParams(location.search).get('dpr') === '1');
+    await assertCanvasHandoff(page, 'DPR 2→1');
+    await page.getByRole('button', { name: 'Device pixel ratio: 1×', exact: true }).click();
+    await page
+      .getByRole('button', { name: '2×', exact: true })
+      .evaluate((element) => (element as HTMLButtonElement).click());
+    await page.waitForFunction(() => new URLSearchParams(location.search).get('dpr') === '2');
+    await assertCanvasHandoff(page, 'DPR 1→2');
+
+    const mtsdfControl = page.getByRole('button', { name: 'MSDF', exact: true });
+    await mtsdfControl.evaluate((element) => (element as HTMLButtonElement).click());
+    await page.waitForFunction(() => {
+      const viewport = document.querySelector<HTMLElement>('[data-testid="comparison-live-viewport"]');
+      return viewport?.dataset.technique === 'mtsdf' && viewport.dataset.presentationPending === 'false';
+    });
+    await assertCanvasHandoff(page, 'Bitmap→MTSDF');
+    await page
+      .getByRole('button', { name: 'Bitmap', exact: true })
+      .evaluate((element) => (element as HTMLButtonElement).click());
+    await page.waitForFunction(() => {
+      const viewport = document.querySelector<HTMLElement>('[data-testid="comparison-live-viewport"]');
+      return viewport?.dataset.technique === 'bitmap' && viewport.dataset.presentationPending === 'false';
+    });
+    await assertCanvasHandoff(page, 'MTSDF→Bitmap');
+  }
   if (consoleProblems.length > 0) {
     throw new Error(`Presentation emitted browser warnings or errors: ${consoleProblems.join(' | ')}`);
   }
@@ -151,6 +231,24 @@ try {
   await server.close();
 }
 
+async function assertCanvasHandoff(page: Page, label: string): Promise<void> {
+  const evidence = await page.evaluate(() => {
+    const scope = globalThis as typeof globalThis & {
+      presentationProbeCanvas: HTMLCanvasElement | undefined;
+      presentationProbeCanvasEvents: string[];
+    };
+    const current = document.querySelector('canvas[data-configured-renderer-active="true"]');
+    return {
+      disconnected: scope.presentationProbeCanvasEvents.some((event) => event.endsWith('disconnected')),
+      rendererCount: Number(document.documentElement.dataset.activeConfiguredRenderers),
+      retained: current !== null && current === scope.presentationProbeCanvas && current.isConnected,
+    };
+  });
+  if (!evidence.retained || evidence.disconnected || evidence.rendererCount !== 1) {
+    throw new Error(`${label} did not retain one continuously attached renderer canvas: ${JSON.stringify(evidence)}`);
+  }
+}
+
 function presentationTechnique(value: string | undefined): 'bitmap' | 'mtsdf' | 'slug' {
   if (value === undefined || value === 'mtsdf') return 'mtsdf';
   if (value === 'bitmap' || value === 'slug') return value;
@@ -159,19 +257,41 @@ function presentationTechnique(value: string | undefined): 'bitmap' | 'mtsdf' |
 
 async function assertPresentationRemainsVisible(page: Page, workload: string): Promise<void> {
   const minimumRequiredInkPixels = workload === 'zoom-text' ? 32 : 300;
-  let minimumVisibleInkPixels = Number.POSITIVE_INFINITY;
-  let sample = 0;
   const startedAt = await page.evaluate(() => performance.now());
   while (true) {
-    const screenshot = await page.screenshot();
-    const visibleInkPixels = await visiblePresentationInkPixels(page, screenshot.toString('base64'));
-    minimumVisibleInkPixels = Math.min(minimumVisibleInkPixels, visibleInkPixels);
-    if (visibleInkPixels < minimumRequiredInkPixels) {
-      await page.screenshot({ path: `/tmp/pmndrs-text-presentation-${workload}-blank-${String(sample)}.png` });
-      throw new Error(
-        `${workload} rendered only ${String(visibleInkPixels)} visible foreground pixels at sample ${String(sample)}`,
-      );
-    }
+    const canvasFailure = await page.evaluate(() => {
+      const scope = globalThis as typeof globalThis & {
+        presentationProbeCanvas: HTMLCanvasElement | undefined;
+        presentationProbeCanvasEvidence: CanvasEvidence | undefined;
+        presentationProbeCanvasEvents: string[];
+        presentationProbeInputEvents: string[];
+      };
+      const canvas = document.querySelector<HTMLCanvasElement>('canvas[data-configured-renderer-active="true"]');
+      const expected = scope.presentationProbeCanvasEvidence;
+      if (canvas === null || expected === undefined) return 'the configured renderer canvas is missing';
+      if (canvas !== scope.presentationProbeCanvas) return 'the configured renderer canvas identity changed';
+      const bounds = canvas.getBoundingClientRect();
+      const actual: CanvasEvidence = {
+        backingHeight: canvas.height,
+        backingWidth: canvas.width,
+        connected: canvas.isConnected,
+        cssHeight: bounds.height,
+        cssWidth: bounds.width,
+      };
+      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        const navigationStatus =
+          document.querySelector<HTMLElement>('[data-testid="canvas-navigation-status"]')?.textContent ?? 'missing';
+        return `the canvas dimensions changed from ${JSON.stringify(expected)} to ${JSON.stringify(actual)}; browser DPR ${String(devicePixelRatio)}; URL ${location.search}; status ${navigationStatus.trim()}; canvas events ${scope.presentationProbeCanvasEvents.slice(-12).join(' | ')}; input events ${scope.presentationProbeInputEvents.slice(-12).join(' | ')}`;
+      }
+      const rendererCount = Number(document.documentElement.dataset.activeConfiguredRenderers);
+      if (rendererCount !== 1) return `the active renderer count changed to ${String(rendererCount)}`;
+      const viewport = document.querySelector<HTMLElement>('[data-testid="comparison-live-viewport"]');
+      if (Number(viewport?.dataset.glyphCount) <= 0 || Number(viewport?.dataset.drawCount) <= 0) {
+        return 'the active workload stopped publishing glyphs or draw calls';
+      }
+      return undefined;
+    });
+    if (canvasFailure !== undefined) throw new Error(`${workload}: ${canvasFailure}`);
     const elapsedMs = await page.evaluate((start) => performance.now() - start, startedAt);
     if (elapsedMs >= presentationIntervalMs) break;
     const nextSampleAt = startedAt + Math.min(presentationIntervalMs, elapsedMs + presentationSamplePeriodMs);
@@ -186,9 +306,24 @@ async function assertPresentationRemainsVisible(page: Page, workload: string): P
         }),
       nextSampleAt,
     );
-    sample += 1;
   }
-  console.log('presentation-workload-visible', workload, minimumVisibleInkPixels);
+
+  // Full-page capture can perturb a hardware-composited canvas on some Chromium/macOS combinations. Keep cadence
+  // monitoring capture-free, then take one bounded headless proof after the workload has survived the interval.
+  const screenshot = await page.screenshot();
+  const visibleInkPixels = await visiblePresentationInkPixels(page, screenshot.toString('base64'));
+  if (visibleInkPixels < minimumRequiredInkPixels) {
+    throw new Error(`${workload} rendered only ${String(visibleInkPixels)} visible foreground pixels`);
+  }
+  console.log('presentation-workload-visible', workload, visibleInkPixels);
+}
+
+interface CanvasEvidence {
+  readonly backingHeight: number;
+  readonly backingWidth: number;
+  readonly connected: boolean;
+  readonly cssHeight: number;
+  readonly cssWidth: number;
 }
 
 async function visiblePresentationInkPixels(page: Page, screenshotBase64: string): Promise<number> {
diff --git a/apps/benchmarks/src/app.tsx b/apps/benchmarks/src/app.tsx
index 0063c176..44e07e77 100644
--- a/apps/benchmarks/src/app.tsx
+++ b/apps/benchmarks/src/app.tsx
@@ -1392,7 +1392,6 @@ function Scene({
         presentationPreset={presentationPreset}
         showLayoutBounds={showLayoutBounds}
         workloadAmount={workloadAmount}
-        key={`${location.mode}-${location.backend}-${location.delivery}-${String(dpr)}`}
         showcaseFrame={showcaseFrame}
         stats={liveStats}
         technique={location.technique}
@@ -1593,6 +1592,7 @@ function BenchmarkSurface({
         animationSpeed={animationSpeed}
         backend={backend}
         delivery={delivery}
+        demoMode={demoMode}
         suppressLoading={demoMode || presentation === 'presentation'}
         dpr={dpr}
         fontSize={fontSize}
@@ -3574,6 +3574,7 @@ function ComparisonWorkloadViewport({
   animationSpeed,
   backend,
   delivery,
+  demoMode,
   dpr,
   fontFixture,
   fontSize,
@@ -3596,6 +3597,7 @@ function ComparisonWorkloadViewport({
   readonly animationSpeed: number;
   readonly backend: GraphicsBackend;
   readonly delivery: FontDelivery;
+  readonly demoMode: boolean;
   readonly dpr: 1 | 2;
   readonly fontFixture: BenchmarkFontFixture;
   readonly fontSize: number;
@@ -3650,6 +3652,7 @@ function ComparisonWorkloadViewport({
       paintStrokeWidth,
       showGrid: grid,
       showLayoutBounds,
+      textLadderExitEnabled: demoMode && workload === 'text-ladder',
       workload,
     }),
   );
@@ -3728,6 +3731,7 @@ function ComparisonWorkloadViewport({
     animationEnabled,
     animationSpeed,
     dpr,
+    demoMode,
     fontFixture,
     fontSize,
     layoutWidthRatio,
diff --git a/apps/benchmarks/src/benchmark/advanced-shaping.test.ts b/apps/benchmarks/src/benchmark/advanced-shaping.test.ts
index 87a0b7f4..2e39e189 100644
--- a/apps/benchmarks/src/benchmark/advanced-shaping.test.ts
+++ b/apps/benchmarks/src/benchmark/advanced-shaping.test.ts
@@ -197,6 +197,9 @@ describe('advanced-shaping timeline', () => {
         missingGlyphCount: 0,
         renderedGlyphCount: 625,
         drawCount: 72,
+        coldReadyObservationCount: 5,
+        warmLifecyclePublicationCount: 63,
+        warmReadyWaitCount: 0,
       },
     };
     expect(scenario.validate([measurement])).toContain('68 frames/sample');
diff --git a/apps/benchmarks/src/benchmark/package-size-budgets.ts b/apps/benchmarks/src/benchmark/package-size-budgets.ts
index 6fbca223..2693f644 100644
--- a/apps/benchmarks/src/benchmark/package-size-budgets.ts
+++ b/apps/benchmarks/src/benchmark/package-size-budgets.ts
@@ -1,9 +1,9 @@
 export const packageSizeBudgets = {
   'browser-core': {
-    rawBytes: 333_000,
-    minifiedBytes: 253_000,
-    gzipBytes: 74_000,
-    brotliBytes: 57_000,
+    rawBytes: 341_000,
+    minifiedBytes: 258_000,
+    gzipBytes: 75_000,
+    brotliBytes: 57_500,
   },
   'font-validator-js': {
     rawBytes: 741_000,
diff --git a/apps/benchmarks/src/benchmark/package-sizes.test.ts b/apps/benchmarks/src/benchmark/package-sizes.test.ts
index 24986d68..3b56b844 100644
--- a/apps/benchmarks/src/benchmark/package-sizes.test.ts
+++ b/apps/benchmarks/src/benchmark/package-sizes.test.ts
@@ -68,10 +68,10 @@ describe('independent package-size report', () => {
   it('bounds the accepted coverage-capability growth from its pre-coverage baseline', () => {
     const coverageGrowth = {
       'browser-core': {
-        rawBytes: { baseline: 324_269, maximumGrowth: 7_900 },
-        minifiedBytes: { baseline: 247_205, maximumGrowth: 5_400 },
-        gzipBytes: { baseline: 72_108, maximumGrowth: 1_300 },
-        brotliBytes: { baseline: 55_251, maximumGrowth: 1_050 },
+        rawBytes: { baseline: 324_269, maximumGrowth: 16_000 },
+        minifiedBytes: { baseline: 247_205, maximumGrowth: 10_500 },
+        gzipBytes: { baseline: 72_108, maximumGrowth: 2_250 },
+        brotliBytes: { baseline: 55_251, maximumGrowth: 1_900 },
       },
       'bitmap-baker-js': {
         rawBytes: { baseline: 17_478, maximumGrowth: 5_700 },
@@ -86,10 +86,10 @@ describe('independent package-size report', () => {
         brotliBytes: { baseline: 173_552, maximumGrowth: 7_000 },
       },
       'bitmap-runtime-js': {
-        rawBytes: { baseline: 361_809, maximumGrowth: 12_300 },
-        minifiedBytes: { baseline: 271_005, maximumGrowth: 8_000 },
-        gzipBytes: { baseline: 78_673, maximumGrowth: 1_750 },
-        brotliBytes: { baseline: 60_857, maximumGrowth: 1_600 },
+        rawBytes: { baseline: 361_809, maximumGrowth: 20_500 },
+        minifiedBytes: { baseline: 271_005, maximumGrowth: 13_000 },
+        gzipBytes: { baseline: 78_673, maximumGrowth: 2_800 },
+        brotliBytes: { baseline: 60_857, maximumGrowth: 2_350 },
       },
       'mtsdf-baker-wasm': {
         rawBytes: { baseline: 534_709, maximumGrowth: 18_500 },
@@ -104,10 +104,10 @@ describe('independent package-size report', () => {
         brotliBytes: { baseline: 4_176, maximumGrowth: 800 },
       },
       'mtsdf-runtime-js': {
-        rawBytes: { baseline: 370_255, maximumGrowth: 11_500 },
-        minifiedBytes: { baseline: 275_271, maximumGrowth: 7_400 },
-        gzipBytes: { baseline: 79_993, maximumGrowth: 1_700 },
-        brotliBytes: { baseline: 62_081, maximumGrowth: 1_500 },
+        rawBytes: { baseline: 370_255, maximumGrowth: 19_750 },
+        minifiedBytes: { baseline: 275_271, maximumGrowth: 12_500 },
+        gzipBytes: { baseline: 79_993, maximumGrowth: 2_800 },
+        brotliBytes: { baseline: 62_081, maximumGrowth: 2_300 },
       },
     } as const;
     const fields = ['rawBytes', 'minifiedBytes', 'gzipBytes', 'brotliBytes'] as const;
diff --git a/apps/benchmarks/src/benchmark/scenarios.ts b/apps/benchmarks/src/benchmark/scenarios.ts
index da4deff0..69df2d29 100644
--- a/apps/benchmarks/src/benchmark/scenarios.ts
+++ b/apps/benchmarks/src/benchmark/scenarios.ts
@@ -408,7 +408,10 @@ function advancedShapingValidation(values: readonly import('./contracts').Benchm
       metrics.missingGlyphCount !== 0 ||
       metrics.glyphCount !== 709 ||
       metrics.renderedGlyphCount !== 625 ||
-      metrics.drawCount !== 72
+      metrics.drawCount !== 72 ||
+      metrics.coldReadyObservationCount !== ADVANCED_SHAPING_CASES.length ||
+      metrics.warmLifecyclePublicationCount !== frameCount - ADVANCED_SHAPING_CASES.length ||
+      metrics.warmReadyWaitCount !== 0
     ) {
       throw new Error('Advanced shaping did not preserve its complete authored frame matrix');
     }
diff --git a/apps/benchmarks/src/generated/autoresearch-baseline-v0.json b/apps/benchmarks/src/generated/autoresearch-baseline-v0.json
index cebb0905..b621ada8 100644
--- a/apps/benchmarks/src/generated/autoresearch-baseline-v0.json
+++ b/apps/benchmarks/src/generated/autoresearch-baseline-v0.json
@@ -14,7 +14,7 @@
     {
       "id": "package-sizes",
       "path": "apps/benchmarks/src/generated/package-sizes.json",
-      "sha256": "049c110460b749edda229b47a1e3151b1c487a28757d28282dd1d751b24946a9",
+      "sha256": "2e7af35a43c9723209db882d67991a257a06133b3908369b12a8c9692554eb8b",
       "bytes": 6825
     },
     {
diff --git a/apps/benchmarks/src/generated/package-sizes.json b/apps/benchmarks/src/generated/package-sizes.json
index 33819901..da1b056d 100644
--- a/apps/benchmarks/src/generated/package-sizes.json
+++ b/apps/benchmarks/src/generated/package-sizes.json
@@ -10,11 +10,11 @@
       "label": "Browser core",
       "status": "measured",
       "format": "javascript",
-      "sha256": "a35287635e592c908a7ca4a1d22424d0eacb5bfd043fe3a00e608d42de520133",
-      "rawBytes": 332090,
-      "minifiedBytes": 252577,
-      "gzipBytes": 73350,
-      "brotliBytes": 56275
+      "sha256": "be3f26f4056391165de7c2612ab92d8b30c26ac6e299183dece2d6a86f9ae1c9",
+      "rawBytes": 340160,
+      "minifiedBytes": 257582,
+      "gzipBytes": 74316,
+      "brotliBytes": 57070
     },
     {
       "id": "font-validator-js",
@@ -76,33 +76,33 @@
       "label": "Bitmap runtime JS graph",
       "status": "measured",
       "format": "javascript",
-      "sha256": "c4941a0ddca821e4b16911dd87c1ae59ca98bac7483bbcdd20597dbf0344de6d",
-      "rawBytes": 373996,
-      "minifiedBytes": 278900,
-      "gzipBytes": 80380,
-      "brotliBytes": 62391
+      "sha256": "557bdc43359c60abf24af30464e07185d0c291d1e2ff3fd3e8ec131c85e5364b",
+      "rawBytes": 382060,
+      "minifiedBytes": 283898,
+      "gzipBytes": 81435,
+      "brotliBytes": 63146
     },
     {
       "id": "mtsdf-runtime-js",
       "label": "MTSDF runtime JS graph",
       "status": "measured",
       "format": "javascript",
-      "sha256": "ed31618835e5fe05588cd5d29daac535d8847349d06239caaed354bf4e5169bb",
-      "rawBytes": 381697,
-      "minifiedBytes": 282631,
-      "gzipBytes": 81656,
-      "brotliBytes": 63478
+      "sha256": "0bf8890daaf4e203ea8bee82a278a504055738525c1b7be26280c91e77caf131",
+      "rawBytes": 389761,
+      "minifiedBytes": 287629,
+      "gzipBytes": 82721,
+      "brotliBytes": 64286
     },
     {
       "id": "slug-runtime-js",
       "label": "Slug runtime JS graph",
       "status": "measured",
       "format": "javascript",
-      "sha256": "c6bf7acc8f3e829d9286b0b651a8154b588286104920eb50f35b97308bd32078",
-      "rawBytes": 382212,
-      "minifiedBytes": 281603,
-      "gzipBytes": 81757,
-      "brotliBytes": 63614
+      "sha256": "6fd4b4c4350ad3085c1d29546de66c3961bb460a9d77bbe854155b6e1f559cd3",
+      "rawBytes": 390276,
+      "minifiedBytes": 286600,
+      "gzipBytes": 82730,
+      "brotliBytes": 64271
     },
     {
       "id": "bitmap-baker-wasm",
diff --git a/apps/benchmarks/src/renderer/advanced-shaping-conformance.ts b/apps/benchmarks/src/renderer/advanced-shaping-conformance.ts
index d17b9198..6439d2d3 100644
--- a/apps/benchmarks/src/renderer/advanced-shaping-conformance.ts
+++ b/apps/benchmarks/src/renderer/advanced-shaping-conformance.ts
@@ -79,6 +79,8 @@ export function createAdvancedShapingConformanceTarget(): BenchmarkTarget {
       let missingGlyphCount = 0;
       let renderedGlyphCount = 0;
       let drawCount = 0;
+      let coldReadyObservationCount = 0;
+      let warmLifecyclePublicationCount = 0;
 
       for (const definition of ADVANCED_SHAPING_CASES) {
         const font = state.fonts.get(definition.fontFixture);
@@ -101,10 +103,13 @@ export function createAdvancedShapingConformanceTarget(): BenchmarkTarget {
                 font,
                 raster: bitmapRequest,
               });
+              await text.ready;
+              coldReadyObservationCount += 1;
             } else {
               text.setProperties(properties);
+              text.updateMatrixWorld(true);
+              warmLifecyclePublicationCount += 1;
             }
-            await text.ready;
             const layout = text.layout;
             if (layout === undefined) throw new Error(`${definition.id}:${frame.tick} has no layout`);
             const rendered = renderedGlyphs(text);
@@ -150,6 +155,9 @@ export function createAdvancedShapingConformanceTarget(): BenchmarkTarget {
           missingGlyphCount,
           renderedGlyphCount,
           drawCount,
+          coldReadyObservationCount,
+          warmLifecyclePublicationCount,
+          warmReadyWaitCount: 0,
         },
       };
     },
diff --git a/apps/benchmarks/src/renderer/canvas-surface.test.ts b/apps/benchmarks/src/renderer/canvas-surface.test.ts
index 425fee57..a325d354 100644
--- a/apps/benchmarks/src/renderer/canvas-surface.test.ts
+++ b/apps/benchmarks/src/renderer/canvas-surface.test.ts
@@ -1,6 +1,7 @@
-import { describe, expect, it } from 'vitest';
+import * as THREE from 'three/webgpu';
+import { describe, expect, it, vi } from 'vitest';
 
-import { createCanvasGridPositions } from './canvas-surface';
+import { createCanvasGridPositions, createCanvasSurface } from './canvas-surface';
 
 describe('canvas surface grid', () => {
   it('builds fixed one-CSS-pixel grid quads at the sixteen-pixel design rhythm', () => {
@@ -15,4 +16,24 @@ describe('canvas surface grid', () => {
     expect(() => createCanvasGridPositions(0, 32)).toThrow(RangeError);
     expect(() => createCanvasGridPositions(32, Number.NaN)).toThrow(RangeError);
   });
+
+  it('does not submit an empty grid mesh while a one-pixel surface is waiting for layout', () => {
+    const renderer = {
+      autoClear: true,
+      clear: vi.fn<(...args: unknown[]) => void>(),
+      clearDepth: vi.fn<(...args: unknown[]) => void>(),
+      render: vi.fn<(...args: unknown[]) => void>(),
+      setClearColor: vi.fn<(...args: unknown[]) => void>(),
+      setRenderTarget: vi.fn<(...args: unknown[]) => void>(),
+    } as unknown as THREE.WebGPURenderer;
+    const surface = createCanvasSurface(renderer, 1, 1, true);
+    const scene = new THREE.Scene();
+    const camera = new THREE.OrthographicCamera();
+
+    surface.render(scene, camera);
+
+    expect(renderer.render).toHaveBeenCalledOnce();
+    expect(renderer.render).toHaveBeenCalledWith(scene, camera);
+    surface.dispose();
+  });
 });
diff --git a/apps/benchmarks/src/renderer/canvas-surface.ts b/apps/benchmarks/src/renderer/canvas-surface.ts
index f2e33f9a..2d2534f6 100644
--- a/apps/benchmarks/src/renderer/canvas-surface.ts
+++ b/apps/benchmarks/src/renderer/canvas-surface.ts
@@ -22,6 +22,7 @@ export function createCanvasSurface(
 ): CanvasSurface {
   let surfaceWidth = width;
   let surfaceHeight = height;
+  let gridRequested = gridVisible;
   const backgroundScene = new THREE.Scene();
   const backgroundCamera = createBackgroundCamera(width, height);
   const grid = new THREE.Mesh(
@@ -34,7 +35,7 @@ export function createCanvasSurface(
     }),
   );
   grid.frustumCulled = false;
-  grid.visible = gridVisible;
+  grid.visible = gridRequested && gridHasVertices(grid.geometry);
   backgroundScene.add(grid);
   renderer.autoClear = false;
   renderer.setClearColor(CANVAS_BACKGROUND_COLOR, 1);
@@ -49,12 +50,14 @@ export function createCanvasSurface(
       const previous = grid.geometry;
       grid.geometry = createCanvasGridGeometry(nextWidth, nextHeight);
       previous.dispose();
+      grid.visible = gridRequested && gridHasVertices(grid.geometry);
       backgroundCamera.right = nextWidth;
       backgroundCamera.bottom = -nextHeight;
       backgroundCamera.updateProjectionMatrix();
     },
     setGridVisible(visible) {
-      grid.visible = visible;
+      gridRequested = visible;
+      grid.visible = gridRequested && gridHasVertices(grid.geometry);
     },
     render(scene, camera) {
       renderer.setRenderTarget(null);
@@ -92,6 +95,10 @@ function createCanvasGridGeometry(width: number, height: number): THREE.BufferGe
   return geometry;
 }
 
+function gridHasVertices(geometry: THREE.BufferGeometry): boolean {
+  return (geometry.getAttribute('position')?.count ?? 0) > 0;
+}
+
 function createBackgroundCamera(width: number, height: number): THREE.OrthographicCamera {
   const camera = new THREE.OrthographicCamera(0, width, 0, -height, 0.1, 10);
   camera.position.z = 1;
diff --git a/apps/benchmarks/src/renderer/comparison-workload.test.ts b/apps/benchmarks/src/renderer/comparison-workload.test.ts
index b3582716..56f7bbc2 100644
--- a/apps/benchmarks/src/renderer/comparison-workload.test.ts
+++ b/apps/benchmarks/src/renderer/comparison-workload.test.ts
@@ -45,6 +45,7 @@ const baseConfiguration: ComparisonWorkloadConfiguration = {
   paintStrokeWidth: 0.5,
   showGrid: true,
   showLayoutBounds: true,
+  textLadderExitEnabled: false,
   workload: 'paint-effects',
 };
 
@@ -362,6 +363,7 @@ describe('text ladder scale selection', () => {
     const position = textLadderScenePosition({
       animationSpeed: 50,
       elapsedMs: 7_200,
+      exitEnabled: true,
       finalCenterY: -1_500,
       finalEntryWidth,
       finalEntryX,
@@ -371,6 +373,21 @@ describe('text ladder scale selection', () => {
 
     expect(position.x + finalEntryX + finalEntryWidth).toBeLessThan(0);
   });
+
+  it('keeps the final specimen visible outside timed presentation playback', () => {
+    const position = textLadderScenePosition({
+      animationSpeed: 50,
+      elapsedMs: 7_200,
+      exitEnabled: false,
+      finalCenterY: -1_500,
+      finalEntryWidth: 2_000,
+      finalEntryX: 120,
+      viewportHeight: 720,
+      viewportWidth: 1_280,
+    });
+
+    expect(position.x).toBe(0);
+  });
 });
 
 describe('icon grid layout', () => {
diff --git a/apps/benchmarks/src/renderer/comparison-workload.ts b/apps/benchmarks/src/renderer/comparison-workload.ts
index 434c4060..b4fb3e0f 100644
--- a/apps/benchmarks/src/renderer/comparison-workload.ts
+++ b/apps/benchmarks/src/renderer/comparison-workload.ts
@@ -117,6 +117,7 @@ export interface ComparisonWorkloadConfiguration {
   readonly paintStrokeWidth: number;
   readonly showGrid: boolean;
   readonly showLayoutBounds: boolean;
+  readonly textLadderExitEnabled: boolean;
   readonly workload: ComparisonWorkloadId;
 }
 
@@ -148,6 +149,7 @@ export interface ComparisonWorkloadPreviewOptions {
   readonly paintStrokeWidth: number;
   readonly showGrid: boolean;
   readonly showLayoutBounds: boolean;
+  readonly textLadderExitEnabled: boolean;
   readonly signal?: AbortSignal;
   readonly slugBakedArtifact?: import('./slug-text').SlugBakedArtifactSource;
   readonly technique: RasterTechnique;
@@ -179,7 +181,6 @@ interface WorkloadEntry {
   readonly bounds?: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicNodeMaterial>;
   readonly role: 'primary' | 'secondary';
   virtualIconIndex?: number;
-  iconAssignmentPending?: boolean;
   disposed?: boolean;
   readonly alignment?: 'start' | 'center' | 'end';
   readonly animationPhase?: number;
@@ -702,7 +703,7 @@ async function createComparisonWorkloadRuntime(
       }
     }
 
-    async function applyIconWindow(window: IconGridVirtualWindow): Promise<void> {
+    function applyIconWindow(window: IconGridVirtualWindow): void {
       if (iconFont === undefined || configuration.workload !== 'icon-grid') return;
       if (window.poolCapacity !== entries.length) {
         throw new Error('icon grid pool capacity changed without a scene rebuild');
@@ -734,31 +735,18 @@ async function createComparisonWorkloadRuntime(
       for (const [missingIndex, iconIndex] of missingIndices.entries()) {
         const entry = availableEntries[missingIndex]!;
         const { content, glyph } = iconGridContent(iconIndex);
-        // A Text object retains its previous complete generation while replacement content loads,
-        // but individual Text objects become ready independently. Keep every recyclable slot hidden
-        // until the complete window is ready so the pool publishes one coherent assignment.
-        entry.node.visible = false;
-        entry.iconAssignmentPending = true;
+        // Keep the old assignment visible while every warm replacement is staged. The Three.js lifecycle publishes
+        // the staged generations together below; no consumer promise coordinates ordinary warm recycling.
         entry.text.setProperties({ text: glyph });
         entry.labelText?.setProperties({ text: iconGridLabel(iconIndex) });
         recycled += 1;
         pendingAssignments.push({ entry, iconIndex, content });
       }
-      try {
-        await Promise.all(pendingAssignments.flatMap(({ entry }) => entryReadyPromises(entry)));
-      } catch (error) {
-        for (const { entry } of pendingAssignments) {
-          entry.node.visible = false;
-          entry.iconAssignmentPending = false;
-          delete entry.virtualIconIndex;
-        }
-        throw error;
-      }
+      publishEntryUpdates(pendingAssignments.map(({ entry }) => entry));
       if (closing || disposed) return;
       for (const { entry, iconIndex, content } of pendingAssignments) {
         if (entry.disposed) continue;
         entry.virtualIconIndex = iconIndex;
-        entry.iconAssignmentPending = false;
         entry.sourceText = content;
         const column = iconIndex % window.layout.columns;
         const row = Math.floor(iconIndex / window.layout.columns);
@@ -801,7 +789,7 @@ async function createComparisonWorkloadRuntime(
         for (const { node } of removed) scene.remove(node);
         disposeEntries(removed);
       }
-      await resizeIconGridEntries(entries, iconSize, layout);
+      resizeIconGridEntries(entries, iconSize, layout);
     }
 
     function settleIconWindow(window: IconGridVirtualWindow): void {
@@ -1657,13 +1645,9 @@ function entryLayouts(entry: WorkloadEntry): readonly ParagraphLayout[] {
     : [committedLayout(entry.text), committedLayout(entry.labelText)];
 }
 
-async function resizeIconGridEntries(
-  entries: readonly WorkloadEntry[],
-  iconSize: number,
-  layout: IconGridLayout,
-): Promise<void> {
+function resizeIconGridEntries(entries: readonly WorkloadEntry[], iconSize: number, layout: IconGridLayout): void {
   for (const entry of entries) entry.text.setProperties({ fontSize: iconSize });
-  await Promise.all(entries.map(({ text }) => text.ready));
+  publishEntryUpdates(entries);
   for (const entry of entries) {
     if (entry.virtualIconIndex === undefined) continue;
     const column = entry.virtualIconIndex % layout.columns;
@@ -1672,6 +1656,10 @@ async function resizeIconGridEntries(
   }
 }
 
+function publishEntryUpdates(entries: readonly WorkloadEntry[]): void {
+  for (const { node } of entries) node.updateMatrixWorld(true);
+}
+
 function positionIconGridEntry(
   entry: WorkloadEntry,
   layout: IconGridLayout,
@@ -1770,7 +1758,7 @@ function layoutZoomTextEntry(entry: WorkloadEntry, viewportWidth: number, viewpo
 function animateTextLadderScene(
   scene: THREE.Scene,
   entries: readonly WorkloadEntry[],
-  configuration: Pick<ComparisonWorkloadConfiguration, 'animationSpeed'>,
+  configuration: Pick<ComparisonWorkloadConfiguration, 'animationSpeed' | 'textLadderExitEnabled'>,
   elapsedMs: number,
   viewportWidth: number,
   viewportHeight: number,
@@ -1781,6 +1769,7 @@ function animateTextLadderScene(
   const position = textLadderScenePosition({
     animationSpeed: configuration.animationSpeed,
     elapsedMs,
+    exitEnabled: configuration.textLadderExitEnabled,
     finalCenterY: finalEntry.text.position.y - layout.height / 2,
     finalEntryX: finalEntry.text.position.x,
     finalEntryWidth: layout.width,
@@ -1793,6 +1782,7 @@ function animateTextLadderScene(
 export function textLadderScenePosition({
   animationSpeed,
   elapsedMs,
+  exitEnabled,
   finalCenterY,
   finalEntryWidth,
   finalEntryX,
@@ -1801,6 +1791,7 @@ export function textLadderScenePosition({
 }: {
   readonly animationSpeed: number;
   readonly elapsedMs: number;
+  readonly exitEnabled: boolean;
   readonly finalCenterY: number;
   readonly finalEntryWidth: number;
   readonly finalEntryX: number;
@@ -1809,10 +1800,10 @@ export function textLadderScenePosition({
 }): Readonly<{ x: number; y: number }> {
   const cycle = modulo((elapsedMs / 9_000) * animationRate({ animationSpeed }), 1);
   const scrollProgress = smoothstep(Math.min(1, cycle / 0.52));
-  const marqueeProgress = smoothstep(Math.max(0, Math.min(1, (cycle - 0.52) / 0.38)));
+  const marqueeProgress = exitEnabled ? smoothstep(Math.max(0, Math.min(1, (cycle - 0.52) / 0.38))) : 0;
   const centeredScrollY = -viewportHeight / 2 - finalCenterY;
   const offscreenLeftX = -finalEntryX - finalEntryWidth - viewportWidth * 0.05;
-  return { x: offscreenLeftX * marqueeProgress, y: centeredScrollY * scrollProgress };
+  return { x: marqueeProgress === 0 ? 0 : offscreenLeftX * marqueeProgress, y: centeredScrollY * scrollProgress };
 }
 
 function animateParagraphStressScene(
@@ -2732,7 +2723,7 @@ function updateIconGridEntryVisibility(
   const viewportBottom = scrollY + viewportHeight;
   for (const entry of entries) {
     const index = entry.virtualIconIndex;
-    if (index === undefined || entry.iconAssignmentPending === true) {
+    if (index === undefined) {
       entry.node.visible = false;
       continue;
     }
diff --git a/apps/benchmarks/src/renderer/mtsdf-text.ts b/apps/benchmarks/src/renderer/mtsdf-text.ts
index c9c10c21..25f9970f 100644
--- a/apps/benchmarks/src/renderer/mtsdf-text.ts
+++ b/apps/benchmarks/src/renderer/mtsdf-text.ts
@@ -770,7 +770,7 @@ async function createResources(backend: RendererBackend, dpr: number): Promise<M
     lines.push(resizeLine);
     await resizeLine.ready;
     resizeLine.setProperties({ width: 476 });
-    await resizeLine.ready;
+    resizeLine.updateMatrixWorld();
     resizeLine.position.set(18, -24, 0);
     scene.add(resizeLine);
 
diff --git a/apps/benchmarks/src/renderer/persistent-render-host-context.tsx b/apps/benchmarks/src/renderer/persistent-render-host-context.tsx
index 9c1a7987..48548d35 100644
--- a/apps/benchmarks/src/renderer/persistent-render-host-context.tsx
+++ b/apps/benchmarks/src/renderer/persistent-render-host-context.tsx
@@ -160,15 +160,7 @@ export function PersistentRenderHostProvider({
         observer.disconnect();
         throw error;
       }
-      return createSurfaceLease(
-        sceneLease,
-        observer,
-        generation,
-        surfaceGenerationRef,
-        activeAnchorRef,
-        runtimeWorld,
-        canvas,
-      );
+      return createSurfaceLease(sceneLease, observer, generation, surfaceGenerationRef, activeAnchorRef, runtimeWorld);
     },
     [canvas, configureSurface, ensureHost, runtimeWorld],
   );
@@ -204,7 +196,6 @@ function createSurfaceLease(
   surfaceGenerationRef: RefObject<number>,
   activeAnchorRef: RefObject<HTMLElement | undefined>,
   runtimeWorld: ReturnType<typeof useRuntimeWorld>,
-  canvas: HTMLCanvasElement,
 ): PersistentRenderSurfaceLease {
   let released = false;
   return {
@@ -215,13 +206,14 @@ function createSurfaceLease(
       await sceneLease.release();
       if (surfaceGenerationRef.current !== generation) return;
       activeAnchorRef.current = undefined;
+      // Keep the provider-owned canvas attached while a replacement effect activates. Its last complete frame is a
+      // better handoff than a DOM detach/reattach flash; provider teardown and anchor removal still detach it.
       runtimeWorld.set(RuntimeCanvasSettings, {
         controller: undefined,
         label: 'Text rendering canvas',
         panEnabled: false,
         zoomEnabled: false,
       });
-      canvas.remove();
     },
   };
 }
diff --git a/apps/benchmarks/src/renderer/persistent-render-host.test.ts b/apps/benchmarks/src/renderer/persistent-render-host.test.ts
index 6bb3f224..c4c373ed 100644
--- a/apps/benchmarks/src/renderer/persistent-render-host.test.ts
+++ b/apps/benchmarks/src/renderer/persistent-render-host.test.ts
@@ -254,6 +254,20 @@ describe('persistent render host', () => {
     await host.dispose();
   });
 
+  it('does not reconfigure the renderer for an identical viewport', async () => {
+    const harness = renderHostHarness();
+    const scene = sceneHarness('scene');
+    const host = await harness.create();
+    await host.replaceScene(scene.scene);
+
+    host.resize(160, 90, 1);
+
+    expect(harness.setPixelRatio).not.toHaveBeenCalled();
+    expect(harness.setSize).not.toHaveBeenCalled();
+    expect(scene.viewports).toHaveLength(1);
+    await host.dispose();
+  });
+
   it('cleans up a scene whose activation fails before admitting the next generation', async () => {
     const harness = renderHostHarness();
     const failed = sceneHarness('failed', Promise.reject(new Error('activation failed')));
diff --git a/apps/benchmarks/src/renderer/persistent-render-host.ts b/apps/benchmarks/src/renderer/persistent-render-host.ts
index 9254994f..08e684b8 100644
--- a/apps/benchmarks/src/renderer/persistent-render-host.ts
+++ b/apps/benchmarks/src/renderer/persistent-render-host.ts
@@ -321,9 +321,14 @@ export async function createPersistentRenderHost(options: PersistentRenderHostOp
       },
       resize(nextWidth, nextHeight, nextDpr = pixelRatio) {
         if (disposed) throw disposedError();
-        logicalWidth = positive(nextWidth, 'persistent render-host width');
-        logicalHeight = positive(nextHeight, 'persistent render-host height');
+        const validatedWidth = positive(nextWidth, 'persistent render-host width');
+        const validatedHeight = positive(nextHeight, 'persistent render-host height');
         const validatedDpr = positive(nextDpr, 'persistent render-host DPR');
+        if (validatedWidth === logicalWidth && validatedHeight === logicalHeight && validatedDpr === pixelRatio) {
+          return;
+        }
+        logicalWidth = validatedWidth;
+        logicalHeight = validatedHeight;
         if (validatedDpr !== pixelRatio) {
           pixelRatio = validatedDpr;
           renderer.setPixelRatio(pixelRatio);
diff --git a/apps/benchmarks/src/renderer/react-text.ts b/apps/benchmarks/src/renderer/react-text.ts
index d368c9c2..be199323 100644
--- a/apps/benchmarks/src/renderer/react-text.ts
+++ b/apps/benchmarks/src/renderer/react-text.ts
@@ -92,7 +92,6 @@ async function createResources(dpr: number): Promise<ReactTextResources> {
     font = await useFont.preload(fontToken);
     const reference = createRef<CoreText>();
     const initial = await renderCommittedText(root, fontToken, reference);
-    await initial.core.ready;
     return { canvas, font, fontToken, reference, renderer, root, store: initial.store };
   } catch (error) {
     flushSync(() => root.unmount());
@@ -109,7 +108,6 @@ async function runReconciliation(resources: ReactTextResources): Promise<TargetR
   assertOracleLayout(initialLayout, 'natural');
 
   const narrow = await renderCommittedText(resources.root, resources.fontToken, resources.reference, 360, '#31d7c5');
-  await narrow.core.ready;
   const narrowLayout = requiredLayout(core);
   assertOracleLayout(narrowLayout, 'narrow');
   if (narrow.core !== core || narrowLayout === initialLayout) {
@@ -117,7 +115,6 @@ async function runReconciliation(resources: ReactTextResources): Promise<TargetR
   }
 
   const restored = await renderCommittedText(resources.root, resources.fontToken, resources.reference);
-  await restored.core.ready;
   const restoredLayout = requiredLayout(core);
   assertOracleLayout(restoredLayout, 'natural');
   if (restored.core !== core) throw new Error('React Text replaced its core object during restore');
@@ -170,6 +167,8 @@ async function renderCommittedText(
   });
   const core = await committed.promise;
   if (store === undefined) throw new Error('R3F did not publish its root store');
+  const state = store.getState();
+  state.gl.render(state.scene, state.camera);
   return { core, store };
 }
 
diff --git a/apps/benchmarks/src/renderer/slug-text.ts b/apps/benchmarks/src/renderer/slug-text.ts
index 76446c8d..131b7bb3 100644
--- a/apps/benchmarks/src/renderer/slug-text.ts
+++ b/apps/benchmarks/src/renderer/slug-text.ts
@@ -897,7 +897,7 @@ async function createResources(backend: RendererBackend, dpr: number): Promise<S
     lines.push(resizeLine);
     await resizeLine.ready;
     resizeLine.setProperties({ width: 476 });
-    await resizeLine.ready;
+    resizeLine.updateMatrixWorld();
     resizeLine.position.set(18, -24, 0);
     scene.add(resizeLine);
 
diff --git a/docs/log.md b/docs/log.md
index e01182e0..8f1b56a5 100644
--- a/docs/log.md
+++ b/docs/log.md
@@ -2,6 +2,8 @@
 
 ## 2026-08-01
 
+- **Warm Presentation publication and continuity** — Published resident `Text` replacements from the Three.js matrix-update lifecycle and removed Icon Grid's hide-and-await recycling path: pooled tiles retain their old complete glyph until one coherent warm assignment is staged and published. Ordinary Text Ladder playback keeps visible content while the timed demo alone owns its authored off-screen exit. The persistent host now ignores identical resize requests and keeps its provider-owned canvas attached across replacement-effect handoffs; benchmark DPR no longer keys a subtree remount. Split the DPR-2 evidence lanes so headless pixel sampling cannot flash a visible GPU canvas while the headful timed demo runs without screenshots. Bitmap, MTSDF, and Slug each complete all seven sequential workloads with visible pixels and one renderer; the headful timed sequence completes at 60.02 Icon Grid FPS, returns to Off-axis / 3D, and emits no warnings. A focused regression hides the zero-vertex screen grid during the temporary 1×1 pre-layout surface instead of submitting an empty WebGPU draw.
+- **Lifecycle-owned warm publication** — Added synchronous cache peeks for registered font loads, initialized shapers, and current decoded raster resources. Resident `Text` updates now shape, lay out, plan paint, and stage without crossing a Promise boundary, retain the previous generation until Three.js object traversal, and publish before raster children. React Suspense continues to own genuinely cold preparation; the React integration performs no consumer `ready` wait and explicitly invalidates its R3F root after core updates. Asynchronous plugin preparation is carried forward under one abort controller rather than probed and restarted. Adversarial findings led to shared staging logic, paint-only layout/page reuse, abort propagation across multi-font preparation, valid replacement preservation after superseded-font disposal, both Three matrix-update entry points, and defensive sibling traversal after a plugin violates the infallible-commit contract. The complete browser conformance lane proves 3/3 exact R3F reconciliations through explicit renderer traversal and 3/3 exact 68-frame Advanced Shaping timelines with five cold observations, 63 warm lifecycle publications, and zero warm readiness waits per sample; the packed consumer remains exact. Against the preceding transaction layer, browser core grows by 8,070 raw / 5,005 minified / 966 gzip / 795 Brotli bytes; Bitmap, MTSDF, and Slug runtime closures grow by 8,064/4,998/1,055/755, 8,064/4,998/1,065/808, and 8,064/4,997/973/657 bytes respectively. Baker hosts and Wasm remain byte-identical.
 - **Renderer-neutral raster transaction** — Started Milestone 10 by replacing the optional Bitmap-only retained-update seam plus separate build/repaint methods with one required `stageBatch` lifecycle for every raster. The portable batch contract no longer imports Three.js; the Three-backed `Text` adapter validates attachment separately. Bitmap, MTSDF, and Slug now share stage/commit/abort ownership, and focused evidence proves success, injected failure, stale abort, idempotent stage transitions, and preservation of the live scene. Against the closed Milestone 6/8 head, browser core grows by 1,747 raw / 1,053 minified / 207 gzip / 144 Brotli bytes; Bitmap, MTSDF, and Slug runtime closures grow by 2,100/1,253/261/253, 2,783/1,524/345/272, and 2,102/1,256/274/274 bytes respectively. Baker hosts and Wasm remain byte-identical. Only the browser-core raw/minified absolute ceilings and the pre-coverage caps for closures containing the new lifecycle advance; compressed absolute ceilings remain unchanged.
 - **Milestone 6/8 closure** — Closed Milestones 6 and 8 after the deferred combined adversarial review, independent remediation of every actionable lifecycle finding, exact size/provenance refresh, 182 package integration tests, 257 benchmark unit tests, complete headless conformance, packed-consumer execution, and zero-error OKF validation. Milestone 10 is now the next authorized implementation milestone.
 - **Scoped Text invalidation recovery** — Bound terminal font-disposal state to the invalidated generation's input rather than a newer replacement already in flight, and clear that saved state on explicit disposal. A two-registry regression proves disposing a superseded font cannot permanently suppress recovery through the healthy replacement font.
diff --git a/docs/packages/benchmarks.md b/docs/packages/benchmarks.md
index 7342d50b..5f108020 100644
--- a/docs/packages/benchmarks.md
+++ b/docs/packages/benchmarks.md
@@ -5,7 +5,7 @@ description: Provides the shared interactive and automated benchmark product sur
 resource: ../../apps/benchmarks
 workspace_package: '@pmndrs/text-benchmarks'
 documentation_type: reference
-source_digest: 'sha256:bde56399089ed6b4a970bcd22a1685edf5266d37d2ad5a9a6feca04df377606e'
+source_digest: 'sha256:e7c99c8d10158636b5eb15a053e1d34ff2f16fa19470e06396a1b46f61897332'
 tags: [package, benchmarks, react, vite, product-e2e]
 sources:
   - id: manifest
@@ -95,7 +95,7 @@ Icon Grid auto-pan integrates a bounded exponential average of observed frame de
 
 Rapid Presentation controls compose against a requested-location revision rather than the last React commit, so a workload selection made while a technique preload is pending retains both requested changes and only the newest preload may commit. Retained Bitmap, MSDF, and Slug controls may arrive before cold scene activation; an activation gate releases them to a latest-value serialized queue, preventing animated text from starving layout completion. Bitmap's exact glyph assertion is committed with the workload instead of leaking from Benchmark Ipsum into Advanced Shaping, and zero-glyph intermediate generations are hidden from GPU submission.
 
-Workload-local view state does not belong to the persistent renderer generation. Every workload transition installs its complete view, layout, amount, animation, and paint default snapshot; the outgoing Paragraph Stress RAF stops writing as soon as another workload is requested. The retained comparison scene atomically swaps the workload-appropriate orthographic or perspective camera with the prepared scene, resets scene pan, camera zoom, animation epochs, and virtual-grid cursors, and preserves those values only for same-workload edits. Text Ladder scrolls to its final 1024 px specimen and aligns that specimen's trailing edge inside the viewport during the cycle hold instead of translating the complete line off-screen. The sequential Presentation product probe operates the actual Base UI selector through all seven workloads, retains one canvas and renderer, rejects browser warnings, validates applied defaults and camera projection, and samples measured foreground pixels in an unobstructed framebuffer crop throughout each complete workload interval so nonzero glyph and draw telemetry cannot mask an off-screen or black result. The same probe is parameterized across Bitmap, MTSDF, and Slug.
+Workload-local view state does not belong to the persistent renderer generation. Every workload transition installs its complete view, layout, amount, animation, and paint default snapshot; the outgoing Paragraph Stress RAF stops writing as soon as another workload is requested. The retained comparison scene atomically swaps the workload-appropriate orthographic or perspective camera with the prepared scene, resets scene pan, camera zoom, animation epochs, and virtual-grid cursors, and preserves those values only for same-workload edits. Text Ladder keeps its final 1024 px specimen visible during ordinary interactive looping; active timed playback alone enables the authored marquee exit so the scene can cut after the specimen clears the left edge. The sequential Presentation product probe operates the actual Base UI selector through all seven workloads, retains one canvas and renderer, rejects browser warnings, validates applied defaults and camera projection, and samples canvas identity, dimensions, renderer count, glyphs, and draws throughout each complete workload interval. After each capture-free interval, one headless DPR-2 framebuffer crop proves visible foreground pixels so nonzero telemetry cannot mask an off-screen or black result; avoiding continuous full-page capture also prevents Chromium's hardware-compositor screenshot path from flashing the observed canvas. The separate headful timed-demo probe performs no screenshots. The same workload probe is parameterized across Bitmap, MTSDF, and Slug. A requested screen grid with zero generated vertices remains hidden during the temporary 1×1 pre-layout surface, preventing an empty WebGPU draw warning without suppressing validation output.
 
 Conformance uses the same route-owned renderer instead of allocating a parallel renderer. The realtime MSDF / Slug comparison is a retained host scene that restores render-target, clear, viewport, scissor, and automatic-clear state after each frame. Finite Bitmap, MTSDF, Slug, source-outline, and runtime-fallback captures run as exclusive borrowed-renderer jobs; their state transaction restores the host renderer after success or failure, and capture disposal releases only capture-owned text, font, raster, and render-target resources. Standalone capture callers retain the existing create-and-dispose behavior when no renderer is supplied.
 
@@ -125,7 +125,7 @@ GitHub CI uses the Ubuntu runner's rolling system Chromium as a deliberate compa
 
 The independent package-size lane measures the initial public browser graph, lazy font validator, runtime Worker boundary, baker and shaper JavaScript/Wasm, and Unicode 17 analysis without zero-byte placeholders. Static entry closures and dynamic chunks are separated from Rollup metadata rather than conflated; the browser-core lane externalizes the package's declared `three`, React, and R3F peers, and package-owned Wasm URLs are externalized from JavaScript measurements regardless of their owning package. The report records its measurement platform and architecture plus the SHA-256 identity of each measured payload: minified bundle bytes for JavaScript and emitted module bytes for Wasm. Same-host regeneration is exact; every foreign-host raw/minified/gzip/Brotli result must satisfy the shared reviewed budget table because native Rust/Binaryen and Rolldown output has small cross-architecture byte variance. Coverage-capability growth is independently bounded against its pre-coverage baseline, and foreign-host failures report the measured payload, reviewed ceiling, and exceeded dimensions. The product inspector's selected-runtime total is the gzip transfer sum of the selected raster runtime graph and separately emitted shaper Wasm. The raster graph already contains the shared core and shaper JavaScript host, so adding the independent browser-core or text-shaper-JavaScript measurements would double-count code. Selected runtime and conditional runtime-bake totals are default-collapsed disclosures; their component rows remain available on demand without displacing the separate font-asset total. The font-asset card reports only one transport quantity: gzip bytes for compressed MTSDF artifacts and exact transferred bytes for uncompressed Bitmap/runtime-source assets. Decoded container, raster, and GPU allocation sizes never appear as children of that transfer total; GPU texture allocation remains isolated in the resource card. Each full row is the interaction target, while fixed label, status, and byte columns use a neutral centered chevron, a green check for loaded code, and a gray X for unloaded code. The total intentionally excludes external Three.js, React, and R3F peers plus font assets; those assets remain separate rows rather than being mislabeled as a complete application bundle.
 
-The current Darwin arm64 record reports a 252,577 minified / 73,350 gzip / 56,275 Brotli peer-externalized browser graph and an independently measured 139,936 / 42,047 / 30,989 Unicode analysis graph. The validator, runtime host, runtime Worker JavaScript, portable baker JavaScript, baker Wasm, shaper JavaScript, and shaper Wasm report 584,479, 9,524, 8,936, 6,077, 422,538, 36,966, and 680,312 minified/raw bytes respectively. The configurable MTSDF baker host measures 19,117 minified / 5,530 gzip / 4,908 Brotli bytes and its coverage-capable full Wasm measures 552,025 raw bytes; the reviewed host ceiling includes authenticated quality and coverage policy. The exact-distance-outline removal experiment measured Slug's isolated runtime graph falling from 288,338 to 278,977 minified bytes, from 83,445 to 81,151 gzip bytes, and from 64,856 to 63,013 Brotli bytes on its original same-host comparison. The current renderer-neutral-transaction Slug runtime measures 281,603 minified / 81,757 gzip / 63,614 Brotli bytes. Its baker host measures 12,913 / 4,129 / 3,680 and its Wasm measures 465,046 raw / 186,683 gzip / 146,720 Brotli bytes. Bitmap-only and MTSDF-only size entries inspect their initial module closures and fail if Slug runtime, shader, baker, or runtime-baker modules enter either graph. Paragraph layout hashes and the policy composite hash share one implementation over the actual normalized layouts; the generator, benchmark target, unit tests, and Vitexec probes no longer maintain parallel digest logic.
+The current Darwin arm64 record reports a 257,582 minified / 74,316 gzip / 57,070 Brotli peer-externalized browser graph and an independently measured 139,936 / 42,047 / 30,989 Unicode analysis graph. The validator, runtime host, runtime Worker JavaScript, portable baker JavaScript, baker Wasm, shaper JavaScript, and shaper Wasm report 584,479, 9,524, 8,936, 6,077, 422,538, 36,966, and 680,312 minified/raw bytes respectively. The configurable MTSDF baker host measures 19,117 minified / 5,530 gzip / 4,908 Brotli bytes and its coverage-capable full Wasm measures 552,025 raw bytes; the reviewed host ceiling includes authenticated quality and coverage policy. The exact-distance-outline removal experiment measured Slug's isolated runtime graph falling from 288,338 to 278,977 minified bytes, from 83,445 to 81,151 gzip bytes, and from 64,856 to 63,013 Brotli bytes on its original same-host comparison. The current lifecycle-published Slug runtime measures 286,600 minified / 82,730 gzip / 64,271 Brotli bytes. Its baker host measures 12,913 / 4,129 / 3,680 and its Wasm measures 465,046 raw / 186,683 gzip / 146,720 Brotli bytes. Bitmap-only and MTSDF-only size entries inspect their initial module closures and fail if Slug runtime, shader, baker, or runtime-baker modules enter either graph. Paragraph layout hashes and the policy composite hash share one implementation over the actual normalized layouts; the generator, benchmark target, unit tests, and Vitexec probes no longer maintain parallel digest logic.
 
 The local Worker-queue Vitexec probe authenticates every output and reports observations rather than asserting machine-sensitive timing. Two Chromium runs measured a three-font queued burst at 30.8–32.0 ms and three separately initialized sequential Workers at 68.3–88.6 ms. The correctness suite separately proves one active post, FIFO completion, queued cancellation, and active-cancellation recovery without timers. The combined live lane runs its performance observation before interaction and conformance probes so accumulated renderer work cannot contaminate cold/steady telemetry.
 
@@ -241,6 +241,8 @@ The packed-consumer lane builds and packs both workspace packages, extracts only
 
 The bake-host report separates the consumer phases without timing conformance work. Each offline sample creates a fresh Wasm baker and records initialization plus first bake as cold, then records a second bake on that instance as warm. Each isolated Chromium context queues two requests onto one Worker: first completion contains Worker/Wasm startup plus its bake, while the interval to second completion is the warm reused-instance bake. Three captured arm64/Chromium 149 samples preserve complete artifact parity; medians were 4.16 ms cold / 2.94 ms warm offline and 21.70 ms cold / 3.50 ms warm in the Worker. These are observations, not cross-host thresholds.
 
+A released scene leaves the provider-owned canvas attached with its last complete frame while its replacement effect activates, avoiding a detach/reparent flash; provider teardown or removal of the owning anchor remains the detach boundary. The continuity probe requires the same connected canvas and exactly one renderer through explicit DPR 2→1→2 and Bitmap→MTSDF→Bitmap handoffs.
+
 The [benchmark plan](../planning/benchmark-plan.md) owns target admission, correctness-before-timing, and product-E2E requirements.[^benchmark-plan]
 
 [^benchmark-plan]: Local GPU evidence supplements rather than replaces deterministic CI-safe checks.
diff --git a/docs/packages/text.md b/docs/packages/text.md
index 1d930093..df65c3a5 100644
--- a/docs/packages/text.md
+++ b/docs/packages/text.md
@@ -5,7 +5,7 @@ description: Implements public font loading, shaping, paragraph measurement, sta
 resource: ../../packages/text
 workspace_package: '@pmndrs/text'
 documentation_type: reference
-source_digest: 'sha256:af34e66d52ba2f4332b2870483e4dceb583ebc43b1032c91f181055cc33d9097'
+source_digest: 'sha256:623f7e44f9e9b08ecf6f6188ae46f55ebddc9fb8efc500fd01bc70388c00dc88'
 tags: [package, public-api, typescript, contracts]
 sources:
   - id: manifest
@@ -201,7 +201,7 @@ One instanced batch family handles fill, outline, opacity, and translated hard s
 
 The checked SIMD comparison builds scalar, compiler-auto-vectorized, and explicit-four-lane kernels from isolated target directories. Every variant preserves all seven corrected native-oracle hashes and the complete Inter result of 2,915 generated glyphs, 22 non-rendering rejected slots, checksum `a5a6aa6e`, and composite SHA-256 `f6381c2f…eef6`; an instrumented warm seven-call corpus records seven request allocations, zero reallocations, and seven deallocations, one owned output copy occurs per call, and Wasm memory does not grow after the cold corpus. On Node 24, scalar measured 46.462 milliseconds for seven warm calls versus 47.079 milliseconds for explicit SIMD. Chromium 149 measured 47.6 versus 48.1 milliseconds. Explicit SIMD improves the complete Inter warm pass from 48.13 to 45.38 seconds, a 5.7% stress/offline win, and saves 297 Brotli bytes. Because the supported runtime default is bounded interactive baking and the target feature would require an alternate artifact, scalar remains the only shipped baker kernel; item 8.6 retains the explicit variant as evidence for phase-led optimization rather than exposing a toggle now. The repository-local Vitexec capture and full-font request emitter preserve the experiment as repeatable evidence rather than product complexity.
 
-The Three-backed `Text` object is a real Three.js `Group` over the portable transaction contract rather than making Three part of that contract. It validates one complete candidate state before committing a patch, resolves every distinct root/span font through registry-scoped loader and HarfRust caches, shares decoded raster resources through `RasterRuntime`, and owns the resulting paragraph and raster batches as one generation. The first incomplete generation stays hidden; a later load keeps the prior complete generation visible until every raster target can swap atomically. Revision-scoped cancellation prevents stale work from publishing. Semantic no-op updates preserve an in-flight cold generation, its abort signal, and its original readiness observation instead of restarting raster decode. Callback-only updates also retain that work and the latest `onLayout` observes the committed layout; after a genuine generation failure, the same semantic input explicitly retries rather than becoming permanently inert. Terminal font-disposal invalidation is distinct: a semantic no-op matching the invalidated generation's input preserves its rejected readiness state, while replacing that input may schedule recovery. The terminal state is scoped to the invalidated generation's own input, so an already-staged replacement remains recoverable if the superseded font is disposed. Explicit disposal clears that saved terminal state along with pending and committed ownership. Every committed replacement releases its superseded font-disposal subscription while preserving a shared paragraph when only constraints changed. Paint-only updates stage through the same lifecycle while keeping the committed generation wrapper and its identity-keyed font-disposal listener attached. They reuse the positioned layout and retain one glyph-to-span paint-index plan while the text and normalized shaping ranges are unchanged. Validation and staging receive the same resolved `GlyphPaint` value, and repeated same-range updates reuse its `Uint16Array` index storage instead of rebuilding a code-unit map, palette-key map, and glyph-index array. One reusable Three color converter removes transient `Color` objects without weakening public color validation. Semantic no-op paint updates skip staging, width updates reuse paragraph shaping, shaping changes replace the paragraph, and disposal releases every owned batch and paragraph. MTSDF batches retain outline-width and shadow-offset structure per instance: color-only updates write only paint attributes, while structural paint changes take the full geometry/UV path. Direct scalar attribute writes avoid short temporary arrays on both paths. Runtime performance instrumentation does not ship in this package; the benchmark measures public `Text` scheduling and readiness externally. Integration evidence covers changing a span's color while retaining the exact committed layout, draw-batch object, and paint-index storage; MTSDF coverage separately proves color-only updates preserve origin/size/UV structure and structural changes recompute it. Focused lifecycle evidence now additionally proves stage success, injected failure, stale abort, commit/abort idempotence, and live-batch preservation. A raw span font inherits the root raster definition but resolves its own font-local resource, preventing cross-font atlas reuse.
+The Three-backed `Text` object is a real Three.js `Group` over the portable transaction contract rather than making Three part of that contract. It validates one complete candidate state before committing a patch, resolves every distinct root/span font through registry-scoped loader and HarfRust caches, shares decoded raster resources through `RasterRuntime`, and owns the resulting paragraph and raster batches as one generation. The first incomplete generation stays hidden; a later load keeps the prior complete generation visible until every raster target can swap atomically. React Suspense owns cold font, shaper, raster decode, and page preparation. The loader, shaper, and raster runtime additionally expose package-internal synchronous cache peeks: once those dependencies and layout-required pages are resident, `setProperties` shapes, lays out, plans paint, and stages synchronously without a consumer readiness wait. The committed generation remains live until `updateMatrixWorld` or `updateWorldMatrix` publishes the candidate before traversing raster children, and the React adapter invalidates its R3F root after changing core properties. Revision-scoped cancellation prevents stale work from publishing. Semantic no-op updates preserve an in-flight cold generation, abort signal, queued warm publication, and their original readiness observations instead of restarting work. Callback-only updates also retain that work and the latest `onLayout` observes the committed layout; after a genuine generation failure, the same semantic input explicitly retries rather than becoming permanently inert. Terminal font-disposal invalidation is distinct: a semantic no-op matching the invalidated generation's input preserves its rejected readiness state, while replacing that input may schedule recovery. The terminal state is scoped to the invalidated generation's own input, so an already-staged replacement remains recoverable if the superseded font is disposed; disposing that old font preserves the valid candidate and its readiness observation. Explicit disposal clears that saved terminal state along with pending and committed ownership. Every committed replacement releases its superseded font-disposal subscription while preserving a shared paragraph when only constraints changed. Paint-only updates stage through the same lifecycle while reusing the positioned layout, resident pages, and one glyph-to-span paint-index plan while text and normalized shaping ranges are unchanged. Validation and staging receive the same resolved `GlyphPaint` value, and repeated same-range updates reuse its `Uint16Array` index storage instead of rebuilding a code-unit map, palette-key map, and glyph-index array. One reusable Three color converter removes transient `Color` objects without weakening public color validation. Semantic no-op paint updates skip staging, width updates reuse paragraph shaping, shaping changes replace the paragraph, and disposal releases every owned batch and paragraph. MTSDF batches retain outline-width and shadow-offset structure per instance: color-only updates write only paint attributes, while structural paint changes take the full geometry/UV path. Direct scalar attribute writes avoid short temporary arrays on both paths. Runtime performance instrumentation does not ship in this package; the benchmark measures public scheduling externally. Integration evidence proves the previous layout remains live until object traversal, publication precedes retained-child traversal, React performs no consumer `ready` wait, same-range paint storage retains identity, asynchronous multi-font preparation aborts after a sibling failure, superseded-font disposal preserves a resident replacement, commit-contract faults cannot abort sibling traversal, and MTSDF color-only updates preserve origin/size/UV structure. A raw span font inherits the root raster definition but resolves its own font-local resource, preventing cross-font atlas reuse.
 
 The `@pmndrs/text/react` export now provides the thin runtime described by the accepted API. It flattens nested text nodes into one UTF-16 string plus ordered inherited spans, rejects nested object/layout props and non-text children, creates one core object only after React 19 dependencies resolve, forwards that object through its ref, and reconciles ordinary R3F transforms separately from core text properties. The forbidden source `text` and `spans` props remain explicit `never` fields because R3F v10's wider intrinsic-element types would otherwise weaken that public boundary. Semantic feature and inline-paint comparison prevents fresh-but-equal React values from scheduling layout or glyph-buffer work; a fresh `onLayout` callback updates ownership without repainting. `useFont`, `.preload`, `.clear`, and `lazyRaster` reuse the same loader, shaper, and raster dependencies as the core. A deterministic microtask-delayed disposal distinguishes React Strict Mode's setup/cleanup/setup cycle without sleeps or timer cushions.
 
diff --git a/docs/planning/api-shapes.md b/docs/planning/api-shapes.md
index ebea83d2..a1a5c677 100644
--- a/docs/planning/api-shapes.md
+++ b/docs/planning/api-shapes.md
@@ -169,7 +169,7 @@ declare class Text extends Group {
 
 `width` and `height` are local Three.js units. A supplied dimension maps to an `exactly` paragraph axis; an omitted dimension maps to `unconstrained`. Standard `Object3D` transforms remain standard Three.js/R3F properties rather than being duplicated in `TextProperties`. Direct text properties follow Drei and uikit conventions; there is no second CSS-like `style` object in V0. React users can create styled wrapper components with ordinary component composition. `lineHeight` is a unitless multiplier of the effective `fontSize`. `rasterPixelRatio` defaults to one, describes physical pixels per paragraph-local CSS pixel, and changes raster batch selection without changing shaping or logical layout. Browser/native integrations supply it explicitly; the core never reads a platform global.
 
-`Text` owns a paragraph instance, the raster resources required by its font slots, and raster-specific Three.js draw objects. The normal `font` value is a composed `FontToken`; callers may instead provide a raw font input plus a raster definition for one-off use. Both forms normalize through the same caches. Because the framework-neutral `Text` class is deliberately non-generic, the raw form is runtime-validated; reusable `defineFont` tokens and `RasterRuntime.load` retain package-owned option types at compile time. The token's raster definition resolves a deterministic serialized raster key; callers never invent that key. `ready` waits for every distinct root/span font, shared-shaper initialization, selected raster index, initial shape/layout, and raster pages required by that initial layout; raw or registered span fonts inherit the root raster definition, while a span `FontToken` carries its own. Once those exist, span inputs are resolved to `FontHandle`s before paragraph creation. The object stays hidden until that first computation completes, but shaping and layout do not introduce another Suspense resource. Updating only transform or paint uniforms does not reflow; updating width reflows; updating text or shaping styles invalidates the affected shaping cache. A later update that needs different pages retains the last complete draw generation until the replacement pages are ready, then swaps batches atomically; stale or cancelled page preparation never replaces newer output.
+`Text` owns a paragraph instance, the raster resources required by its font slots, and raster-specific Three.js draw objects. The normal `font` value is a composed `FontToken`; callers may instead provide a raw font input plus a raster definition for one-off use. Both forms normalize through the same caches. Because the framework-neutral `Text` class is deliberately non-generic, the raw form is runtime-validated; reusable `defineFont` tokens and `RasterRuntime.load` retain package-owned option types at compile time. The token's raster definition resolves a deterministic serialized raster key; callers never invent that key. `ready` observes every distinct root/span font, shared-shaper initialization, selected raster index, initial shape/layout, raster pages required by that layout, and any candidate queued for object-lifecycle publication; raw or registered span fonts inherit the root raster definition, while a span `FontToken` carries its own. React Suspense owns those genuinely cold dependencies. Once font, shaper, decoded raster, and required pages are resident, `setProperties` resolves handles, shapes, lays out, plans paint, and stages synchronously. The previous complete generation remains authoritative until `updateMatrixWorld` or `updateWorldMatrix` atomically publishes the candidate before traversing raster children, so React consumers do not await `ready` for ordinary warm updates; the React adapter explicitly invalidates the R3F root after changing core properties. Updating only transform does not reflow; updating paint reuses the resident layout, pages, and paint-index storage; updating width reflows; updating text or shaping styles invalidates the affected shaping cache. A later update that needs different pages retains the last complete draw generation until the replacement pages are ready; stale or cancelled preparation never replaces newer output. Synchronous validation, shaping, preparation, and staging faults throw from `setProperties` while preserving the prior state and any earlier candidate. Asynchronous preparation failures and defensive handling of a plugin that violates the infallible-commit contract reject `ready`; a plugin fault cannot stop unrelated Three.js sibling traversal.
 
 `setProperties` uses an atomic `TextUpdateProperties` patch rather than `Partial<TextProperties>`. Replacing spans requires supplying their source `text`; replacing a raw font requires its raster in the same patch; a composed token replaces both together. The complete merged state, span ordering, UTF-16 ranges, and raster configuration are validated before any change is committed.
 
@@ -963,7 +963,7 @@ interface RasterModule<Kind extends string, Resource, DrawBatch extends RasterDr
   readonly runtimeBaker?: RuntimeRasterBakerLoader<Kind, Options>;
   descriptor(options: RasterOptionsArgument<Options>): JsonValue;
   decode(font: RegisteredFont, raster: RegisteredRaster<Kind>, signal?: AbortSignal): Promise<Resource>;
-  prepare(layout: ParagraphLayout, resource: Resource, fontSlot: FontSlot, signal?: AbortSignal): Promise<void>;
+  prepare(layout: ParagraphLayout, resource: Resource, fontSlot: FontSlot, signal?: AbortSignal): void | Promise<void>;
   stageBatch(
     previous: DrawBatch | undefined,
     layout: ParagraphLayout,
@@ -1027,7 +1027,7 @@ interface LoadedRaster<M extends AnyRasterModule> {
 }
 ```
 
-Each raster package owns its configuration surface and returns a typed raster definition. A raster with no required configuration may export a ready-made module value. A module whose options are optional may be passed bare for its canonical defaults or paired with an options object; a module with required options cannot be passed bare. Bitmap exposes only its factory because its strike set is mandatory. MSDF exposes a ready-made module whose optional quality controls default to 64 px/em and a full eight-pixel range:
+Each raster package owns its configuration surface and returns a typed raster definition. A raster with no required configuration may export a ready-made module value. A module whose options are optional may be passed bare for its canonical defaults or paired with an options object; a module with required options cannot be passed bare. `prepare` is the residency boundary: it returns `void` when the layout's required pages are already resident and one Promise only while genuinely cold work remains. Core carries that Promise forward under the generation's abort signal rather than probing or restarting it. Concurrent unpublished stages against one prior batch own independent staging state, so aborting one candidate cannot release another candidate's scratch or mutation plan. Bitmap exposes only its factory because its strike set is mandatory. MSDF exposes a ready-made module whose optional quality controls default to 64 px/em and a full eight-pixel range:
 
 ```ts
 type StaticNumberTuple<Values extends readonly [number, ...number[]]> = number extends Values[number] ? never : Values;
diff --git a/docs/planning/decision-register.md b/docs/planning/decision-register.md
index 4de8a62d..f315097e 100644
--- a/docs/planning/decision-register.md
+++ b/docs/planning/decision-register.md
@@ -135,48 +135,49 @@ The [architecture](architecture.md) owns loading behavior and dependency rules.
 
 ## Raster
 
-| ID    | Decision                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |       Status        |
-| ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :-----------------: |
-| D-050 | V1 ships bitmap, MSDF, and Slug; bitmap alone is only the proof.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |      Accepted       |
-| D-051 | Rasters never duplicate advances, kerning, or shaping behavior.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |      Accepted       |
-| D-052 | Direct-to-GPU means no reconstruction/repacking, not zero upload.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |      Accepted       |
-| D-053 | The MSDF raster uses linear MTSDF RGBA8; padding stays in raster bounds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |      Accepted       |
-| D-054 | Deterministic unhinted bitmap oversampling is the baseline candidate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |     Experiment      |
-| D-055 | Recommend MSDF generally, but require an explicit raster module.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |      Accepted       |
-| D-056 | Windfoil is research prior art, not a planned text backend.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |      Accepted       |
-| D-057 | Post-slice Slug includes color-emoji vector paint; safe OpenType-SVG and standalone-SVG icon baking lands in the large-coverage CJK/icon milestone.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |      Accepted       |
-| D-058 | Fill, opacity, outline, and hard shadow are baseline game-text styles.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |      Accepted       |
-| D-059 | Payload reports separate shaping, transport, decoded, and GPU bytes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |      Accepted       |
-| D-061 | Slug bands compress exactly; curve compression remains quality-gated.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |      Accepted       |
-| D-064 | V1 does not support plain MSDF assets or parallel MSDF/MTSDF batches.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |      Accepted       |
-| D-065 | First-party raster packages use TSL internally; the core raster API is shader-system and backend agnostic.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |      Accepted       |
-| D-073 | V1 assigns one selected raster per font slot; per-glyph raster mixing is additive color/SVG work after the first release.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |      Accepted       |
-| D-075 | Latin remains the V1 rendering and raster-coverage priority. Pre-render CJK shaping/layout conformance may harden universal core assumptions, but CJK raster paging and icon coverage remain a post-V1 milestone and do not expand the Latin-first renderer exit gate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |      Accepted       |
-| D-076 | Raster page indexes are logical IDs; page payloads may be embedded or independently addressed, and raster modules own preparation, residency, eviction, and backend batching.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |      Accepted       |
-| D-091 | Bitmap plane bounds preserve the rasterizer's integer pixel placement with `planeUnitsPerEm = strike ppem`; the shared TSL vertex graph snaps projected quad edges to physical framebuffer pixels so native rendering maps one atlas texel to one device pixel.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |      Accepted       |
-| D-092 | Hinted grayscale strikes and optional four-phase grayscale packing remain measured research. LCD/ClearType subpixel rendering, panel-order assumptions, runtime hint interpreters, and distance-field reconstruction are out of scope.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |     Experiment      |
-| D-093 | Bitmap V0 renders fill and opacity only and rejects outline or shadow through the raster paint-validation seam; MTSDF owns those distance-based effects rather than silently degrading them.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |      Accepted       |
-| D-096 | Bitmap presentation transitions are optional `@pmndrs/text/raster/bitmap` helpers over copied glyph identities and instance origins. Shaping and layout commit discretely; only identity-matched glyph positions interpolate before the existing physical-pixel snap, and unused consumers pay no target-origin allocation.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |   Settled for V0    |
-| D-097 | Milestone 8 owns a purpose-built `no_std + alloc` Rust MTSDF core under `packages/text/rust`, with repository-defined types, limits, reusable scratch storage, data-oriented scalar/SIMD experiments, typed errors, and the generated direct-memory C ABI/JSON boundary. The scalar path is a correctness oracle; if `simd128` wins the complete quality, full-font-time, and size comparison, it is the single default shipped Wasm kernel rather than a baker option. The core may retain proven design ideas from reviewed implementations but is not a copied Klyff fork. Pinned native Chlumsky `msdfgen` remains the canonical test-only oracle and port reference; Klyff, OxiText, Rust bindings, and UIKit/Zappar remain research evidence rather than product dependencies. |      Accepted       |
-| D-099 | MTSDF V0 originally fixed one opinionated bake: 64 plane units per em, a full eight-pixel encoded distance range, four field-padding texels, one atlas-gap texel, 1024-pixel pages, dense 20-byte records, and lossless linear RGBA8 KTX2. The published baker composes the admitted scalar kernel with the shared Fontations provider and lossless artifact primitives; standalone generator evidence remains separately measurable but is not a second published Wasm.                                                                                                                                                                                                                                                                                                             | Superseded by D-110 |
-| D-100 | Text size is logical CSS geometry. A rendering integration supplies an explicit raster pixel ratio; bitmap targets `CSS size × ratio`, deterministically selects the nearest declared physical strike, and never changes paragraph geometry to compensate for DPR. The core installs no DOM or gesture listeners.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |      Accepted       |
-| D-101 | Bitmap density strikes remain independent grayscale record/texture sets rather than RGB(A)-channel packing. A combined artifact may carry several strikes, while Milestone 13 adds independently fetched and evictable strike pages.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |      Accepted       |
-| D-102 | Language delivery is exact-coverage-first and locale-aware. A family directory may route grapheme-safe runs to font-local units, but language labels alone never prove coverage and units never split contextual shaping runs. Compiler-produced shaping closure/remapping remains Milestone 17.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |      Accepted       |
-| D-103 | Explicit and fallback runtime raster baking accept normalized bounded coverage and raster options through the same Worker-only path. Coverage may be seeded by Unicode ranges, authored text, or exact font-local glyph IDs, but it reduces atlas generation only: it does not subset the shaping font, remap glyph IDs, or claim transitive shaping closure.                                                                                                                                                                                                                                                                                                                                                                                                                        |      Accepted       |
-| D-104 | Every direct-memory Wasm ABI layout is represented by fixed-width `#[repr(C)]` Rust types. Build-only Rust generators derive published JSON and exact `as const` TypeScript contracts from `size_of`, `align_of`, and `offset_of!`; production hosts import those generated facts, and production Wasm embeds no duplicate contract or ABI-pointer bootstrap. WebAssembly direct memory uses its guaranteed little-endian order; portable GLB, KTX2, SFNT, and extension encodings retain their format-defined byte order.                                                                                                                                                                                                                                                           |      Accepted       |
-| D-105 | V1 retains the current Three.js/TSL integration through Slug so its real shader, resource, batching, and lifetime requirements define the abstraction. After Slug lands, Milestone 10 extracts one renderer-neutral direct integration beneath Bitmap, MSDF, and Slug; Three.js becomes a supported adapter over it, while raw WebGPU and a possible TypeGPU adapter remain independently selectable integrations. Optional TypeGPU compute-baker research may proceed earlier but cannot force the renderer refactor or enter unrelated runtime graphs.                                                                                                                                                                                                                             |      Accepted       |
-| D-106 | Slug V0 artifacts retain exact R16UI reference grids. The Three.js 0.185.1 adapter may pair-pack those values into R32UI texels at decode time because its WebGL TSL backend does not declare an unsigned sampler for `UnsignedShortType`; this preserves reference identity and two-byte density plus at most one terminal padding value. Other adapters remain free to upload R16UI directly, and the exception does not redefine the portable artifact.                                                                                                                                                                                                                                                                                                                           |      Accepted       |
-| D-107 | Repository TypeScript commands execute the installed native compiler through one bounded runner that first proves its kill/reap path with a synthetic allocator, supervises the native PID rather than a shell or Node shim, caps aggregate tracked RSS, enforces a wall-time limit, and reports no success while a compiler survives. TSL changes compile reduced operation fixtures and a narrow graph before package or application projects; free functions remain the first mitigation but exact-version pathological overloads use one proven concrete compatibility boundary.                                                                                                                                                                                                 | Superseded by D-114 |
-| D-108 | MTSDF V0 uploads only the authenticated base level and uses bilinear field sampling plus screen derivatives for reconstruction. Conventional GPU mip generation and trilinear cross-level sampling are rejected: averaging encoded MSDF channels is not a distance-field-preserving operation, and the primary MSDF paper plus official generators provide no affirmative mipmap guidance. Runtime, standalone validation, fixtures, and the inspector report the exact padded base texture-array allocation. Any future size-specific representation is an independently authored atlas layer or strike, not a conventional mip chain.                                                                                                                                              |      Accepted       |
-| D-109 | Slug V0 implemented a centered exact-distance outline in one specialized fill-plus-outline draw. Retained measurements later showed `2.44×–4.33×` fill-only GPU time, and generated-shader inspection found duplicated traversal, curve loads, closest-point refinement, and a derivative inside divergent control flow.                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Superseded by D-111 |
-| D-110 | MTSDF V0 exposes `emSize` and full `pixelRange` as authenticated integer bake options. `emSize` is limited to `1..=1022`, `pixelRange` to `1..=1020`, `planeUnitsPerEm` equals `emSize`, and field padding is `ceil(pixelRange / 2)`. Omitted or partial options resolve against the 64/8 compatibility defaults; explicit effective 64/8 canonicalizes to the legacy fieldless descriptor and raster key, while every non-default descriptor contains both effective values. The low-level Wasm ABI is unchanged. Passing 32/4 and 32/6 155-glyph subset bakes proves the control path, not a new recommended default; quality and payload benchmarking owns that decision.                                                                                                         |      Accepted       |
-| D-111 | Remove the dynamic exact-distance Slug outline rather than ship an expensive fallback. Slug V0 supports fill and opacity and rejects every runtime outline or shadow property. The generic text outline API remains because MTSDF owns it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |      Accepted       |
-| D-112 | Research one bounded Slug outline approximation that reuses ordinary fill traversal and screen derivatives without closest-point solving or independent halo traversal. It ships only if its quality is no worse than the MTSDF outline corpus and its median GPU time is at most `1.15×` a same-expanded-quad fill control on both WebGPU and forced WebGL2; otherwise Slug remains fill-only.                                                                                                                                                                                                                                                                                                                                                                                      |     Experiment      |
-| D-114 | Carry the upstream `NodeExtras` lookup-map rewrite as a version-pinned pnpm patch for `@types/three` 0.185.1. A focused compile-only regression owns every previously explosive TSL operation. Package and application scripts invoke the pinned compiler directly; the native-process memory guard and its repository-wide invocation requirement are removed because they contained a dependency type-graph defect now corrected at its declaration boundary.                                                                                                                                                                                                                                                                                                                      |      Accepted       |
-| D-115 | The benchmark app uses Koota as an application-boundary state manager. Coherent singleton world traits own live controls and published telemetry; direct world reads/writes coordinate capture and renderer state. The world instance is exported from a dedicated HMR-stable module. Koota does not enter core text, shaping, layout, baking, raster, or public package APIs, and entities/queries are reserved for data that genuinely has collection lifecycle.                                                                                                                                                                                                                                                                                                                   |      Accepted       |
-| D-116 | Interactive benchmark overlays use official shadcn components backed by Base UI rather than application-owned dismissal, focus, portal, or keyboard machinery. Repository semantic tokens theme those checked-in components. Koota remains the single owner of runtime control values; shadcn/Base UI owns interaction behavior only.                                                                                                                                                                                                                                                                                                                                                                                                                                                |      Accepted       |
-| D-117 | Each benchmark route owns one persistent render host per backend generation. The host owns the canvas, renderer, animation loop, GPU timing, telemetry history, viewport, and serialized scene/job lifecycle. React Suspense owns cold asset readiness; scene, technique, delivery, and font selections preload and commit with React transitions so the last complete scene remains visible until an atomic replacement is ready. Compatible font changes retain the active `Text` objects and registry.                                                                                                                                                                                                                                                                            |      Accepted       |
-| D-118 | Milestone 10 replaces `buildBatches`, optional retained updates, and separate repaint mutation with one required renderer-neutral `stageBatch(previous, layout, resource, fontSlot, paint, rasterPixelRatio)` transaction. A stage owns one unpublished target batch, may retain or replace the previous batch, cannot mutate committed state before publication, commits synchronously and infallibly, and aborts idempotently; committed batch disposal is also idempotent. The portable contract exposes no Three.js, TSL, WebGPU, WebGL, or first-party raster-kind union. Three.js object attachment is an adapter requirement enforced by `Text`, not part of `RasterDrawBatch`.                                                                                               |      Accepted       |
+| ID    | Decision                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |       Status        |
+| ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-----------------: |
+| D-050 | V1 ships bitmap, MSDF, and Slug; bitmap alone is only the proof.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |      Accepted       |
+| D-051 | Rasters never duplicate advances, kerning, or shaping behavior.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |      Accepted       |
+| D-052 | Direct-to-GPU means no reconstruction/repacking, not zero upload.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |      Accepted       |
+| D-053 | The MSDF raster uses linear MTSDF RGBA8; padding stays in raster bounds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |      Accepted       |
+| D-054 | Deterministic unhinted bitmap oversampling is the baseline candidate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |     Experiment      |
+| D-055 | Recommend MSDF generally, but require an explicit raster module.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |      Accepted       |
+| D-056 | Windfoil is research prior art, not a planned text backend.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |      Accepted       |
+| D-057 | Post-slice Slug includes color-emoji vector paint; safe OpenType-SVG and standalone-SVG icon baking lands in the large-coverage CJK/icon milestone.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |      Accepted       |
+| D-058 | Fill, opacity, outline, and hard shadow are baseline game-text styles.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |      Accepted       |
+| D-059 | Payload reports separate shaping, transport, decoded, and GPU bytes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |      Accepted       |
+| D-061 | Slug bands compress exactly; curve compression remains quality-gated.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |      Accepted       |
+| D-064 | V1 does not support plain MSDF assets or parallel MSDF/MTSDF batches.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |      Accepted       |
+| D-065 | First-party raster packages use TSL internally; the core raster API is shader-system and backend agnostic.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |      Accepted       |
+| D-073 | V1 assigns one selected raster per font slot; per-glyph raster mixing is additive color/SVG work after the first release.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |      Accepted       |
+| D-075 | Latin remains the V1 rendering and raster-coverage priority. Pre-render CJK shaping/layout conformance may harden universal core assumptions, but CJK raster paging and icon coverage remain a post-V1 milestone and do not expand the Latin-first renderer exit gate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |      Accepted       |
+| D-076 | Raster page indexes are logical IDs; page payloads may be embedded or independently addressed, and raster modules own preparation, residency, eviction, and backend batching.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |      Accepted       |
+| D-091 | Bitmap plane bounds preserve the rasterizer's integer pixel placement with `planeUnitsPerEm = strike ppem`; the shared TSL vertex graph snaps projected quad edges to physical framebuffer pixels so native rendering maps one atlas texel to one device pixel.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |      Accepted       |
+| D-092 | Hinted grayscale strikes and optional four-phase grayscale packing remain measured research. LCD/ClearType subpixel rendering, panel-order assumptions, runtime hint interpreters, and distance-field reconstruction are out of scope.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     Experiment      |
+| D-093 | Bitmap V0 renders fill and opacity only and rejects outline or shadow through the raster paint-validation seam; MTSDF owns those distance-based effects rather than silently degrading them.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |      Accepted       |
+| D-096 | Bitmap presentation transitions are optional `@pmndrs/text/raster/bitmap` helpers over copied glyph identities and instance origins. Shaping and layout commit discretely; only identity-matched glyph positions interpolate before the existing physical-pixel snap, and unused consumers pay no target-origin allocation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |   Settled for V0    |
+| D-097 | Milestone 8 owns a purpose-built `no_std + alloc` Rust MTSDF core under `packages/text/rust`, with repository-defined types, limits, reusable scratch storage, data-oriented scalar/SIMD experiments, typed errors, and the generated direct-memory C ABI/JSON boundary. The scalar path is a correctness oracle; if `simd128` wins the complete quality, full-font-time, and size comparison, it is the single default shipped Wasm kernel rather than a baker option. The core may retain proven design ideas from reviewed implementations but is not a copied Klyff fork. Pinned native Chlumsky `msdfgen` remains the canonical test-only oracle and port reference; Klyff, OxiText, Rust bindings, and UIKit/Zappar remain research evidence rather than product dependencies.                                                                                                                                                                                                         |      Accepted       |
+| D-099 | MTSDF V0 originally fixed one opinionated bake: 64 plane units per em, a full eight-pixel encoded distance range, four field-padding texels, one atlas-gap texel, 1024-pixel pages, dense 20-byte records, and lossless linear RGBA8 KTX2. The published baker composes the admitted scalar kernel with the shared Fontations provider and lossless artifact primitives; standalone generator evidence remains separately measurable but is not a second published Wasm.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Superseded by D-110 |
+| D-100 | Text size is logical CSS geometry. A rendering integration supplies an explicit raster pixel ratio; bitmap targets `CSS size × ratio`, deterministically selects the nearest declared physical strike, and never changes paragraph geometry to compensate for DPR. The core installs no DOM or gesture listeners.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |      Accepted       |
+| D-101 | Bitmap density strikes remain independent grayscale record/texture sets rather than RGB(A)-channel packing. A combined artifact may carry several strikes, while Milestone 13 adds independently fetched and evictable strike pages.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |      Accepted       |
+| D-102 | Language delivery is exact-coverage-first and locale-aware. A family directory may route grapheme-safe runs to font-local units, but language labels alone never prove coverage and units never split contextual shaping runs. Compiler-produced shaping closure/remapping remains Milestone 17.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |      Accepted       |
+| D-103 | Explicit and fallback runtime raster baking accept normalized bounded coverage and raster options through the same Worker-only path. Coverage may be seeded by Unicode ranges, authored text, or exact font-local glyph IDs, but it reduces atlas generation only: it does not subset the shaping font, remap glyph IDs, or claim transitive shaping closure.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |      Accepted       |
+| D-104 | Every direct-memory Wasm ABI layout is represented by fixed-width `#[repr(C)]` Rust types. Build-only Rust generators derive published JSON and exact `as const` TypeScript contracts from `size_of`, `align_of`, and `offset_of!`; production hosts import those generated facts, and production Wasm embeds no duplicate contract or ABI-pointer bootstrap. WebAssembly direct memory uses its guaranteed little-endian order; portable GLB, KTX2, SFNT, and extension encodings retain their format-defined byte order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |      Accepted       |
+| D-105 | V1 retains the current Three.js/TSL integration through Slug so its real shader, resource, batching, and lifetime requirements define the abstraction. After Slug lands, Milestone 10 extracts one renderer-neutral direct integration beneath Bitmap, MSDF, and Slug; Three.js becomes a supported adapter over it, while raw WebGPU and a possible TypeGPU adapter remain independently selectable integrations. Optional TypeGPU compute-baker research may proceed earlier but cannot force the renderer refactor or enter unrelated runtime graphs.                                                                                                                                                                                                                                                                                                                                                                                                                                     |      Accepted       |
+| D-106 | Slug V0 artifacts retain exact R16UI reference grids. The Three.js 0.185.1 adapter may pair-pack those values into R32UI texels at decode time because its WebGL TSL backend does not declare an unsigned sampler for `UnsignedShortType`; this preserves reference identity and two-byte density plus at most one terminal padding value. Other adapters remain free to upload R16UI directly, and the exception does not redefine the portable artifact.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |      Accepted       |
+| D-107 | Repository TypeScript commands execute the installed native compiler through one bounded runner that first proves its kill/reap path with a synthetic allocator, supervises the native PID rather than a shell or Node shim, caps aggregate tracked RSS, enforces a wall-time limit, and reports no success while a compiler survives. TSL changes compile reduced operation fixtures and a narrow graph before package or application projects; free functions remain the first mitigation but exact-version pathological overloads use one proven concrete compatibility boundary.                                                                                                                                                                                                                                                                                                                                                                                                         | Superseded by D-114 |
+| D-108 | MTSDF V0 uploads only the authenticated base level and uses bilinear field sampling plus screen derivatives for reconstruction. Conventional GPU mip generation and trilinear cross-level sampling are rejected: averaging encoded MSDF channels is not a distance-field-preserving operation, and the primary MSDF paper plus official generators provide no affirmative mipmap guidance. Runtime, standalone validation, fixtures, and the inspector report the exact padded base texture-array allocation. Any future size-specific representation is an independently authored atlas layer or strike, not a conventional mip chain.                                                                                                                                                                                                                                                                                                                                                      |      Accepted       |
+| D-109 | Slug V0 implemented a centered exact-distance outline in one specialized fill-plus-outline draw. Retained measurements later showed `2.44×–4.33×` fill-only GPU time, and generated-shader inspection found duplicated traversal, curve loads, closest-point refinement, and a derivative inside divergent control flow.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Superseded by D-111 |
+| D-110 | MTSDF V0 exposes `emSize` and full `pixelRange` as authenticated integer bake options. `emSize` is limited to `1..=1022`, `pixelRange` to `1..=1020`, `planeUnitsPerEm` equals `emSize`, and field padding is `ceil(pixelRange / 2)`. Omitted or partial options resolve against the 64/8 compatibility defaults; explicit effective 64/8 canonicalizes to the legacy fieldless descriptor and raster key, while every non-default descriptor contains both effective values. The low-level Wasm ABI is unchanged. Passing 32/4 and 32/6 155-glyph subset bakes proves the control path, not a new recommended default; quality and payload benchmarking owns that decision.                                                                                                                                                                                                                                                                                                                 |      Accepted       |
+| D-111 | Remove the dynamic exact-distance Slug outline rather than ship an expensive fallback. Slug V0 supports fill and opacity and rejects every runtime outline or shadow property. The generic text outline API remains because MTSDF owns it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |      Accepted       |
+| D-112 | Research one bounded Slug outline approximation that reuses ordinary fill traversal and screen derivatives without closest-point solving or independent halo traversal. It ships only if its quality is no worse than the MTSDF outline corpus and its median GPU time is at most `1.15×` a same-expanded-quad fill control on both WebGPU and forced WebGL2; otherwise Slug remains fill-only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |     Experiment      |
+| D-114 | Carry the upstream `NodeExtras` lookup-map rewrite as a version-pinned pnpm patch for `@types/three` 0.185.1. A focused compile-only regression owns every previously explosive TSL operation. Package and application scripts invoke the pinned compiler directly; the native-process memory guard and its repository-wide invocation requirement are removed because they contained a dependency type-graph defect now corrected at its declaration boundary.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |      Accepted       |
+| D-115 | The benchmark app uses Koota as an application-boundary state manager. Coherent singleton world traits own live controls and published telemetry; direct world reads/writes coordinate capture and renderer state. The world instance is exported from a dedicated HMR-stable module. Koota does not enter core text, shaping, layout, baking, raster, or public package APIs, and entities/queries are reserved for data that genuinely has collection lifecycle.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |      Accepted       |
+| D-116 | Interactive benchmark overlays use official shadcn components backed by Base UI rather than application-owned dismissal, focus, portal, or keyboard machinery. Repository semantic tokens theme those checked-in components. Koota remains the single owner of runtime control values; shadcn/Base UI owns interaction behavior only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |      Accepted       |
+| D-117 | Each benchmark route owns one persistent render host per backend generation. The host owns the canvas, renderer, animation loop, GPU timing, telemetry history, viewport, and serialized scene/job lifecycle. React Suspense owns cold asset readiness; scene, technique, delivery, and font selections preload and commit with React transitions so the last complete scene remains visible until an atomic replacement is ready. Compatible font changes retain the active `Text` objects and registry.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |      Accepted       |
+| D-118 | Milestone 10 replaces `buildBatches`, optional retained updates, and separate repaint mutation with one required renderer-neutral `stageBatch(previous, layout, resource, fontSlot, paint, rasterPixelRatio)` transaction. A stage owns one unpublished target batch, may retain or replace the previous batch, cannot mutate committed state before publication, commits synchronously and infallibly, and aborts idempotently; committed batch disposal is also idempotent. The portable contract exposes no Three.js, TSL, WebGPU, WebGL, or first-party raster-kind union. Three.js object attachment is an adapter requirement enforced by `Text`, not part of `RasterDrawBatch`.                                                                                                                                                                                                                                                                                                       |      Accepted       |
+| D-119 | Once a font, shared shaper, decoded raster resource, and layout-required raster pages are resident, `Text.setProperties` shapes, lays out, plans paint, and stages synchronously while retaining the previous complete generation. The Three.js adapter publishes that candidate at the start of `updateMatrixWorld` or `updateWorldMatrix`, before child traversal; the React adapter explicitly invalidates its R3F root after a core-property update. `ready` remains an observation channel for cold work and queued publication, not a consumer coordination requirement for warm React updates. Synchronous validation, shaping, preparation, or staging faults throw from `setProperties` without cancelling an earlier candidate or live generation; asynchronous preparation and defensive commit-contract faults reject `ready`. A raster `prepare` implementation returns `void` when its requirement is resident and one shared idempotent Promise only for genuinely cold work. |      Accepted       |
 
 The [raster contract](raster-data-contract.md) owns records. The [capability matrix](renderer-capabilities.md), [payload budget](payload-budget.md), and [compression analysis](gpu-compression.md) own evidence and limitations.
 
diff --git a/docs/roadmap/roadmap.md b/docs/roadmap/roadmap.md
index 4b26d13f..cf9c2805 100644
--- a/docs/roadmap/roadmap.md
+++ b/docs/roadmap/roadmap.md
@@ -118,9 +118,9 @@ These rows replace the former separate backlog. Each is intended to become one f
 | 9.2  |   ✅   | Copy and adapt the version-matched analytic TSL fill runtime, batching, lifecycle, fail-closed paint boundary, and public `Text` integration.                                            |  XL  | 9.1        |
 | 9.3  |   ✅   | Integrate Slug into the shared benchmark/conformance product, release-role scenes, source-outline matrix, and complete two-axis icon-font grid.                                          |  XL  | 9.2        |
 | 9.4  |   ✅   | Reproduce the applicable prior-fork performance baseline, evaluate retained challengers, and close payload, residency, frame-time, and bundle-isolation gates.                           |  XL  | 9.3        |
-| 10.1 |   🟡   | Replace the optional Three-shaped plugin seam with one required renderer-neutral transactional raster lifecycle and retain Three.js as an adapter.                                       |  L   | 8.6, 9.4   |
-| 10.2 |   ⬜   | Publish warm shaping, layout, paint planning, and raster staging through the Three.js object-update lifecycle without consumer `ready` waits.                                            |  L   | 10.1       |
-| 10.3 |   ⬜   | Add bounded glyph-capacity slack, complete in-place field replacement, authoritative shrink counts, overflow replacement, and coalesced dirty uploads to all three rasters.              |  XL  | 10.2       |
+| 10.1 |   ✅   | Replace the optional Three-shaped plugin seam with one required renderer-neutral transactional raster lifecycle and retain Three.js as an adapter.                                       |  L   | 8.6, 9.4   |
+| 10.2 |   ✅   | Publish warm shaping, layout, paint planning, and raster staging through the Three.js object-update lifecycle without consumer `ready` waits.                                            |  L   | 10.1       |
+| 10.3 |   🟡   | Add bounded glyph-capacity slack, complete in-place field replacement, authoritative shrink counts, overflow replacement, and coalesced dirty uploads to all three rasters.              |  XL  | 10.2       |
 | 10.4 |   ⬜   | Prove the public extension boundary with a private workspace raster/baker package that owns a new kind, artifact, adapter, retained updates, overflow, abort, and disposal.              |  L   | 10.1, 10.3 |
 | 10.5 |   ⬜   | Remove benchmark recycling workarounds and prove Icon Grid plus every Presentation workload through sequential, timed, allocation, cadence, dual-backend, and React Doctor gates.        |  XL  | 10.2–10.4  |
 | 10.6 |   ⬜   | Complete raster switching, release conformance, public API review, recommendations, migration material, package-size evidence, and signed stacked delivery.                              |  L   | 10.5       |
@@ -684,7 +684,7 @@ Milestone 9 is closed. Additional Slug optimization hypotheses are future measur
 
 ## Milestone 10 — harden the first shippable release
 
-Item 10.1 is active. The accepted implementation order is the required renderer-neutral transaction, Three.js adapter parity, lifecycle-owned warm publication, bounded retained capacity, the external raster/baker proof, benchmark cleanup and hardware evidence, then release review. Each layer must remain independently green; renderer-wide batching across separate `Text` objects is explicitly not part of this milestone.
+Item 10.3 is active. Item 10.1 established the required renderer-neutral transaction and Three.js adapter parity, and item 10.2 moved resident shaping, layout, paint planning, raster staging, and atomic publication into the Three.js object-update lifecycle without warm consumer readiness waits. The remaining accepted order is bounded retained capacity, the external raster/baker proof, benchmark cleanup and hardware evidence, then release review. Each layer must remain independently green; renderer-wide batching across separate `Text` objects is explicitly not part of this milestone.
 
 ### 10.1–10.6 closure checklist
 
diff --git a/packages/text/src/internal/text-runtime.ts b/packages/text/src/internal/text-runtime.ts
index 7c592742..c27acee2 100644
--- a/packages/text/src/internal/text-runtime.ts
+++ b/packages/text/src/internal/text-runtime.ts
@@ -6,6 +6,7 @@ import { createRuntimeShaper, type RuntimeShaper } from '../shaper.js';
 
 const loaders = new WeakMap<FontRegistry, FontLoader>();
 const shapers = new WeakMap<FontRegistry, Promise<RuntimeShaper>>();
+const resolvedShapers = new WeakMap<FontRegistry, RuntimeShaper>();
 let defaultRegistry: FontRegistry | undefined;
 
 export const sharedRasterRuntime: RasterRuntime = new RasterRuntime();
@@ -17,26 +18,44 @@ export function textRegistry(font?: RegisteredFont): FontRegistry {
 }
 
 export function loadTextFont(input: FontInput, registry: FontRegistry, signal?: AbortSignal): Promise<RegisteredFont> {
-  let loader = loaders.get(registry);
-  if (loader === undefined) {
-    loader = new FontLoader({ registry });
-    loaders.set(registry, loader);
-  }
-  return loader.load(input, signal === undefined ? undefined : { signal });
+  return textLoader(registry).load(input, signal === undefined ? undefined : { signal });
+}
+
+export function loadedTextFont(input: FontInput, registry: FontRegistry): RegisteredFont | undefined {
+  return textLoader(registry)._peek(input);
 }
 
 export function textShaper(registry: FontRegistry): Promise<RuntimeShaper> {
   let promise = shapers.get(registry);
   if (promise === undefined) {
-    promise = createRuntimeShaper({ registry }).catch((error: unknown) => {
-      shapers.delete(registry);
-      throw error;
-    });
+    promise = createRuntimeShaper({ registry }).then(
+      (shaper) => {
+        resolvedShapers.set(registry, shaper);
+        return shaper;
+      },
+      (error: unknown) => {
+        shapers.delete(registry);
+        throw error;
+      },
+    );
     shapers.set(registry, promise);
   }
   return promise;
 }
 
+export function loadedTextShaper(registry: FontRegistry): RuntimeShaper | undefined {
+  return resolvedShapers.get(registry);
+}
+
+function textLoader(registry: FontRegistry): FontLoader {
+  let loader = loaders.get(registry);
+  if (loader === undefined) {
+    loader = new FontLoader({ registry });
+    loaders.set(registry, loader);
+  }
+  return loader;
+}
+
 export async function loadTextToken<Module extends AnyRasterModule, Input extends FontInput>(
   token: { readonly input: Input; readonly raster: RasterRequest<Module> },
   registry: FontRegistry,
diff --git a/packages/text/src/loader.ts b/packages/text/src/loader.ts
index 9d055c2f..17ff65d5 100644
--- a/packages/text/src/loader.ts
+++ b/packages/text/src/loader.ts
@@ -88,6 +88,7 @@ interface FontAssetContext {
 interface SharedFontLoad {
   readonly controller: AbortController;
   promise: Promise<RegisteredFont>;
+  value: RegisteredFont | undefined;
   consumers: number;
   settled: boolean;
 }
@@ -405,6 +406,18 @@ export class FontLoader {
     return active;
   }
 
+  /** @internal Return a currently registered load without crossing a Promise boundary. */
+  _peek(input: FontInput): RegisteredFont | undefined {
+    const request = resolveFontRequest(input, this.#baseUrl);
+    const key = requestKey(request);
+    const shared = this.#loads.get(key);
+    const font = shared?.value;
+    if (font === undefined) return undefined;
+    if (this.registry.get(font.key) === font) return font;
+    if (this.#loads.get(key) === shared) this.#loads.delete(key);
+    return undefined;
+  }
+
   #sharedLoad(request: ResolvedFontRequest, key: string): SharedFontLoad {
     let shared = this.#loads.get(key);
     if (shared?.controller.signal.aborted === true) {
@@ -417,6 +430,7 @@ export class FontLoader {
       const promise = this.#load(request, controller.signal).then(
         (font) => {
           created.settled = true;
+          created.value = font;
           return font;
         },
         (error: unknown) => {
@@ -427,6 +441,7 @@ export class FontLoader {
       );
       created = {
         controller,
+        value: undefined,
         consumers: 0,
         settled: false,
         promise,
diff --git a/packages/text/src/raster-runtime.ts b/packages/text/src/raster-runtime.ts
index 24235e6f..a0899b1a 100644
--- a/packages/text/src/raster-runtime.ts
+++ b/packages/text/src/raster-runtime.ts
@@ -2,7 +2,7 @@ import type { RasterBakeArtifact } from './bake.js';
 import type { RegisteredFont } from './font.js';
 import type { RasterKey } from './identity.js';
 import { FontLoadError, registeredFontRegistry } from './loader.js';
-import { deriveRasterKey } from './internal/raster-identity.js';
+import { canonicalJson, deriveRasterKey } from './internal/raster-identity.js';
 import { getRegisteredFontData } from './internal/registered-font.js';
 import type {
   AnyRasterModule,
@@ -18,6 +18,8 @@ type LoadedAnyRaster = LoadedRaster<AnyRasterModule>;
 interface CachedRaster {
   readonly promise: Promise<LoadedAnyRaster>;
   readonly controller: AbortController;
+  readonly descriptorKey: string;
+  value: LoadedAnyRaster | undefined;
   consumers: number;
   settled: boolean;
 }
@@ -46,6 +48,27 @@ export class RasterRuntime {
     return this.#load(font, request, options);
   }
 
+  /** @internal Return a current decoded resource without crossing a Promise boundary. */
+  _peek<const Module extends AnyRasterModule>(
+    font: RegisteredFont,
+    request: RasterRequest<Module>,
+  ): LoadedRaster<Module> | undefined {
+    this.#assertActive();
+    const rasters = this.#fonts.get(font)?.get(request.module);
+    if (rasters === undefined) return undefined;
+    const descriptorKey = rasterDescriptorKey(request.module, request.options);
+    for (const [rasterKey, cached] of rasters) {
+      if (cached.descriptorKey !== descriptorKey || cached.value === undefined) continue;
+      if (isCurrentRaster(font, rasterKey as RasterKey, cached.value.artifact)) {
+        return cached.value as LoadedRaster<Module>;
+      }
+      rasters.delete(rasterKey);
+      request.module.dispose(cached.value.resource);
+      return undefined;
+    }
+    return undefined;
+  }
+
   dispose(): void {
     if (this.#disposed) return;
     this.#disposed = true;
@@ -61,6 +84,7 @@ export class RasterRuntime {
   ): Promise<LoadedRaster<Module>> {
     const module = request.module;
     const descriptor = module.descriptor(request.options);
+    const descriptorKey = rasterDescriptorKey(module, request.options, descriptor);
     const rasterKey = await deriveRasterKey({
       descriptor,
       extension: module.extension,
@@ -119,6 +143,7 @@ export class RasterRuntime {
       .then(
         (loaded) => {
           cached.settled = true;
+          cached.value = loaded;
           return loaded;
         },
         (error: unknown) => {
@@ -127,7 +152,7 @@ export class RasterRuntime {
           throw error;
         },
       );
-    cached = { promise, controller, consumers: 0, settled: false };
+    cached = { promise, controller, descriptorKey, value: undefined, consumers: 0, settled: false };
     rasters.set(rasterKey, cached);
     return consumeCachedRaster<Module>(cached, options.signal);
   }
@@ -254,6 +279,14 @@ export class RasterRuntime {
   }
 }
 
+function rasterDescriptorKey(
+  module: AnyRasterModule,
+  options: unknown,
+  descriptor = module.descriptor(options),
+): string {
+  return canonicalJson({ descriptor, extension: module.extension, kind: module.kind, version: module.version });
+}
+
 function isCurrentRaster(font: RegisteredFont, rasterKey: RasterKey, raster: LoadedAnyRaster['artifact']): boolean {
   try {
     return font.getRaster(rasterKey) === raster;
diff --git a/packages/text/src/raster.ts b/packages/text/src/raster.ts
index cbe3abe8..ffaf1987 100644
--- a/packages/text/src/raster.ts
+++ b/packages/text/src/raster.ts
@@ -121,10 +121,12 @@ export interface RasterModule<Kind extends string, Resource, DrawBatch extends R
 
   decode(font: RegisteredFont, raster: RegisteredRaster<Kind>, signal?: AbortSignal): Promise<Resource>;
 
-  prepare(layout: ParagraphLayout, resource: Resource, fontSlot: FontSlot, signal?: AbortSignal): Promise<void>;
+  prepare(layout: ParagraphLayout, resource: Resource, fontSlot: FontSlot, signal?: AbortSignal): void | Promise<void>;
   /**
    * Stage one complete renderer-owned batch generation. The implementation must not mutate
-   * `previous` before commit and must release partial allocations before throwing.
+   * `previous` before commit and must release partial allocations before throwing. Each stage
+   * owns its unpublished state independently: aborting one candidate must not affect another
+   * candidate staged concurrently against the same `previous` batch.
    */
   stageBatch(
     previous: DrawBatch | undefined,
diff --git a/packages/text/src/raster/bitmap.ts b/packages/text/src/raster/bitmap.ts
index 8241c809..3d6a9e13 100644
--- a/packages/text/src/raster/bitmap.ts
+++ b/packages/text/src/raster/bitmap.ts
@@ -173,7 +173,7 @@ const bitmapModule: RasterModule<typeof BITMAP_KIND, BitmapResource, BitmapDrawB
       signal?.throwIfAborted();
       return resource;
     },
-    async prepare(layout, resource, fontSlot, signal) {
+    prepare(layout, resource, fontSlot, signal) {
       signal?.throwIfAborted();
       assertRasterCoverage(layout, fontSlot, resource.coverage, BITMAP_KIND);
     },
diff --git a/packages/text/src/raster/msdf.ts b/packages/text/src/raster/msdf.ts
index 83f05441..a09b3be1 100644
--- a/packages/text/src/raster/msdf.ts
+++ b/packages/text/src/raster/msdf.ts
@@ -177,7 +177,7 @@ const msdfModule: RasterModule<typeof MSDF_KIND, MsdfResource, MsdfDrawBatch, Ms
     signal?.throwIfAborted();
     return resource;
   },
-  async prepare(layout, resource, fontSlot, signal) {
+  prepare(layout, resource, fontSlot, signal) {
     signal?.throwIfAborted();
     assertRasterCoverage(layout, fontSlot, resource.coverage, MSDF_KIND);
   },
diff --git a/packages/text/src/raster/slug.ts b/packages/text/src/raster/slug.ts
index b3a3685b..85330316 100644
--- a/packages/text/src/raster/slug.ts
+++ b/packages/text/src/raster/slug.ts
@@ -139,7 +139,7 @@ const slugModule: RasterModule<typeof SLUG_KIND, SlugResource, SlugDrawBatch> =
     signal?.throwIfAborted();
     return resource;
   },
-  async prepare(_layout, _resource, _fontSlot, signal) {
+  prepare(_layout, _resource, _fontSlot, signal) {
     signal?.throwIfAborted();
   },
   stageBatch(previous, layout, resource, fontSlot, paint) {
diff --git a/packages/text/src/react.ts b/packages/text/src/react.ts
index 60a6c0ca..1095b390 100644
--- a/packages/text/src/react.ts
+++ b/packages/text/src/react.ts
@@ -1,4 +1,4 @@
-import type { ThreeElements } from '@react-three/fiber/webgpu';
+import { useThree, type ThreeElements } from '@react-three/fiber/webgpu';
 import {
   createElement,
   isValidElement,
@@ -86,6 +86,7 @@ const lifecycles = new WeakMap<CoreText, number>();
 export function Text(properties: ReactTextProps): ReactElement {
   const { core, object, ref } = splitProperties(properties);
   for (const dependency of textDependencies(core)) use(dependency);
+  const invalidate = useThree((state) => state.invalidate);
 
   // Keep the Strict Mode double-invoked initializer resource-free. The committed layout effect
   // supplies the already-suspended properties to the retained object.
@@ -94,8 +95,11 @@ export function Text(properties: ReactTextProps): ReactElement {
   useLayoutEffect(() => {
     const update = textPatch(committedProperties.get(text) ?? {}, core);
     committedProperties.set(text, core);
-    if (update !== undefined) text.setProperties(update);
-  }, [core, text]);
+    if (update !== undefined) {
+      text.setProperties(update);
+      invalidate();
+    }
+  }, [core, invalidate, text]);
 
   useLayoutEffect(() => {
     const lifecycle = (lifecycles.get(text) ?? 0) + 1;
diff --git a/packages/text/src/text.ts b/packages/text/src/text.ts
index 18bd14f4..16c65a1f 100644
--- a/packages/text/src/text.ts
+++ b/packages/text/src/text.ts
@@ -13,7 +13,6 @@ import {
   normalizeRasterInput,
   normalizeTextState,
   sameLayoutInput,
-  samePaintInput,
   sameParagraphInput,
   sameTextInput,
   type NormalizedRasterRequest,
@@ -22,6 +21,8 @@ import {
 } from './internal/text-properties.js';
 import {
   isRegisteredFont,
+  loadedTextFont,
+  loadedTextShaper,
   loadTextFont,
   sharedRasterRuntime,
   textRegistry,
@@ -173,6 +174,12 @@ interface TextGeneration {
   readonly releaseFontDisposal: () => void;
 }
 
+interface PendingPublication {
+  readonly generation: TextGeneration;
+  readonly resolve: () => void;
+  readonly reject: (reason?: unknown) => void;
+}
+
 interface GlyphPaintPlan {
   readonly paintIndices: Uint16Array;
   readonly spanCount: number;
@@ -185,11 +192,18 @@ interface ResolvedParagraphInput {
   readonly spans: readonly import('./paragraph.js').ParagraphSpan[];
 }
 
-/** Framework-neutral Three.js text object with transactional async generations. */
+interface PreparedFontRaster {
+  readonly fontHandle: FontHandle;
+  readonly fontRaster: ResolvedFontRaster;
+  readonly fontSlot: FontSlot;
+}
+
+/** Framework-neutral Three.js text object with transactional generations. */
 export class Text extends THREE.Group {
   #state: TextState;
   #generation: TextGeneration | undefined;
   #pending: AbortController | undefined;
+  #publication: PendingPublication | undefined;
   #invalidatedState: TextState | undefined;
   #revision = 0;
   #ready: Promise<void> = Promise.resolve();
@@ -217,6 +231,10 @@ export class Text extends THREE.Group {
       this.#state = next;
       if (this.#invalidatedState !== undefined && sameTextInput(this.#invalidatedState, next)) return;
       if (this.#pending !== undefined) return;
+      if (this.#publication !== undefined && sameTextInput(this.#publication.generation.state, next)) {
+        this.#publication.generation.state = next;
+        return;
+      }
       if (this.#generation !== undefined && sameTextInput(this.#generation.state, next)) {
         this.#generation.state = next;
         return;
@@ -245,35 +263,58 @@ export class Text extends THREE.Group {
     const reason = new DOMException('The text object was disposed', 'AbortError');
     this.#pending?.abort(reason);
     this.#pending = undefined;
+    this.#cancelPublication(reason);
     this.#disposeGeneration(this.#generation);
     this.#generation = undefined;
     this.#invalidatedState = undefined;
     this.#setCancelledReady(reason);
   }
 
+  override updateMatrixWorld(force?: boolean): void {
+    this.#publishPending();
+    super.updateMatrixWorld(force);
+  }
+
+  override updateWorldMatrix(updateParents: boolean, updateChildren: boolean): void {
+    this.#publishPending();
+    super.updateWorldMatrix(updateParents, updateChildren);
+  }
+
   #schedule(prevalidatedPaint?: GlyphPaint): void {
     if (this.#state.font === undefined) {
       this.#invalidatedState = undefined;
       this.#revision += 1;
       this.#pending?.abort();
       this.#pending = undefined;
+      this.#cancelPublication(new DOMException('The text generation was superseded', 'AbortError'));
       this.#disposeGeneration(this.#generation);
       this.#generation = undefined;
       this.#ready = Promise.resolve();
       return;
     }
 
-    if (this.#generation !== undefined && sameLayoutInput(this.#generation.state, this.#state)) {
-      if (!samePaintInput(this.#generation.state, this.#state)) {
-        const paint = prevalidatedPaint ?? resolveGlyphPaint(this.#state, this.#generation.paintPlan);
-        this.#commitBatchStages(this.#generation, paint);
-      }
+    const controller = new AbortController();
+    const warm = this.#buildWarmGeneration(this.#state, prevalidatedPaint, controller);
+    if (warm !== undefined) {
       this.#invalidatedState = undefined;
       this.#revision += 1;
+      const revision = this.#revision;
       this.#pending?.abort();
       this.#pending = undefined;
-      this.#generation.state = this.#state;
-      this.#ready = Promise.resolve();
+      this.#cancelPublication(new DOMException('The text generation was superseded', 'AbortError'));
+      if (warm instanceof Promise) {
+        this.#trackAsyncGeneration(warm, controller, revision);
+        return;
+      }
+      if (this.#generation === undefined) {
+        this.#commitGeneration(warm);
+        this.#ready = Promise.resolve();
+        return;
+      }
+      const publication = Promise.withResolvers<void>();
+      void publication.promise.catch(() => undefined);
+      this.#publication = { generation: warm, resolve: publication.resolve, reject: publication.reject };
+      this.#ready = publication.promise;
       return;
     }
 
@@ -282,39 +323,20 @@ export class Text extends THREE.Group {
     const revision = this.#revision;
     this.#pending?.abort();
     this.#pending = undefined;
-    const controller = new AbortController();
+    this.#cancelPublication(new DOMException('The text generation was superseded', 'AbortError'));
+    this.#trackAsyncGeneration(this.#buildGeneration(this.#state, controller), controller, revision);
+  }
+
+  #trackAsyncGeneration(build: Promise<TextGeneration>, controller: AbortController, revision: number): void {
     this.#pending = controller;
-    const state = this.#state;
-    const ready = this.#buildGeneration(state, controller).then((generation) => {
+    const ready = build.then((generation) => {
       if (this.#disposed || revision !== this.#revision || controller.signal.aborted) {
         this.#disposeUncommitted(generation);
         controller.signal.throwIfAborted();
         return;
       }
       this.#pending = undefined;
-      const previous = this.#generation;
-      try {
-        for (const { stage } of generation.batchStages) stage.commit();
-      } catch (error) {
-        this.#disposeUncommitted(generation);
-        throw error;
-      }
-      generation.batchStages.length = 0;
-      generation.state = this.#state;
-      this.#generation = generation;
-      previous?.releaseFontDisposal();
-      for (const owned of previous?.batches ?? []) {
-        if (generation.batches.some(({ batch }) => batch === owned.batch)) continue;
-        this.remove(owned.batch.object);
-        owned.batch.dispose();
-      }
-      if (previous !== undefined && previous.paragraph !== generation.paragraph) {
-        previous.paragraph.dispose();
-      }
-      for (const owned of generation.batches) {
-        if (owned.batch.object.parent !== this) this.add(owned.batch.object);
-      }
-      this.#state.onLayout?.(generation.layout);
+      this.#commitGeneration(generation);
     });
     // `ready` remains an observation channel that rejects on failure or cancellation. The
     // internal branch prevents an abandoned generation from becoming an unhandled rejection.
@@ -324,6 +346,96 @@ export class Text extends THREE.Group {
     this.#ready = ready;
   }
 
+  #buildWarmGeneration(
+    state: TextState,
+    prevalidatedPaint: GlyphPaint | undefined,
+    controller: AbortController,
+  ): TextGeneration | Promise<TextGeneration> | undefined {
+    const resolved = resolveParagraphInputSync(state);
+    if (resolved === undefined) return undefined;
+    const reusableParagraph =
+      this.#generation !== undefined && sameParagraphInput(this.#generation.state, state)
+        ? this.#generation.paragraph
+        : undefined;
+    let paragraph = reusableParagraph;
+    let ownsParagraph = false;
+    let handedOff = false;
+    const cleanup = () => {
+      if (handedOff) return;
+      handedOff = true;
+      if (ownsParagraph) paragraph?.dispose();
+    };
+    try {
+      if (paragraph === undefined) {
+        const shaper = loadedTextShaper(resolved.registry);
+        if (shaper === undefined) return undefined;
+        paragraph = createParagraphEngine({ shaper }).create({
+          text: state.text,
+          font: resolved.root.font.handle,
+          spans: resolved.spans,
+          style: paragraphStyle(state),
+        });
+        ownsParagraph = true;
+      }
+      const builtParagraph = paragraph;
+      const retainedLayout =
+        this.#generation !== undefined && sameLayoutInput(this.#generation.state, state) ? this.#generation : undefined;
+      const layout = retainedLayout?.layout ?? builtParagraph.layout(paragraphConstraints(state));
+      const paintPlan = retainedLayout?.paintPlan ?? createGlyphPaintPlan(layout, state);
+      const paint = prevalidatedPaint ?? resolveGlyphPaint(state, paintPlan);
+      const prepared: PreparedFontRaster[] = [];
+      const preparations: Promise<void>[] = [];
+      for (let slot = 0; slot < layout.fontHandles.length; slot += 1) {
+        const handle = layout.fontHandles[slot] as FontHandle | undefined;
+        if (handle === undefined) throw new Error('paragraph layout has an incomplete font table');
+        const fontRaster = resolved.fontsByHandle.get(handle);
+        if (fontRaster === undefined) throw new Error('paragraph layout references an unresolved font');
+        fontRaster.raster.module.validatePaint?.(paint);
+        if (retainedLayout === undefined) {
+          const preparation = fontRaster.raster.module.prepare(
+            layout,
+            fontRaster.raster.resource,
+            slot,
+            controller.signal,
+          );
+          if (preparation !== undefined) {
+            void preparation.catch(() => undefined);
+            preparations.push(preparation);
+          }
+        }
+        prepared.push({ fontHandle: handle, fontRaster, fontSlot: slot });
+      }
+      const finish = (): TextGeneration => {
+        controller.signal.throwIfAborted();
+        const generation = this.#stageGeneration({
+          state,
+          resolved,
+          paragraph: builtParagraph,
+          createdParagraph: ownsParagraph,
+          layout,
+          paintPlan,
+          paint,
+          prepared,
+          controller,
+        });
+        handedOff = true;
+        return generation;
+      };
+      if (preparations.length === 0) return finish();
+      return Promise.all(preparations)
+        .then(finish)
+        .catch((error: unknown) => {
+          controller.abort(error);
+          cleanup();
+          throw error;
+        });
+    } catch (error) {
+      controller.abort(error);
+      cleanup();
+      throw error;
+    }
+  }
+
   async #buildGeneration(state: TextState, controller: AbortController): Promise<TextGeneration> {
     const { signal } = controller;
     const reusableParagraph =
@@ -332,8 +444,6 @@ export class Text extends THREE.Group {
         : undefined;
     let paragraph = reusableParagraph;
     let ownsParagraph = false;
-    const batches: OwnedBatch[] = [];
-    const batchStages: StagedBatch[] = [];
     try {
       let resolved: ResolvedParagraphInput;
       if (paragraph === undefined) {
@@ -356,11 +466,7 @@ export class Text extends THREE.Group {
       const layout = paragraph.layout(paragraphConstraints(state));
       const paintPlan = createGlyphPaintPlan(layout, state);
       const paint = resolveGlyphPaint(state, paintPlan);
-      const prepared: Array<{
-        readonly fontHandle: FontHandle;
-        readonly fontRaster: ResolvedFontRaster;
-        readonly fontSlot: FontSlot;
-      }> = [];
+      const prepared: PreparedFontRaster[] = [];
       for (let slot = 0; slot < layout.fontHandles.length; slot += 1) {
         const handle = layout.fontHandles[slot] as FontHandle | undefined;
         if (handle === undefined) throw new Error('paragraph layout has an incomplete font table');
@@ -373,6 +479,38 @@ export class Text extends THREE.Group {
         signal.throwIfAborted();
         prepared.push({ fontHandle: handle, fontRaster, fontSlot: slot });
       }
+      return this.#stageGeneration({
+        state,
+        resolved,
+        paragraph,
+        createdParagraph: ownsParagraph,
+        layout,
+        paintPlan,
+        paint,
+        prepared,
+        controller,
+      });
+    } catch (error) {
+      if (ownsParagraph) paragraph?.dispose();
+      throw error;
+    }
+  }
+
+  #stageGeneration(input: {
+    readonly state: TextState;
+    readonly resolved: ResolvedParagraphInput;
+    readonly paragraph: Paragraph;
+    readonly createdParagraph: boolean;
+    readonly layout: ParagraphLayout;
+    readonly paintPlan: GlyphPaintPlan;
+    readonly paint: GlyphPaint;
+    readonly prepared: readonly PreparedFontRaster[];
+    readonly controller: AbortController;
+  }): TextGeneration {
+    const { state, resolved, paragraph, createdParagraph, layout, paintPlan, paint, prepared, controller } = input;
+    const batches: OwnedBatch[] = [];
+    const batchStages: StagedBatch[] = [];
+    try {
       for (const { fontHandle, fontRaster, fontSlot } of prepared) {
         const previous = this.#generation?.batches.find(
           (owned) => owned.fontHandle === fontHandle && owned.module === fontRaster.raster.module,
@@ -410,12 +548,13 @@ export class Text extends THREE.Group {
         if (!fontHandles.has(font.handle)) return;
         const reason = new DOMException('A font used by this text was disposed', 'AbortError');
         controller.abort(reason);
-        if (this.#generation === generation) this.#invalidateGeneration(generation, reason);
+        if (this.#publication?.generation === generation) this.#cancelPublication(reason);
+        else if (this.#generation === generation) this.#invalidateGeneration(generation, reason);
       });
       generation = {
         state,
         paragraph,
-        createdParagraph: ownsParagraph,
+        createdParagraph,
         layout,
         paintPlan,
         batches,
@@ -425,7 +564,6 @@ export class Text extends THREE.Group {
       return generation;
     } catch (error) {
       for (const staged of batchStages) abortStagedBatch(staged);
-      if (ownsParagraph) paragraph?.dispose();
       throw error;
     }
   }
@@ -446,63 +584,63 @@ export class Text extends THREE.Group {
     if (generation.createdParagraph) generation.paragraph.dispose();
   }
 
-  #invalidateGeneration(generation: TextGeneration, reason: unknown): void {
-    if (this.#generation !== generation) return;
-    this.#invalidatedState = generation.state;
-    this.#revision += 1;
-    this.#pending?.abort(reason);
-    this.#pending = undefined;
-    this.#disposeGeneration(generation);
-    this.#generation = undefined;
-    this.#setCancelledReady(reason);
-  }
-
-  #commitBatchStages(generation: TextGeneration, paint: GlyphPaint): void {
-    const stages: StagedBatch[] = [];
-    const batches: OwnedBatch[] = [];
-    try {
-      for (const owned of generation.batches) {
-        const stage = owned.module.stageBatch(
-          owned.batch,
-          generation.layout,
-          owned.raster.resource,
-          owned.fontSlot,
-          paint,
-          this.#state.rasterPixelRatio,
-        );
-        try {
-          assertRasterBatchStage(stage);
-        } catch (error) {
-          try {
-            stage.abort();
-          } catch {
-            // The untrusted module returned no usable cleanup surface.
-          }
-          throw error;
-        }
-        stages.push({ stage, previous: owned.batch });
-        batches.push({ ...owned, batch: stage.batch });
-      }
-    } catch (error) {
-      for (const staged of stages) abortStagedBatch(staged);
-      throw error;
-    }
+  #commitGeneration(generation: TextGeneration): void {
     try {
-      for (const { stage } of stages) stage.commit();
+      for (const { stage } of generation.batchStages) stage.commit();
     } catch (error) {
-      for (const staged of stages) abortStagedBatch(staged);
+      this.#disposeUncommitted(generation);
       throw error;
     }
-    const previous = generation.batches;
-    generation.batches = batches;
-    for (const owned of previous) {
-      if (batches.some(({ batch }) => batch === owned.batch)) continue;
+    generation.batchStages.length = 0;
+    generation.state = this.#state;
+    const previous = this.#generation;
+    this.#generation = generation;
+    previous?.releaseFontDisposal();
+    for (const owned of previous?.batches ?? []) {
+      if (generation.batches.some(({ batch }) => batch === owned.batch)) continue;
       this.remove(owned.batch.object);
       owned.batch.dispose();
     }
-    for (const owned of batches) {
+    if (previous !== undefined && previous.paragraph !== generation.paragraph) previous.paragraph.dispose();
+    for (const owned of generation.batches) {
       if (owned.batch.object.parent !== this) this.add(owned.batch.object);
     }
+    if (previous?.layout !== generation.layout) this.#state.onLayout?.(generation.layout);
+  }
+
+  #publishPending(): void {
+    const publication = this.#publication;
+    if (publication === undefined) return;
+    this.#publication = undefined;
+    try {
+      this.#commitGeneration(publication.generation);
+      publication.resolve();
+    } catch (error) {
+      publication.reject(error);
+    }
+  }
+
+  #cancelPublication(reason: unknown): void {
+    const publication = this.#publication;
+    if (publication === undefined) return;
+    this.#publication = undefined;
+    this.#disposeUncommitted(publication.generation);
+    publication.reject(reason);
+  }
+
+  #invalidateGeneration(generation: TextGeneration, reason: unknown): void {
+    if (this.#generation !== generation) return;
+    this.#invalidatedState = generation.state;
+    this.#revision += 1;
+    this.#pending?.abort(reason);
+    this.#pending = undefined;
+    this.#disposeGeneration(generation);
+    this.#generation = undefined;
+    if (this.#publication !== undefined) {
+      this.#invalidatedState = undefined;
+      return;
+    }
+    this.#setCancelledReady(reason);
   }
 
   #setCancelledReady(reason: unknown): void {
@@ -567,6 +705,46 @@ async function resolveParagraphInput(state: TextState, signal: AbortSignal): Pro
   return { registry: rootRegistry, root, fontsByHandle, spans };
 }
 
+function resolveParagraphInputSync(state: TextState): ResolvedParagraphInput | undefined {
+  const rootSource = state.font;
+  if (rootSource === undefined) throw new Error('text has no font');
+  const registry = isRegisteredFont(rootSource) ? textRegistry(rootSource) : textRegistry();
+  const root = resolveFontRasterSync(rootSource, state.raster, registry);
+  if (root === undefined) return undefined;
+  const rootRegistry = textRegistry(root.font);
+  const fontsByHandle = new Map<FontHandle, ResolvedFontRaster>([[root.font.handle, root]]);
+  const spans = [] as import('./paragraph.js').ParagraphSpan[];
+  for (const span of state.spans) {
+    let font = root;
+    if (span.font !== undefined) {
+      const resolvedFont = resolveFontRasterSync(span.font, root.request, rootRegistry);
+      if (resolvedFont === undefined) return undefined;
+      font = resolvedFont;
+      const existing = fontsByHandle.get(font.font.handle);
+      if (
+        existing !== undefined &&
+        (existing.raster.module !== font.raster.module ||
+          existing.raster.artifact.rasterKey !== font.raster.artifact.rasterKey)
+      ) {
+        throw new TypeError('one font cannot select multiple raster definitions in one paragraph');
+      }
+      fontsByHandle.set(font.font.handle, font);
+    }
+    spans.push({
+      start: span.start,
+      end: span.end,
+      font: font.font.handle,
+      ...(span.fontSize === undefined ? {} : { fontSize: span.fontSize }),
+      ...(span.lineHeight === undefined ? {} : { lineHeight: span.lineHeight }),
+      ...(span.letterSpacing === undefined ? {} : { letterSpacing: span.letterSpacing }),
+      ...(span.language === undefined ? {} : { language: span.language }),
+      ...(span.direction === undefined ? {} : { direction: span.direction }),
+      ...(span.features === undefined ? {} : { features: span.features }),
+    });
+  }
+  return { registry: rootRegistry, root, fontsByHandle, spans };
+}
+
 async function resolveFontRaster(
   source: AnyFontToken | FontInput | RegisteredFont,
   inheritedRaster: AnyRasterInput | NormalizedRasterRequest | undefined,
@@ -590,6 +768,30 @@ async function resolveFontRaster(
   return { font, request, raster };
 }
 
+function resolveFontRasterSync(
+  source: AnyFontToken | FontInput | RegisteredFont,
+  inheritedRaster: AnyRasterInput | NormalizedRasterRequest | undefined,
+  registry: FontRegistry,
+): ResolvedFontRaster | undefined {
+  const font = isRegisteredFont(source)
+    ? source
+    : loadedTextFont(isFontToken(source) ? source.input : source, registry);
+  if (font === undefined) return undefined;
+  let request: NormalizedRasterRequest;
+  if (isFontToken(source)) {
+    request = normalizeRasterInput(source.raster);
+  } else {
+    if (inheritedRaster === undefined) throw new TypeError('raw fonts require a raster definition');
+    request = isNormalizedRasterRequest(inheritedRaster) ? inheritedRaster : normalizeRasterInput(inheritedRaster);
+  }
+  if (textRegistry(font) !== registry) {
+    throw new TypeError('all fonts in one Text object must belong to the same registry');
+  }
+  const raster = sharedRasterRuntime._peek(font, { module: request.module, options: request.options });
+  if (raster === undefined) return undefined;
+  return { font, request, raster };
+}
+
 function paragraphStyle(state: TextState) {
   return {
     ...(state.fontSize === undefined ? {} : { fontSize: state.fontSize }),
diff --git a/packages/text/tests/integration/bitmap-baker.test.mjs b/packages/text/tests/integration/bitmap-baker.test.mjs
index 969b6475..9ac2f6d7 100644
--- a/packages/text/tests/integration/bitmap-baker.test.mjs
+++ b/packages/text/tests/integration/bitmap-baker.test.mjs
@@ -160,8 +160,8 @@ test('bakes bounded coverage with deterministic progress and a validated selecti
   const module = bitmap(options).module;
   const resource = await module.decode(font, runtimeRaster);
   await module.prepare({ glyphIds: Uint16Array.of(43), glyphFontSlots: Uint16Array.of(0) }, resource, 0);
-  await assert.rejects(
-    module.prepare({ glyphIds: Uint16Array.of(45), glyphFontSlots: Uint16Array.of(0) }, resource, 0),
+  assert.throws(
+    () => module.prepare({ glyphIds: Uint16Array.of(45), glyphFontSlots: Uint16Array.of(0) }, resource, 0),
     RasterCoverageError,
   );
   module.dispose(resource);
diff --git a/packages/text/tests/integration/mtsdf-baker.test.mjs b/packages/text/tests/integration/mtsdf-baker.test.mjs
index 19f5581d..37d3d566 100644
--- a/packages/text/tests/integration/mtsdf-baker.test.mjs
+++ b/packages/text/tests/integration/mtsdf-baker.test.mjs
@@ -282,8 +282,8 @@ test('bakes bounded coverage with deterministic progress and a validated selecti
   };
   const resource = await msdf.decode(font, runtimeRaster);
   await msdf.prepare({ glyphIds: Uint16Array.of(43), glyphFontSlots: Uint16Array.of(0) }, resource, 0);
-  await assert.rejects(
-    msdf.prepare({ glyphIds: Uint16Array.of(45), glyphFontSlots: Uint16Array.of(0) }, resource, 0),
+  assert.throws(
+    () => msdf.prepare({ glyphIds: Uint16Array.of(45), glyphFontSlots: Uint16Array.of(0) }, resource, 0),
     RasterCoverageError,
   );
   msdf.dispose(resource);
diff --git a/packages/text/tests/integration/react-text.test.mjs b/packages/text/tests/integration/react-text.test.mjs
index 8439059b..9451fbec 100644
--- a/packages/text/tests/integration/react-text.test.mjs
+++ b/packages/text/tests/integration/react-text.test.mjs
@@ -48,7 +48,7 @@ test('React Text flattens spans, reconciles, forwards its ref, and disposes', as
       reference.current instanceof CoreText,
       `forwarded ref resolved to ${reference.current?.constructor?.name ?? String(reference.current)}`,
     );
-    await reference.current.ready;
+    reference.current.updateMatrixWorld();
     assert.equal(reference.current.children.length, 1);
     assert.equal(reference.current.layout?.glyphIds.length, 11);
     assert.equal(layouts.length, 1);
@@ -56,13 +56,13 @@ test('React Text flattens spans, reconciles, forwards its ref, and disposes', as
     const object = reference.current;
     const initialLayout = object.layout;
     await renderer.update(render('office', '#00aaff', [2, 1, 0]));
-    await object.ready;
+    object.updateMatrixWorld();
     assert.equal(reference.current, object, 'React updates retain the core object identity');
     assert.equal(object.layout, initialLayout, 'paint and transform changes do not reflow');
     assert.deepEqual(object.position.toArray(), [2, 1, 0]);
 
     await renderer.update(render('accurate', '#00aaff', [2, 1, 0]));
-    await object.ready;
+    object.updateMatrixWorld();
     assert.notEqual(object.layout, initialLayout, 'text changes replace the layout generation');
     assert.equal(object.layout?.glyphIds.length, 13);
     assert.equal(layouts.length, 2);
@@ -117,7 +117,7 @@ test('lazyRaster participates in the real React Text dependency and draw path',
         React.createElement(Text, { font, fontSize: 16, ref: reference }, 'lazy raster'),
       );
     });
-    await reference.current.ready;
+    reference.current.updateMatrixWorld();
     assert.equal(reference.current.children.length, 1);
   } finally {
     if (renderer !== undefined) await renderer.unmount();
diff --git a/packages/text/tests/integration/text-object.test.mjs b/packages/text/tests/integration/text-object.test.mjs
index e398d653..de7373a4 100644
--- a/packages/text/tests/integration/text-object.test.mjs
+++ b/packages/text/tests/integration/text-object.test.mjs
@@ -5,6 +5,7 @@ import test from 'node:test';
 import { createFontBaker } from '@pmndrs/text-font-baker';
 import { validateFontArtifact } from '@pmndrs/text-font-baker/validate';
 import { bitmapBakerFromCore, createBitmapBaker } from '@pmndrs/text/bakers/bitmap';
+import * as THREE from 'three/webgpu';
 import { FontLoader, FontRegistry, RasterRuntime, Text, defineRaster } from '../../dist/index.js';
 import {
   bitmap,
@@ -18,6 +19,11 @@ import { composeFontBake } from '../../dist/internal/compose-bake.js';
 const fixtureUrl = new URL('../../../../apps/benchmarks/fixtures/rendering/inter-bitmap-16.font.glb', import.meta.url);
 const shaperUrl = new URL('../../dist/text_shaper.wasm', import.meta.url);
 
+async function publishText(text) {
+  text.updateMatrixWorld();
+  await text.ready;
+}
+
 test('Text commits layout and draw generations atomically', async () => {
   const restoreFetch = installFileFetch();
   const registry = new FontRegistry();
@@ -33,7 +39,7 @@ test('Text commits layout and draw generations atomically', async () => {
   });
   try {
     assert.equal(text.children.length, 0);
-    await text.ready;
+    await publishText(text);
     assert.equal(text.children.length, 1);
     assert.equal(text.layout, layouts[0]);
     assert.ok((text.layout?.glyphIds.length ?? 0) > 0);
@@ -41,7 +47,7 @@ test('Text commits layout and draw generations atomically', async () => {
     const initialLayout = text.layout;
     const initialBatch = text.children[0];
     text.setProperties({ opacity: 0.5 });
-    await text.ready;
+    await publishText(text);
     assert.equal(text.layout, initialLayout, 'paint-only updates retain the committed layout');
     assert.equal(text.children[0], initialBatch, 'paint-only updates retain the draw batch');
 
@@ -49,19 +55,27 @@ test('Text commits layout and draw generations atomically', async () => {
       text: 'office AVATAR',
       spans: [{ start: 0, end: 6, color: 0x0000ff }],
     });
-    await text.ready;
+    await publishText(text);
     assert.equal(text.layout, initialLayout, 'span-color updates retain the committed layout');
     assert.equal(text.children[0], initialBatch, 'span-color updates retain the draw batch');
 
+    const updateBatchMatrixWorld = initialBatch.updateMatrixWorld.bind(initialBatch);
+    let childTraversalLayout;
+    initialBatch.updateMatrixWorld = (force) => {
+      childTraversalLayout = text.layout;
+      updateBatchMatrixWorld(force);
+    };
     text.setProperties({ width: 72 });
-    await text.ready;
+    assert.equal(text.layout, initialLayout, 'warm staging leaves the previous layout live before object traversal');
+    await publishText(text);
     assert.notEqual(text.layout, initialLayout, 'constraint updates commit a new layout');
+    assert.equal(childTraversalLayout, text.layout, 'warm publication precedes retained child traversal');
     assert.equal(text.children.length, 1);
     assert.equal(text.children[0], initialBatch, 'compatible bitmap reflow retains the draw batch');
 
     const narrowLayout = text.layout;
     text.setProperties({ fontSize: 18 });
-    await text.ready;
+    await publishText(text);
     assert.notEqual(text.layout, narrowLayout, 'font-size updates reshape and commit a new layout');
     assert.equal(text.children[0], initialBatch, 'same-strike bitmap font-size updates retain the draw batch');
 
@@ -69,7 +83,7 @@ test('Text commits layout and draw generations atomically', async () => {
     const supersededReady = text.ready;
     text.setProperties({ text: 'second update' });
     await assert.rejects(supersededReady, { name: 'AbortError' });
-    await text.ready;
+    await publishText(text);
     assert.equal(text.layout?.glyphIds.length, 13);
 
     const committedLayout = text.layout;
@@ -143,13 +157,12 @@ test('Text preserves its live batch across staged success, failure, and stale ab
     fontSize: 16,
   });
   try {
-    await text.ready;
+    await publishText(text);
     const liveBatch = text.children[0];
     const committedBeforeFailure = commits;
 
     failNext = true;
-    text.setProperties({ width: 140 });
-    await assert.rejects(text.ready, /injected raster staging failure/);
+    assert.throws(() => text.setProperties({ width: 140 }), /injected raster staging failure/);
     assert.equal(text.children[0], liveBatch);
     assert.equal(commits, committedBeforeFailure);
 
@@ -157,7 +170,7 @@ test('Text preserves its live batch across staged success, failure, and stale ab
     text.setProperties({ width: 160 });
     const stale = text.ready;
     await assert.rejects(stale, { name: 'AbortError' });
-    await text.ready;
+    await publishText(text);
     assert.equal(text.children[0], liveBatch);
     assert.ok(aborts >= 2, 'failed and stale stages are both released');
     assert.equal(commits, committedBeforeFailure + 1);
@@ -167,7 +180,7 @@ test('Text preserves its live batch across staged success, failure, and stale ab
     text.setProperties({ text: 'fresh batch that must become stale' });
     const throwingStale = text.ready;
     await assert.rejects(throwingStale, { name: 'AbortError' });
-    await text.ready;
+    await publishText(text);
     assert.ok(fallbackDisposals >= 1, 'a fresh target is defensively disposed when plugin abort throws');
     assert.equal(text.children.length, 1);
   } finally {
@@ -177,6 +190,60 @@ test('Text preserves its live batch across staged success, failure, and stale ab
   }
 });
 
+test('a raster commit contract violation rejects readiness without aborting Three traversal', async () => {
+  const restoreFetch = installFileFetch();
+  const registry = new FontRegistry();
+  const font = await registry.registerAsset(await readFile(fixtureUrl));
+  const request = bitmap({ strikes: [16] });
+  let failNextCommit = false;
+  const raster = defineRaster({
+    ...request.module,
+    stageBatch(...arguments_) {
+      const stage = request.module.stageBatch(...arguments_);
+      if (!failNextCommit) return stage;
+      failNextCommit = false;
+      return {
+        batch: stage.batch,
+        commit() {
+          throw new Error('injected raster commit contract violation');
+        },
+        abort() {
+          stage.abort();
+        },
+      };
+    },
+  });
+  const text = new Text({
+    text: 'traversal survives a plugin fault',
+    font,
+    raster: { module: raster, options: request.options },
+    fontSize: 16,
+  });
+  const scene = new THREE.Group();
+  const sibling = new THREE.Group();
+  let siblingTraversals = 0;
+  const updateSiblingMatrixWorld = sibling.updateMatrixWorld.bind(sibling);
+  sibling.updateMatrixWorld = (force) => {
+    siblingTraversals += 1;
+    updateSiblingMatrixWorld(force);
+  };
+  scene.add(text, sibling);
+  try {
+    await publishText(text);
+    failNextCommit = true;
+    text.setProperties({ width: 120 });
+    const failedReady = text.ready;
+    assert.doesNotThrow(() => scene.updateMatrixWorld());
+    assert.equal(siblingTraversals, 1, 'a plugin commit fault does not prevent later sibling traversal');
+    await assert.rejects(failedReady, /injected raster commit contract violation/);
+    assert.equal(text.children.length, 1, 'the previously committed generation remains attached');
+  } finally {
+    text.dispose();
+    font.dispose();
+    restoreFetch();
+  }
+});
+
 test('a failed paint transaction preserves an earlier pending layout generation', async () => {
   const restoreFetch = installFileFetch();
   const registry = new FontRegistry();
@@ -184,15 +251,21 @@ test('a failed paint transaction preserves an earlier pending layout generation'
   const request = bitmap({ strikes: [16] });
   const prepareStarted = Promise.withResolvers();
   const releasePrepare = Promise.withResolvers();
-  let delayNextPrepare = false;
+  let blockNextLayout = false;
+  let blockedLayout;
+  let blockedPrepareCalls = 0;
   const raster = defineRaster({
     ...request.module,
-    async prepare(...arguments_) {
-      await request.module.prepare(...arguments_);
-      if (!delayNextPrepare) return;
-      delayNextPrepare = false;
-      prepareStarted.resolve();
-      await releasePrepare.promise;
+    prepare(...arguments_) {
+      request.module.prepare(...arguments_);
+      if (blockNextLayout && blockedLayout === undefined) {
+        blockedLayout = arguments_[0];
+        prepareStarted.resolve();
+      }
+      if (arguments_[0] === blockedLayout) {
+        blockedPrepareCalls += 1;
+        return releasePrepare.promise;
+      }
     },
     stageBatch(...arguments_) {
       const paint = arguments_[4];
@@ -208,9 +281,9 @@ test('a failed paint transaction preserves an earlier pending layout generation'
     width: 200,
   });
   try {
-    await text.ready;
+    await publishText(text);
     const initialLayout = text.layout;
-    delayNextPrepare = true;
+    blockNextLayout = true;
     text.setProperties({ width: 100 });
     const pendingReady = text.ready;
     await prepareStarted.promise;
@@ -219,6 +292,7 @@ test('a failed paint transaction preserves an earlier pending layout generation'
     assert.equal(text.ready, pendingReady, 'the failed reversion does not cancel or replace pending readiness');
     releasePrepare.resolve();
     await pendingReady;
+    assert.equal(blockedPrepareCalls, 1, 'an asynchronous warm preparation is carried forward instead of restarted');
     assert.notEqual(text.layout, initialLayout, 'the original pending layout still commits');
   } finally {
     releasePrepare.resolve();
@@ -303,7 +377,7 @@ test('Text semantic no-ops retry a failed generation', async () => {
   try {
     await assert.rejects(text.ready, /synthetic decode failure/);
     text.setProperties({});
-    await text.ready;
+    await publishText(text);
     assert.equal(decodeCount, 2);
     assert.equal(text.children.length, 1);
   } finally {
@@ -325,14 +399,14 @@ test('bitmap glyph-position transitions preserve authoritative layouts and pixel
     width: 280,
   });
   try {
-    await text.ready;
+    await publishText(text);
     const wideObject = text.children[0];
     assert.ok(wideObject);
     const wideOrigins = bitmapOrigins(wideObject);
     const wideSnapshot = captureBitmapGlyphPositions(wideObject);
 
     text.setProperties({ width: 104 });
-    await text.ready;
+    await publishText(text);
     const narrowObject = text.children[0];
     const narrowLayout = text.layout;
     assert.ok(narrowObject);
@@ -353,7 +427,7 @@ test('bitmap glyph-position transitions preserve authoritative layouts and pixel
     assert.throws(() => transition.setProgress(Number.NaN), /progress must be in \[0, 1\]/);
 
     text.setProperties({ opacity: 0.5 });
-    await text.ready;
+    await publishText(text);
     transition.setProgress(0.75);
     assert.deepEqual(
       bitmapOrigins(narrowObject),
@@ -365,7 +439,7 @@ test('bitmap glyph-position transitions preserve authoritative layouts and pixel
     const midpointSnapshot = captureBitmapGlyphPositions(narrowObject);
     transition.dispose();
     text.setProperties({ width: 156 });
-    await text.ready;
+    await publishText(text);
     const finalObject = text.children[0];
     assert.ok(finalObject);
     const finalTargetOrigins = bitmapOrigins(finalObject);
@@ -398,14 +472,14 @@ test('bitmap glyph-position transitions leave unmatched target glyphs authoritat
     fontSize: 16,
   });
   try {
-    await text.ready;
+    await publishText(text);
     const sourceObject = text.children[0];
     assert.ok(sourceObject);
     const sourceSnapshot = captureBitmapGlyphPositions(sourceObject);
     assert.equal(sourceSnapshot.glyphCount, 1);
 
     text.setProperties({ text: 'office' });
-    await text.ready;
+    await publishText(text);
     const targetObject = text.children[0];
     assert.ok(targetObject);
     const targetOrigins = bitmapOrigins(targetObject);
@@ -432,7 +506,7 @@ test('disposing Text rejects both pending and subsequent ready observations', as
     fontSize: 16,
   });
   try {
-    await text.ready;
+    await publishText(text);
     text.setProperties({ width: 120 });
     const pending = text.ready;
     text.dispose();
@@ -469,7 +543,7 @@ test('a cancelled reflow does not claim ownership of its committed paragraph', a
     fontSize: 16,
   });
   try {
-    await text.ready;
+    await publishText(text);
     disposeFontAfterBuild = true;
     text.setProperties({ width: 120 });
     const cancelled = text.ready;
@@ -508,12 +582,12 @@ test('Text releases the superseded font-disposal listener after every committed
     fontSize: 16,
   });
   try {
-    await text.ready;
+    await publishText(text);
     const stableSubscriptions = activeSubscriptions;
     assert.ok(stableSubscriptions > 0);
     for (let width = 120; width < 140; width += 1) {
       text.setProperties({ width });
-      await text.ready;
+      await publishText(text);
       assert.equal(activeSubscriptions, stableSubscriptions);
     }
     text.dispose();
@@ -564,8 +638,13 @@ test('Text skips semantic no-op paint uploads and bitmap rejects unsupported eff
   const bitmapRequest = bitmap({ strikes: [16] });
   let validatedPaint;
   let updatedPaint;
+  let prepareCount = 0;
   const raster = defineRaster({
     ...bitmapRequest.module,
+    prepare(...arguments_) {
+      prepareCount += 1;
+      return bitmapRequest.module.prepare(...arguments_);
+    },
     validatePaint(paint) {
       bitmapRequest.module.validatePaint?.(paint);
       validatedPaint = paint;
@@ -583,21 +662,23 @@ test('Text skips semantic no-op paint uploads and bitmap rejects unsupported eff
     features: [{ tag: 'liga' }],
   });
   try {
-    await text.ready;
+    await publishText(text);
     const batch = text.children[0];
     const mesh = batch?.children[0];
     const colors = mesh?.geometry?.getAttribute('bitmapColor');
     assert.ok(colors);
     const initialVersion = colors.version;
+    const residentPrepareCount = prepareCount;
     text.setProperties({ features: [{ tag: 'liga' }], onLayout: () => undefined });
-    await text.ready;
+    await publishText(text);
     assert.equal(colors.version, initialVersion);
     text.setProperties({ opacity: 0.5 });
-    await text.ready;
+    await publishText(text);
     assert.equal(updatedPaint, validatedPaint, 'paint validation and upload reuse one resolved glyph-paint value');
     const retainedPaintIndices = updatedPaint.paintIndices;
     text.setProperties({ opacity: 0.75 });
-    await text.ready;
+    await publishText(text);
+    assert.equal(prepareCount, residentPrepareCount, 'paint-only updates reuse the resident layout and pages');
     assert.equal(
       updatedPaint.paintIndices,
       retainedPaintIndices,
@@ -627,10 +708,10 @@ test('disposing a registered font invalidates live Text batches before raster re
     fontSize: 16,
   });
   try {
-    await text.ready;
+    await publishText(text);
     assert.equal(text.children.length, 1);
     text.setProperties({ opacity: 0.5 });
-    await text.ready;
+    await publishText(text);
     text.visible = false;
     font.dispose();
     const invalidatedReady = text.ready;
@@ -653,20 +734,26 @@ test('disposing a superseded font does not terminally invalidate its pending rep
   const registryB = new FontRegistry();
   const fontA = await registryA.registerAsset(bytes);
   const fontB = await registryB.registerAsset(bytes);
+  const raster = bitmap({ strikes: [16] });
+  const preload = new Text({ text: 'resident replacement', font: fontB, raster, fontSize: 16 });
+  await publishText(preload);
+  preload.dispose();
   const text = new Text({
     text: 'font replacement lifecycle',
     font: fontA,
-    raster: bitmap({ strikes: [16] }),
+    raster,
     fontSize: 16,
   });
   try {
-    await text.ready;
+    await publishText(text);
     text.setProperties({ font: fontB });
+    const replacementReady = text.ready;
     fontA.dispose();
-    await text.ready.catch(() => undefined);
-    text.setProperties({});
-    await text.ready;
+    assert.equal(text.ready, replacementReady, 'disposing the old font preserves a resident queued replacement');
+    text.updateMatrixWorld();
+    await replacementReady;
     assert.equal(text.children.length, 1);
+    assert.equal(text.layout?.glyphIds.length, 'font replacement lifecycle'.length);
   } finally {
     text.dispose();
     fontA.dispose();
@@ -724,8 +811,27 @@ test('Text resolves independent raster resources for two fonts in one paragraph'
   const content = 'Latin العربية';
   const request = bitmap({ strikes: [16] });
   let failFontSlot;
+  let failPreparation = false;
+  let firstPreparationAborted = false;
   const raster = defineRaster({
     ...request.module,
+    prepare(...arguments_) {
+      request.module.prepare(...arguments_);
+      if (!failPreparation) return;
+      const fontSlot = arguments_[2];
+      const signal = arguments_[3];
+      if (fontSlot === 1) throw new Error('injected second-font preparation failure');
+      return new Promise((_resolve, reject) => {
+        signal.addEventListener(
+          'abort',
+          () => {
+            firstPreparationAborted = true;
+            reject(signal.reason);
+          },
+          { once: true },
+        );
+      });
+    },
     stageBatch(...arguments_) {
       if (arguments_[3] === failFontSlot) throw new Error('injected second-font staging failure');
       return request.module.stageBatch(...arguments_);
@@ -747,10 +853,14 @@ test('Text resolves independent raster resources for two fonts in one paragraph'
     ],
   });
   try {
-    await text.ready;
+    await publishText(text);
     assert.equal(text.layout?.fontHandles.length, 2);
     assert.equal(text.children.length, 2);
     const liveBatches = [...text.children];
+    failPreparation = true;
+    assert.throws(() => text.setProperties({ width: 200 }), /injected second-font preparation failure/);
+    assert.equal(firstPreparationAborted, true, 'a later warm preparation failure aborts earlier pending work');
+    failPreparation = false;
     const paintedSpans = [
       {
         start: 6,
@@ -770,7 +880,7 @@ test('Text resolves independent raster resources for two fonts in one paragraph'
     assert.equal(text.children[1], liveBatches[1], 'a later font failure preserves the second live batch');
     failFontSlot = undefined;
     text.setProperties({ text: content, spans: paintedSpans });
-    await text.ready;
+    await publishText(text);
     assert.equal(text.children[0], liveBatches[0], 'a successful transaction retains the first batch');
     assert.equal(text.children[1], liveBatches[1], 'a successful transaction retains the second batch');
   } finally {
@@ -868,13 +978,16 @@ test('RasterRuntime caches one decoded resource per font and disposes it with it
     },
   });
 
+  assert.equal(runtime._peek(font, { module }), undefined);
   const [left, right] = await Promise.all([runtime.load(font, { module }), runtime.load(font, { module })]);
   assert.equal(left.resource, right.resource);
   assert.equal(decodeCount, 1);
+  assert.equal(runtime._peek(font, { module }), left, 'a settled current raster is synchronously observable');
 
   font.dispose();
   await Promise.resolve();
   assert.equal(disposeCount, 1);
+  assert.equal(runtime._peek(font, { module }), undefined);
   runtime.dispose();
 });