@lightningjs/renderer 3.0.0-beta22 → 3.0.0-beta23

package/src/core/{lib → platforms/web/lib}/ImageWorker.ts

@@ -17,19 +17,14 @@
  * limitations under the License.
  */
 
-import type { CreateImageBitmapSupport } from '../lib/validateImageBitmap.js';
-import { type TextureData } from '../textures/Texture.js';
+import type { ImageResponse } from '../../../textures/ImageTexture.js';
 
 type MessageCallback = [(value: any) => void, (reason: any) => void];
-interface getImageReturn {
-  data: ImageBitmap;
-  premultiplyAlpha: boolean | null;
-}
 
 interface ImageWorkerMessage {
   id: number;
   src: string;
-  data: getImageReturn;
+  data: ImageResponse;
   error: string;
   sx: number | null;
   sy: number | null;
@@ -59,15 +54,8 @@ function createImageWorker() {
     y: number | null,
     width: number | null,
     height: number | null,
-    options: {
-      supportsOptionsCreateImageBitmap: boolean;
-      supportsFullCreateImageBitmap: boolean;
-    },
-  ): Promise<getImageReturn> {
+  ): Promise<ImageResponse> {
     return new Promise(function (resolve, reject) {
-      var supportsOptionsCreateImageBitmap =
-        options.supportsOptionsCreateImageBitmap;
-      var supportsFullCreateImageBitmap = options.supportsFullCreateImageBitmap;
       var xhr = new XMLHttpRequest();
       xhr.open('GET', src, true);
       xhr.responseType = 'blob';
@@ -91,11 +79,7 @@ function createImageWorker() {
             : hasAlphaChannel(blob.type);
 
         // createImageBitmap with crop and options
-        if (
-          supportsFullCreateImageBitmap === true &&
-          width !== null &&
-          height !== null
-        ) {
+        if (width !== null && height !== null) {
           createImageBitmap(blob, x || 0, y || 0, width, height, {
             premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
             colorSpaceConversion: 'none',
@@ -108,19 +92,6 @@ function createImageWorker() {
               reject(error);
             });
           return;
-        } else if (
-          supportsOptionsCreateImageBitmap === false &&
-          supportsOptionsCreateImageBitmap === 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
-          createImageBitmap(blob)
-            .then(function (data) {
-              resolve({ data, premultiplyAlpha: premultiplyAlpha });
-            })
-            .catch(function (error) {
-              reject(error);
-            });
         } else {
           createImageBitmap(blob, {
             premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
@@ -155,14 +126,7 @@ function createImageWorker() {
     var width = event.data.sw;
     var height = event.data.sh;
 
-    // these will be set to true if the browser supports the createImageBitmap options or full
-    var supportsOptionsCreateImageBitmap = false;
-    var supportsFullCreateImageBitmap = false;
-
-    getImage(src, premultiplyAlpha, x, y, width, height, {
-      supportsOptionsCreateImageBitmap,
-      supportsFullCreateImageBitmap,
-    })
+    getImage(src, premultiplyAlpha, x, y, width, height)
       .then(function (data) {
         // @ts-ignore ts has wrong postMessage signature
         self.postMessage({ id: id, src: src, data: data }, [data.data]);
@@ -181,14 +145,8 @@ export class ImageWorkerManager {
   workerLoad: number[] = [];
   nextId = 0;
 
-  constructor(
-    numImageWorkers: number,
-    createImageBitmapSupport: CreateImageBitmapSupport,
-  ) {
-    this.workers = this.createWorkers(
-      numImageWorkers,
-      createImageBitmapSupport,
-    );
+  constructor(numImageWorkers: number) {
+    this.workers = this.createWorkers(numImageWorkers);
     this.workers.forEach((worker, index) => {
       worker.onmessage = (event) => this.handleMessage(event, index);
     });
@@ -213,36 +171,14 @@ export class ImageWorkerManager {
     }
   }
 
-  private createWorkers(
-    numWorkers = 1,
-    createImageBitmapSupport: CreateImageBitmapSupport,
-  ): Worker[] {
+  private createWorkers(numWorkers = 1): Worker[] {
     let workerCode = `(${createImageWorker.toString()})()`;
 
-    // Replace placeholders with actual initialization values
-    if (createImageBitmapSupport.options === true) {
-      workerCode = workerCode.replace(
-        'var supportsOptionsCreateImageBitmap = false;',
-        'var supportsOptionsCreateImageBitmap = true;',
-      );
-    }
-
-    if (createImageBitmapSupport.full === true) {
-      workerCode = workerCode.replace(
-        'var supportsOptionsCreateImageBitmap = false;',
-        'var supportsOptionsCreateImageBitmap = true;',
-      );
-
-      workerCode = workerCode.replace(
-        'var supportsFullCreateImageBitmap = false;',
-        'var supportsFullCreateImageBitmap = true;',
-      );
-    }
-
     workerCode = workerCode.replace('"use strict";', '');
     const blob: Blob = new Blob([workerCode], {
       type: 'application/javascript',
     });
+
     const blobURL: string = (self.URL ? URL : webkitURL).createObjectURL(blob);
     const workers: Worker[] = [];
     for (let i = 0; i < numWorkers; i++) {
@@ -280,7 +216,7 @@ export class ImageWorkerManager {
     sy: number | null,
     sw: number | null,
     sh: number | null,
-  ): Promise<TextureData> {
+  ): Promise<ImageResponse> {
     return new Promise((resolve, reject) => {
       try {
         if (this.workers) {

package/src/core/platforms/web/lib/createImageBitmap.ts

@@ -0,0 +1,40 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2026 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export const createImageBitmap = (
+  blob: ImageBitmapSource,
+  sxOrOptions?: number | ImageBitmapOptions,
+  sy?: number,
+  sw?: number,
+  sh?: number,
+  options?: ImageBitmapOptions,
+): Promise<ImageBitmap> => {
+  if (typeof sxOrOptions === 'number') {
+    return createImageBitmap(
+      blob,
+      sxOrOptions,
+      sy ?? 0,
+      sw ?? 0,
+      sh ?? 0,
+      options,
+    );
+  } else {
+    return createImageBitmap(blob, sxOrOptions);
+  }
+};

package/src/core/{lib → platforms/web/lib}/textureCompression.ts

@@ -16,8 +16,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { type CompressedData, type TextureData } from '../textures/Texture.js';
-import type { WebGlContextWrapper } from './WebGlContextWrapper.js';
+import { type CompressedData } from '../../../textures/Texture.js';
+import type { ImageResponse } from '../../../textures/ImageTexture.js';
+import type { WebGlContextWrapper } from '../WebGlContextWrapper.js';
 
 export type UploadCompressedTextureFunction = (
   glw: WebGlContextWrapper,
@@ -25,18 +26,6 @@ export type UploadCompressedTextureFunction = (
   data: CompressedData,
 ) => void;
 
-/**
- * Tests if the given location is a compressed texture container
- * @param url
- * @remarks
- * This function is used to determine if the given image url is a compressed
- * and only supports the following extensions: .ktx and .pvr
- * @returns
- */
-export function isCompressedTextureContainer(src: string): boolean {
-  return /\.(ktx|pvr)$/.test(src);
-}
-
 const PVR_MAGIC = 0x03525650; // 'PVR3' in little-endian
 const PVR_TO_GL_INTERNAL_FORMAT: Record<string, number> = {
   0: 0x8c01,
@@ -72,7 +61,7 @@ const KTX_IDENTIFIER = [
  */
 export const loadCompressedTexture = async (
   url: string,
-): Promise<TextureData> => {
+): Promise<ImageResponse> => {
   try {
     const response = await fetch(url);
     if (!response.ok) {
@@ -133,7 +122,7 @@ function readUint24(view: DataView, offset: number) {
  * @param view
  * @returns
  */
-const loadASTC = async function (view: DataView): Promise<TextureData> {
+const loadASTC = async function (view: DataView): Promise<ImageResponse> {
   const blockX = view.getUint8(4);
   const blockY = view.getUint8(5);
   const sizeX = readUint24(view, 7);
@@ -167,43 +156,18 @@ const loadASTC = async function (view: DataView): Promise<TextureData> {
       mipmaps,
       w: sizeX,
       h: sizeY,
-      type: 'astc',
+      type: 'ASTC',
     },
     premultiplyAlpha: false,
   };
 };
 
-const uploadASTC = function (
-  glw: WebGlContextWrapper,
-  texture: WebGLTexture,
-  data: CompressedData,
-) {
-  if (glw.getExtension('WEBGL_compressed_texture_astc') === null) {
-    throw new Error('ASTC compressed textures not supported by this device');
-  }
-
-  glw.bindTexture(texture);
-
-  const { glInternalFormat, mipmaps, w, h } = data;
-  if (mipmaps === undefined) {
-    return;
-  }
-
-  const view = new Uint8Array(mipmaps[0]!);
-
-  glw.compressedTexImage2D(0, glInternalFormat, w, h, 0, view);
-  // ASTC textures MUST use no mipmaps unless stored
-  glw.texParameteri(glw.TEXTURE_WRAP_S, glw.CLAMP_TO_EDGE);
-  glw.texParameteri(glw.TEXTURE_WRAP_T, glw.CLAMP_TO_EDGE);
-  glw.texParameteri(glw.TEXTURE_MAG_FILTER, glw.LINEAR);
-  glw.texParameteri(glw.TEXTURE_MIN_FILTER, glw.LINEAR);
-};
 /**
  * Loads a KTX texture container and returns the texture data
  * @param view
  * @returns
  */
-const loadKTX = async function (view: DataView): Promise<TextureData> {
+const loadKTX = async function (view: DataView): Promise<ImageResponse> {
   const endianness = view.getUint32(12, true);
   const littleEndian = endianness === 0x04030201;
   if (littleEndian === false && endianness !== 0x01020304) {
@@ -267,58 +231,12 @@ const loadKTX = async function (view: DataView): Promise<TextureData> {
       mipmaps,
       w: width,
       h: height,
-      type: 'ktx',
+      type: 'KTX',
     },
     premultiplyAlpha: false,
   };
 };
 
-const uploadKTX = function (
-  glw: WebGlContextWrapper,
-  texture: WebGLTexture,
-  data: CompressedData,
-) {
-  const { glInternalFormat, mipmaps, w: width, h: height, blockInfo } = data;
-  if (mipmaps === undefined) {
-    return;
-  }
-  glw.bindTexture(texture);
-
-  const blockWidth = blockInfo.width;
-  const blockHeight = blockInfo.height;
-  let w = width;
-  let h = height;
-
-  for (let i = 0; i < mipmaps!.length; i++) {
-    let view = new Uint8Array(mipmaps![i]!);
-
-    const uploadW = Math.ceil(w / blockWidth) * blockWidth;
-    const uploadH = Math.ceil(h / blockHeight) * blockHeight;
-
-    const expectedBytes =
-      Math.ceil(w / blockWidth) * Math.ceil(h / blockHeight) * blockInfo.bytes;
-
-    if (view.byteLength < expectedBytes) {
-      const padded = new Uint8Array(expectedBytes);
-      padded.set(view);
-      view = padded;
-    }
-
-    glw.compressedTexImage2D(i, glInternalFormat, uploadW, uploadH, 0, view);
-
-    w = Math.max(1, w >> 1);
-    h = Math.max(1, h >> 1);
-  }
-
-  glw.texParameteri(glw.TEXTURE_WRAP_S, glw.CLAMP_TO_EDGE);
-  glw.texParameteri(glw.TEXTURE_WRAP_T, glw.CLAMP_TO_EDGE);
-  glw.texParameteri(glw.TEXTURE_MAG_FILTER, glw.LINEAR);
-  glw.texParameteri(
-    glw.TEXTURE_MIN_FILTER,
-    mipmaps!.length > 1 ? glw.LINEAR_MIPMAP_LINEAR : glw.LINEAR,
-  );
-};
-
 function pvrtcMipSize(width: number, height: number, bpp: 2 | 4) {
   const minW = bpp === 2 ? 16 : 8;
   const minH = 8;
@@ -327,7 +245,7 @@ function pvrtcMipSize(width: number, height: number, bpp: 2 | 4) {
   return (w * h * bpp) / 8;
 }
 
-const loadPVR = async function (view: DataView): Promise<TextureData> {
+const loadPVR = async function (view: DataView): Promise<ImageResponse> {
   const pixelFormatLow = view.getUint32(8, true);
   const internalFormat = PVR_TO_GL_INTERNAL_FORMAT[pixelFormatLow];
 
@@ -405,50 +323,22 @@ const loadPVR = async function (view: DataView): Promise<TextureData> {
       mipmaps,
       w: width,
       h: height,
-      type: 'pvr',
+      type: 'PVR',
     },
     premultiplyAlpha: false,
   };
 };
 
-const uploadPVR = function (
-  glw: WebGlContextWrapper,
-  texture: WebGLTexture,
-  data: CompressedData,
-) {
-  const { glInternalFormat, mipmaps, w: width, h: height } = data;
-  if (mipmaps === undefined) {
-    return;
-  }
-  glw.bindTexture(texture);
-
-  let w = width;
-  let h = height;
-
-  for (let i = 0; i < mipmaps!.length; i++) {
-    glw.compressedTexImage2D(
-      i,
-      glInternalFormat,
-      w,
-      h,
-      0,
-      new Uint8Array(mipmaps[i]!),
-    );
-
-    w = Math.max(1, w >> 1);
-    h = Math.max(1, h >> 1);
-  }
-
-  glw.texParameteri(glw.TEXTURE_WRAP_S, glw.CLAMP_TO_EDGE);
-  glw.texParameteri(glw.TEXTURE_WRAP_T, glw.CLAMP_TO_EDGE);
-  glw.texParameteri(glw.TEXTURE_MAG_FILTER, glw.LINEAR);
-  glw.texParameteri(
-    glw.TEXTURE_MIN_FILTER,
-    mipmaps.length > 1 ? glw.LINEAR_MIPMAP_LINEAR : glw.LINEAR,
-  );
-};
+export interface CompressedImageData {
+  blockInfo: BlockInfo;
+  glInternalFormat: number;
+  mipmaps: ArrayBuffer[];
+  w: number;
+  h: number;
+  type: 'PVR' | 'KTX' | 'ASTC';
+}
 
-type BlockInfo = {
+export type BlockInfo = {
   width: number;
   height: number;
   bytes: number;
@@ -499,12 +389,3 @@ export const blockInfoMap: { [key: number]: BlockInfo } = {
   0x93b5: BLOCK_12x12x16, // 12x12
   0x93d5: BLOCK_12x12x16,
 };
-
-export const uploadCompressedTexture: Record<
-  string,
-  UploadCompressedTextureFunction
-> = {
-  ktx: uploadKTX,
-  pvr: uploadPVR,
-  astc: uploadASTC,
-};

package/src/core/{lib → platforms/web/lib}/textureSvg.ts

@@ -17,20 +17,8 @@
  * limitations under the License.
  */
 
-import { assertTruthy } from '../../utils.js';
-import { type TextureData } from '../textures/Texture.js';
-
-/**
- * Tests if the given location is a SVG
- * @param url
- * @remarks
- * This function is used to determine if the given image url is a SVG
- * image
- * @returns
- */
-export function isSvgImage(url: string): boolean {
-  return /\.(svg)(\?.*)?$/.test(url);
-}
+import { assertTruthy } from '../../../../utils.js';
+import type { ImageResponse } from '../../../textures/ImageTexture.js';
 
 /**
  * Loads a SVG image
@@ -45,7 +33,7 @@ export const loadSvg = (
   sy: number | null,
   sw: number | null,
   sh: number | null,
-): Promise<TextureData> => {
+): Promise<ImageResponse> => {
   return new Promise((resolve, reject) => {
     const canvas = document.createElement('canvas');
     const ctx = canvas.getContext('2d');

package/src/core/platforms/web/lib/utils.ts

@@ -0,0 +1,105 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2026 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export const PROTOCOL_REGEX = /^(data|ftps?|https?):/;
+
+export function isBase64Image(src: string) {
+  return src.startsWith('data:') === true;
+}
+
+export function dataURIToBlob(dataURI: string): Blob {
+  dataURI = dataURI.replace(/^data:/, '');
+
+  const type = dataURI.match(/image\/[^;]+/)?.[0] || '';
+  const base64 = dataURI.replace(/^[^,]+,/, '');
+
+  const sliceSize = 1024;
+  const byteCharacters = atob(base64);
+  const bytesLength = byteCharacters.length;
+  const slicesCount = Math.ceil(bytesLength / sliceSize);
+  const byteArrays = new Array(slicesCount);
+
+  for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+    const begin = sliceIndex * sliceSize;
+    const end = Math.min(begin + sliceSize, bytesLength);
+
+    const bytes = new Array(end - begin);
+    for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+      bytes[i] = byteCharacters[offset]?.charCodeAt(0);
+    }
+    byteArrays[sliceIndex] = new Uint8Array(bytes);
+  }
+  return new Blob(byteArrays, { type });
+}
+
+export function convertUrlToAbsolute(url: string): string {
+  // handle local file imports if the url isn't remote resource or data blob
+  if (self.location.protocol === 'file:' && !PROTOCOL_REGEX.test(url)) {
+    const path = self.location.pathname.split('/');
+    path.pop();
+    const basePath = path.join('/');
+    const baseUrl = self.location.protocol + '//' + basePath;
+
+    // check if url has a leading dot
+    if (url.charAt(0) === '.') {
+      url = url.slice(1);
+    }
+
+    // check if url has a leading slash
+    if (url.charAt(0) === '/') {
+      url = url.slice(1);
+    }
+
+    return baseUrl + '/' + url;
+  }
+
+  const absoluteUrl = new URL(url, self.location.href);
+  return absoluteUrl.href;
+}
+
+export function createWebGLContext(
+  canvas: HTMLCanvasElement | OffscreenCanvas,
+  forceWebGL2 = false,
+): WebGLRenderingContext {
+  const config: WebGLContextAttributes = {
+    alpha: true,
+    antialias: false,
+    depth: false,
+    stencil: true,
+    desynchronized: false,
+    // Disabled because it prevents Visual Regression Tests from working
+    // failIfMajorPerformanceCaveat: true,
+    powerPreference: 'high-performance',
+    premultipliedAlpha: true,
+    preserveDrawingBuffer: false,
+  };
+  const gl =
+    // TODO: Remove this assertion once this issue is fixed in TypeScript
+    // https://github.com/microsoft/TypeScript/issues/53614
+    (canvas.getContext(forceWebGL2 ? 'webgl2' : 'webgl', config) ||
+      canvas.getContext(
+        'experimental-webgl' as 'webgl',
+        config,
+      )) as unknown as WebGLRenderingContext | null;
+  if (!gl) {
+    throw new Error('Unable to create WebGL context');
+  }
+
+  return gl;
+}

package/src/core/renderers/CoreRenderer.ts

@@ -25,20 +25,12 @@ import type { Texture, TextureCoords } from '../textures/Texture.js';
 import { CoreContextTexture } from './CoreContextTexture.js';
 import type { CoreShaderType, CoreShaderNode } from './CoreShaderNode.js';
 
-export interface CoreRendererOptions {
-  stage: Stage;
-  canvas: HTMLCanvasElement | OffscreenCanvas;
-  contextSpy: ContextSpy | null;
-  forceWebGL2: boolean;
-}
-
 export interface BufferInfo {
   totalUsed: number;
   totalAvailable: number;
 }
 
 export abstract class CoreRenderer {
-  public options: CoreRendererOptions;
   public mode: 'webgl' | 'canvas' | undefined;
   defaultTextureCoords: TextureCoords | undefined = undefined;
   readonly stage: Stage;
@@ -46,9 +38,8 @@ export abstract class CoreRenderer {
   //// Core Managers
   rttNodes: CoreNode[] = [];
 
-  constructor(options: CoreRendererOptions) {
-    this.options = options;
-    this.stage = options.stage;
+  constructor(stage: Stage) {
+    this.stage = stage;
   }
 
   abstract reset(): void;

package/src/core/renderers/canvas/CanvasRenderer.ts

@@ -20,11 +20,12 @@ import type { CoreNode } from '../../CoreNode.js';
 import { SubTexture } from '../../textures/SubTexture.js';
 import { TextureType, type Texture } from '../../textures/Texture.js';
 import type { CoreContextTexture } from '../CoreContextTexture.js';
-import { CoreRenderer, type CoreRendererOptions } from '../CoreRenderer.js';
+import { CoreRenderer } from '../CoreRenderer.js';
 import { CanvasTexture } from './CanvasTexture.js';
 import { parseColor } from '../../lib/colorParser.js';
 import { CanvasShaderNode, type CanvasShaderType } from './CanvasShaderNode.js';
 import { normalizeCanvasColor } from '../../lib/colorCache.js';
+import type { Stage } from '../../Stage.js';
 
 export class CanvasRenderer extends CoreRenderer {
   private context: CanvasRenderingContext2D;
@@ -34,11 +35,12 @@ export class CanvasRenderer extends CoreRenderer {
   public renderToTextureActive = false;
   activeRttNode: CoreNode | null = null;
 
-  constructor(options: CoreRendererOptions) {
-    super(options);
+  constructor(stage: Stage) {
+    super(stage);
 
     this.mode = 'canvas';
-    const { canvas } = options;
+    const platform = stage.platform!;
+    const canvas = platform.canvas!;
     this.canvas = canvas as HTMLCanvasElement;
     this.context = canvas.getContext('2d') as CanvasRenderingContext2D;
     this.pixelRatio = this.stage.pixelRatio;

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

@@ -70,7 +70,8 @@ export class SdfRenderOp extends CoreRenderOp {
   }
 
   draw() {
-    const { glw, options, stage } = this.renderer;
+    const { glw, stage } = this.renderer;
+    const canvas = stage.platform!.canvas!;
 
     stage.shManager.useShader(this.shader.program);
     this.shader.program.bindRenderOp(this);
@@ -82,7 +83,7 @@ export class SdfRenderOp extends CoreRenderOp {
       const clipWidth = Math.round(this.clippingRect.w * pixelRatio);
       const clipHeight = Math.round(this.clippingRect.h * pixelRatio);
       let clipY = Math.round(
-        options.canvas.height - clipHeight - this.clippingRect.y * pixelRatio,
+        canvas.height - clipHeight - this.clippingRect.y * pixelRatio,
       );
       // if parent has render texture, we need to adjust the scissor rect
       // to be relative to the parent's framebuffer

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

@@ -19,7 +19,7 @@
 
 import type { Dimensions } from '../../../common/CommonTypes.js';
 import type { TextureMemoryManager } from '../../TextureMemoryManager.js';
-import type { WebGlContextWrapper } from '../../lib/WebGlContextWrapper.js';
+import type { GlContextWrapper } from '../../platforms/GlContextWrapper.js';
 import type { Bound } from '../../lib/utils.js';
 import type { RenderTexture } from '../../textures/RenderTexture.js';
 import { WebGlCtxTexture } from './WebGlCtxTexture.js';
@@ -37,7 +37,7 @@ export class WebGlCtxRenderTexture extends WebGlCtxTexture {
   };
 
   constructor(
-    glw: WebGlContextWrapper,
+    glw: GlContextWrapper,
     memManager: TextureMemoryManager,
     textureSource: RenderTexture,
   ) {

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

@@ -20,7 +20,7 @@
 import type { Dimensions } from '../../../common/CommonTypes.js';
 import { assertTruthy } from '../../../utils.js';
 import type { TextureMemoryManager } from '../../TextureMemoryManager.js';
-import type { WebGlContextWrapper } from '../../lib/WebGlContextWrapper.js';
+import type { GlContextWrapper } from '../../platforms/GlContextWrapper.js';
 import type { SubTexture } from '../../textures/SubTexture.js';
 import type { SubTextureProps } from '../../textures/SubTexture.js';
 import type { CompressedData } from '../../textures/Texture.js';
@@ -28,7 +28,7 @@ import { WebGlCtxTexture } from './WebGlCtxTexture.js';
 
 export class WebGlCtxSubTexture extends WebGlCtxTexture {
   constructor(
-    glw: WebGlContextWrapper,
+    glw: GlContextWrapper,
     memManager: TextureMemoryManager,
     textureSource: SubTexture,
   ) {