@aethervtt/shard-gpu-webgl2 0.1.0 → 0.2.0

package/dist/commands.d.ts

@@ -1,5 +1,6 @@
 import type { Webgl2BindGroup } from './binding.js';
 import type { Webgl2RenderPipeline } from './pipeline.js';
+import type { Webgl2QuerySet } from './queries.js';
 import type { Webgl2Buffer, Webgl2TextureView } from './resources.js';
 export declare const OP: {
     readonly BEGIN_PASS: 1;
@@ -19,6 +20,9 @@ export declare const OP: {
     readonly COPY_TEXTURE_TO_BUFFER: 15;
     readonly COPY_TEXTURE: 16;
     readonly CLEAR_BUFFER: 17;
+    readonly BEGIN_QUERY: 18;
+    readonly END_QUERY: 19;
+    readonly RESOLVE_QUERIES: 20;
 };
 export declare class CommandStream {
     nums: Float64Array<ArrayBuffer>;
@@ -41,6 +45,8 @@ export declare class Webgl2CommandBuffer {
 type Extent = GPUExtent3D;
 export declare class Webgl2CommandEncoder {
     label: string;
+    /** @internal The pass being recorded times itself (`timestampWrites`): its end ends the query. */
+    timedPass: boolean;
     private stream;
     private readonly pass;
     private readonly buffer;
@@ -56,7 +62,8 @@ export declare class Webgl2CommandEncoder {
     copyTextureToBuffer(source: GPUTexelCopyTextureInfo, destination: GPUTexelCopyBufferInfo, size: Extent): void;
     copyTextureToTexture(source: GPUTexelCopyTextureInfo, destination: GPUTexelCopyTextureInfo, size: Extent): void;
     clearBuffer(buffer: Webgl2Buffer, offset?: number, size?: number): void;
-    resolveQuerySet(): never;
+    /** Pairs of the set to the buffer: written when the buffer is mapped (queries.ts). */
+    resolveQuerySet(querySet: Webgl2QuerySet, firstQuery: number, queryCount: number, destination: Webgl2Buffer, destinationOffset: number): void;
     writeTimestamp(): never;
     pushDebugGroup(): void;
     popDebugGroup(): void;

package/dist/commands.js

@@ -16,7 +16,10 @@ const OP = {
   COPY_BUFFER_TO_TEXTURE: 14,
   COPY_TEXTURE_TO_BUFFER: 15,
   COPY_TEXTURE: 16,
-  CLEAR_BUFFER: 17
+  CLEAR_BUFFER: 17,
+  BEGIN_QUERY: 18,
+  END_QUERY: 19,
+  RESOLVE_QUERIES: 20
 };
 class CommandStream {
   nums = new Float64Array(1024);
@@ -70,6 +73,8 @@ function colorOf(c, i) {
 }
 class Webgl2CommandEncoder {
   label = "";
+  /** @internal The pass being recorded times itself (`timestampWrites`): its end ends the query. */
+  timedPass = false;
   stream;
   pass;
   buffer;
@@ -92,6 +97,14 @@ class Webgl2CommandEncoder {
   beginRenderPass(d) {
     const s = this.recording;
     if (d.occlusionQuerySet) throw unsupported(`run occlusion queries ("${d.label ?? this.label}")`);
+    const writes = d.timestampWrites;
+    const index = writes?.beginningOfPassWriteIndex ?? writes?.endOfPassWriteIndex;
+    this.timedPass = writes !== void 0 && index !== void 0;
+    if (this.timedPass) {
+      s.num(OP.BEGIN_QUERY);
+      s.num(index >> 1);
+      s.ref(writes.querySet);
+    }
     s.num(OP.BEGIN_PASS);
     const colors = d.colorAttachments;
     s.num(colors.length);
@@ -211,11 +224,18 @@ class Webgl2CommandEncoder {
     s.num(size ?? buffer.size - offset);
     s.ref(buffer);
   }
-  resolveQuerySet() {
-    throw unsupported("resolve query sets", "timestamp-query is never offered on WebGL2.");
+  /** Pairs of the set to the buffer: written when the buffer is mapped (queries.ts). */
+  resolveQuerySet(querySet, firstQuery, queryCount, destination, destinationOffset) {
+    const s = this.recording;
+    s.num(OP.RESOLVE_QUERIES);
+    s.num(firstQuery);
+    s.num(queryCount);
+    s.num(destinationOffset);
+    s.ref(querySet);
+    s.ref(destination);
   }
   writeTimestamp() {
-    throw unsupported("write timestamps", "timestamp-query is never offered on WebGL2.");
+    throw unsupported("write timestamps", "WebGL2 times passes (timestampWrites) only.");
   }
   pushDebugGroup() {
   }
@@ -345,7 +365,12 @@ class Webgl2RenderPassEncoder {
   insertDebugMarker() {
   }
   end() {
-    this.encoder.recording.num(OP.END_PASS);
+    const s = this.encoder.recording;
+    s.num(OP.END_PASS);
+    if (this.encoder.timedPass) {
+      s.num(OP.END_QUERY);
+      this.encoder.timedPass = false;
+    }
   }
 }
 function layerOf(view, depthSlice) {

package/dist/copies.js

@@ -232,6 +232,14 @@ class Copier {
     gl.bindBuffer(GL.COPY_READ_BUFFER, src.gl);
     gl.bindBuffer(GL.COPY_WRITE_BUFFER, dst.gl);
     gl.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, srcOffset, dstOffset, size);
+    if (src.queryReads.length > 0) {
+      for (let i = src.queryReads.length - 1; i >= 0; i--) {
+        const read = src.queryReads[i];
+        if (read.offset < srcOffset || read.offset >= srcOffset + size) continue;
+        src.queryReads.splice(i, 1);
+        dst.queryReads.push({ offset: read.offset - srcOffset + dstOffset, queries: read.queries });
+      }
+    }
     if (dst.shadow) {
       if (src.shadow) dst.shadow.set(src.shadow.subarray(srcOffset, srcOffset + size), dstOffset);
       else gl.getBufferSubData(GL.COPY_WRITE_BUFFER, dstOffset, dst.shadow, dstOffset, size);

package/dist/device.d.ts

@@ -5,6 +5,7 @@ import { Copier } from './copies.js';
 import { ShimError } from './errors.js';
 import { FramebufferCache } from './fbo.js';
 import { Webgl2RenderPipeline, Webgl2ShaderModule } from './pipeline.js';
+import { QueryPool, Webgl2QuerySet } from './queries.js';
 import { Webgl2Queue } from './queue.js';
 import { Replayer } from './replay.js';
 import { Webgl2Buffer, Webgl2Sampler, Webgl2Texture } from './resources.js';
@@ -71,6 +72,8 @@ export interface Webgl2DeviceOptions {
 /** Extensions the device calls into, enabled by the adapter. */
 export interface Webgl2Extensions {
     clipControl: unknown;
+    /** EXT_disjoint_timer_query_webgl2: TIME_ELAPSED queries time passes (0074). */
+    timer: unknown;
     indexed: OES_draw_buffers_indexed | null;
     lose: WEBGL_lose_context | null;
 }
@@ -85,6 +88,10 @@ export declare class Webgl2Device extends EventTarget {
     readonly state: GlState;
     readonly fbos: FramebufferCache;
     readonly copier: Copier;
+    /** Query objects for timed passes (`timestamp-query`, 0074). */
+    readonly queries: QueryPool;
+    /** Where the next timed pass's stamps start: one timeline across frames, as GPU clocks are. */
+    timerAt: bigint;
     readonly replayer: Replayer;
     readonly queue: Webgl2Queue;
     readonly features: ReadonlySet<string>;
@@ -122,7 +129,8 @@ export declare class Webgl2Device extends EventTarget {
     createRenderPipelineAsync(descriptor: GPURenderPipelineDescriptor): Promise<Webgl2RenderPipeline>;
     createComputePipeline(descriptor: GPUComputePipelineDescriptor): never;
     createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise<never>;
-    createQuerySet(descriptor: GPUQuerySetDescriptor): never;
+    /** Timestamp query sets where the timer extension exists (see queries.ts). */
+    createQuerySet(descriptor: GPUQuerySetDescriptor): Webgl2QuerySet;
     createRenderBundleEncoder(): never;
     importExternalTexture(): never;
     createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): Webgl2CommandEncoder;

package/dist/device.js

@@ -7,6 +7,7 @@ import { ShimError, unsupported } from "./errors.js";
 import { FramebufferCache } from "./fbo.js";
 import { CLIP, GL } from "./gl.js";
 import { Webgl2RenderPipeline, Webgl2ShaderModule } from "./pipeline.js";
+import { finishQueryReads, QueryPool, Webgl2QuerySet } from "./queries.js";
 import { Webgl2Queue } from "./queue.js";
 import { Replayer } from "./replay.js";
 import { Webgl2Buffer, Webgl2Sampler, Webgl2Texture } from "./resources.js";
@@ -19,6 +20,10 @@ class Webgl2Device extends EventTarget {
   state;
   fbos;
   copier;
+  /** Query objects for timed passes (`timestamp-query`, 0074). */
+  queries;
+  /** Where the next timed pass's stamps start: one timeline across frames, as GPU clocks are. */
+  timerAt = 1n;
   replayer;
   queue;
   features;
@@ -62,6 +67,7 @@ class Webgl2Device extends EventTarget {
       this.fbos.incomplete = (status) => this.raise("validation", `A framebuffer is incomplete (0x${status.toString(16)})`);
     }
     this.copier = new Copier(this);
+    this.queries = new QueryPool(gl);
     this.replayer = new Replayer(this);
     this.queue = new Webgl2Queue(this);
     gl.pixelStorei(GL.UNPACK_ALIGNMENT, 1);
@@ -150,8 +156,12 @@ class Webgl2Device extends EventTarget {
       )
     );
   }
+  /** Timestamp query sets where the timer extension exists (see queries.ts). */
   createQuerySet(descriptor) {
-    throw unsupported(`make a ${descriptor.type} query set`);
+    if (descriptor.type !== "timestamp" || !this.features.has("timestamp-query")) {
+      throw unsupported(`make a ${descriptor.type} query set`);
+    }
+    return new Webgl2QuerySet(this, descriptor);
   }
   createRenderBundleEncoder() {
     throw unsupported("record render bundles");
@@ -199,6 +209,7 @@ class Webgl2Device extends EventTarget {
   lose(reason, message) {
     if (this.isLost) return;
     this.isLost = true;
+    this.queries.clear();
     this.canvas?.removeEventListener("webglcontextlost", this.onContextLost);
     for (const f of this.fences.splice(0)) f.resolve();
     this.resolveLost({ reason, message });
@@ -282,7 +293,7 @@ class Webgl2Device extends EventTarget {
       return Promise.reject(error);
     }
     buffer.mapState = "pending";
-    return this.afterGpu().then(() => {
+    return this.afterGpu().then(async () => {
       if (buffer.destroyed || buffer.mapState !== "pending") {
         const error = new Error(`Mapping "${buffer.label}" was aborted`);
         error.name = "AbortError";
@@ -304,6 +315,12 @@ class Webgl2Device extends EventTarget {
         }
         buffer.reads.length = 0;
       }
+      if (buffer.queryReads.length > 0) await finishQueryReads(this, buffer, bytes, offset);
+      if (buffer.destroyed || buffer.mapState !== "pending") {
+        const error = new Error(`Mapping "${buffer.label}" was aborted`);
+        error.name = "AbortError";
+        throw error;
+      }
       buffer.mapped = bytes.buffer;
       buffer.mappedOffset = offset;
       buffer.mapState = "mapped";

package/dist/fake-gl.d.ts

@@ -116,6 +116,14 @@ export interface FakeGlOptions {
     linkPolls?: number;
     /** UNIFORM_BLOCK_DATA_SIZE by block name prefix (default 0: whatever is bound). */
     blockSizes?: Record<string, number>;
+    /**
+     * Offers EXT_disjoint_timer_query_webgl2 (0074): every TIME_ELAPSED query takes `elapsedNs`, and
+     * its result is available after `polls` reads of QUERY_RESULT_AVAILABLE (default 0).
+     */
+    timerQuery?: {
+        elapsedNs: number;
+        polls?: number;
+    };
 }
 export declare class FakeGl {
     readonly canvas: {
@@ -309,6 +317,20 @@ export declare class FakeGl {
     drawArraysInstanced(mode: number, first: number, count: number, instances: number): void;
     drawElementsInstanced(mode: number, count: number, type: number, offset: number, instances: number): void;
     private record;
+    /** Queries begun so far, and the one running. */
+    queriesBegun: number;
+    private activeQuery;
+    createQuery(): object;
+    deleteQuery(): void;
+    beginQuery(_target: number, query: {
+        polls: number;
+        ended: boolean;
+    }): void;
+    endQuery(): void;
+    getQueryParameter(query: {
+        polls: number;
+        ended: boolean;
+    }, p: number): number | boolean;
     fenceSync(): object;
     getSyncParameter(): number;
     deleteSync(): void;

package/dist/fake-gl.js

@@ -155,6 +155,7 @@ class FakeGl {
         }
       }
     };
+    if (options.timerQuery) all.EXT_disjoint_timer_query_webgl2 = {};
     for (const [name, ext] of Object.entries(all)) {
       if (!options.without?.includes(name)) this.extensions.set(name, ext);
     }
@@ -893,6 +894,36 @@ class FakeGl {
     });
   }
   // --- sync -----------------------------------------------------------------------------
+  // --- timer queries (EXT_disjoint_timer_query_webgl2) --------------------------------
+  /** Queries begun so far, and the one running. */
+  queriesBegun = 0;
+  activeQuery = null;
+  createQuery() {
+    return { kind: "query", id: this.next++, polls: 0, ended: false };
+  }
+  deleteQuery() {
+  }
+  beginQuery(_target, query) {
+    query.polls = this.options.timerQuery?.polls ?? 0;
+    query.ended = false;
+    this.activeQuery = query;
+    this.queriesBegun++;
+  }
+  endQuery() {
+    if (this.activeQuery) this.activeQuery.ended = true;
+    this.activeQuery = null;
+  }
+  getQueryParameter(query, p) {
+    if (p === 34919) {
+      if (!query.ended) return false;
+      if (query.polls > 0) {
+        query.polls--;
+        return false;
+      }
+      return true;
+    }
+    return this.options.timerQuery?.elapsedNs ?? 0;
+  }
   fenceSync() {
     return { kind: "sync", id: this.next++ };
   }

package/dist/gpu.js

@@ -70,7 +70,7 @@ class Webgl2Adapter {
     const { caps, extensions } = capsOf(opened.gl, options.profile ?? "native");
     this.caps = caps;
     this.extensions = extensions;
-    this.features = featuresOf(opened.gl, caps);
+    this.features = featuresOf(opened.gl, caps, extensions.timer !== null);
     this.limits = limitsOf(caps);
     this.info = infoOf(opened.gl);
   }
@@ -113,6 +113,7 @@ function capsOf(gl, profile) {
   const floatLinear = ext("OES_texture_float_linear");
   const indexed = ext("OES_draw_buffers_indexed");
   const lose = gl.getExtension("WEBGL_lose_context");
+  const timer = ext("EXT_disjoint_timer_query_webgl2");
   const bc = ext("WEBGL_compressed_texture_s3tc") !== null && ext("WEBGL_compressed_texture_s3tc_srgb") !== null && ext("EXT_texture_compression_rgtc") !== null && ext("EXT_texture_compression_bptc") !== null;
   const caps = {
     maxSamples: minimum ? Math.min(4, p(GL.MAX_SAMPLES)) : p(GL.MAX_SAMPLES),
@@ -141,10 +142,11 @@ function capsOf(gl, profile) {
       etc2: ext("WEBGL_compressed_texture_etc") !== null
     }
   };
-  return { caps, extensions: { clipControl, indexed, lose } };
+  return { caps, extensions: { clipControl, indexed, lose, timer } };
 }
-function featuresOf(gl, caps) {
+function featuresOf(gl, caps, timer) {
   const features = /* @__PURE__ */ new Set(["depth32float-stencil8"]);
+  if (timer) features.add("timestamp-query");
   if (caps.compression.bc) features.add("texture-compression-bc");
   if (caps.compression.astc) features.add("texture-compression-astc");
   if (caps.compression.etc2) features.add("texture-compression-etc2");

package/dist/queries.d.ts

@@ -0,0 +1,41 @@
+import type { Webgl2Device } from './device.js';
+import type { Webgl2Buffer } from './resources.js';
+export declare const TIME_ELAPSED_EXT = 35007;
+export declare const GPU_DISJOINT_EXT = 36795;
+/** Queries resolved into a buffer, waiting for results: pair k's begin/end at `offset + 16k`. */
+export interface QueryRead {
+    offset: number;
+    queries: (WebGLQuery | null)[];
+}
+export declare class Webgl2QuerySet {
+    readonly type: GPUQueryType;
+    readonly count: number;
+    label: string;
+    /** The query recording each pair this frame (one per pass), until resolved. */
+    private readonly pairs;
+    private readonly device;
+    private destroyed;
+    constructor(device: Webgl2Device, descriptor: GPUQuerySetDescriptor);
+    /** @internal Replay: starts timing pair `pair` (a pass with timestamp writes begins). */
+    begin(pair: number): void;
+    /** @internal Replay: the timed pass ended. */
+    end(): void;
+    /** @internal Replay: hands queries `first` to `first + count` to `buffer` at `offset`. */
+    resolve(first: number, count: number, buffer: Webgl2Buffer, offset: number): void;
+    destroy(): void;
+}
+/** Query objects, reused: a frame times a few dozen passes, every frame. */
+export declare class QueryPool {
+    private readonly free;
+    private readonly gl;
+    constructor(gl: WebGL2RenderingContext);
+    take(): WebGLQuery | null;
+    give(query: WebGLQuery): void;
+    /** Forgets the pool (the context was lost: its queries went with it). */
+    clear(): void;
+}
+/**
+ * Waits for `buffer`'s pending query results and writes them into `bytes` (the mapped range, which
+ * starts at `mapOffset`), then returns the queries to the pool.
+ */
+export declare function finishQueryReads(device: Webgl2Device, buffer: Webgl2Buffer, bytes: Uint8Array, mapOffset: number): Promise<void>;

package/dist/queries.js

@@ -0,0 +1,110 @@
+const TIME_ELAPSED_EXT = 35007;
+const GPU_DISJOINT_EXT = 36795;
+const QUERY_RESULT = 34918;
+const QUERY_RESULT_AVAILABLE = 34919;
+const WAIT_MS = 2e3;
+class Webgl2QuerySet {
+  type = "timestamp";
+  count;
+  label;
+  /** The query recording each pair this frame (one per pass), until resolved. */
+  pairs;
+  device;
+  destroyed = false;
+  constructor(device, descriptor) {
+    this.device = device;
+    this.count = descriptor.count;
+    this.label = descriptor.label ?? "";
+    this.pairs = new Array(Math.ceil(descriptor.count / 2)).fill(null);
+  }
+  /** @internal Replay: starts timing pair `pair` (a pass with timestamp writes begins). */
+  begin(pair) {
+    if (this.destroyed) return;
+    const query = this.device.queries.take();
+    if (!query) return;
+    this.device.gl.beginQuery(TIME_ELAPSED_EXT, query);
+    this.pairs[pair] = query;
+  }
+  /** @internal Replay: the timed pass ended. */
+  end() {
+    this.device.gl.endQuery(TIME_ELAPSED_EXT);
+  }
+  /** @internal Replay: hands queries `first` to `first + count` to `buffer` at `offset`. */
+  resolve(first, count, buffer, offset) {
+    const from = first >> 1;
+    const to = first + count + 1 >> 1;
+    const queries = [];
+    for (let p = from; p < to; p++) {
+      queries.push(this.pairs[p] ?? null);
+      this.pairs[p] = null;
+    }
+    buffer.queryReads.push({ offset, queries });
+  }
+  destroy() {
+    this.destroyed = true;
+    for (let p = 0; p < this.pairs.length; p++) {
+      const q = this.pairs[p];
+      if (q) this.device.queries.give(q);
+      this.pairs[p] = null;
+    }
+  }
+}
+class QueryPool {
+  free = [];
+  gl;
+  constructor(gl) {
+    this.gl = gl;
+  }
+  take() {
+    return this.free.pop() ?? this.gl.createQuery();
+  }
+  give(query) {
+    this.free.push(query);
+  }
+  /** Forgets the pool (the context was lost: its queries went with it). */
+  clear() {
+    this.free.length = 0;
+  }
+}
+const waitTick = () => new Promise((resolve) => setTimeout(resolve, 4));
+async function finishQueryReads(device, buffer, bytes, mapOffset) {
+  const reads = buffer.queryReads.splice(0);
+  if (reads.length === 0) return;
+  const gl = device.gl;
+  const deadline = performance.now() + WAIT_MS;
+  const ready = () => reads.every(
+    (r) => r.queries.every((q) => !q || gl.getQueryParameter(q, QUERY_RESULT_AVAILABLE) === true)
+  );
+  while (!device.isLost && !ready() && performance.now() < deadline) await waitTick();
+  const lost = device.isLost;
+  const disjoint = !lost && gl.getParameter(GPU_DISJOINT_EXT) === true;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (const read of reads) {
+    let at = device.timerAt;
+    for (let k = 0; k < read.queries.length; k++) {
+      const q = read.queries[k];
+      const pos = read.offset - mapOffset + k * 16;
+      let begin = 0n;
+      let end = 0n;
+      if (q && !lost && !disjoint && gl.getQueryParameter(q, QUERY_RESULT_AVAILABLE) === true) {
+        const elapsed = BigInt(gl.getQueryParameter(q, QUERY_RESULT));
+        begin = at;
+        end = at + elapsed;
+        at = end;
+        device.timerAt = end;
+      }
+      if (pos >= 0 && pos + 16 <= bytes.byteLength) {
+        view.setBigUint64(pos, begin, true);
+        view.setBigUint64(pos + 8, end, true);
+      }
+      if (q && !lost) device.queries.give(q);
+    }
+  }
+}
+export {
+  GPU_DISJOINT_EXT,
+  QueryPool,
+  TIME_ELAPSED_EXT,
+  Webgl2QuerySet,
+  finishQueryReads
+};

package/dist/replay.d.ts

@@ -10,6 +10,8 @@ export declare class Replayer {
     private stream;
     private i;
     private r;
+    /** The query set timing the pass being replayed. */
+    private timed;
     private passFbo;
     private passWidth;
     private passHeight;

package/dist/replay.js

@@ -12,6 +12,8 @@ class Replayer {
   stream;
   i = 0;
   r = 0;
+  /** The query set timing the pass being replayed. */
+  timed;
   // The pass.
   passFbo = null;
   passWidth = 0;
@@ -245,6 +247,25 @@ class Replayer {
             this.device.copier.clearBuffer(this.ref(), offset, size);
             break;
           }
+          case OP.BEGIN_QUERY: {
+            const pair = this.num();
+            const set = this.ref();
+            set.begin(pair);
+            this.timed = set;
+            break;
+          }
+          case OP.END_QUERY:
+            this.timed?.end();
+            this.timed = void 0;
+            break;
+          case OP.RESOLVE_QUERIES: {
+            const first = this.num();
+            const count = this.num();
+            const offset = this.num();
+            const set = this.ref();
+            set.resolve(first, count, this.ref(), offset);
+            break;
+          }
           default:
             throw new Error(`Unknown recorded command ${op}`);
         }

package/dist/resources.d.ts

@@ -1,6 +1,7 @@
 import type { ReadJob } from './copies.js';
 import type { Webgl2Device } from './device.js';
 import { type GlFormat } from './formats.js';
+import type { QueryRead } from './queries.js';
 export declare class Webgl2Buffer {
     readonly id: number;
     readonly size: number;
@@ -28,6 +29,8 @@ export declare class Webgl2Buffer {
     mappedOffset: number;
     /** Texture reads into this buffer, repacked when it's mapped. */
     readonly reads: ReadJob[];
+    /** Timer queries resolved into this buffer, written when it's mapped (0074). */
+    readonly queryReads: QueryRead[];
     destroyed: boolean;
     private readonly device;
     constructor(device: Webgl2Device, descriptor: GPUBufferDescriptor);

package/dist/resources.js

@@ -30,6 +30,8 @@ class Webgl2Buffer {
   mappedOffset = 0;
   /** Texture reads into this buffer, repacked when it's mapped. */
   reads = [];
+  /** Timer queries resolved into this buffer, written when it's mapped (0074). */
+  queryReads = [];
   destroyed = false;
   device;
   constructor(device, descriptor) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-gpu-webgl2",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@aethervtt/shard-core": "0.1.0"
+    "@aethervtt/shard-core": "0.2.0"
   },
   "repository": {
     "type": "git",
@@ -33,6 +33,6 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
+    "buildSha": "32c22a3944ed23f5d1baa90bf7cc9fae724f5fd8"
   }
 }