@solidtv/renderer 1.3.0 → 1.3.2

package/src/core/text-rendering/SdfTextRenderer.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { CoreTextNodeProps } from '../CoreTextNode.js';
+
+// Mock the font handler so renderText/generateTextLayout can run without a
+// real loaded font. getFontData is only invoked on a layout-cache MISS, so the
+// call count is our probe for cache hits vs misses.
+vi.mock('./SdfFontHandler.js', () => {
+  const fontData = {
+    data: {
+      common: { base: 0, scaleW: 512, scaleH: 512, lineHeight: 50 },
+      info: { size: 42 },
+      distanceField: { distanceRange: 4 },
+    },
+    glyphMap: new Map(),
+    kernings: {},
+    atlasTexture: {},
+    metrics: {},
+    maxCharHeight: 50,
+  };
+  const metrics = {
+    ascender: 40,
+    descender: -10,
+    lineGap: 0,
+    capHeight: 30,
+    xHeight: 20,
+  };
+  return {
+    type: 'sdf',
+    init: vi.fn(),
+    getFontData: vi.fn(() => fontData),
+    getFontMetrics: vi.fn(() => metrics),
+    measureText: vi.fn((text: string) => text.length * 10),
+    getAtlas: vi.fn(() => null),
+  };
+});
+
+import SdfTextRenderer from './SdfTextRenderer.js';
+import * as SdfFontHandler from './SdfFontHandler.js';
+
+const makeProps = (text: string): CoreTextNodeProps =>
+  ({
+    text,
+    fontFamily: 'Test',
+    fontStyle: 'normal',
+    fontSize: 42,
+    letterSpacing: 0,
+    lineHeight: 0,
+    maxHeight: 0,
+    maxWidth: 100000,
+    maxLines: 0,
+    textAlign: 'left',
+    wordBreak: 'normal',
+    overflowSuffix: '',
+  } as unknown as CoreTextNodeProps);
+
+const initRenderer = (cacheSize: number): void => {
+  const fakeStage = {
+    options: { textLayoutCacheSize: cacheSize },
+    shManager: {
+      registerShaderType: vi.fn(),
+      createShader: vi.fn(() => ({})),
+    },
+  };
+  SdfTextRenderer.init(fakeStage as never);
+};
+
+const render = (text: string): void => {
+  SdfTextRenderer.renderText(makeProps(text));
+};
+
+describe('SdfTextRenderer layout cache', () => {
+  beforeEach(() => {
+    // Empty the module-level cache between tests, then reset call counts.
+    initRenderer(0);
+    SdfTextRenderer.cleanup();
+    vi.clearAllMocks();
+  });
+
+  it('reuses the cached layout for identical strings', () => {
+    initRenderer(10);
+
+    render('Badge');
+    render('Badge');
+
+    // Second render is a cache hit: no fresh layout generation.
+    expect(SdfFontHandler.getFontData).toHaveBeenCalledTimes(1);
+  });
+
+  it('caches long strings too (no length-based skip)', () => {
+    initRenderer(10);
+    const long = 'x'.repeat(500);
+
+    render(long);
+    render(long);
+
+    // Bounded purely by the LRU cap, not by length.
+    expect(SdfFontHandler.getFontData).toHaveBeenCalledTimes(1);
+  });
+
+  it('cleanup trims to the cap and evicts least-recently-used first', () => {
+    initRenderer(2);
+
+    render('A');
+    render('B');
+    render('C');
+    // Re-access 'A' so it becomes most-recently-used; 'B' is now the LRU.
+    render('A');
+
+    SdfTextRenderer.cleanup();
+
+    vi.clearAllMocks();
+    render('B'); // evicted -> miss
+    render('A'); // survived -> hit
+    render('C'); // survived -> hit
+
+    expect(SdfFontHandler.getFontData).toHaveBeenCalledTimes(1);
+  });
+
+  it('cleanup is a no-op while under the cap', () => {
+    initRenderer(10);
+
+    render('one');
+    render('two');
+
+    SdfTextRenderer.cleanup();
+
+    vi.clearAllMocks();
+    render('one'); // still cached -> hit
+    render('two'); // still cached -> hit
+
+    expect(SdfFontHandler.getFontData).toHaveBeenCalledTimes(0);
+  });
+});

package/src/core/text-rendering/SdfTextRenderer.ts

@@ -24,10 +24,20 @@ const type = 'sdf' as const;
 
 let sdfShader: WebGlShaderNode | null = null;
 
+// Upper bound on layoutCache entries, enforced on idle via `cleanup`.
+// Overridden from stage options in `init`. The cache is allowed to grow past
+// this during active rendering and is trimmed back to it when the stage idles.
+let maxLayoutCacheSize = 250;
+
 // Initialize the SDF text renderer
 const init = (stage: Stage): void => {
   SdfFontHandler.init();
 
+  const configuredCacheSize = stage.options.textLayoutCacheSize;
+  if (configuredCacheSize !== undefined) {
+    maxLayoutCacheSize = configuredCacheSize;
+  }
+
   // Register SDF shader with the shader manager
   stage.shManager.registerShaderType('Sdf', Sdf);
   sdfShader = stage.shManager.createShader('Sdf') as WebGlShaderNode;
@@ -58,6 +68,11 @@ const renderText = (props: CoreTextNodeProps): TextRenderInfo => {
   const cacheKey = getLayoutCacheKey(props);
   let layout = layoutCache.get(cacheKey);
   if (layout !== undefined) {
+    // Refresh LRU recency: re-insert moves the key to the most-recently-used
+    // end so idle `cleanup` evicts genuinely cold entries first. renderText
+    // runs on text/layout change, not per frame, so this re-insert is cheap.
+    layoutCache.delete(cacheKey);
+    layoutCache.set(cacheKey, layout);
     return {
       remainingLines: 0,
       hasRemainingText: false,
@@ -357,6 +372,20 @@ const generateTextLayout = (
   };
 };
 
+/**
+ * Trim the layout cache back down to `maxLayoutCacheSize`, evicting the
+ * least-recently-used entries first. Called when the stage goes idle so this
+ * never competes with active rendering. A fresh iterator is taken each step so
+ * we always delete the current front (oldest) key without iterator-invalidation
+ * concerns; this runs at most once per idle transition and only when over cap.
+ */
+const cleanup = (): void => {
+  while (layoutCache.size > maxLayoutCacheSize) {
+    const oldest = layoutCache.keys().next().value as string;
+    layoutCache.delete(oldest);
+  }
+};
+
 /**
  * SDF Text Renderer - implements TextRenderer interface
  */
@@ -367,6 +396,7 @@ const SdfTextRenderer = {
   addQuads,
   renderQuads,
   init,
+  cleanup,
 };
 
 export default SdfTextRenderer;

package/src/core/text-rendering/TextRenderer.ts

@@ -435,6 +435,13 @@ export interface TextRenderer {
     renderProps: TextRenderProps,
   ) => void | SdfRenderOp | null;
   init: (stage: Stage) => void;
+  /**
+   * Trim internal caches back down to their configured limits.
+   * Called when the stage goes idle so cache eviction never competes with
+   * active rendering. Backends with no bounded cache may implement this as a
+   * no-op.
+   */
+  cleanup: () => void;
 }
 
 /**

package/src/core/text-rendering/tests/SdfFontHandler.test.ts

@@ -0,0 +1,112 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { loadFont } from '../SdfFontHandler.js';
+import { EventEmitter } from '../../../common/EventEmitter.js';
+import { TextureError, TextureErrorCode } from '../../TextureError.js';
+import type { Stage } from '../../Stage.js';
+
+// Minimal XHR stand-in: synchronously delivers valid SDF font JSON so loadFont
+// proceeds to create the atlas texture and attach its event listeners.
+class FakeXHR {
+  status = 200;
+  response: unknown = null;
+  responseType = '';
+  onload: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  open(): void {}
+  send(): void {
+    this.response = { chars: [{}] };
+    if (this.onload !== null) {
+      this.onload();
+    }
+  }
+}
+
+// A texture is just an EventEmitter to loadFont; stub the few props it reads.
+function makeFakeTexture() {
+  const tex = new EventEmitter() as unknown as EventEmitter & {
+    state: string;
+    preventCleanup: boolean;
+    setRenderableOwner: (owner: string, val: boolean) => void;
+  };
+  tex.state = 'loading'; // not 'loaded' -> goes through the listener path
+  tex.preventCleanup = false;
+  tex.setRenderableOwner = () => {};
+  return tex;
+}
+
+// Drain microtasks + one macrotask so the async loader reaches listener setup.
+const flush = (): Promise<void> => new Promise((r) => setTimeout(r, 0));
+
+describe('SdfFontHandler loadFont — failed event argument', () => {
+  let errSpy: ReturnType<typeof vi.spyOn>;
+  let originalXHR: unknown;
+
+  beforeEach(() => {
+    errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    originalXHR = (globalThis as unknown as { XMLHttpRequest: unknown })
+      .XMLHttpRequest;
+    (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
+      FakeXHR;
+  });
+
+  afterEach(() => {
+    errSpy.mockRestore();
+    (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
+      originalXHR;
+  });
+
+  it('rejects with the TextureError (second emit arg), not the emitting texture', async () => {
+    const tex = makeFakeTexture();
+    const stage = {
+      txManager: { createTexture: () => tex },
+    } as unknown as Stage;
+
+    const promise = loadFont(stage, {
+      fontFamily: 'TestSdfFailFont',
+      atlasUrl: 'atlas.png',
+      atlasDataUrl: 'atlas.json',
+    } as Parameters<typeof loadFont>[1]);
+
+    await flush();
+
+    const error = new TextureError(
+      TextureErrorCode.TEXTURE_UPLOAD_FAILED,
+      'boom',
+    );
+
+    // Attach the rejection assertion before emitting so the handler is ready.
+    const assertion = expect(promise).rejects.toBe(error);
+
+    // EventEmitter calls listeners as (target, data) -> (tex, error).
+    tex.emit('failed', error);
+
+    await assertion;
+  });
+
+  it('logs the error, not the texture, on failure', async () => {
+    const tex = makeFakeTexture();
+    const stage = {
+      txManager: { createTexture: () => tex },
+    } as unknown as Stage;
+
+    const promise = loadFont(stage, {
+      fontFamily: 'TestSdfFailFontLog',
+      atlasUrl: 'atlas.png',
+      atlasDataUrl: 'atlas.json',
+    } as Parameters<typeof loadFont>[1]);
+
+    await flush();
+
+    const error = new TextureError(
+      TextureErrorCode.TEXTURE_UPLOAD_FAILED,
+      'boom',
+    );
+    const rejected = promise.catch(() => {});
+    tex.emit('failed', error);
+    await rejected;
+
+    const lastCall = errSpy.mock.calls[errSpy.mock.calls.length - 1]!;
+    expect(lastCall[1]).toBe(error);
+    expect(lastCall[1]).not.toBe(tex);
+  });
+});

package/src/core/textures/ImageTexture.ts

@@ -269,6 +269,24 @@ export class ImageTexture extends Texture {
   }
 
   override async getTextureSource(): Promise<TextureData> {
+    // Compressed textures are not supported by the Canvas2D renderer.
+    // Fail fast here before incurring a network fetch or binary decode.
+    if (this.txManager.renderer?.mode === 'canvas') {
+      const { src, type } = this.props;
+      if (
+        type === 'compressed' ||
+        (typeof src === 'string' && isCompressedTextureContainer(src) === true)
+      ) {
+        const err = new Error(
+          `ImageTexture: Compressed textures are not supported in Canvas2D render mode (src: ${String(
+            src,
+          )})`,
+        );
+        this.setState('failed', err);
+        return { data: null };
+      }
+    }
+
     let resp: TextureData;
     try {
       resp = await this.determineImageTypeAndLoadImage();

package/src/core/textures/SubTexture.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SubTexture } from './SubTexture.js';
+import { ImageTexture } from './ImageTexture.js';
+import type { CoreTextureManager } from '../CoreTextureManager.js';
+
+const flushMicrotasks = () => Promise.resolve();
+
+describe('SubTexture lifecycle', () => {
+  it('detaches its parent-texture listeners on destroy', async () => {
+    // 'initial' state means the constructor's microtask attaches listeners
+    // without synchronously firing any of the state handlers.
+    const parent = {
+      state: 'initial',
+      dimensions: null,
+      error: null,
+      on: vi.fn(),
+      off: vi.fn(),
+    };
+    const txManager = {
+      maxRetryCount: 0,
+      platform: {},
+      resolveParentTexture: () => parent,
+    } as unknown as CoreTextureManager;
+
+    const parentImage = new ImageTexture(txManager, {} as never);
+    const sub = new SubTexture(txManager, {
+      texture: parentImage,
+      x: 0,
+      y: 0,
+      w: 10,
+      h: 10,
+    });
+
+    // Listeners are attached in a microtask after construction.
+    await flushMicrotasks();
+    expect(parent.on).toHaveBeenCalledTimes(4);
+
+    sub.destroy();
+
+    const offEvents = (parent.off.mock.calls as Array<[string]>)
+      .map((c) => c[0])
+      .sort();
+    expect(offEvents).toEqual(['failed', 'freed', 'loaded', 'loading']);
+  });
+});

package/src/core/textures/SubTexture.ts

@@ -133,6 +133,19 @@ export class SubTexture extends Texture {
     this.parentTexture.setRenderableOwner(this.subtextureId, isRenderable);
   }
 
+  override destroy(): void {
+    // Detach from the parent texture's event emitter. The parent is typically a
+    // long-lived shared atlas (preventCleanup), so without this each destroyed
+    // SubTexture — and everything its handlers capture — would be retained by
+    // the parent's listener lists for the rest of the session.
+    const parentTx = this.parentTexture;
+    parentTx.off('loading', this.onParentTxLoading);
+    parentTx.off('loaded', this.onParentTxLoaded);
+    parentTx.off('failed', this.onParentTxFailed);
+    parentTx.off('freed', this.onParentTxFreed);
+    super.destroy();
+  }
+
   override async getTextureSource(): Promise<TextureData> {
     // Check if parent texture is loaded
     return new Promise((resolve, reject) => {

package/src/core/textures/Texture.ts

@@ -240,6 +240,11 @@ export abstract class Texture extends EventEmitter {
       return false;
     }
 
+    // Don't cleanup a texture that is in the process of loading
+    if (this.state === 'loading') {
+      return false;
+    }
+
     // Don't cleanup if not renderable
     if (this.renderable === true) {
       return false;
@@ -341,6 +346,9 @@ export abstract class Texture extends EventEmitter {
    */
   free(): void {
     this.ctxTexture?.free();
+    // Null out the freed ctxTexture so a subsequent reload re-creates it via
+    // getCtxTexture() instead of reusing a stale, already-freed reference.
+    this.ctxTexture = undefined;
   }
 
   /**
@@ -370,6 +378,10 @@ export abstract class Texture extends EventEmitter {
 
     // Always free texture data regardless of state
     this.freeTextureData();
+
+    // Drop any remaining subscribers so a texture destroyed while something
+    // still holds a listener does not retain it (and its captures).
+    this.removeAllListeners();
   }
 
   /**

package/src/main-api/Renderer.ts

@@ -28,7 +28,7 @@ import { Platform } from '../core/platforms/Platform.js';
  * @category Events
  * @example
  * ```typescript
- * renderer.on('fpsUpdate', (data) => {
+ * renderer.on('fpsUpdate', (_target, data) => {
  *   console.log(`Current FPS: ${data.fps}`);
  *   if (data.contextSpyData) {
  *     console.log('WebGL calls:', data.contextSpyData);
@@ -49,7 +49,7 @@ export interface RendererMainFpsUpdateEvent {
  * @category Events
  * @example
  * ```typescript
- * renderer.on('frameTick', (data) => {
+ * renderer.on('frameTick', (_target, data) => {
  *   console.log(`Frame time: ${data.time}ms, delta: ${data.delta}ms`);
  * });
  * ```
@@ -67,7 +67,7 @@ export interface RendererMainFrameTickEvent {
  * @category Events
  * @example
  * ```typescript
- * renderer.on('renderUpdate', (data) => {
+ * renderer.on('renderUpdate', (_target, data) => {
  *   console.log(`Rendered quads: ${data.quads}, renderOps: ${data.renderOps}`);
  * });
  * ```
@@ -110,7 +110,7 @@ export interface RendererMainIdleEvent {
  * @category Events
  * @example
  * ```typescript
- * renderer.on('criticalCleanup', (data) => {
+ * renderer.on('criticalCleanup', (_target, data) => {
  *   console.log(`Memory cleanup triggered!`);
  *   console.log(`Memory used: ${data.memUsed} bytes`);
  *   console.log(`Critical threshold: ${data.criticalThreshold} bytes`);
@@ -130,7 +130,7 @@ export interface RendererMainCriticalCleanupEvent {
  * @category Events
  * @example
  * ```typescript
- * renderer.on('criticalCleanupFailed', (data) => {
+ * renderer.on('criticalCleanupFailed', (_target, data) => {
  *   console.warn(`Memory cleanup failed!`);
  *   console.log(`Memory still used: ${data.memUsed} bytes`);
  *   console.log(`Critical threshold: ${data.criticalThreshold} bytes`);
@@ -167,6 +167,90 @@ export interface RendererMainContextLostEvent {
   readonly __eventHasNoPayload?: never;
 }
 
+/**
+ * GPU Out Of Memory Event Data
+ *
+ * @remarks
+ * Fired when the renderer detects a real `GL_OUT_OF_MEMORY` from the GPU (probed
+ * once per frame). This is the only certain signal that the texture memory
+ * estimate has overshot the device's real VRAM budget. At this point a texture
+ * upload has already failed and the driver may soon drop the WebGL context, so
+ * the supported recovery is for the application to reload with a lower
+ * `criticalThreshold`.
+ *
+ * `memUsed` is the estimated texture memory in use at the moment of the failure.
+ * Because the upload failed, the real GPU budget is at or below this value — so
+ * it is a good basis for the next `criticalThreshold`.
+ *
+ * The renderer deliberately does NOT persist, reload, or change the threshold
+ * itself — that is application policy. The recommended integration is to lower
+ * the threshold, persist it, and reload:
+ *
+ * @category Events
+ * @example
+ * ```typescript
+ * // --- on startup: read the calibrated threshold before creating the renderer
+ * //
+ * // Namespace the storage key per app. On TV devices that run from the
+ * // filesystem (file://) the origin is null/opaque, so a bare key can collide
+ * // across apps — including the path keeps each app's calibration separate.
+ * const STORAGE_KEY = `myapp:criticalThreshold:${location.pathname}`;
+ *
+ * // Never let calibration drive the threshold so low the UX breaks. Pick a
+ * // floor that matches your app (here, 70% of the default budget).
+ * const DEFAULT_CRITICAL = 200e6;
+ * const MIN_THRESHOLD = Math.round(DEFAULT_CRITICAL * 0.7);
+ *
+ * function readCriticalThreshold(): number {
+ *   const raw =
+ *     typeof localStorage !== 'undefined'
+ *       ? localStorage.getItem(STORAGE_KEY)
+ *       : null;
+ *   const stored = raw !== null ? parseInt(raw, 10) : NaN;
+ *   if (Number.isNaN(stored) === false && stored > 0) {
+ *     return Math.max(stored, MIN_THRESHOLD);
+ *   }
+ *   return DEFAULT_CRITICAL;
+ * }
+ *
+ * const renderer = new RendererMain(
+ *   { textureMemory: { criticalThreshold: readCriticalThreshold() } },
+ *   'app',
+ * );
+ *
+ * // --- at runtime: react to a real GPU out-of-memory
+ * let handlingOOM = false;
+ * renderer.on('outOfMemory', (_target, { memUsed, criticalThreshold }) => {
+ *   if (handlingOOM === true) {
+ *     return; // debounce — several uploads can fail in the same burst
+ *   }
+ *   handlingOOM = true;
+ *
+ *   // The OOM proves the real budget is <= memUsed. Drop to 90% of the lower
+ *   // of (estimate, current threshold), but never below the floor.
+ *   const ceiling = Math.min(memUsed, criticalThreshold);
+ *   const next = Math.max(Math.round(ceiling * 0.9), MIN_THRESHOLD);
+ *
+ *   try {
+ *     localStorage.setItem(STORAGE_KEY, String(next));
+ *   } catch (e) {
+ *     // storage may be blocked (e.g. file:// with storage disabled); the new
+ *     // value just won't survive the reload.
+ *   }
+ *
+ *   // Reload so the renderer reinitializes with the lower budget. The engine
+ *   // does not rebuild GPU resources in place, so reload is the clean recovery.
+ *   location.reload();
+ * });
+ * ```
+ */
+export interface RendererMainOutOfMemoryEvent {
+  /** Estimated texture memory in use at the time of the failure (bytes) */
+  memUsed: number;
+  /** Critical threshold in effect at the time of the failure (bytes) */
+  criticalThreshold: number;
+}
+
 /**
  * Settings for the Renderer that can be updated during runtime.
  */
@@ -309,6 +393,23 @@ export interface RendererRuntimeSettings {
  * Configuration settings for {@link RendererMain}
  */
 export type RendererMainSettings = RendererRuntimeSettings & {
+  /**
+   * Maximum number of entries kept in the SDF text layout cache
+   *
+   * @remarks
+   * The SDF text renderer caches the computed glyph layout for a given
+   * `text` + font + layout-prop combination so that identical strings (e.g.
+   * repeated badges/labels) are not re-laid-out. The cache is content-keyed
+   * and shared across nodes, and is trimmed down to this many (most recently
+   * used) entries whenever the stage goes idle.
+   *
+   * Set this higher for content-dense UIs with many simultaneous unique
+   * strings, or lower to cap memory more aggressively.
+   *
+   * @defaultValue `250`
+   */
+  textLayoutCacheSize: number;
+
   /**
    * Include context call (i.e. WebGL) information in FPS updates
    *
@@ -532,11 +633,11 @@ export type RendererMainSettings = RendererRuntimeSettings & {
  *
  * Listen to events using the standard EventEmitter API:
  * ```typescript
- * renderer.on('fpsUpdate', (data: RendererMainFpsUpdateEvent) => {
+ * renderer.on('fpsUpdate', (_target, data: RendererMainFpsUpdateEvent) => {
  *   console.log(`FPS: ${data.fps}`);
  * });
  *
- * renderer.on('idle', (data: RendererMainIdleEvent) => {
+ * renderer.on('idle', () => {
  *   // Renderer is idle - no scene changes
  * });
  * ```
@@ -548,6 +649,7 @@ export type RendererMainSettings = RendererRuntimeSettings & {
  * @see {@link RendererMainCriticalCleanupEvent}
  * @see {@link RendererMainCriticalCleanupFailedEvent}
  * @see {@link RendererMainContextLostEvent}
+ * @see {@link RendererMainOutOfMemoryEvent}
  *
  * @fires RendererMain#fpsUpdate
  * @fires RendererMain#frameTick
@@ -556,6 +658,7 @@ export type RendererMainSettings = RendererRuntimeSettings & {
  * @fires RendererMain#criticalCleanup
  * @fires RendererMain#criticalCleanupFailed
  * @fires RendererMain#contextLost
+ * @fires RendererMain#outOfMemory
  */
 export class RendererMain extends EventEmitter {
   readonly root: INode;
@@ -592,6 +695,7 @@ export class RendererMain extends EventEmitter {
       fpsUpdateInterval: settings.fpsUpdateInterval || 0,
       enableClear: settings.enableClear ?? true,
       targetFPS: settings.targetFPS || 0,
+      textLayoutCacheSize: settings.textLayoutCacheSize ?? 250,
       numImageWorkers:
         settings.numImageWorkers !== undefined ? settings.numImageWorkers : 2,
       enableContextSpy: settings.enableContextSpy ?? false,
@@ -669,6 +773,7 @@ export class RendererMain extends EventEmitter {
       textBaselineMode: settings.textBaselineMode!,
       inspector: settings.inspector !== null,
       targetFPS: settings.targetFPS!,
+      textLayoutCacheSize: settings.textLayoutCacheSize!,
       textureProcessingTimeLimit: settings.textureProcessingTimeLimit!,
       createImageBitmapSupport: settings.createImageBitmapSupport!,
       premultiplyAlphaHonored: settings.premultiplyAlphaHonored,
@@ -717,11 +822,13 @@ export class RendererMain extends EventEmitter {
     const currentTxSettings =
       (this.stage && this.stage.options.textureMemory) || {};
 
+    const criticalThreshold =
+      textureMemory?.criticalThreshold ??
+      currentTxSettings?.criticalThreshold ??
+      200e6;
+
     return {
-      criticalThreshold:
-        textureMemory?.criticalThreshold ??
-        currentTxSettings?.criticalThreshold ??
-        200e6,
+      criticalThreshold,
       targetThresholdLevel:
         textureMemory?.targetThresholdLevel ??
         currentTxSettings?.targetThresholdLevel ??