@solidtv/renderer 1.2.9 → 1.3.0

package/src/core/CoreTextureManager.ts

@@ -10,6 +10,7 @@ import { EventEmitter } from '../common/EventEmitter.js';
 import type { Stage } from './Stage.js';
 import {
   validateCreateImageBitmap,
+  detectPremultiplyAlphaHonored,
   type CreateImageBitmapSupport,
 } from './lib/validateImageBitmap.js';
 import type { Platform } from './platforms/Platform.js';
@@ -46,6 +47,9 @@ export interface TextureManagerDebugInfo {
 export interface TextureManagerSettings {
   numImageWorkers: number;
   createImageBitmapSupport: 'auto' | 'basic' | 'options' | 'full';
+  // Override for whether createImageBitmap honors premultiplyAlpha:'premultiply'.
+  // 'auto' = detect via probe; boolean = force the value and skip the probe.
+  premultiplyAlphaHonored: boolean | 'auto';
   maxRetryCount: number;
 }
 
@@ -255,6 +259,7 @@ export class CoreTextureManager extends EventEmitter {
     basic: false,
     options: false,
     full: false,
+    premultiplyHonored: null as boolean | null,
   };
 
   hasWorker = !!self.Worker;
@@ -281,8 +286,12 @@ export class CoreTextureManager extends EventEmitter {
   constructor(stage: Stage, settings: TextureManagerSettings) {
     super();
 
-    const { numImageWorkers, createImageBitmapSupport, maxRetryCount } =
-      settings;
+    const {
+      numImageWorkers,
+      createImageBitmapSupport,
+      premultiplyAlphaHonored,
+      maxRetryCount,
+    } = settings;
 
     this.stage = stage;
     this.platform = stage.platform;
@@ -292,7 +301,7 @@ export class CoreTextureManager extends EventEmitter {
     if (createImageBitmapSupport === 'auto') {
       validateCreateImageBitmap(this.platform)
         .then((result) => {
-          this.initialize(result);
+          this.resolvePremultiplyAndInit(result, premultiplyAlphaHonored);
         })
         .catch(() => {
           console.warn(
@@ -304,11 +313,15 @@ export class CoreTextureManager extends EventEmitter {
           this.emit('initialized');
         });
     } else {
-      this.initialize({
-        basic: createImageBitmapSupport === 'basic',
-        options: createImageBitmapSupport === 'options',
-        full: createImageBitmapSupport === 'full',
-      });
+      this.resolvePremultiplyAndInit(
+        {
+          basic: createImageBitmapSupport === 'basic',
+          options: createImageBitmapSupport === 'options',
+          full: createImageBitmapSupport === 'full',
+          premultiplyHonored: null,
+        },
+        premultiplyAlphaHonored,
+      );
     }
 
     this.registerTextureType('ImageTexture', ImageTexture);
@@ -325,11 +338,51 @@ export class CoreTextureManager extends EventEmitter {
     this.txConstructors[textureType] = textureClass;
   }
 
+  /**
+   * Resolve `premultiplyHonored` on the support object, then initialize.
+   *
+   * - boolean override -> use it directly, skip the probe
+   * - 'auto' -> run the detection probe (only meaningful when the options/full
+   *   API exists, since that's the only path that passes the premultiply option)
+   */
+  private resolvePremultiplyAndInit(
+    support: CreateImageBitmapSupport,
+    premultiplyAlphaHonored: boolean | 'auto',
+  ): void {
+    if (premultiplyAlphaHonored !== 'auto') {
+      support.premultiplyHonored = premultiplyAlphaHonored;
+      this.initialize(support);
+      return;
+    }
+
+    if (support.options === false && support.full === false) {
+      support.premultiplyHonored = null;
+      this.initialize(support);
+      return;
+    }
+
+    detectPremultiplyAlphaHonored(this.platform)
+      .then((honored) => {
+        support.premultiplyHonored = honored;
+        this.initialize(support);
+      })
+      .catch(() => {
+        support.premultiplyHonored = null;
+        this.initialize(support);
+      });
+  }
+
   private initialize(support: CreateImageBitmapSupport) {
     this.hasCreateImageBitmap =
       support.basic || support.options || support.full;
     this.imageBitmapSupported = support;
 
+    if (support.premultiplyHonored === false) {
+      console.warn(
+        '[Lightning] createImageBitmap premultiplyAlpha:"premultiply" is not honored on this device — images may show alpha ghosting. GL-side premultiply fallback recommended.',
+      );
+    }
+
     if (this.hasCreateImageBitmap === false) {
       console.warn(
         '[Lightning] createImageBitmap is not supported on this browser. ImageTexture will be slower.',

package/src/core/Stage.contextLoss.test.ts

@@ -0,0 +1,45 @@
+/**
+ * Tests for WebGL context-loss handling on the Stage.
+ *
+ * Covers the pragmatic core support added for low-RAM devices (Chromium 123+
+ * drops the GPU context when backgrounded). On loss we stop the render loop
+ * and emit a `contextLost` event so consumers can reload; the engine does not
+ * rebuild GL resources in place, so there is no restore path.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { Stage } from './Stage.js';
+import { EventEmitter } from '../common/EventEmitter.js';
+
+// Build a minimal Stage-like object that exercises the context-loss methods
+// without standing up the full GL-backed constructor.
+function makeStage() {
+  const eventBus = new EventEmitter();
+  const stage = Object.create(Stage.prototype) as Stage;
+  (stage as unknown as { eventBus: EventEmitter }).eventBus = eventBus;
+  stage.isContextLost = false;
+  return { stage, eventBus };
+}
+
+describe('Stage.setContextLost', () => {
+  it('sets the flag and emits contextLost', () => {
+    const { stage, eventBus } = makeStage();
+    const onLost = vi.fn();
+    eventBus.on('contextLost', onLost);
+
+    stage.setContextLost();
+
+    expect(stage.isContextLost).toBe(true);
+    expect(onLost).toHaveBeenCalledTimes(1);
+  });
+
+  it('is idempotent — does not re-emit when already lost', () => {
+    const { stage, eventBus } = makeStage();
+    const onLost = vi.fn();
+    eventBus.on('contextLost', onLost);
+
+    stage.setContextLost();
+    stage.setContextLost();
+
+    expect(onLost).toHaveBeenCalledTimes(1);
+  });
+});

package/src/core/Stage.ts

@@ -119,6 +119,18 @@ export class Stage {
    */
   public readonly eventBus: EventEmitter;
 
+  /**
+   * Whether the underlying WebGL context has been lost.
+   *
+   * @remarks
+   * Set by the renderer's `webglcontextlost` listener. Once true it stays true:
+   * the engine does not rebuild GPU resources in-place, so the render loop
+   * stops and the supported recovery is to reload the app (see the `contextLost`
+   * event). This avoids issuing GL calls against a dead context, which return
+   * null/throw on low-RAM devices (e.g. Chromium 123+ backgrounding behaviour).
+   */
+  public isContextLost = false;
+
   /// State
   startTime = 0;
   deltaTime = 0;
@@ -167,6 +179,7 @@ export class Stage {
       renderEngine,
       fontEngines,
       createImageBitmapSupport,
+      premultiplyAlphaHonored,
       platform,
       maxRetryCount,
     } = options;
@@ -194,6 +207,8 @@ export class Stage {
     this.txManager = new CoreTextureManager(this, {
       numImageWorkers,
       createImageBitmapSupport,
+      // undefined -> true (default: assume honored, no probe)
+      premultiplyAlphaHonored: premultiplyAlphaHonored ?? true,
       maxRetryCount,
     });
 
@@ -429,6 +444,21 @@ export class Stage {
     });
   }
 
+  /**
+   * Mark the WebGL context as lost. Stops GL work and notifies consumers.
+   *
+   * @remarks
+   * The engine does not rebuild GPU resources in-place; consumers are expected
+   * to reload the app in response to the `contextLost` event.
+   */
+  setContextLost() {
+    if (this.isContextLost === true) {
+      return;
+    }
+    this.isContextLost = true;
+    this.eventBus.emit('contextLost');
+  }
+
   /**
    * Create default PixelTexture
    */

package/src/core/lib/ImageWorker.ts

@@ -43,12 +43,14 @@ function createImageWorker() {
     options: {
       supportsOptionsCreateImageBitmap: boolean;
       supportsFullCreateImageBitmap: boolean;
+      premultiplyAlphaHonored: boolean;
     },
   ): Promise<getImageReturn> {
     return new Promise(function (resolve, reject) {
       var supportsOptionsCreateImageBitmap =
         options.supportsOptionsCreateImageBitmap;
       var supportsFullCreateImageBitmap = options.supportsFullCreateImageBitmap;
+      var premultiplyAlphaHonored = options.premultiplyAlphaHonored;
       var xhr = new XMLHttpRequest();
       xhr.open('GET', src, true);
       xhr.responseType = 'blob';
@@ -71,6 +73,17 @@ function createImageWorker() {
             ? premultiplyAlpha
             : hasAlphaChannel(blob.type);
 
+        // When the device ignores the createImageBitmap premultiply option,
+        // create a straight ('none') bitmap and let WebGL premultiply on
+        // upload. `premultiplyAlpha` in the resolved value means "WebGL should
+        // premultiply this source on upload".
+        var useGlPremultiply =
+          withAlphaChannel === true && premultiplyAlphaHonored === false;
+        var bitmapMode: 'premultiply' | 'none' =
+          withAlphaChannel === true && useGlPremultiply === false
+            ? 'premultiply'
+            : 'none';
+
         // createImageBitmap with crop and options
         if (
           supportsFullCreateImageBitmap === true &&
@@ -78,12 +91,12 @@ function createImageWorker() {
           height !== null
         ) {
           createImageBitmap(blob, x || 0, y || 0, width, height, {
-            premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
+            premultiplyAlpha: bitmapMode,
             colorSpaceConversion: 'none',
             imageOrientation: 'none',
           })
             .then(function (data) {
-              resolve({ data: data, premultiplyAlpha: withAlphaChannel });
+              resolve({ data: data, premultiplyAlpha: useGlPremultiply });
             })
             .catch(function (error) {
               reject(error);
@@ -94,22 +107,23 @@ function createImageWorker() {
           supportsFullCreateImageBitmap === false
         ) {
           // Fallback for browsers that do not support createImageBitmap with options
-          // this is supported for Chrome v50 to v52/54 that doesn't support options
+          // this is supported for Chrome v50 to v52/54 that doesn't support options.
+          // The browser default premultiplies, so WebGL must not premultiply again.
           createImageBitmap(blob)
             .then(function (data) {
-              resolve({ data: data, premultiplyAlpha: withAlphaChannel });
+              resolve({ data: data, premultiplyAlpha: false });
             })
             .catch(function (error) {
               reject(error);
             });
         } else {
           createImageBitmap(blob, {
-            premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
+            premultiplyAlpha: bitmapMode,
             colorSpaceConversion: 'none',
             imageOrientation: 'none',
           })
             .then(function (data) {
-              resolve({ data: data, premultiplyAlpha: withAlphaChannel });
+              resolve({ data: data, premultiplyAlpha: useGlPremultiply });
             })
             .catch(function (error) {
               reject(error);
@@ -139,10 +153,13 @@ function createImageWorker() {
     // these will be set to true if the browser supports the createImageBitmap options or full
     var supportsOptionsCreateImageBitmap = false;
     var supportsFullCreateImageBitmap = false;
+    // set to false when the device is known to ignore the premultiply option
+    var premultiplyAlphaHonored = true;
 
     getImage(src, premultiplyAlpha, x, y, width, height, {
       supportsOptionsCreateImageBitmap,
       supportsFullCreateImageBitmap,
+      premultiplyAlphaHonored,
     })
       .then(function (data) {
         // @ts-ignore ts has wrong postMessage signature
@@ -240,6 +257,13 @@ export class ImageWorkerManager {
       );
     }
 
+    if (createImageBitmapSupport.premultiplyHonored === false) {
+      workerCode = workerCode.replace(
+        'var premultiplyAlphaHonored = true;',
+        'var premultiplyAlphaHonored = false;',
+      );
+    }
+
     workerCode = workerCode.replace('"use strict";', '');
     const blob: Blob = new Blob([workerCode], {
       type: 'application/javascript',

package/src/core/lib/textureSvg.ts

@@ -91,8 +91,11 @@ export const loadSvg = async (
     }
   }
 
+  // getImageData returns straight (un-premultiplied) pixels, so WebGL must
+  // premultiply this source on upload (unlike the ImageBitmap path above,
+  // where the canvas is already premultiplied by createImageBitmap's default).
   return {
     data: ctx.getImageData(0, 0, physW, physH),
-    premultiplyAlpha: false,
+    premultiplyAlpha: true,
   };
 };

package/src/core/lib/validateImageBitmap.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { detectPremultiplyAlphaHonored } from './validateImageBitmap.js';
+import type { Platform } from '../platforms/Platform.js';
+
+/**
+ * Minimal stand-in for the WebGL constants/methods the probe touches. The probe
+ * uploads a known straight pixel, reads it back, and infers whether
+ * createImageBitmap premultiplied it. `readbackRed` is what readPixels returns
+ * for the red channel: ~128 = premultiplied (honored), ~255 = straight (ignored).
+ */
+function createFakeGl(readbackRed: number, framebufferComplete = true) {
+  return {
+    TEXTURE_2D: 0x0de1,
+    UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241,
+    UNPACK_FLIP_Y_WEBGL: 0x9240,
+    RGBA: 0x1908,
+    UNSIGNED_BYTE: 0x1401,
+    FRAMEBUFFER: 0x8d40,
+    COLOR_ATTACHMENT0: 0x8ce0,
+    FRAMEBUFFER_COMPLETE: 0x8cd5,
+    createTexture: vi.fn(() => ({})),
+    bindTexture: vi.fn(),
+    pixelStorei: vi.fn(),
+    texImage2D: vi.fn(),
+    createFramebuffer: vi.fn(() => ({})),
+    bindFramebuffer: vi.fn(),
+    framebufferTexture2D: vi.fn(),
+    checkFramebufferStatus: vi.fn(() => (framebufferComplete ? 0x8cd5 : 0)),
+    readPixels: vi.fn(
+      (
+        _x: number,
+        _y: number,
+        _w: number,
+        _h: number,
+        _format: number,
+        _type: number,
+        px: Uint8Array,
+      ) => {
+        px[0] = readbackRed;
+        px[1] = 0;
+        px[2] = 0;
+        px[3] = 128;
+      },
+    ),
+    deleteFramebuffer: vi.fn(),
+    deleteTexture: vi.fn(),
+  };
+}
+
+function createPlatform(gl: object | null): Platform {
+  const close = vi.fn();
+  return {
+    createImageBitmap: vi.fn(() => Promise.resolve({ close })),
+    createCanvas: vi.fn(() => ({
+      width: 0,
+      height: 0,
+      getContext: vi.fn((type: string) => (type === 'webgl' ? gl : null)),
+    })),
+  } as unknown as Platform;
+}
+
+describe('detectPremultiplyAlphaHonored', () => {
+  beforeEach(() => {
+    // node test env has no ImageData global; the probe constructs one.
+    (globalThis as unknown as { ImageData: unknown }).ImageData = class {
+      data: Uint8ClampedArray;
+      width: number;
+      height: number;
+      constructor(data: Uint8ClampedArray, width: number, height: number) {
+        this.data = data;
+        this.width = width;
+        this.height = height;
+      }
+    };
+  });
+
+  afterEach(() => {
+    delete (globalThis as unknown as { ImageData?: unknown }).ImageData;
+  });
+
+  it('returns true when the bitmap reads back premultiplied (~128)', async () => {
+    const platform = createPlatform(createFakeGl(128));
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(true);
+  });
+
+  it('returns false when the bitmap reads back straight (~255)', async () => {
+    const platform = createPlatform(createFakeGl(255));
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(false);
+  });
+
+  it('returns null when createImageBitmap throws', async () => {
+    const platform = {
+      createImageBitmap: vi.fn(() => Promise.reject(new Error('unsupported'))),
+      createCanvas: vi.fn(),
+    } as unknown as Platform;
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(null);
+  });
+
+  it('returns null when no WebGL context is available', async () => {
+    const platform = createPlatform(null);
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(null);
+  });
+
+  it('returns null when the framebuffer is incomplete', async () => {
+    const platform = createPlatform(createFakeGl(128, false));
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(null);
+  });
+
+  it('disables GL-side premultiply on the probe upload', async () => {
+    const gl = createFakeGl(128);
+    await detectPremultiplyAlphaHonored(createPlatform(gl));
+    // The probe must observe the bitmap's own alpha state, so GL premultiply
+    // has to be off during the readback upload.
+    expect(gl.pixelStorei).toHaveBeenCalledWith(
+      gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,
+      false,
+    );
+  });
+});

package/src/core/lib/validateImageBitmap.ts

@@ -4,6 +4,11 @@ export interface CreateImageBitmapSupport {
   basic: boolean; // Supports createImageBitmap(image)
   options: boolean; // Supports createImageBitmap(image, options)
   full: boolean; // Supports createImageBitmap(image, sx, sy, sw, sh, options)
+  // Whether `premultiplyAlpha: 'premultiply'` is actually HONORED (not just
+  // accepted without throwing). null = could not determine. Older Safari/WebKit
+  // accepts the option but ignores it, returning straight alpha — the source of
+  // the edge-ghosting bug on those devices.
+  premultiplyHonored: boolean | null;
 }
 
 export async function validateCreateImageBitmap(
@@ -47,6 +52,7 @@ export async function validateCreateImageBitmap(
     basic: false,
     options: false,
     full: false,
+    premultiplyHonored: null,
   };
 
   // Test basic createImageBitmap support
@@ -83,5 +89,88 @@ export async function validateCreateImageBitmap(
     /* ignore */
   }
 
+  // premultiplyHonored is resolved separately by the caller (it may be a
+  // forced override or an explicit opt-in to the probe), so it is left as its
+  // default (null) here.
   return support;
 }
+
+/**
+ * Determine whether `createImageBitmap(..., { premultiplyAlpha: 'premultiply' })`
+ * is actually honored by this browser.
+ *
+ * Strategy: feed a known straight-alpha pixel (255, 0, 0, 128) through
+ * createImageBitmap with 'premultiply', upload it to a WebGL texture with
+ * GL-side premultiply DISABLED (so we observe the bitmap's own state), then
+ * read the raw texel back via a framebuffer.
+ *
+ *  - honored   -> red comes back premultiplied (~128)
+ *  - ignored   -> red comes back straight (~255)  [older Safari/WebKit]
+ *
+ * @returns true if honored, false if ignored, null if it couldn't be measured
+ * (no WebGL, createImageBitmap from ImageData unsupported, framebuffer
+ * incomplete, etc.) — caller should treat null as "unknown".
+ */
+export async function detectPremultiplyAlphaHonored(
+  platform: Platform,
+): Promise<boolean | null> {
+  let bitmap: ImageBitmap;
+  try {
+    // Straight (un-premultiplied) RGBA. ImageData is straight-alpha by spec.
+    const imageData = new ImageData(
+      new Uint8ClampedArray([255, 0, 0, 128]),
+      1,
+      1,
+    );
+    bitmap = await platform.createImageBitmap(imageData, {
+      premultiplyAlpha: 'premultiply',
+      colorSpaceConversion: 'none',
+      imageOrientation: 'none',
+    });
+  } catch (e) {
+    return null;
+  }
+
+  const canvas = platform.createCanvas();
+  canvas.width = 1;
+  canvas.height = 1;
+  const gl = (canvas.getContext('webgl') ||
+    canvas.getContext('experimental-webgl')) as WebGLRenderingContext | null;
+  if (gl === null) {
+    bitmap.close?.();
+    return null;
+  }
+
+  const tex = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  // Critical: do NOT let GL premultiply. We want to observe whatever state the
+  // bitmap itself is in.
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
+
+  const fb = gl.createFramebuffer();
+  gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+  gl.framebufferTexture2D(
+    gl.FRAMEBUFFER,
+    gl.COLOR_ATTACHMENT0,
+    gl.TEXTURE_2D,
+    tex,
+    0,
+  );
+
+  let result: boolean | null = null;
+  if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE) {
+    const px = new Uint8Array(4);
+    gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, px);
+    // Straight red reads ~255; premultiplied red reads ~128. Split at the
+    // midpoint to tolerate rounding/colorspace drift.
+    result = px[0]! < 192;
+  }
+
+  gl.deleteFramebuffer(fb);
+  gl.deleteTexture(tex);
+  bitmap.close?.();
+
+  return result;
+}

package/src/core/platforms/web/WebPlatform.contextLoss.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Tests that the render loop stops doing GL work once the WebGL context is
+ * lost.
+ *
+ * When `stage.isContextLost === true`, `runLoop` must issue no GL-touching
+ * calls and must not reschedule itself — the engine does not rebuild GL
+ * resources, so recovery is via app reload.
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { WebPlatform } from './WebPlatform.js';
+import type { Stage } from '../../Stage.js';
+
+function makeFakeStage(isContextLost: boolean) {
+  return {
+    isContextLost,
+    targetFrameTime: 0,
+    updateFrameTime: vi.fn(),
+    updateAnimations: vi.fn(() => false),
+    hasSceneUpdates: vi.fn(() => true),
+    drawFrame: vi.fn(),
+    flushFrameEvents: vi.fn(),
+    calculateFps: vi.fn(),
+  } as unknown as Stage;
+}
+
+describe('WebPlatform render loop context-loss guard', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('skips all GL work and does not reschedule while context is lost', () => {
+    let capturedLoop: ((t?: number) => void) | null = null;
+    const raf = vi.fn((cb: (t?: number) => void) => {
+      capturedLoop = cb;
+      return 1;
+    });
+    const setTimeoutSpy = vi.fn(
+      (_cb: () => void, _ms?: number) =>
+        1 as unknown as ReturnType<typeof setTimeout>,
+    );
+    vi.stubGlobal('requestAnimationFrame', raf);
+    vi.stubGlobal('setTimeout', setTimeoutSpy);
+
+    const stage = makeFakeStage(true);
+    new WebPlatform().startLoop(stage);
+
+    // startLoop kicks off the first frame via requestAnimationFrame
+    expect(capturedLoop).not.toBeNull();
+    expect(raf).toHaveBeenCalledTimes(1);
+
+    // Run one iteration with the context lost
+    capturedLoop!(0);
+
+    // No GL-touching frame work happened
+    expect(stage.updateFrameTime).not.toHaveBeenCalled();
+    expect(stage.drawFrame).not.toHaveBeenCalled();
+    expect(stage.hasSceneUpdates).not.toHaveBeenCalled();
+
+    // The loop did not reschedule itself (neither RAF nor setTimeout)
+    expect(raf).toHaveBeenCalledTimes(1);
+    expect(setTimeoutSpy).not.toHaveBeenCalled();
+  });
+
+  it('runs frame work when the context is healthy', () => {
+    let capturedLoop: ((t?: number) => void) | null = null;
+    const raf = vi.fn((cb: (t?: number) => void) => {
+      capturedLoop = cb;
+      return 1;
+    });
+    vi.stubGlobal('requestAnimationFrame', raf);
+
+    const stage = makeFakeStage(false);
+    new WebPlatform().startLoop(stage);
+
+    capturedLoop!(0);
+
+    expect(stage.updateFrameTime).toHaveBeenCalledTimes(1);
+    expect(stage.drawFrame).toHaveBeenCalledTimes(1);
+  });
+});

package/src/core/platforms/web/WebPlatform.ts

@@ -32,6 +32,13 @@ export class WebPlatform extends Platform {
     const buffer = 4;
 
     const runLoop = (currentTime: number = 0) => {
+      // The GL context is lost and the engine does not rebuild it in place.
+      // Stop the loop entirely (no reschedule) so we issue no GL calls against
+      // a dead context. Recovery is via app reload (see the `contextLost` event).
+      if (stage.isContextLost === true) {
+        return;
+      }
+
       const targetFrameTime = stage.targetFrameTime;
 
       // Frame Limiting logic

package/src/core/renderers/webgl/WebGlCtxTexture.ts

@@ -188,9 +188,13 @@ export class WebGlCtxTexture extends CoreContextTexture {
       w = tdata.width;
       h = tdata.height;
       glw.bindTexture(this._nativeCtxTexture);
+      // `premultiplyAlpha` carries the source's GL-upload intent: true when the
+      // source pixels are straight and WebGL must premultiply (e.g. a straight
+      // bitmap produced when the device ignores the createImageBitmap
+      // premultiply option), false when the source is already premultiplied.
       glw.pixelStorei(
         glw.UNPACK_PREMULTIPLY_ALPHA_WEBGL,
-        isImageBitmap ? false : !!textureData.premultiplyAlpha,
+        !!textureData.premultiplyAlpha,
       );
 
       glw.texImage2D(0, format, format, glw.UNSIGNED_BYTE, tdata);