@solidtv/renderer 1.3.2 → 1.4.0

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

@@ -0,0 +1,106 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ImageWorkerManager } from './ImageWorker.js';
+import type { CreateImageBitmapSupport } from './validateImageBitmap.js';
+
+/**
+ * Minimal Web Worker stand-in. The real Worker spawns a thread that parses the
+ * blob script; here we only care about how many are constructed and when, so we
+ * record every instance and never auto-respond (so `getImage` calls stay
+ * "in flight" and accumulate load, simulating concurrency).
+ */
+class FakeWorker {
+  static instances: FakeWorker[] = [];
+  static reset() {
+    FakeWorker.instances = [];
+  }
+  onmessage: ((e: unknown) => void) | null = null;
+  onerror: ((e: unknown) => void) | null = null;
+  onmessageerror: ((e: unknown) => void) | null = null;
+  postMessage = vi.fn();
+  terminate = vi.fn();
+  constructor(public url: string) {
+    FakeWorker.instances.push(this);
+  }
+}
+
+const support: CreateImageBitmapSupport = {
+  basic: true,
+  options: true,
+  full: true,
+  premultiplyHonored: true,
+};
+
+let createObjectURL: ReturnType<typeof vi.fn>;
+let revokeObjectURL: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  FakeWorker.reset();
+  createObjectURL = vi.fn(() => 'blob:fake-url');
+  revokeObjectURL = vi.fn();
+  // The manager builds the worker source via Blob + object URL, then spawns
+  // Workers. None of these exist in the node test env, so stub them.
+  vi.stubGlobal(
+    'Blob',
+    class {
+      constructor(public parts: unknown[], public opts: unknown) {}
+    },
+  );
+  vi.stubGlobal('URL', { createObjectURL, revokeObjectURL });
+  vi.stubGlobal('self', { URL: { createObjectURL, revokeObjectURL } });
+  vi.stubGlobal('Worker', FakeWorker);
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+const load = (mgr: ImageWorkerManager) =>
+  void mgr.getImage('img.png', null, null, null, null, null);
+
+describe('ImageWorkerManager pool spawning', () => {
+  it('does not spawn any workers at construction', () => {
+    new ImageWorkerManager(3, support);
+    // Spawning is lazy — nothing happens until the first image request.
+    expect(FakeWorker.instances.length).toBe(0);
+  });
+
+  it('spawns the whole pool at once on the first image request', () => {
+    const mgr = new ImageWorkerManager(3, support);
+    load(mgr);
+    expect(FakeWorker.instances.length).toBe(3);
+  });
+
+  it('does not respawn the pool on subsequent requests', () => {
+    const mgr = new ImageWorkerManager(3, support);
+    load(mgr); // spawns the pool
+    expect(FakeWorker.instances.length).toBe(3);
+    // Subsequent requests reuse the existing pool — no new workers.
+    load(mgr);
+    load(mgr);
+    load(mgr);
+    expect(FakeWorker.instances.length).toBe(3);
+  });
+
+  it('spawns exactly maxWorkers when that is 1', () => {
+    const mgr = new ImageWorkerManager(1, support);
+    load(mgr);
+    expect(FakeWorker.instances.length).toBe(1);
+    load(mgr);
+    load(mgr);
+    expect(FakeWorker.instances.length).toBe(1);
+  });
+
+  it('serializes the worker source once, reusing the blob per worker', () => {
+    const mgr = new ImageWorkerManager(3, support);
+    load(mgr);
+    // One object URL created+revoked per spawned worker (3), serialized once.
+    expect(createObjectURL).toHaveBeenCalledTimes(3);
+    expect(revokeObjectURL).toHaveBeenCalledTimes(3);
+  });
+
+  it('routes each request to a worker via postMessage', () => {
+    const mgr = new ImageWorkerManager(2, support);
+    load(mgr);
+    expect(FakeWorker.instances[0]!.postMessage).toHaveBeenCalledTimes(1);
+  });
+});

package/src/core/lib/ImageWorker.ts

@@ -177,20 +177,32 @@ export class ImageWorkerManager {
   workers: Worker[] = [];
   workerLoad: number[] = [];
   nextId = 0;
+  /** Upper bound on the pool size, from the `numImageWorkers` setting. */
+  private readonly maxWorkers: number;
+  /** Retained so the worker source is serialized once, when the pool spawns. */
+  private workerBlob: Blob | null = null;
+  private readonly createImageBitmapSupport: CreateImageBitmapSupport;
 
   constructor(
     numImageWorkers: number,
     createImageBitmapSupport: CreateImageBitmapSupport,
   ) {
-    this.workers = this.createWorkers(
-      numImageWorkers,
-      createImageBitmapSupport,
-    );
-    this.workers.forEach((worker, index) => {
-      worker.onmessage = (event) => this.handleMessage(event, index);
-      worker.onerror = (event) => this.handleWorkerError(event, index);
-      worker.onmessageerror = (event) => this.handleWorkerError(event, index);
-    });
+    this.maxWorkers = numImageWorkers;
+    this.createImageBitmapSupport = createImageBitmapSupport;
+  }
+
+  /**
+   * Build the shared worker source once and spawn the full pool in a single
+   * burst. Called lazily on the first image request. No-op once spawned.
+   */
+  private spawnWorkers(): void {
+    if (this.workers.length > 0) {
+      return;
+    }
+    this.workerBlob = this.createWorkerBlob(this.createImageBitmapSupport);
+    for (let i = 0; i < this.maxWorkers; i++) {
+      this.spawnWorker();
+    }
   }
 
   private handleMessage(event: MessageEvent, workerIndex: number) {
@@ -231,10 +243,9 @@ export class ImageWorkerManager {
     this.workerLoad[workerIndex] = 0;
   }
 
-  private createWorkers(
-    numWorkers = 1,
+  private createWorkerBlob(
     createImageBitmapSupport: CreateImageBitmapSupport,
-  ): Worker[] {
+  ): Blob {
     let workerCode = `(${createImageWorker.toString()})()`;
 
     // Replace placeholders with actual initialization values
@@ -265,19 +276,39 @@ export class ImageWorkerManager {
     }
 
     workerCode = workerCode.replace('"use strict";', '');
-    const blob: Blob = new Blob([workerCode], {
+    return new Blob([workerCode], {
       type: 'application/javascript',
     });
-    const urlFactory = self.URL ? URL : webkitURL;
-    const blobURL: string = urlFactory.createObjectURL(blob);
-    const workers: Worker[] = [];
-    for (let i = 0; i < numWorkers; i++) {
-      workers.push(new Worker(blobURL));
-      this.workerLoad.push(0);
+  }
+
+  /**
+   * Spawn a single worker from the shared blob and wire up its handlers.
+   * No-op once the pool has reached `maxWorkers`.
+   */
+  private spawnWorker(): void {
+    if (this.workerBlob === null || this.workers.length >= this.maxWorkers) {
+      return;
     }
-    // Workers retain the script; the URL itself is no longer needed.
+
+    const index = this.workers.length;
+    const urlFactory = self.URL ? URL : webkitURL;
+    const blobURL: string = urlFactory.createObjectURL(this.workerBlob);
+    const worker = new Worker(blobURL);
+    // The worker retains the script after construction; the URL is no longer
+    // needed once the Worker has been created from it.
     urlFactory.revokeObjectURL(blobURL);
-    return workers;
+
+    worker.onmessage = (event) => this.handleMessage(event, index);
+    worker.onerror = (event) => this.handleWorkerError(event, index);
+    worker.onmessageerror = (event) => this.handleWorkerError(event, index);
+
+    this.workers.push(worker);
+    this.workerLoad.push(0);
+
+    // Pool is full — the blob will never be needed again, so release it.
+    if (this.workers.length >= this.maxWorkers) {
+      this.workerBlob = null;
+    }
   }
 
   private getNextWorkerIndex(): number {
@@ -311,7 +342,14 @@ export class ImageWorkerManager {
   ): Promise<TextureData> {
     return new Promise((resolve, reject) => {
       try {
-        const nextWorkerIndex = this.getNextWorkerIndex();
+        let nextWorkerIndex = this.getNextWorkerIndex();
+        if (nextWorkerIndex === -1) {
+          // Pool not spawned yet — spin up all workers at once on the first
+          // image request, off the boot/first-render critical path.
+          this.spawnWorkers();
+          nextWorkerIndex = this.getNextWorkerIndex();
+        }
+
         if (nextWorkerIndex === -1) {
           reject(new Error('No image workers available'));
           return;

package/src/core/lib/WebGlContextWrapper.ts

@@ -6,13 +6,12 @@ import type {
   Vec3,
   Vec4,
 } from '../renderers/webgl/internal/ShaderUtils.js';
-import { isWebGl2 } from '../renderers/webgl/internal/WebGlUtils.js';
 
 /**
  * Optimized WebGL Context Wrapper
  *
  * @remarks
- * This class contains the subset of the WebGLRenderingContext & WebGL2RenderingContext
+ * This class contains the subset of the WebGLRenderingContext
  * API that is used by the renderer. Select high volume WebGL methods include
  * caching optimizations to avoid making WebGL calls if the state is already set
  * to the desired value.
@@ -94,56 +93,40 @@ export class WebGlContextWrapper {
   public readonly INVALID_OPERATION: number;
   //#endregion WebGL Enums
 
-  constructor(private gl: WebGLRenderingContext | WebGL2RenderingContext) {
-    // The following code extracts the current state of the WebGL context
-    // to our local JavaScript cached version of it. This is so we can
-    // avoid making WebGL calls if we don't need to.
-    // We could assume that the WebGL context is in a default state, but
-    // in the future we may want to support restoring a broken WebGL context
-    // and this will help with that.
-    this.activeTextureUnit =
-      (gl.getParameter(gl.ACTIVE_TEXTURE) as number) - gl.TEXTURE0;
+  constructor(private gl: WebGLRenderingContext) {
+    // A freshly created WebGL context is in a fully specified default state.
+    // Rather than reading that state back with getParameter/isEnabled — each a
+    // synchronous CPU<->GPU round-trip, and previously ~one per texture unit
+    // (16-32) just to enumerate the bindings — we seed the cache with those
+    // known defaults. The engine never restores a lost context in place (it
+    // reloads the app on `contextLost`), so there is no live state to recover.
+    this.activeTextureUnit = 0;
     const maxTextureUnits = gl.getParameter(
       gl.MAX_TEXTURE_IMAGE_UNITS,
     ) as number;
-    // save current texture units
-    this.texture2dUnits = new Array<undefined>(maxTextureUnits)
-      .fill(undefined)
-      .map((_, i) => {
-        this.activeTexture(i);
-        return gl.getParameter(gl.TEXTURE_BINDING_2D) as WebGLTexture;
-      });
-    // restore active texture unit
-    this.activeTexture(this.activeTextureUnit);
-    this.scissorEnabled = gl.isEnabled(gl.SCISSOR_TEST);
-
-    const scissorBox = gl.getParameter(gl.SCISSOR_BOX) as [
-      number,
-      number,
-      number,
-      number,
-    ];
-    this.scissorX = scissorBox[0];
-    this.scissorY = scissorBox[1];
-    this.scissorWidth = scissorBox[2];
-    this.scissorHeight = scissorBox[3];
-
-    this.blendEnabled = gl.isEnabled(gl.BLEND);
-    this.blendSrcRgb = gl.getParameter(gl.BLEND_SRC_RGB) as number;
-    this.blendDstRgb = gl.getParameter(gl.BLEND_DST_RGB) as number;
-    this.blendSrcAlpha = gl.getParameter(gl.BLEND_SRC_ALPHA) as number;
-    this.blendDstAlpha = gl.getParameter(gl.BLEND_DST_ALPHA) as number;
-
-    this.boundArrayBuffer = gl.getParameter(
-      gl.ARRAY_BUFFER_BINDING,
-    ) as WebGLBuffer;
-    this.boundElementArrayBuffer = gl.getParameter(
-      gl.ELEMENT_ARRAY_BUFFER_BINDING,
-    ) as WebGLBuffer;
-
-    this.curProgram = gl.getParameter(
-      gl.CURRENT_PROGRAM,
-    ) as WebGLProgram | null;
+    // All texture units start unbound (TEXTURE_BINDING_2D === null).
+    this.texture2dUnits = new Array<WebGLTexture | null>(maxTextureUnits).fill(
+      null,
+    );
+
+    // SCISSOR_TEST disabled; SCISSOR_BOX defaults to the full drawing buffer.
+    this.scissorEnabled = false;
+    this.scissorX = 0;
+    this.scissorY = 0;
+    this.scissorWidth = gl.drawingBufferWidth;
+    this.scissorHeight = gl.drawingBufferHeight;
+
+    // BLEND disabled; blend func defaults to (ONE, ZERO) for both RGB and alpha.
+    this.blendEnabled = false;
+    this.blendSrcRgb = gl.ONE;
+    this.blendDstRgb = gl.ZERO;
+    this.blendSrcAlpha = gl.ONE;
+    this.blendDstAlpha = gl.ZERO;
+
+    // No buffers or program bound on a fresh context.
+    this.boundArrayBuffer = null;
+    this.boundElementArrayBuffer = null;
+    this.curProgram = null;
 
     this.canvas = gl.canvas;
 
@@ -175,9 +158,6 @@ export class WebGlContextWrapper {
     this.UNSIGNED_SHORT = gl.UNSIGNED_SHORT;
     this.ONE = gl.ONE;
     this.ONE_MINUS_SRC_ALPHA = gl.ONE_MINUS_SRC_ALPHA;
-    this.MAX_VERTEX_TEXTURE_IMAGE_UNITS = gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS;
-    this.TRIANGLES = gl.TRIANGLES;
-    this.UNSIGNED_SHORT = gl.UNSIGNED_SHORT;
     this.VERTEX_SHADER = gl.VERTEX_SHADER;
     this.FRAGMENT_SHADER = gl.FRAGMENT_SHADER;
     this.STATIC_DRAW = gl.STATIC_DRAW;
@@ -188,15 +168,6 @@ export class WebGlContextWrapper {
     this.INVALID_ENUM = gl.INVALID_ENUM;
     this.INVALID_OPERATION = gl.INVALID_OPERATION;
   }
-  /**
-   * Returns true if the WebGL context is WebGL2
-   *
-   * @returns
-   */
-  isWebGl2() {
-    return isWebGl2(this.gl);
-  }
-
   /**
    * ```
    * gl.activeTexture(textureUnit + gl.TEXTURE0);
@@ -1109,33 +1080,6 @@ export class WebGlContextWrapper {
     return this.gl.getError();
   }
 
-  /**
-   * ```
-   * gl.createVertexArray();
-   * ```
-   *
-   * @returns
-   */
-  createVertexArray() {
-    if (this.gl instanceof WebGL2RenderingContext) {
-      return this.gl.createVertexArray();
-    }
-    return undefined;
-  }
-
-  /**
-   * ```
-   * gl.bindVertexArray(vertexArray);
-   * ```
-   *
-   * @param vertexArray
-   */
-  bindVertexArray(vertexArray: WebGLVertexArrayObject | null) {
-    if (this.gl instanceof WebGL2RenderingContext) {
-      this.gl.bindVertexArray(vertexArray);
-    }
-  }
-
   /**
    * ```
    * gl.getAttribLocation(program, name);
@@ -1341,19 +1285,6 @@ export class WebGlContextWrapper {
     }
   }
 
-  /**
-   * ```
-   * gl.deleteVertexArray(vertexArray);
-   * ```
-   *
-   * @param vertexArray - The vertex array object to delete
-   */
-  deleteVertexArray(vertexArray: WebGLVertexArrayObject) {
-    if (this.isWebGl2()) {
-      (this.gl as WebGL2RenderingContext).deleteVertexArray(vertexArray);
-    }
-  }
-
   /**
    * Check for WebGL errors and return error information
    * @param operation Description of the operation for error reporting

package/src/core/renderers/CoreRenderer.ts

@@ -10,7 +10,6 @@ export interface CoreRendererOptions {
   stage: Stage;
   canvas: HTMLCanvasElement | OffscreenCanvas;
   contextSpy: ContextSpy | null;
-  forceWebGL2: boolean;
 }
 
 export interface BufferInfo {

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

@@ -14,10 +14,6 @@ import { SdfRenderOp } from './SdfRenderOp.js';
 import type { CoreContextTexture } from '../CoreContextTexture.js';
 import {
   createIndexBuffer,
-  type CoreWebGlParameters,
-  type CoreWebGlExtensions,
-  getWebGlParameters,
-  getWebGlExtensions,
   type WebGlColor,
 } from './internal/RendererUtils.js';
 import { WebGlCtxTexture } from './WebGlCtxTexture.js';
@@ -51,17 +47,11 @@ const GL_OUT_OF_MEMORY = 0x0505;
  */
 const MAX_DRAINED_GL_ERRORS = 8;
 
-interface CoreWebGlSystem {
-  parameters: CoreWebGlParameters;
-  extensions: CoreWebGlExtensions;
-}
-
 export type WebGlRenderOp = CoreNode | SdfRenderOp;
 
 export class WebGlRenderer extends CoreRenderer {
   //// WebGL Native Context and Data
   glw: WebGlContextWrapper;
-  system: CoreWebGlSystem;
 
   //// Persistent data
   quadBuffer: ArrayBuffer;
@@ -169,17 +159,20 @@ export class WebGlRenderer extends CoreRenderer {
   constructor(options: WebGlRendererOptions) {
     super(options);
 
+    // CPU-side vertex buffers, reused every frame. Their GL buffers and
+    // BufferCollections are wired up below, once the GL context exists.
     this.quadBuffer = new ArrayBuffer(this.stage.options.quadBufferSize);
     this.fQuadBuffer = new Float32Array(this.quadBuffer);
     this.uiQuadBuffer = new Uint32Array(this.quadBuffer);
 
+    // Shared SDF vertex buffer: 512 KB for ~3600 glyphs.
+    this.sdfBuffer = new ArrayBuffer(512 * 1024);
+    this.fSdfBuffer = new Float32Array(this.sdfBuffer);
+    this.uiSdfBuffer = new Uint32Array(this.sdfBuffer);
+
     this.mode = 'webgl';
 
-    const gl = createWebGLContext(
-      options.canvas,
-      options.forceWebGL2,
-      options.contextSpy,
-    );
+    const gl = createWebGLContext(options.canvas, options.contextSpy);
     const glw = (this.glw = new WebGlContextWrapper(gl));
     glw.viewport(0, 0, options.canvas.width, options.canvas.height);
 
@@ -192,11 +185,6 @@ export class WebGlRenderer extends CoreRenderer {
 
     createIndexBuffer(glw, this.stage.bufferMemory);
 
-    this.system = {
-      parameters: getWebGlParameters(this.glw),
-      extensions: getWebGlExtensions(this.glw),
-    };
-
     // Create the static node coords buffer
     // 80 is the magic number used in createIndexBuffer
     // @see RendererUtils.ts
@@ -261,13 +249,8 @@ export class WebGlRenderer extends CoreRenderer {
         },
       },
     ]);
-    // --- Shared SDF buffer ---------------------------------------------------
-    // Allocate 512 KB for SDF vertex data (~3600 glyphs).
-    const sdfBufSize = 512 * 1024;
-    this.sdfBuffer = new ArrayBuffer(sdfBufSize);
-    this.fSdfBuffer = new Float32Array(this.sdfBuffer);
-    this.uiSdfBuffer = new Uint32Array(this.sdfBuffer);
 
+    // --- Shared SDF buffer collection (CPU buffer allocated above) ----------
     const sdfWebGlBuffer = glw.createBuffer();
     const sdfStride = 6 * Float32Array.BYTES_PER_ELEMENT; // 24 bytes
     this.sdfQuadBufferCollection = new BufferCollection([

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

@@ -21,11 +21,11 @@ export type ShaderSource<T> =
 export type WebGlShaderType<T extends object = Record<string, unknown>> =
   CoreShaderType<T> & {
     /**
-     * fragment shader source for WebGl or WebGl2
+     * fragment shader source for WebGl
      */
     fragment: ShaderSource<T>;
     /**
-     * vertex shader source for WebGl or WebGl2
+     * vertex shader source for WebGl
      */
     vertex?: ShaderSource<T>;
     /**
@@ -43,7 +43,6 @@ export type WebGlShaderType<T extends object = Record<string, unknown>> =
      * extensions required for specific shader?
      */
     webgl1Extensions?: string[];
-    webgl2Extensions?: string[];
     supportsIndexedTextures?: boolean;
   };
 

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

@@ -19,13 +19,6 @@ import { CoreNode } from '../../CoreNode.js';
 
 export class WebGlShaderProgram implements CoreShaderProgram {
   protected program: WebGLProgram | null;
-  /**
-   * Vertex Array Object
-   *
-   * @remarks
-   * Used by WebGL2 Only
-   */
-  protected vao: WebGLVertexArrayObject | undefined;
   protected renderer: WebGlRenderer;
   protected glw: WebGlContextWrapper;
   protected attributeLocations: string[];
@@ -45,22 +38,15 @@ export class WebGlShaderProgram implements CoreShaderProgram {
     this.renderer = renderer;
     const glw = (this.glw = renderer.glw);
 
-    // Check that extensions are supported
-    const webGl2 = glw.isWebGl2();
-    let requiredExtensions: string[] = [];
-
     this.supportsIndexedTextures =
       config.supportsIndexedTextures || this.supportsIndexedTextures;
-    requiredExtensions =
-      (webGl2 && config.webgl2Extensions) ||
-      (!webGl2 && config.webgl1Extensions) ||
-      [];
 
-    const glVersion = webGl2 ? '2.0' : '1.0';
+    // Check that required extensions are supported
+    const requiredExtensions = config.webgl1Extensions || [];
     requiredExtensions.forEach((extensionName) => {
       if (!glw.getExtension(extensionName)) {
         throw new Error(
-          `Shader "${this.constructor.name}" requires extension "${extensionName}" for WebGL ${glVersion} but wasn't found`,
+          `Shader "${this.constructor.name}" requires extension "${extensionName}" for WebGL 1.0 but wasn't found`,
         );
       }
     });
@@ -310,9 +296,6 @@ export class WebGlShaderProgram implements CoreShaderProgram {
       return;
     }
     this.glw.useProgram(this.program, this.uniformLocations!);
-    if (this.glw.isWebGl2() && this.vao) {
-      this.glw.bindVertexArray(this.vao);
-    }
   }
 
   detach(): void {

package/src/core/renderers/webgl/internal/RendererUtils.ts

@@ -1,92 +1,5 @@
 import type { WebGlContextWrapper } from '../../../lib/WebGlContextWrapper.js';
 
-export interface CoreWebGlParameters {
-  MAX_RENDERBUFFER_SIZE: number;
-  MAX_TEXTURE_SIZE: number;
-  MAX_VIEWPORT_DIMS: Int32Array;
-  MAX_VERTEX_TEXTURE_IMAGE_UNITS: number;
-  MAX_TEXTURE_IMAGE_UNITS: number;
-  MAX_COMBINED_TEXTURE_IMAGE_UNITS: number;
-  MAX_VERTEX_ATTRIBS: number;
-  MAX_VARYING_VECTORS: number;
-  MAX_VERTEX_UNIFORM_VECTORS: number;
-  MAX_FRAGMENT_UNIFORM_VECTORS: number;
-}
-
-/**
- * Get device specific webgl parameters
- * @param glw
- */
-export function getWebGlParameters(
-  glw: WebGlContextWrapper,
-): CoreWebGlParameters {
-  const params: CoreWebGlParameters = {
-    MAX_RENDERBUFFER_SIZE: 0,
-    MAX_TEXTURE_SIZE: 0,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-    MAX_VIEWPORT_DIMS: 0 as any, // Code below will replace this with an Int32Array
-    MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0,
-    MAX_TEXTURE_IMAGE_UNITS: 0,
-    MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0,
-    MAX_VERTEX_ATTRIBS: 0,
-    MAX_VARYING_VECTORS: 0,
-    MAX_VERTEX_UNIFORM_VECTORS: 0,
-    MAX_FRAGMENT_UNIFORM_VECTORS: 0,
-  };
-
-  // Map over all parameters and get them
-  const keys = Object.keys(params) as Array<keyof CoreWebGlParameters>;
-  keys.forEach((key) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    params[key] = glw.getParameter(glw[key]);
-  });
-
-  return params;
-}
-
-export interface CoreWebGlExtensions {
-  ANGLE_instanced_arrays: ANGLE_instanced_arrays | null;
-  WEBGL_compressed_texture_s3tc: WEBGL_compressed_texture_s3tc | null;
-  WEBGL_compressed_texture_astc: WEBGL_compressed_texture_astc | null;
-  WEBGL_compressed_texture_etc: WEBGL_compressed_texture_etc | null;
-  WEBGL_compressed_texture_etc1: WEBGL_compressed_texture_etc1 | null;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  WEBGL_compressed_texture_pvrtc: any | null;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  WEBKIT_WEBGL_compressed_texture_pvrtc: any | null;
-  WEBGL_compressed_texture_s3tc_srgb: WEBGL_compressed_texture_s3tc_srgb | null;
-  OES_vertex_array_object: OES_vertex_array_object | null;
-}
-
-/**
- * Get device webgl extensions
- * @param glw
- */
-export function getWebGlExtensions(
-  glw: WebGlContextWrapper,
-): CoreWebGlExtensions {
-  const extensions: CoreWebGlExtensions = {
-    ANGLE_instanced_arrays: null,
-    WEBGL_compressed_texture_s3tc: null,
-    WEBGL_compressed_texture_astc: null,
-    WEBGL_compressed_texture_etc: null,
-    WEBGL_compressed_texture_etc1: null,
-    WEBGL_compressed_texture_pvrtc: null,
-    WEBKIT_WEBGL_compressed_texture_pvrtc: null,
-    WEBGL_compressed_texture_s3tc_srgb: null,
-    OES_vertex_array_object: null,
-  };
-
-  // Map over all extensions and get them
-  const keys = Object.keys(extensions) as Array<keyof CoreWebGlExtensions>;
-  keys.forEach((key) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    extensions[key] = glw.getExtension(key);
-  });
-
-  return extensions;
-}
-
 /**
  * Allocate big memory chunk that we
  * can re-use to draw quads

package/src/core/renderers/webgl/internal/ShaderUtils.ts

@@ -85,7 +85,6 @@ export interface ShaderOptions {
   shaderSources?: ShaderProgramSources;
   supportsIndexedTextures?: boolean;
   webgl1Extensions?: string[];
-  webgl2Extensions?: string[];
 }
 
 // prettier-ignore

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

@@ -19,12 +19,6 @@ interface CanvasFont {
   metrics?: FontMetrics;
 }
 
-/**
- * Global font set regardless of if run in the main thread or a web worker
- */
-// const globalFontSet: FontFaceSet = (resolvedGlobal.document?.fonts ||
-//   (resolvedGlobal as unknown as { fonts: FontFaceSet }).fonts) as FontFaceSet;
-
 // Global state variables for fontHandler
 const fontFamilies: Record<string, FontFace> = {};
 const fontLoadPromises = new Map<string, Promise<void>>();