@solidtv/renderer 1.5.4 → 1.5.6

package/src/core/shaders/webgl/LinearGradient.ts

@@ -1,3 +1,4 @@
+import type { CoreNode } from '../../CoreNode.js';
 import { getNormalizedRgbaComponents } from '../../lib/utils.js';
 import {
   LinearGradientTemplate,
@@ -8,9 +9,33 @@ import type { WebGlShaderType } from '../../renderers/webgl/WebGlShaderNode.js';
 
 export const LinearGradient: WebGlShaderType<LinearGradientProps> = {
   props: LinearGradientTemplate.props,
-  update() {
+  update(node: CoreNode) {
     const props = this.props!;
-    this.uniform1f('u_angle', props.angle - (Math.PI / 180) * 90);
+
+    // The gradient distance is an affine function of the node-local texture
+    // coordinates, so it reduces to `dist = dot(v_textureCoords, a) + b`.
+    // `a`/`b` depend only on the angle and node dimensions (both are part of
+    // the value-key), so we compute them once on the CPU here instead of
+    // recomputing the trig per fragment on the GPU.
+    const angle = props.angle - (Math.PI / 180) * 90;
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    const w = node.w;
+    const h = node.h;
+
+    const lineDist = Math.abs(w * c) + Math.abs(h * s);
+    // Gradient axis (from -> to), gradVec = -lineDist * (c, s)
+    const gx = -lineDist * c;
+    const gy = -lineDist * s;
+    const gg = gx * gx + gy * gy;
+    const invGG = gg > 0 ? 1 / gg : 0;
+    // Gradient origin: f = lineDist * 0.5 * (c, s) + dimensions * 0.5
+    const fx = lineDist * 0.5 * c + w * 0.5;
+    const fy = lineDist * 0.5 * s + h * 0.5;
+
+    this.uniform2f('u_grad_a', w * gx * invGG, h * gy * invGG);
+    this.uniform1f('u_grad_b', -(fx * gx + fy * gy) * invGG);
+
     this.uniform1fv('u_stops', new Float32Array(props.stops));
     const colors: number[] = [];
     for (let i = 0; i < props.colors.length; i++) {
@@ -22,51 +47,6 @@ export const LinearGradient: WebGlShaderType<LinearGradientProps> = {
   getCacheMarkers(props: LinearGradientProps) {
     return `colors:${props.colors.length}`;
   },
-  vertex: `
-    # ifdef GL_FRAGMENT_PRECISION_HIGH
-    precision highp float;
-    # else
-    precision mediump float;
-    # endif
-
-    attribute vec2 a_position;
-    attribute vec2 a_textureCoords;
-    attribute vec4 a_color;
-
-    uniform vec2 u_resolution;
-    uniform float u_pixelRatio;
-    uniform vec2 u_dimensions;
-    uniform float u_angle;
-
-    varying vec4 v_color;
-    varying vec2 v_textureCoords;
-    varying float v_dist;
-
-    const float PI = 3.14159265359;
-
-    vec2 calcPoint(float d, float angle) {
-      return d * vec2(cos(angle), sin(angle)) + (u_dimensions * 0.5);
-    }
-
-    void main() {
-      vec2 normalized = a_position * u_pixelRatio / u_resolution;
-      vec2 zero_two = normalized * 2.0;
-      vec2 clip_space = zero_two - 1.0;
-
-      gl_Position = vec4(clip_space * vec2(1.0, -1.0), 0, 1);
-
-      v_color = a_color;
-      v_textureCoords = a_textureCoords;
-
-      float a = u_angle;
-      float lineDist = abs(u_dimensions.x * cos(a)) + abs(u_dimensions.y * sin(a));
-      vec2 f = calcPoint(lineDist * 0.5, a);
-      vec2 t = calcPoint(lineDist * 0.5, a + PI);
-      vec2 gradVec = t - f;
-      float dist = dot(a_textureCoords * u_dimensions - f, gradVec) / dot(gradVec, gradVec);
-      v_dist = dist;
-    }
-  `,
   fragment(renderer: WebGlRenderer, props: LinearGradientProps) {
     return `
     # ifdef GL_FRAGMENT_PRECISION_HIGH
@@ -78,13 +58,17 @@ export const LinearGradient: WebGlShaderType<LinearGradientProps> = {
     #define MAX_STOPS ${props.colors.length}
     #define LAST_STOP ${props.colors.length - 1}
 
+    uniform float u_alpha;
+
     uniform sampler2D u_texture;
+
+    uniform vec2 u_grad_a;
+    uniform float u_grad_b;
     uniform float u_stops[MAX_STOPS];
     uniform vec4 u_colors[MAX_STOPS];
 
     varying vec4 v_color;
     varying vec2 v_textureCoords;
-    varying float v_dist;
 
     vec4 getGradientColor(float dist) {
       dist = clamp(dist, 0.0, 1.0);
@@ -110,9 +94,10 @@ export const LinearGradient: WebGlShaderType<LinearGradientProps> = {
 
     void main() {
       vec4 color = texture2D(u_texture, v_textureCoords) * v_color;
-      vec4 colorOut = getGradientColor(v_dist);
-      vec3 blendedRGB = mix(color.rgb, colorOut.rgb, clamp(colorOut.a, 0.0, 1.0));
-      gl_FragColor = vec4(blendedRGB, color.a);
+      float dist = dot(v_textureCoords, u_grad_a) + u_grad_b;
+      vec4 colorOut = getGradientColor(dist);
+      color = mix(color, colorOut, clamp(colorOut.a, 0.0, 1.0));
+      gl_FragColor = color * u_alpha;
     }
   `;
   },

package/src/core/shaders/webgl/RadialGradient.ts

@@ -83,8 +83,8 @@ export const RadialGradient: WebGlShaderType<RadialGradientProps> = {
         float dist = length((point - u_projection) / u_size);
 
         vec4 colorOut = getGradientColor(dist);
-        vec3 blendedRGB = mix(color.rgb, colorOut.rgb, clamp(colorOut.a, 0.0, 1.0));
-        gl_FragColor = vec4(blendedRGB, color.a);
+        color = mix(color, colorOut, clamp(colorOut.a, 0.0, 1.0));
+        gl_FragColor = color * u_alpha;
       }
     `;
   },

package/src/core/shaders/webgl/RadialProgress.ts

@@ -171,6 +171,13 @@ export const RadialProgress: WebGlShaderType<RadialProgressProps> = {
           layer = fillPM * fillCoverage;
         #endif
 
+        // Apply node opacity to the introduced ring/track colors. They come
+        // from u_colors / u_trackColor and do not carry worldAlpha, so without
+        // this a fading RadialProgress node would keep its ring fully opaque.
+        // \`base\` already includes worldAlpha (via v_color), so it is left as-is
+        // to avoid double-applying. Scaling a premultiplied layer is valid.
+        layer *= u_alpha;
+
         // Premultiplied "over": out = src + dst*(1 - src.a). The output stays
         // visible on a fully-transparent \`base\` because layer brings its own alpha.
         float la = clamp(layer.a, 0.0, 1.0);

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

@@ -109,6 +109,12 @@ export interface SdfFont {
   maxCharHeight: number;
 }
 
+// Number of times a failed font load is automatically retried before
+// loadFont() finally rejects. Counts reloads *after* the initial attempt
+// (matching the `maxRetryCount` = retries convention used for textures), so
+// the load is attempted up to MAX_FONT_LOAD_RETRIES + 1 times in total.
+export const MAX_FONT_LOAD_RETRIES = 3;
+
 //global state variables for SdfFontHandler
 const fontCache = new Map<string, SdfFont>();
 const fontLoadPromises = new Map<string, Promise<void>>();
@@ -320,10 +326,18 @@ export const loadFont = (
     );
   }
 
-  const nwff: CoreTextNode[] = (nodesWaitingForFont[fontFamily] = []);
-  // Create loading promise
-  const loadPromise = (async (): Promise<void> => {
-    const fontData = await new Promise<SdfFontData>((resolve, reject) => {
+  // Reuse an existing waiter list. A previous load attempt for this font may
+  // have failed and left nodes parked here; overwriting the list would strand
+  // them, so a successful retry could never wake them. The list is consumed
+  // (and deleted) on the next successful load.
+  let nwff = nodesWaitingForFont[fontFamily];
+  if (nwff === undefined) {
+    nwff = nodesWaitingForFont[fontFamily] = [];
+  }
+  // One attempt at fetching + decoding the JSON atlas description. A fresh
+  // XHR runs per attempt so a transient network/parse failure can recover.
+  const fetchFontData = (): Promise<SdfFontData> =>
+    new Promise<SdfFontData>((resolve, reject) => {
       const xhr = new XMLHttpRequest();
       xhr.open('GET', atlasDataUrl, true);
       xhr.responseType = 'json';
@@ -352,16 +366,23 @@ export const loadFont = (
       };
       xhr.send(null);
     });
+
+  // One attempt at loading the atlas texture for the given font data. On
+  // success it processes + caches the font and wakes parked nodes. On failure
+  // it drops the dead atlas texture (createTexture caches by `src`, so the
+  // next attempt must evict it to build a fresh one) and rejects.
+  const loadAtlas = (fontData: SdfFontData): Promise<void> => {
     if (!fontData || !fontData.chars) {
-      throw new Error('Invalid SDF font data format');
+      return Promise.reject(new Error('Invalid SDF font data format'));
     }
 
     // Atlas texture should be provided externally
     if (!atlasUrl) {
-      throw new Error('Atlas texture must be provided for SDF fonts');
+      return Promise.reject(
+        new Error('Atlas texture must be provided for SDF fonts'),
+      );
     }
 
-    // Wait for atlas texture to load
     return new Promise<void>((resolve, reject) => {
       // create new atlas texture using ImageTexture
       const atlasTexture = stage.txManager.createTexture('ImageTexture', {
@@ -372,46 +393,72 @@ export const loadFont = (
       atlasTexture.setRenderableOwner(fontFamily, true);
       atlasTexture.preventCleanup = true; // Prevent automatic cleanup
 
-      if (atlasTexture.state === 'loaded') {
-        // If already loaded, process immediately
-        processFontData(fontFamily, fontData, atlasTexture, metrics);
-        fontLoadPromises.delete(fontFamily);
-
-        for (let key in nwff) {
-          nwff[key]!.setUpdateType(UpdateType.Local);
-        }
-        delete nodesWaitingForFont[fontFamily];
-        return resolve();
-      }
-
-      atlasTexture.on('loaded', () => {
+      const onLoaded = () => {
         // Process and cache font data
         processFontData(fontFamily, fontData, atlasTexture, metrics);
 
-        // remove from promises
-        fontLoadPromises.delete(fontFamily);
-
         for (let key in nwff) {
           nwff[key]!.setUpdateType(UpdateType.Local);
         }
         delete nodesWaitingForFont[fontFamily];
         resolve();
-      });
+      };
+
+      if (atlasTexture.state === 'loaded') {
+        // If already loaded, process immediately
+        onLoaded();
+        return;
+      }
+
+      atlasTexture.on('loaded', onLoaded);
 
       // EventEmitter invokes listeners as (target, data), so the error payload
       // is the SECOND argument. The first arg is the Texture that emitted the
       // event. Reading it as the only param (the previous behavior) rejected
       // and logged the Texture instead of the actual TextureError.
       atlasTexture.on('failed', (_target, error: TextureError) => {
-        // Cleanup on error
-        fontLoadPromises.delete(fontFamily);
-        if (fontCache[fontFamily]) {
-          delete fontCache[fontFamily];
-        }
-        console.error(`Failed to load SDF font: ${fontFamily}`, error);
+        // Drop the failed atlas so a retry builds a fresh texture rather than
+        // getting this dead instance back from the createTexture key-cache.
+        atlasTexture.setRenderableOwner(fontFamily, false);
+        stage.txManager.removeTextureFromCache(atlasTexture);
         reject(error);
       });
     });
+  };
+
+  // Initial attempt plus up to MAX_FONT_LOAD_RETRIES automatic reloads.
+  const loadPromise = (async (): Promise<void> => {
+    let lastError: unknown;
+    for (let attempt = 0; attempt <= MAX_FONT_LOAD_RETRIES; attempt++) {
+      try {
+        await loadAtlas(await fetchFontData());
+        // Success: clear the in-flight marker (the font now lives in fontCache)
+        // — parked nodes were already woken inside loadAtlas.
+        fontLoadPromises.delete(fontFamily);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < MAX_FONT_LOAD_RETRIES) {
+          console.warn(
+            `SDF font "${fontFamily}" failed to load (attempt ${
+              attempt + 1
+            } of ${MAX_FONT_LOAD_RETRIES + 1}), retrying.`,
+            error,
+          );
+        }
+      }
+    }
+
+    // Every attempt failed. Clear the in-flight marker so the font can be
+    // requested again and drop any partial cache entry. nodesWaitingForFont
+    // is deliberately kept: nodes parked here must survive so a later
+    // loadFont() (which reuses the list) can still wake them if the font
+    // eventually loads. The list shrinks as nodes self-remove via
+    // stopWaitingForFont on destroy.
+    fontLoadPromises.delete(fontFamily);
+    fontCache.delete(fontFamily);
+    console.error(`Failed to load SDF font: ${fontFamily}`, lastError);
+    throw lastError;
   })();
 
   fontLoadPromises.set(fontFamily, loadPromise);

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

@@ -1,5 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { loadFont } from '../SdfFontHandler.js';
+import {
+  loadFont,
+  waitingForFont,
+  isFontLoaded,
+  MAX_FONT_LOAD_RETRIES,
+} from '../SdfFontHandler.js';
 import { EventEmitter } from '../../../common/EventEmitter.js';
 import { TextureError, TextureErrorCode } from '../../TextureError.js';
 import type { Stage } from '../../Stage.js';
@@ -14,7 +19,19 @@ class FakeXHR {
   onerror: (() => void) | null = null;
   open(): void {}
   send(): void {
-    this.response = { chars: [{}] };
+    // Enough shape for processFontData to run on the success path without
+    // throwing: a chars array, an (empty) kernings array, and metrics so it
+    // skips the atlas-derived cap/x-height branches.
+    this.response = {
+      chars: [{}],
+      kernings: [],
+      lightningMetrics: {
+        ascender: 800,
+        descender: -200,
+        lineGap: 200,
+        unitsPerEm: 1000,
+      },
+    };
     if (this.onload !== null) {
       this.onload();
     }
@@ -34,15 +51,59 @@ function makeFakeTexture() {
   return tex;
 }
 
+type FakeTexture = ReturnType<typeof makeFakeTexture>;
+
+// A stage whose txManager hands out a fresh fake texture per loadFont attempt
+// (so each retry has its own texture to fail/succeed) and records them.
+function makeStage(): { stage: Stage; textures: FakeTexture[] } {
+  const textures: FakeTexture[] = [];
+  const stage = {
+    txManager: {
+      createTexture: () => {
+        const t = makeFakeTexture();
+        textures.push(t);
+        return t;
+      },
+      // loadFont evicts a failed atlas before retrying; a no-op is enough here.
+      removeTextureFromCache: () => {},
+    },
+  } as unknown as Stage;
+  return { stage, textures };
+}
+
+const opts = (fontFamily: string) =>
+  ({
+    fontFamily,
+    atlasUrl: 'atlas.png',
+    atlasDataUrl: 'atlas.json',
+  } as Parameters<typeof loadFont>[1]);
+
 // 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', () => {
+// Fail every attempt: each iteration waits for the next attempt to wire up its
+// atlas listener, then fires 'failed' on that attempt's texture.
+async function failAllAttempts(
+  textures: FakeTexture[],
+  error: TextureError,
+  attempts: number,
+): Promise<void> {
+  for (let i = 0; i < attempts; i++) {
+    await flush();
+    textures[i]!.emit('failed', error);
+  }
+}
+
+const TOTAL_ATTEMPTS = MAX_FONT_LOAD_RETRIES + 1; // initial + retries
+
+describe('SdfFontHandler loadFont — failure after exhausting retries', () => {
   let errSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof vi.spyOn>;
   let originalXHR: unknown;
 
   beforeEach(() => {
     errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
     originalXHR = (globalThis as unknown as { XMLHttpRequest: unknown })
       .XMLHttpRequest;
     (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
@@ -51,62 +112,147 @@ describe('SdfFontHandler loadFont — failed event argument', () => {
 
   afterEach(() => {
     errSpy.mockRestore();
+    warnSpy.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;
+  it('rejects with the last TextureError (second emit arg), not the emitting texture', async () => {
+    const { stage, textures } = makeStage();
+    const promise = loadFont(stage, opts('TestSdfFailFont'));
 
-    const promise = loadFont(stage, {
-      fontFamily: 'TestSdfFailFont',
-      atlasUrl: 'atlas.png',
-      atlasDataUrl: 'atlas.json',
-    } as Parameters<typeof loadFont>[1]);
+    const error = new TextureError(
+      TextureErrorCode.TEXTURE_UPLOAD_FAILED,
+      'boom',
+    );
 
-    await flush();
+    // Attach the rejection assertion before driving failures.
+    const assertion = expect(promise).rejects.toBe(error);
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await assertion;
+  });
+
+  it('logs the error, not the texture, after the final attempt', async () => {
+    const { stage, textures } = makeStage();
+    const promise = loadFont(stage, opts('TestSdfFailFontLog'));
 
     const error = new TextureError(
       TextureErrorCode.TEXTURE_UPLOAD_FAILED,
       'boom',
     );
+    const rejected = promise.catch(() => {});
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await rejected;
 
-    // Attach the rejection assertion before emitting so the handler is ready.
-    const assertion = expect(promise).rejects.toBe(error);
+    const lastCall = errSpy.mock.calls[errSpy.mock.calls.length - 1]!;
+    expect(lastCall[1]).toBe(error);
+    expect(lastCall[1]).not.toBe(textures[textures.length - 1]);
+  });
 
-    // EventEmitter calls listeners as (target, data) -> (tex, error).
-    tex.emit('failed', error);
+  it('attempts the load exactly initial + MAX_FONT_LOAD_RETRIES times', async () => {
+    const { stage, textures } = makeStage();
+    const promise = loadFont(stage, opts('TestSdfAttemptCount'));
 
-    await assertion;
+    const error = new TextureError(
+      TextureErrorCode.TEXTURE_UPLOAD_FAILED,
+      'boom',
+    );
+    const rejected = promise.catch(() => {});
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await rejected;
+
+    // One texture is created per attempt; no further attempts after exhaustion.
+    expect(textures.length).toBe(TOTAL_ATTEMPTS);
+    // A warning per retried attempt, error only on the final failure.
+    expect(warnSpy).toHaveBeenCalledTimes(MAX_FONT_LOAD_RETRIES);
+    expect(errSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('SdfFontHandler loadFont — automatic retry', () => {
+  let errSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof vi.spyOn>;
+  let originalXHR: unknown;
+
+  beforeEach(() => {
+    errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    originalXHR = (globalThis as unknown as { XMLHttpRequest: unknown })
+      .XMLHttpRequest;
+    (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
+      FakeXHR;
+  });
+
+  afterEach(() => {
+    errSpy.mockRestore();
+    warnSpy.mockRestore();
+    (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
+      originalXHR;
   });
 
-  it('logs the error, not the texture, on failure', async () => {
-    const tex = makeFakeTexture();
-    const stage = {
-      txManager: { createTexture: () => tex },
-    } as unknown as Stage;
+  it('recovers when a retry succeeds and wakes nodes parked before the failure', async () => {
+    const { stage, textures } = makeStage();
+    const fontFamily = 'RetryRecoverFont';
+
+    const promise = loadFont(stage, opts(fontFamily));
 
-    const promise = loadFont(stage, {
-      fontFamily: 'TestSdfFailFontLog',
-      atlasUrl: 'atlas.png',
-      atlasDataUrl: 'atlas.json',
-    } as Parameters<typeof loadFont>[1]);
+    // Park a node while the font is loading (waiter list exists synchronously).
+    const node = { id: 1, setUpdateType: vi.fn() };
+    waitingForFont(
+      fontFamily,
+      node as unknown as Parameters<typeof waitingForFont>[1],
+    );
 
+    // First attempt fails...
     await flush();
+    textures[0]!.emit(
+      'failed',
+      new TextureError(TextureErrorCode.TEXTURE_UPLOAD_FAILED, 'boom'),
+    );
 
+    // ...the automatic retry succeeds.
+    await flush();
+    textures[1]!.emit('loaded');
+    await promise;
+
+    expect(isFontLoaded(fontFamily)).toBe(true);
+    expect(node.setUpdateType).toHaveBeenCalledTimes(1);
+    // Only two attempts were needed.
+    expect(textures.length).toBe(2);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(errSpy).not.toHaveBeenCalled();
+  });
+
+  it('keeps parked nodes after every retry fails so a later loadFont still wakes them', async () => {
+    const { stage, textures } = makeStage();
+    const fontFamily = 'RetryExhaustReuseFont';
     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);
+    const first = loadFont(stage, opts(fontFamily));
+    const firstRejected = first.catch(() => {});
+
+    const node = { id: 1, setUpdateType: vi.fn() };
+    waitingForFont(
+      fontFamily,
+      node as unknown as Parameters<typeof waitingForFont>[1],
+    );
+
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await firstRejected;
+
+    expect(isFontLoaded(fontFamily)).toBe(false);
+    expect(node.setUpdateType).not.toHaveBeenCalled();
+
+    // A fresh load reuses the still-parked node and wakes it on success.
+    const second = loadFont(stage, opts(fontFamily));
+    await flush();
+    textures[TOTAL_ATTEMPTS]!.emit('loaded');
+    await second;
+
+    expect(isFontLoaded(fontFamily)).toBe(true);
+    expect(node.setUpdateType).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ImageTexture } from './ImageTexture.js';
+import type { CoreTextureManager } from '../CoreTextureManager.js';
+
+describe('ImageTexture.createImageBitmap', () => {
+  beforeEach(() => {
+    vi.stubGlobal('ImageBitmap', class {});
+  });
+
+  it('passes options to createImageBitmap when no crop is requested and options/full are supported', async () => {
+    const createImageBitmapMock = vi.fn(() =>
+      Promise.resolve({ close: () => {} }),
+    );
+    const txManager = {
+      imageBitmapSupported: {
+        basic: true,
+        options: true,
+        full: true,
+        premultiplyHonored: false,
+      },
+      platform: {
+        createImageBitmap: createImageBitmapMock,
+      },
+    } as unknown as CoreTextureManager;
+
+    const props = ImageTexture.resolveDefaults({
+      src: 'test.png',
+      premultiplyAlpha: true,
+    });
+    const texture = new ImageTexture(txManager, props);
+
+    const blob = new Blob([], { type: 'image/png' });
+    const result = await texture.createImageBitmap(
+      blob,
+      true,
+      null,
+      null,
+      null,
+      null,
+    );
+
+    // It should have called createImageBitmap with the options object
+    expect(createImageBitmapMock).toHaveBeenCalledWith(blob, {
+      premultiplyAlpha: 'none',
+      colorSpaceConversion: 'none',
+      imageOrientation: 'none',
+    });
+
+    // Since premultiplyHonored is false, useGlPremultiply should be true
+    expect(result.premultiplyAlpha).toBe(true);
+  });
+
+  it('falls back to basic createImageBitmap when options are not supported', async () => {
+    const createImageBitmapMock = vi.fn(() =>
+      Promise.resolve({ close: () => {} }),
+    );
+    const txManager = {
+      imageBitmapSupported: {
+        basic: true,
+        options: false,
+        full: false,
+        premultiplyHonored: null,
+      },
+      platform: {
+        createImageBitmap: createImageBitmapMock,
+      },
+    } as unknown as CoreTextureManager;
+
+    const props = ImageTexture.resolveDefaults({
+      src: 'test.png',
+      premultiplyAlpha: true,
+    });
+    const texture = new ImageTexture(txManager, props);
+
+    const blob = new Blob([], { type: 'image/png' });
+    const result = await texture.createImageBitmap(
+      blob,
+      true,
+      null,
+      null,
+      null,
+      null,
+    );
+
+    // It should have called basic createImageBitmap without options
+    expect(createImageBitmapMock).toHaveBeenCalledWith(blob);
+
+    // And premultiplyAlpha should be false (browser default is assumed to premultiply)
+    expect(result.premultiplyAlpha).toBe(false);
+  });
+});