@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-NZTKLY2W.js

@@ -0,0 +1,1442 @@
+'use strict';
+
+var chunkFXVJ2HFU_js = require('./chunk-FXVJ2HFU.js');
+var chunkJ2U6PJSO_js = require('./chunk-J2U6PJSO.js');
+var chunk2O2CG465_js = require('./chunk-2O2CG465.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/backends/engine/session-grant.ts
+var ENGINE_SESSION_AUDIENCE = { player: 1, ios: 2, android: 3, cli: 4 };
+var REFUSALS = ["missing", "malformed", "unknown_key", "forged", "expired", "not_yet_valid", "lifetime", "audience", "origin"], REFUSAL_TEXT = {
+  missing: "no engine session token was given before the engine started",
+  malformed: "the engine session token is malformed",
+  unknown_key: "the engine session token was signed by a key this engine does not trust",
+  forged: "the engine session token signature does not verify",
+  expired: "the engine session token has expired",
+  not_yet_valid: "the engine session token is not valid yet",
+  lifetime: "the engine session token lives longer than its audience allows",
+  audience: "the engine session token was issued for a different host",
+  origin: "the engine session token was issued for a different origin",
+  unknown: "the engine refused to start without a valid session"
+}, ACCEPTED = 0, ENFORCED = 1, BYTE_ALIGN = 1, PRESENT_EXPORT = "engine_session_present", STATUS_EXPORT = "engine_session_status", ENFORCED_EXPORT = "engine_session_enforced";
+function engineSessionRefusal(code) {
+  return REFUSALS[-code - 1] ?? "unknown";
+}
+var EngineSessionError = class extends chunk2V7IL4HC_js.GameError {
+  constructor(code) {
+    let refusal = engineSessionRefusal(code);
+    super("not_initialized", `the engine did not start: ${REFUSAL_TEXT[refusal]}`), this.name = "EngineSessionError", this.refusal = refusal;
+  }
+};
+function exported(symbols, name) {
+  let value = symbols[name];
+  return typeof value == "function" ? value : null;
+}
+function presentEngineSession(target, grant, nowMs = Date.now()) {
+  let present = exported(target.symbols, PRESENT_EXPORT);
+  if (present === null) return null;
+  let encoder = new TextEncoder(), token = encoder.encode(grant.token), origin = encoder.encode(grant.origin), tokenAt = token.length === 0 ? 0 : target.exports.engine_alloc(token.length, (1)), originAt = origin.length === 0 ? 0 : target.exports.engine_alloc(origin.length, (1));
+  try {
+    return tokenAt !== 0 && new Uint8Array(target.memory.buffer, tokenAt, token.length).set(token), originAt !== 0 && new Uint8Array(target.memory.buffer, originAt, origin.length).set(origin), present(tokenAt, token.length, ENGINE_SESSION_AUDIENCE[grant.audience], originAt, origin.length, nowMs);
+  } finally {
+    tokenAt !== 0 && target.exports.engine_free(tokenAt, token.length, (1)), originAt !== 0 && target.exports.engine_free(originAt, origin.length, (1));
+  }
+}
+function engineSessionFailure(symbols) {
+  let enforced = exported(symbols, ENFORCED_EXPORT), status = exported(symbols, STATUS_EXPORT);
+  if (enforced === null || status === null || enforced() !== (1)) return null;
+  let code = status();
+  return code === (0) ? null : new EngineSessionError(code);
+}
+function noteGuestRead(byteOffset, byteLength) {
+}
+
+// src/game/backends/engine/web-gpu.ts
+var NONE = 0, WHOLE = 4294967295, SURFACE_TEXTURE = 1, SURFACE_VIEW = 2, FIRST_ID = 3, MAX_COLOR_ATTACHMENTS = 8, MAX_SHADER_ERRORS = 64, MAX_SUBMIT = 8, LOAD_CLEAR = 1, STORE_KEEP = 1, MAP_READ = 1, MAP_MODE_READ = 1, MAP_MODE_WRITE = 2, TRANSIENT_ATTACHMENT = 32, OP_END = 1, OP_PIPELINE = 2, OP_BIND_GROUP = 3, OP_VERTEX = 4, OP_INDEX = 5, OP_DRAW = 6, OP_DRAW_INDEXED = 7, OP_DRAW_INDIRECT = 8, OP_DRAW_INDEXED_INDIRECT = 9, OP_VIEWPORT = 10, OP_SCISSOR = 11, OP_BLEND = 12, OP_STENCIL = 13, OP_DISPATCH = 14, OP_DISPATCH_INDIRECT = 15, OP_RENDER_PASS = 20, OP_COMPUTE_PASS = 21, OP_COPY_BUFFER = 22, OP_COPY_BUFFER_TO_TEXTURE = 23, OP_COPY_TEXTURE_TO_BUFFER = 24, OP_COPY_TEXTURE = 25, OP_CLEAR_BUFFER = 26, OP_RESOLVE_QUERY = 27, OP_TIMESTAMP = 28, BINDING_BUFFER = 1, BINDING_SAMPLER = 2, BINDING_TEXTURE = 3, BINDING_STORAGE_TEXTURE = 4, RESOURCE_BUFFER = 1, RESOURCE_SAMPLER = 2, RESOURCE_VIEW = 3, TEXTURE_FORMATS = [
+  void 0,
+  "r8unorm",
+  "r8snorm",
+  "r8uint",
+  "r8sint",
+  "r16uint",
+  "r16sint",
+  "r16float",
+  "rg8unorm",
+  "rg8snorm",
+  "rg8uint",
+  "rg8sint",
+  "r32uint",
+  "r32sint",
+  "r32float",
+  "rg16uint",
+  "rg16sint",
+  "rg16float",
+  "rgba8unorm",
+  "rgba8unorm-srgb",
+  "rgba8snorm",
+  "rgba8uint",
+  "rgba8sint",
+  "bgra8unorm",
+  "bgra8unorm-srgb",
+  "rgb9e5ufloat",
+  "rgb10a2uint",
+  "rgb10a2unorm",
+  "rg11b10ufloat",
+  "rg32uint",
+  "rg32sint",
+  "rg32float",
+  "rgba16uint",
+  "rgba16sint",
+  "rgba16float",
+  "rgba32uint",
+  "rgba32sint",
+  "rgba32float",
+  "stencil8",
+  "depth16unorm",
+  "depth24plus",
+  "depth24plus-stencil8",
+  "depth32float",
+  "depth32float-stencil8",
+  "bc7-rgba-unorm",
+  "bc7-rgba-unorm-srgb",
+  "etc2-rgba8unorm",
+  "etc2-rgba8unorm-srgb",
+  "astc-4x4-unorm",
+  "astc-4x4-unorm-srgb",
+  "bc1-rgba-unorm",
+  "bc1-rgba-unorm-srgb",
+  "bc3-rgba-unorm",
+  "bc3-rgba-unorm-srgb",
+  "bc4-r-unorm",
+  "bc5-rg-unorm",
+  "bc6h-rgb-ufloat",
+  "etc2-rgb8unorm",
+  "etc2-rgb8unorm-srgb"
+], VERTEX_FORMATS = [
+  void 0,
+  "uint8x2",
+  "uint8x4",
+  "sint8x2",
+  "sint8x4",
+  "unorm8x2",
+  "unorm8x4",
+  "snorm8x2",
+  "snorm8x4",
+  "uint16x2",
+  "uint16x4",
+  "sint16x2",
+  "sint16x4",
+  "unorm16x2",
+  "unorm16x4",
+  "snorm16x2",
+  "snorm16x4",
+  "float16x2",
+  "float16x4",
+  "float32",
+  "float32x2",
+  "float32x3",
+  "float32x4",
+  "uint32",
+  "uint32x2",
+  "uint32x3",
+  "uint32x4",
+  "sint32",
+  "sint32x2",
+  "sint32x3",
+  "sint32x4",
+  "unorm10-10-10-2",
+  "uint8",
+  "sint8",
+  "unorm8",
+  "snorm8",
+  "uint16",
+  "sint16",
+  "unorm16",
+  "snorm16",
+  "float16",
+  "unorm8x4-bgra"
+], COMPARE = [void 0, "never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"], STENCIL = ["keep", "keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"], BLEND_FACTORS = [
+  "zero",
+  "zero",
+  "one",
+  "src",
+  "one-minus-src",
+  "src-alpha",
+  "one-minus-src-alpha",
+  "dst",
+  "one-minus-dst",
+  "dst-alpha",
+  "one-minus-dst-alpha",
+  "src-alpha-saturated",
+  "constant",
+  "one-minus-constant",
+  "src1",
+  "one-minus-src1",
+  "src1-alpha",
+  "one-minus-src1-alpha"
+], BLEND_OPERATIONS = ["add", "add", "subtract", "reverse-subtract", "min", "max"], ADDRESS = ["clamp-to-edge", "clamp-to-edge", "repeat", "mirror-repeat"], FILTERS = ["nearest", "nearest", "linear"], MIPMAP_FILTERS = ["nearest", "nearest", "linear"], TOPOLOGY = ["triangle-list", "point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"], INDEX_FORMATS = [void 0, "uint16", "uint32"], FRONT_FACE = ["ccw", "ccw", "cw"], CULL = ["none", "none", "front", "back"], STEP = ["vertex", "vertex", "instance"], VIEW_DIMENSIONS = [void 0, "1d", "2d", "2d-array", "cube", "cube-array", "3d"], DIMENSIONS = ["2d", "1d", "2d", "3d"], ASPECTS = ["all", "all", "stencil-only", "depth-only"], SAMPLE_TYPES = ["float", "float", "unfilterable-float", "depth", "sint", "uint"], ACCESS = ["write-only", "write-only", "read-only", "read-write"], BUFFER_TYPES = ["uniform", "uniform", "storage", "read-only-storage"], SAMPLER_TYPES = ["filtering", "filtering", "non-filtering", "comparison"], ERROR_VALIDATION = 1, ERROR_OUT_OF_MEMORY = 2, ERROR_INTERNAL = 3, ERROR_FILTERS = ["validation", "validation", "out-of-memory", "internal"];
+function errorKind(error) {
+  let name = error.constructor.name;
+  return name === "GPUOutOfMemoryError" ? (2) : name === "GPUInternalError" ? (3) : (1);
+}
+function colorSlot() {
+  return { view: null, resolveTarget: void 0, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 }, depthSlice: void 0 };
+}
+function timestampSlot() {
+  return { querySet: null, beginningOfPassWriteIndex: void 0, endOfPassWriteIndex: void 0 };
+}
+function optional(word) {
+  return word === (4294967295) ? void 0 : word;
+}
+var WebGpuExecutor = class {
+  constructor() {
+    this.shaderErrors = [];
+    this.memory = null;
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.signed = new Int32Array(0);
+    this.bytes = new Uint8Array(0);
+    this.target = null;
+    this.callbacks = null;
+    this.objects = [null, null, null];
+    this.free = [];
+    this.released = [];
+    this.pipelines = [];
+    this.submits = [];
+    this.renderPasses = [];
+    this.depth = {
+      view: null,
+      depthLoadOp: void 0,
+      depthStoreOp: void 0,
+      depthClearValue: 0,
+      depthReadOnly: false,
+      stencilLoadOp: void 0,
+      stencilStoreOp: void 0,
+      stencilClearValue: 0,
+      stencilReadOnly: false
+    };
+    this.renderTimestamps = timestampSlot();
+    this.computeTimestamps = timestampSlot();
+    this.computePass = { timestampWrites: void 0 };
+    this.origin = { x: 0, y: 0, z: 0 };
+    this.origin2 = { x: 0, y: 0, z: 0 };
+    this.extent = { width: 0, height: 0, depthOrArrayLayers: 0 };
+    this.textureCopy = { texture: null, mipLevel: 0, origin: this.origin, aspect: "all" };
+    this.textureCopy2 = { texture: null, mipLevel: 0, origin: this.origin2, aspect: "all" };
+    this.bufferCopy = { buffer: null, offset: 0, bytesPerRow: void 0, rowsPerImage: void 0 };
+    this.pending = 0;
+    this.releasedCount = 0;
+    this.cursor = 0;
+    this.submissions = 0;
+    this.transient = true;
+    this.decoder = new TextDecoder();
+    this.encoder = new TextEncoder();
+    this.scopes = 0;
+    this.onUncaptured = (event) => {
+      let error = event.error;
+      this.report(errorKind(error), error.message);
+    };
+    this.externalSource = { source: null, flipY: false };
+    this.externalTarget = { texture: null, mipLevel: 0, origin: this.origin, colorSpace: "srgb", premultipliedAlpha: false };
+    this.externalSize = { width: 0, height: 0, depthOrArrayLayers: 1 };
+    this.blend = { r: 0, g: 0, b: 0, a: 0 };
+    this.pendingBuffers = new Array((8)).fill(null);
+    for (let count = 0; count <= (8); count++) {
+      let colors = [];
+      for (let i = 0; i < count; i++) colors.push(colorSlot());
+      this.renderPasses.push({ colorAttachments: colors, depthStencilAttachment: void 0, timestampWrites: void 0 });
+    }
+    for (let count = 0; count <= (8); count++) {
+      let list = [];
+      for (let i = 0; i < count; i++) list.push(null);
+      this.submits.push(list);
+    }
+    this.imports = {
+      gpu_shader: (code, len) => this.shader(code, len),
+      gpu_bind_group_layout: (desc, len) => (this.bindGroupLayout(desc, len)),
+      gpu_pipeline_layout: (desc, len) => (this.pipelineLayout(desc, len)),
+      gpu_bind_group: (desc, len) => (this.bindGroup(desc, len)),
+      gpu_render_pipeline: (desc, len) => (this.renderPipeline(desc, len)),
+      gpu_compute_pipeline: (desc, len) => (this.computePipeline(desc, len)),
+      gpu_pipeline_group_layout: (pipeline, index) => this.groupLayout(pipeline, index),
+      gpu_buffer: (size, usage, mapped) => this.buffer(size, usage, mapped),
+      gpu_texture: (desc, len) => (this.texture(desc, len)),
+      gpu_view: (texture, desc, len) => (this.view(texture, desc, len)),
+      gpu_sampler: (desc, len) => (this.sampler(desc, len)),
+      gpu_query_set: (kind, count) => this.querySet(kind, count),
+      gpu_release: (id) => this.release(id),
+      gpu_destroy: (id) => this.destroy(id),
+      gpu_write_buffer: (buffer, offset, data, len) => this.writeBuffer(buffer, offset, data, len),
+      gpu_write_texture: (desc, len, data, dataLen) => (this.writeTexture(desc, len, data, dataLen)),
+      gpu_execute: (stream, len) => (this.execute(stream, len)),
+      gpu_submit: () => this.submit(),
+      gpu_configure: (desc, len) => (this.configure(desc, len)),
+      gpu_current_texture: () => this.currentTexture(),
+      gpu_map: (buffer, mode, offset, size, token) => this.map(buffer, mode, offset, size, token),
+      gpu_read_mapped: (buffer, offset, size, out) => this.readMapped(buffer, offset, size, out),
+      gpu_write_mapped: (buffer, offset, size, data) => (this.writeMapped(buffer, offset, size, data)),
+      gpu_unmap: (buffer) => this.unmap(buffer),
+      gpu_push_error_scope: (filter) => this.pushErrorScope(filter),
+      gpu_pop_error_scope: () => this.popErrorScope()
+    };
+  }
+  report(kind, message) {
+    let callbacks = this.callbacks;
+    if (callbacks === null) return;
+    let text = this.encoder.encode(message), at = callbacks.errorBuffer(text.byteLength);
+    this.refresh(), this.bytes.set(text, at), callbacks.error(kind, text.byteLength);
+  }
+  pushErrorScope(filter) {
+    return this.device.pushErrorScope(ERROR_FILTERS[filter] ?? "validation"), this.scopes++;
+  }
+  popErrorScope() {
+    this.scopes--, this.device.popErrorScope().then(
+      (error) => {
+        error !== null && this.report(errorKind(error), error.message);
+      },
+      () => {
+      }
+    );
+  }
+  bindMemory(memory, callbacks) {
+    this.memory = memory, this.callbacks = callbacks, this.refresh();
+  }
+  bindTarget(target) {
+    this.target?.device !== target.device && (this.target?.device.removeEventListener("uncapturederror", this.onUncaptured), target.device.addEventListener("uncapturederror", this.onUncaptured)), this.target = target;
+    let usage = globalThis.GPUTextureUsage;
+    this.transient = usage?.TRANSIENT_ATTACHMENT === (32);
+  }
+  unbind() {
+    this.target?.device.removeEventListener("uncapturederror", this.onUncaptured), this.target = null;
+  }
+  refresh() {
+    let buffer = this.memory.buffer;
+    this.words.buffer !== buffer && (this.words = new Uint32Array(buffer), this.floats = new Float32Array(buffer), this.signed = new Int32Array(buffer), this.bytes = new Uint8Array(buffer));
+  }
+  get device() {
+    if (this.target === null) throw new Error("the engine drew before its WebGPU surface was attached");
+    return this.target.device;
+  }
+  copyExternalImage(handle, source, width, height) {
+    let object = this.objects[handle];
+    if (this.target === null || object === null || object === void 0 || !("createView" in object)) return false;
+    let texture = object;
+    return this.origin.x = 0, this.origin.y = 0, this.origin.z = 0, this.externalSource.source = source, this.externalTarget.texture = texture, this.externalSize.width = Math.min(width, texture.width), this.externalSize.height = Math.min(height, texture.height), this.device.queue.copyExternalImageToTexture(this.externalSource, this.externalTarget, this.externalSize), this.externalSource.source = null, true;
+  }
+  store(object) {
+    let id = this.free.pop();
+    return id !== void 0 ? (this.objects[id] = object, id) : (this.objects.push(object), this.objects.length - 1);
+  }
+  text(ptr, len) {
+    return this.decoder.decode(this.bytes.subarray(ptr, ptr + len));
+  }
+  entry(at) {
+    let ptr = this.words[at];
+    return ptr === (0) ? void 0 : this.text(ptr, this.words[at + 1]);
+  }
+  constants(at, out) {
+    let w = this.words, count = w[at++];
+    if (count === 0) return at;
+    let constants = {};
+    for (let i = 0; i < count; i++)
+      constants[this.text(w[at], w[at + 1])] = this.floats[at + 2], at += 3;
+    return out.constants = constants, at;
+  }
+  shader(code, len) {
+    this.refresh();
+    let module = this.device.createShaderModule({ code: this.text(code, len) });
+    return typeof module.getCompilationInfo == "function" && module.getCompilationInfo().then((info) => {
+      for (let message of info.messages)
+        message.type !== "error" || this.shaderErrors.length >= (64) || this.shaderErrors.push(`${message.lineNum}:${message.linePos} ${message.message}`);
+    }), this.store(module);
+  }
+  bindGroupLayout(desc, _len) {
+    this.refresh();
+    let w = this.words, at = desc >>> 2, count = w[at++], entries = [];
+    for (let i = 0; i < count; i++) {
+      let binding = w[at], visibility = w[at + 1], kind = w[at + 2], a = w[at + 3], b = w[at + 4], c = w[at + 5];
+      at += 6, kind === (1) ? entries.push({ binding, visibility, buffer: { type: BUFFER_TYPES[a], hasDynamicOffset: b !== 0, minBindingSize: c } }) : kind === (2) ? entries.push({ binding, visibility, sampler: { type: SAMPLER_TYPES[a] } }) : kind === (3) ? entries.push({ binding, visibility, texture: { sampleType: SAMPLE_TYPES[a], viewDimension: VIEW_DIMENSIONS[b], multisampled: c !== 0 } }) : kind === (4) && entries.push({ binding, visibility, storageTexture: { access: ACCESS[a], format: TEXTURE_FORMATS[b], viewDimension: VIEW_DIMENSIONS[c] } });
+    }
+    return this.store(this.device.createBindGroupLayout({ entries }));
+  }
+  pipelineLayout(desc, _len) {
+    this.refresh();
+    let w = this.words, at = desc >>> 2, count = w[at++], bindGroupLayouts = [];
+    for (let i = 0; i < count; i++) bindGroupLayouts.push(this.objects[w[at + i]]);
+    return this.store(this.device.createPipelineLayout({ bindGroupLayouts }));
+  }
+  bindGroup(desc, _len) {
+    this.refresh();
+    let w = this.words, at = desc >>> 2, layout = this.objects[w[at++]], count = w[at++], entries = [];
+    for (let i = 0; i < count; i++) {
+      let binding = w[at], kind = w[at + 1], id = w[at + 2], offset = w[at + 3], size = w[at + 4];
+      at += 5, kind === (1) ? entries.push({ binding, resource: { buffer: this.objects[id], offset, size: optional(size) } }) : kind === (2) ? entries.push({ binding, resource: this.objects[id] }) : kind === (3) && entries.push({ binding, resource: this.objects[id] });
+    }
+    return this.store(this.device.createBindGroup({ layout, entries }));
+  }
+  layout(id) {
+    return id === (0) ? "auto" : this.objects[id];
+  }
+  renderDescriptor(desc) {
+    let w = this.words, f = this.floats, label = this.entry(desc >>> 2), at = (desc >>> 2) + 2, layout = this.layout(w[at++]), vertex = { module: this.objects[w[at++]], entryPoint: this.entry(at), buffers: [] };
+    at = this.constants(at + 2, vertex);
+    let bufferCount = w[at++], buffers = [];
+    for (let i = 0; i < bufferCount; i++) {
+      let arrayStride = w[at];
+      if (arrayStride === (4294967295)) {
+        buffers.push(null), at += 1;
+        continue;
+      }
+      let stepMode = STEP[w[at + 1]], attributeCount = w[at + 2];
+      at += 3;
+      let attributes = [];
+      for (let j = 0; j < attributeCount; j++)
+        attributes.push({ format: VERTEX_FORMATS[w[at]], offset: w[at + 1], shaderLocation: w[at + 2] }), at += 3;
+      buffers.push({ arrayStride, stepMode, attributes });
+    }
+    vertex.buffers = buffers;
+    let stripIndexFormat = INDEX_FORMATS[w[at + 1]], primitive = { topology: TOPOLOGY[w[at]], frontFace: FRONT_FACE[w[at + 2]], cullMode: CULL[w[at + 3]], unclippedDepth: w[at + 4] !== 0 };
+    stripIndexFormat !== void 0 && (primitive.stripIndexFormat = stripIndexFormat), at += 5;
+    let descriptor = { layout, vertex, primitive };
+    label !== void 0 && (descriptor.label = label);
+    let depthFormat = w[at++];
+    if (depthFormat !== (0)) {
+      let write = w[at], compare = COMPARE[w[at + 1]];
+      at += 2;
+      let face = () => {
+        let state = { compare: COMPARE[w[at]], failOp: STENCIL[w[at + 1]], depthFailOp: STENCIL[w[at + 2]], passOp: STENCIL[w[at + 3]] };
+        return at += 4, state;
+      }, stencilFront = face(), stencilBack = face(), depthStencil = {
+        format: TEXTURE_FORMATS[depthFormat],
+        stencilFront,
+        stencilBack,
+        stencilReadMask: w[at],
+        stencilWriteMask: w[at + 1],
+        depthBias: this.signed[at + 2],
+        depthBiasSlopeScale: f[at + 3],
+        depthBiasClamp: f[at + 4]
+      };
+      write !== (0) && (depthStencil.depthWriteEnabled = write === 2), compare !== void 0 && (depthStencil.depthCompare = compare), at += 5, descriptor.depthStencil = depthStencil;
+    }
+    descriptor.multisample = { count: w[at], mask: w[at + 1], alphaToCoverageEnabled: w[at + 2] !== 0 }, at += 3;
+    let fragmentModule = w[at++];
+    if (fragmentModule !== (0)) {
+      let fragment = { module: this.objects[fragmentModule], entryPoint: this.entry(at), targets: [] };
+      at = this.constants(at + 2, fragment);
+      let targetCount = w[at++], targets = [];
+      for (let i = 0; i < targetCount; i++) {
+        let format = w[at++];
+        if (format === (0)) {
+          targets.push(null);
+          continue;
+        }
+        let target = { format: TEXTURE_FORMATS[format] };
+        w[at++] !== (0) && (target.blend = {
+          color: { srcFactor: BLEND_FACTORS[w[at]], dstFactor: BLEND_FACTORS[w[at + 1]], operation: BLEND_OPERATIONS[w[at + 2]] },
+          alpha: { srcFactor: BLEND_FACTORS[w[at + 3]], dstFactor: BLEND_FACTORS[w[at + 4]], operation: BLEND_OPERATIONS[w[at + 5]] }
+        }, at += 6), target.writeMask = w[at++], targets.push(target);
+      }
+      fragment.targets = targets, descriptor.fragment = fragment;
+    }
+    return descriptor;
+  }
+  track(id, descriptor, compiled) {
+    compiled.then(
+      (pipeline) => {
+        this.objects[id] !== null || this.pipelines[id] !== descriptor || (this.objects[id] = pipeline, this.pipelines[id] = void 0);
+      },
+      (error) => this.report((1), `${descriptor.label ?? "pipeline"}: ${error.message}`)
+    );
+  }
+  renderPipeline(desc, _len) {
+    this.refresh();
+    let descriptor = this.renderDescriptor(desc), id = this.store(null);
+    return this.pipelines[id] = descriptor, this.track(id, descriptor, this.device.createRenderPipelineAsync(descriptor)), id;
+  }
+  computePipeline(desc, _len) {
+    this.refresh();
+    let w = this.words, label = this.entry(desc >>> 2), at = (desc >>> 2) + 2, compute = { module: this.objects[w[at + 1]], entryPoint: this.entry(at + 2) };
+    this.constants(at + 4, compute);
+    let descriptor = { layout: this.layout(w[at]), compute };
+    label !== void 0 && (descriptor.label = label);
+    let id = this.store(null);
+    return this.pipelines[id] = descriptor, this.track(id, descriptor, this.device.createComputePipelineAsync(descriptor)), id;
+  }
+  force(id) {
+    let descriptor = this.pipelines[id];
+    if (descriptor === void 0) throw new Error(`engine pipeline ${id} does not exist`);
+    this.pipelines[id] = void 0;
+    let pipeline = "vertex" in descriptor ? this.device.createRenderPipeline(descriptor) : this.device.createComputePipeline(descriptor);
+    return this.objects[id] = pipeline, pipeline;
+  }
+  pipeline(id) {
+    let object = this.objects[id];
+    return object === null ? this.force(id) : object;
+  }
+  groupLayout(pipeline, index) {
+    return this.store(this.pipeline(pipeline).getBindGroupLayout(index));
+  }
+  buffer(size, usage, mapped) {
+    return this.store(this.device.createBuffer({ size, usage, mappedAtCreation: mapped !== 0 }));
+  }
+  texture(desc, _len) {
+    this.refresh();
+    let w = this.words, at = desc >>> 2, viewFormats = [];
+    for (let i = 0; i < w[at + 8]; i++) viewFormats.push(TEXTURE_FORMATS[w[at + 9 + i]]);
+    let usage = this.transient ? w[at + 7] : w[at + 7] & ~(32);
+    return this.store(
+      this.device.createTexture({
+        size: { width: w[at], height: w[at + 1], depthOrArrayLayers: w[at + 2] },
+        mipLevelCount: w[at + 3],
+        sampleCount: w[at + 4],
+        dimension: DIMENSIONS[w[at + 5]],
+        format: TEXTURE_FORMATS[w[at + 6]],
+        usage,
+        viewFormats
+      })
+    );
+  }
+  view(texture, desc, _len) {
+    this.refresh();
+    let w = this.words, at = desc >>> 2, descriptor = { aspect: ASPECTS[w[at + 2]], baseMipLevel: w[at + 3], baseArrayLayer: w[at + 5] }, format = TEXTURE_FORMATS[w[at]], dimension = VIEW_DIMENSIONS[w[at + 1]];
+    return format !== void 0 && (descriptor.format = format), dimension !== void 0 && (descriptor.dimension = dimension), w[at + 4] !== (4294967295) && (descriptor.mipLevelCount = w[at + 4]), w[at + 6] !== (4294967295) && (descriptor.arrayLayerCount = w[at + 6]), this.store(this.objects[texture].createView(descriptor));
+  }
+  sampler(desc, _len) {
+    this.refresh();
+    let w = this.words, at = desc >>> 2, descriptor = {
+      addressModeU: ADDRESS[w[at]],
+      addressModeV: ADDRESS[w[at + 1]],
+      addressModeW: ADDRESS[w[at + 2]],
+      magFilter: FILTERS[w[at + 3]],
+      minFilter: FILTERS[w[at + 4]],
+      mipmapFilter: MIPMAP_FILTERS[w[at + 5]],
+      lodMinClamp: this.floats[at + 6],
+      lodMaxClamp: this.floats[at + 7],
+      maxAnisotropy: Math.max(1, w[at + 9])
+    }, compare = COMPARE[w[at + 8]];
+    return compare !== void 0 && (descriptor.compare = compare), this.store(this.device.createSampler(descriptor));
+  }
+  querySet(kind, count) {
+    return this.store(this.device.createQuerySet({ type: kind === 1 ? "occlusion" : "timestamp", count }));
+  }
+  release(id) {
+    id < (3) || (this.releasedCount === this.released.length ? this.released.push(id) : this.released[this.releasedCount] = id, this.releasedCount++);
+  }
+  destroy(id) {
+    this.objects[id]?.destroy?.();
+  }
+  writeBuffer(buffer, offset, data, len) {
+    this.refresh(), this.device.queue.writeBuffer(this.objects[buffer], offset, this.words.buffer, data, len);
+  }
+  writeTexture(desc, _len, data, dataLen) {
+    this.refresh();
+    let w = this.words, at = desc >>> 2, bytesPerRow = optional(w[at + 7]), rowsPerImage = optional(w[at + 8]);
+    this.device.queue.writeTexture(
+      { texture: this.objects[w[at]], mipLevel: w[at + 1], origin: { x: w[at + 2], y: w[at + 3], z: w[at + 4] }, aspect: ASPECTS[w[at + 5]] },
+      this.bytes.subarray(data, data + dataLen),
+      { offset: w[at + 6], bytesPerRow, rowsPerImage },
+      { width: w[at + 9], height: w[at + 10], depthOrArrayLayers: w[at + 11] }
+    );
+  }
+  configure(desc, _len) {
+    this.refresh();
+    let target = this.target;
+    if (target === null) return;
+    let w = this.words, at = desc >>> 2, viewFormats = [];
+    for (let i = 0; i < w[at + 5]; i++) viewFormats.push(TEXTURE_FORMATS[w[at + 6 + i]]);
+    target.canvas.width = w[at + 2], target.canvas.height = w[at + 3], target.context.configure({
+      device: target.device,
+      format: TEXTURE_FORMATS[w[at]],
+      usage: w[at + 1],
+      alphaMode: w[at + 4] !== 0 ? "premultiplied" : "opaque",
+      viewFormats
+    });
+  }
+  currentTexture() {
+    let target = this.target;
+    if (target === null) return 0;
+    let texture = target.context.getCurrentTexture();
+    return this.objects[(1)] = texture, this.objects[(2)] = texture, 1;
+  }
+  map(buffer, mode, offset, size, token) {
+    let callbacks = this.callbacks;
+    this.objects[buffer].mapAsync(mode === (1) ? (1) : (2), offset, size).then(
+      () => callbacks.mapped(token, 1),
+      () => callbacks.mapped(token, 0)
+    );
+  }
+  readMapped(buffer, offset, size, out) {
+    this.refresh(), this.bytes.set(new Uint8Array(this.objects[buffer].getMappedRange(offset, size)), out);
+  }
+  writeMapped(buffer, offset, size, data) {
+    this.refresh(), new Uint8Array(this.objects[buffer].getMappedRange(offset, size)).set(this.bytes.subarray(data, data + size));
+  }
+  unmap(buffer) {
+    let object = this.objects[buffer];
+    object.mapState !== "unmapped" && object.unmap();
+  }
+  timestamps(slot, at) {
+    let w = this.words;
+    if (w[at] !== (0))
+      return slot.querySet = this.objects[w[at]], slot.beginningOfPassWriteIndex = optional(w[at + 1]), slot.endOfPassWriteIndex = optional(w[at + 2]), slot;
+  }
+  beginRender(encoder, at) {
+    let w = this.words, f = this.floats, objects = this.objects, count = w[at++], slot = this.renderPasses[count], colors = slot.colorAttachments;
+    for (let i = 0; i < count; i++) {
+      let view = w[at];
+      if (view === (0)) {
+        colors[i] = null, at += 1;
+        continue;
+      }
+      let color = colors[i] ?? (colors[i] = colorSlot());
+      color.view = objects[view];
+      let resolve = w[at + 1];
+      color.resolveTarget = resolve === (0) ? void 0 : objects[resolve], color.loadOp = w[at + 2] === (1) ? "clear" : "load", color.storeOp = w[at + 3] === (1) ? "store" : "discard";
+      let clear = color.clearValue;
+      clear.r = f[at + 4], clear.g = f[at + 5], clear.b = f[at + 6], clear.a = f[at + 7], color.depthSlice = optional(w[at + 8]), at += 9;
+    }
+    let depthView = w[at++];
+    if (depthView === (0)) slot.depthStencilAttachment = void 0;
+    else {
+      let depth = this.depth;
+      depth.view = objects[depthView];
+      let depthLoad = w[at];
+      depth.depthLoadOp = depthLoad === (0) ? void 0 : depthLoad === (1) ? "clear" : "load", depth.depthStoreOp = depthLoad === (0) ? void 0 : w[at + 1] === (1) ? "store" : "discard", depth.depthReadOnly = depthLoad === (0), depth.depthClearValue = f[at + 2];
+      let stencilLoad = w[at + 3];
+      depth.stencilLoadOp = stencilLoad === (0) ? void 0 : stencilLoad === (1) ? "clear" : "load", depth.stencilStoreOp = stencilLoad === (0) ? void 0 : w[at + 4] === (1) ? "store" : "discard", depth.stencilClearValue = w[at + 5], at += 6, slot.depthStencilAttachment = depth;
+    }
+    return slot.timestampWrites = this.timestamps(this.renderTimestamps, at), this.cursor = at + 3, encoder.beginRenderPass(slot);
+  }
+  runRender(pass, at) {
+    let w = this.words, f = this.floats, objects = this.objects;
+    for (; ; ) {
+      let op = w[at++];
+      switch (op) {
+        case (1):
+          return pass.end(), at;
+        case (2):
+          pass.setPipeline(this.pipeline(w[at])), at += 1;
+          break;
+        case (3): {
+          let count = w[at + 2];
+          count === 0 ? pass.setBindGroup(w[at], objects[w[at + 1]]) : pass.setBindGroup(w[at], objects[w[at + 1]], w, at + 3, count), at += 3 + count;
+          break;
+        }
+        case (4): {
+          let size = w[at + 3];
+          size === (4294967295) ? pass.setVertexBuffer(w[at], objects[w[at + 1]], w[at + 2]) : pass.setVertexBuffer(w[at], objects[w[at + 1]], w[at + 2], size), at += 4;
+          break;
+        }
+        case (5): {
+          let size = w[at + 3], format = INDEX_FORMATS[w[at + 1]];
+          size === (4294967295) ? pass.setIndexBuffer(objects[w[at]], format, w[at + 2]) : pass.setIndexBuffer(objects[w[at]], format, w[at + 2], size), at += 4;
+          break;
+        }
+        case (6):
+          pass.draw(w[at], w[at + 1], w[at + 2], w[at + 3]), at += 4;
+          break;
+        case (7):
+          pass.drawIndexed(w[at], w[at + 1], w[at + 2], this.signed[at + 3], w[at + 4]), at += 5;
+          break;
+        case (8):
+          pass.drawIndirect(objects[w[at]], w[at + 1]), at += 2;
+          break;
+        case (9):
+          pass.drawIndexedIndirect(objects[w[at]], w[at + 1]), at += 2;
+          break;
+        case (10):
+          pass.setViewport(f[at], f[at + 1], f[at + 2], f[at + 3], f[at + 4], f[at + 5]), at += 6;
+          break;
+        case (11):
+          pass.setScissorRect(w[at], w[at + 1], w[at + 2], w[at + 3]), at += 4;
+          break;
+        case (12):
+          this.blend.r = f[at], this.blend.g = f[at + 1], this.blend.b = f[at + 2], this.blend.a = f[at + 3], pass.setBlendConstant(this.blend), at += 4;
+          break;
+        case (13):
+          pass.setStencilReference(w[at]), at += 1;
+          break;
+        default:
+          throw new Error(`engine render pass op ${op} is unknown`);
+      }
+    }
+  }
+  runCompute(pass, at) {
+    let w = this.words, objects = this.objects;
+    for (; ; ) {
+      let op = w[at++];
+      switch (op) {
+        case (1):
+          return pass.end(), at;
+        case (2):
+          pass.setPipeline(this.pipeline(w[at])), at += 1;
+          break;
+        case (3): {
+          let count = w[at + 2];
+          count === 0 ? pass.setBindGroup(w[at], objects[w[at + 1]]) : pass.setBindGroup(w[at], objects[w[at + 1]], w, at + 3, count), at += 3 + count;
+          break;
+        }
+        case (14):
+          pass.dispatchWorkgroups(w[at], w[at + 1], w[at + 2]), at += 3;
+          break;
+        case (15):
+          pass.dispatchWorkgroupsIndirect(objects[w[at]], w[at + 1]), at += 2;
+          break;
+        default:
+          throw new Error(`engine compute pass op ${op} is unknown`);
+      }
+    }
+  }
+  texelTexture(slot, at) {
+    let w = this.words;
+    return slot.texture = this.objects[w[at]], slot.mipLevel = w[at + 1], slot.origin.x = w[at + 2], slot.origin.y = w[at + 3], slot.origin.z = w[at + 4], slot.aspect = ASPECTS[w[at + 5]], at + 6;
+  }
+  texelBuffer(at) {
+    let w = this.words, slot = this.bufferCopy;
+    return slot.buffer = this.objects[w[at]], slot.offset = w[at + 1], slot.bytesPerRow = optional(w[at + 2]), slot.rowsPerImage = optional(w[at + 3]), at + 4;
+  }
+  texelExtent(at) {
+    let w = this.words;
+    return this.extent.width = w[at], this.extent.height = w[at + 1], this.extent.depthOrArrayLayers = w[at + 2], at + 3;
+  }
+  execute(stream, len) {
+    this.refresh();
+    let w = this.words, objects = this.objects, encoder = this.device.createCommandEncoder(), at = stream >>> 2, end = at + len;
+    for (; at < end; ) {
+      let op = w[at++];
+      switch (op) {
+        case (20): {
+          let pass = this.beginRender(encoder, at);
+          at = this.runRender(pass, this.cursor);
+          break;
+        }
+        case (21): {
+          this.computePass.timestampWrites = this.timestamps(this.computeTimestamps, at), at = this.runCompute(encoder.beginComputePass(this.computePass), at + 3);
+          break;
+        }
+        case (22): {
+          let size = w[at + 4], source = objects[w[at]], target = objects[w[at + 2]];
+          size === (4294967295) ? encoder.copyBufferToBuffer(source, w[at + 1], target, w[at + 3]) : encoder.copyBufferToBuffer(source, w[at + 1], target, w[at + 3], size), at += 5;
+          break;
+        }
+        case (23):
+          at = this.texelExtent(this.texelTexture(this.textureCopy, this.texelBuffer(at))), encoder.copyBufferToTexture(this.bufferCopy, this.textureCopy, this.extent);
+          break;
+        case (24):
+          at = this.texelExtent(this.texelBuffer(this.texelTexture(this.textureCopy, at))), encoder.copyTextureToBuffer(this.textureCopy, this.bufferCopy, this.extent);
+          break;
+        case (25):
+          at = this.texelExtent(this.texelTexture(this.textureCopy2, this.texelTexture(this.textureCopy, at))), encoder.copyTextureToTexture(this.textureCopy, this.textureCopy2, this.extent);
+          break;
+        case (26): {
+          let size = w[at + 2];
+          size === (4294967295) ? encoder.clearBuffer(objects[w[at]], w[at + 1]) : encoder.clearBuffer(objects[w[at]], w[at + 1], size), at += 3;
+          break;
+        }
+        case (27):
+          encoder.resolveQuerySet(objects[w[at]], w[at + 1], w[at + 2], objects[w[at + 3]], w[at + 4]), at += 5;
+          break;
+        case (28):
+          at += 2;
+          break;
+        default:
+          throw new Error(`engine command op ${op} is unknown`);
+      }
+    }
+    if (this.pending === (8)) throw new Error("the engine submitted too many command buffers in one batch");
+    this.pendingBuffers[this.pending++] = encoder.finish();
+  }
+  submit() {
+    let count = this.pending;
+    if (count > 0) {
+      let list = this.submits[count], buffers = this.pendingBuffers;
+      for (let i = 0; i < count; i++)
+        list[i] = buffers[i], buffers[i] = null;
+      this.device.queue.submit(list);
+      for (let i = 0; i < count; i++) list[i] = null;
+      this.pending = 0;
+    }
+    let released = this.released;
+    for (let i = 0; i < this.releasedCount; i++) {
+      let id = released[i];
+      this.objects[id] = null, this.pipelines[id] = void 0, this.free.push(id);
+    }
+    return this.releasedCount = 0, ++this.submissions;
+  }
+};
+
+// src/game/backends/engine/web-gl2.ts
+var OP_PROGRAM = 1, OP_TEXTURE = 2, OP_UPLOAD = 3, OP_DELETE_TEXTURE = 4, OP_TARGET = 5, OP_CLEAR = 6, OP_BLEND2 = 7, OP_USE = 8, OP_BIND_TEXTURE = 9, OP_UNIFORMS = 10, OP_DRAW2 = 11, OP_COPY = 12, OP_READ = 13, OP_MIPMAPS = 14, OP_BUFFER = 15, OP_BUFFER_WRITE = 16, OP_DELETE_BUFFER = 17, OP_SAMPLER = 18, OP_DELETE_SAMPLER = 19, OP_DELETE_PROGRAM = 20, OP_PASS = 21, OP_STATE = 22, OP_ATTRIBUTE = 23, OP_INDEX2 = 24, OP_DRAW_INDEXED2 = 25, OP_VIEWPORT2 = 26, OP_SCISSOR2 = 27, OP_STENCIL_REFERENCE = 28, OP_BLEND_COLOR = 29, OP_BIND_UNIFORM = 30, OP_BIND_SAMPLER = 31, OP_END_PASS = 32;
+var BUFFER_INDEX = 1, BUFFER_UNIFORM = 2, DRAW_POINTS = 2, DRAW_LINES = 3, DRAW_LINE_STRIP = 4, LOAD_CLEAR2 = 0, INDEX_U16 = 1, MAX_ATTRIBUTES = 16, MAX_COLORS = 8, STATE_WORDS = 27, ATTRIBUTE_WORDS = 9, PASS_COLOR_WORDS = 6, PASS_DEPTH_WORDS = 6, FILTER_LINEAR = 1, WRAP_REPEAT = 0, WRAP_MIRROR = 1, COMPARE_NONE = 0, CULL_FRONT = 1, CULL_BACK = 2, MASK_RED = 1, MASK_GREEN = 2, MASK_BLUE = 4, MASK_ALPHA = 8, FILTER_NEAREST = 0, FILTER_MIPMAP = 2, UPLOAD_FLIP = 1, TARGET_CANVAS = 0, BLEND_PREMULTIPLIED = 1, DRAW_STRIP = 1, NO_TEXTURE = 0, FLOAT_UNITS = 15, SCRATCH_UNIT = 16, WORD_BYTES = 4, HALF_BYTES = 2, RGBA_BYTES = 4, MAX_TEXEL_BYTES = 16, FIRST_INSTANCE_UNIFORM = "naga_vs_first_instance", COLOR_BUFFER_FLOAT = "EXT_color_buffer_float", COLOR_BUFFER_HALF_FLOAT = "EXT_color_buffer_half_float", PARALLEL_COMPILE = "KHR_parallel_shader_compile", MAX_ERRORS = 16, GL_IMPORTS = "cimplify_gl", GL_ATTACH_EXPORT = "engine_render_attach_webgl", VERSION_LINE_END = `
+`;
+function salted(source, salt) {
+  if (salt.length === 0) return source;
+  let end = source.indexOf(VERSION_LINE_END);
+  return source.slice(0, end + 1) + salt + source.slice(end + 1);
+}
+var WebGl2Executor = class {
+  constructor() {
+    this.errors = [];
+    this.gl = null;
+    this.memory = null;
+    this.buffer = null;
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.bytes = new Uint8Array(0);
+    this.halves = new Uint16Array(0);
+    this.singles = new Float32Array(0);
+    this.programs = [];
+    this.textures = [];
+    this.blocks = [];
+    this.blockSizes = [];
+    this.formats = [];
+    this.current = null;
+    this.targetHeight = 0;
+    this.readsCanvas = true;
+    this.lastOp = 0;
+    this.checked = false;
+    this.salt = null;
+    this.compileMs = [];
+    this.fallback = null;
+    this.sampler = null;
+    this.row = new Uint8Array(0);
+    this.decoder = new TextDecoder();
+    this.signed = new Int8Array(0);
+    this.blendFactors = [];
+    this.blendOps = [];
+    this.compares = [];
+    this.stencilOps = [];
+    this.attributeTypes = [];
+    this.vertexArray = null;
+    this.buffers = [];
+    this.samplers = [];
+    this.passes = [];
+    this.drawBuffers = [];
+    this.clearColor = new Float32Array(4);
+    this.clearDepth = new Float32Array(1);
+    this.clearStencil = new Int32Array(1);
+    this.indexType = 0;
+    this.stencilFront = [0, 0, 255];
+    this.stencilBack = [0, 0, 255];
+    this.stencilReference = 0;
+    this.enabledAttributes = 0;
+    this.imports = { gl_execute: (words, len) => this.execute(words, len) };
+  }
+  bindMemory(memory) {
+    this.memory = memory, this.buffer = null;
+  }
+  bindContext(gl) {
+    if (gl.getExtension(PARALLEL_COMPILE), !(gl.getExtension(COLOR_BUFFER_FLOAT) !== null || gl.getExtension(COLOR_BUFFER_HALF_FLOAT) !== null)) return false;
+    this.gl = gl, this.formats = [
+      { internal: 0, format: 0, type: 0, bytes: 0 },
+      { internal: gl.RGBA8, format: gl.RGBA, type: gl.UNSIGNED_BYTE, bytes: (4) },
+      { internal: gl.SRGB8_ALPHA8, format: gl.RGBA, type: gl.UNSIGNED_BYTE, bytes: (4) },
+      { internal: gl.RGBA16F, format: gl.RGBA, type: gl.HALF_FLOAT, bytes: (4) * (2) },
+      { internal: gl.RGBA32UI, format: gl.RGBA_INTEGER, type: gl.UNSIGNED_INT, bytes: (4) * (4) },
+      { internal: gl.R8, format: gl.RED, type: gl.UNSIGNED_BYTE, bytes: 1 },
+      { internal: gl.RG8, format: gl.RG, type: gl.UNSIGNED_BYTE, bytes: 2 },
+      { internal: gl.R16F, format: gl.RED, type: gl.HALF_FLOAT, bytes: (2) },
+      { internal: gl.RGBA32F, format: gl.RGBA, type: gl.FLOAT, bytes: (4) * (4) },
+      { internal: gl.RG16F, format: gl.RG, type: gl.HALF_FLOAT, bytes: 2 * (2) },
+      { internal: gl.RG32F, format: gl.RG, type: gl.FLOAT, bytes: 2 * (4) },
+      { internal: gl.R32F, format: gl.RED, type: gl.FLOAT, bytes: (4) },
+      { internal: gl.RGB10_A2, format: gl.RGBA, type: gl.UNSIGNED_INT_2_10_10_10_REV, bytes: (4) },
+      { internal: gl.R11F_G11F_B10F, format: gl.RGB, type: gl.UNSIGNED_INT_10F_11F_11F_REV, bytes: (4) },
+      { internal: gl.DEPTH_COMPONENT16, format: gl.DEPTH_COMPONENT, type: gl.UNSIGNED_SHORT, bytes: (2) },
+      { internal: gl.DEPTH24_STENCIL8, format: gl.DEPTH_STENCIL, type: gl.UNSIGNED_INT_24_8, bytes: (4) },
+      { internal: gl.DEPTH_COMPONENT32F, format: gl.DEPTH_COMPONENT, type: gl.FLOAT, bytes: (4) },
+      { internal: gl.DEPTH32F_STENCIL8, format: gl.DEPTH_STENCIL, type: gl.FLOAT_32_UNSIGNED_INT_24_8_REV, bytes: 2 * (4) },
+      { internal: gl.RGBA8_SNORM, format: gl.RGBA, type: gl.BYTE, bytes: (4) }
+    ], this.blendFactors = [
+      gl.ZERO,
+      gl.ONE,
+      gl.SRC_COLOR,
+      gl.ONE_MINUS_SRC_COLOR,
+      gl.SRC_ALPHA,
+      gl.ONE_MINUS_SRC_ALPHA,
+      gl.DST_COLOR,
+      gl.ONE_MINUS_DST_COLOR,
+      gl.DST_ALPHA,
+      gl.ONE_MINUS_DST_ALPHA,
+      gl.SRC_ALPHA_SATURATE,
+      gl.CONSTANT_COLOR,
+      gl.ONE_MINUS_CONSTANT_COLOR
+    ], this.blendOps = [gl.FUNC_ADD, gl.FUNC_SUBTRACT, gl.FUNC_REVERSE_SUBTRACT, gl.MIN, gl.MAX], this.compares = [gl.NEVER, gl.LESS, gl.EQUAL, gl.LEQUAL, gl.GREATER, gl.NOTEQUAL, gl.GEQUAL, gl.ALWAYS], this.stencilOps = [gl.KEEP, gl.ZERO, gl.REPLACE, gl.INCR, gl.DECR, gl.INVERT, gl.INCR_WRAP, gl.DECR_WRAP], this.attributeTypes = [gl.FLOAT, gl.UNSIGNED_BYTE, gl.BYTE, gl.UNSIGNED_SHORT, gl.SHORT, gl.HALF_FLOAT, gl.UNSIGNED_INT], this.vertexArray = gl.createVertexArray(), gl.bindVertexArray(this.vertexArray);
+    let fallback = gl.createTexture();
+    gl.activeTexture(gl.TEXTURE0 + (16)), gl.bindTexture(gl.TEXTURE_2D, fallback), gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, 1, 1), gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array((4))), this.fallback = fallback;
+    let sampler = gl.createSampler();
+    gl.samplerParameteri(sampler, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR), gl.samplerParameteri(sampler, gl.TEXTURE_MAG_FILTER, gl.LINEAR), gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE), gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    for (let unit = 0; unit < (15); unit++) gl.bindSampler(unit, sampler);
+    return this.sampler = sampler, gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1), gl.pixelStorei(gl.PACK_ALIGNMENT, 1), true;
+  }
+  unbind() {
+    let gl = this.gl;
+    if (gl !== null) {
+      for (let slot of this.textures)
+        slot !== void 0 && (gl.deleteTexture(slot.texture), slot.framebuffer !== null && gl.deleteFramebuffer(slot.framebuffer));
+      for (let program of this.programs) program !== void 0 && gl.deleteProgram(program.program);
+      for (let block of this.blocks) block !== void 0 && gl.deleteBuffer(block);
+      this.fallback !== null && gl.deleteTexture(this.fallback), this.sampler !== null && gl.deleteSampler(this.sampler);
+    }
+    this.textures.length = 0, this.programs.length = 0, this.blocks.length = 0, this.blockSizes.length = 0, this.current = null, this.gl = null;
+  }
+  views() {
+    let memory = this.memory;
+    if (memory === null || memory.buffer === this.buffer) return;
+    let buffer = memory.buffer;
+    this.buffer = buffer, this.words = new Uint32Array(buffer), this.floats = new Float32Array(buffer), this.bytes = new Uint8Array(buffer), this.halves = new Uint16Array(buffer), this.singles = new Float32Array(buffer), this.signed = new Int8Array(buffer);
+  }
+  fail(message) {
+    this.errors.length < (16) && this.errors.push(message);
+  }
+  text(pointer, length) {
+    let view = this.bytes.subarray(pointer, pointer + length);
+    return this.decoder.decode(view.buffer instanceof ArrayBuffer ? view : view.slice());
+  }
+  shader(gl, type, source) {
+    let shader = gl.createShader(type);
+    return shader === null ? null : (gl.shaderSource(shader, source), gl.compileShader(shader), gl.getShaderParameter(shader, gl.COMPILE_STATUS) ? shader : (this.fail(`shader: ${gl.getShaderInfoLog(shader) ?? ""}`), gl.deleteShader(shader), null));
+  }
+  program(gl, at) {
+    let w = this.words, id = w[at + 1], vertex = this.text(w[at + 2], w[at + 3]), fragment = this.text(w[at + 4], w[at + 5]), cursor = at + 6, blockCount = w[cursor++], blocks = [];
+    for (let i = 0; i < blockCount; i++, cursor += 3) blocks.push([this.text(w[cursor], w[cursor + 1]), w[cursor + 2]]);
+    let samplerCount = w[cursor++], samplers = [];
+    for (let i = 0; i < samplerCount; i++, cursor += 3) samplers.push([this.text(w[cursor], w[cursor + 1]), w[cursor + 2]]);
+    let started = performance.now(), salt = this.salt === null ? "" : `
+const uint SALT_${this.salt} = 0u;
+`, vs = this.shader(gl, gl.VERTEX_SHADER, salted(vertex, salt)), fs = this.shader(gl, gl.FRAGMENT_SHADER, salted(fragment, salt)), program = gl.createProgram();
+    if (vs !== null && fs !== null && program !== null) {
+      gl.attachShader(program, vs), gl.attachShader(program, fs), gl.linkProgram(program), gl.deleteShader(vs), gl.deleteShader(fs);
+      let slot = { id, program, firstInstance: null, pending: { blocks, samplers, started } };
+      this.programs[id] = slot;
+    }
+    return cursor;
+  }
+  ready(gl, slot) {
+    let pending = slot.pending;
+    if (pending === null) return true;
+    slot.pending = null;
+    let program = slot.program;
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS))
+      return this.fail(`program ${slot.id}: ${gl.getProgramInfoLog(program) ?? ""}`), this.programs[slot.id] = void 0, false;
+    for (let [name, index] of pending.blocks) {
+      let block = gl.getUniformBlockIndex(program, name);
+      block !== gl.INVALID_INDEX && gl.uniformBlockBinding(program, block, index);
+    }
+    gl.useProgram(program);
+    for (let [name, unit] of pending.samplers) {
+      let location = gl.getUniformLocation(program, name);
+      location !== null && gl.uniform1i(location, unit);
+    }
+    return slot.firstInstance = gl.getUniformLocation(program, FIRST_INSTANCE_UNIFORM), this.compileMs.push(performance.now() - pending.started), this.current !== null && this.current !== slot && gl.useProgram(this.current.program), true;
+  }
+  texture(gl, at) {
+    let w = this.words, id = w[at + 1], width = w[at + 2], height = w[at + 3], format = this.formats[w[at + 4]], filter = w[at + 5];
+    if (this.deleteTexture(gl, id), format === void 0 || format.internal === 0) return;
+    let texture = gl.createTexture();
+    if (texture === null) return;
+    let levels = filter === (2) ? Math.floor(Math.log2(Math.max(width, height))) + 1 : Math.max(1, w[at + 6]);
+    gl.activeTexture(gl.TEXTURE0 + (16)), gl.bindTexture(gl.TEXTURE_2D, texture), gl.texStorage2D(gl.TEXTURE_2D, levels, format.internal, width, height);
+    let nearest = filter === (0);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, nearest ? gl.NEAREST : filter === (2) ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR), gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, nearest ? gl.NEAREST : gl.LINEAR), gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE), gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE), this.textures[id] = { texture, format, framebuffer: null };
+  }
+  deleteTexture(gl, id) {
+    let slot = this.textures[id];
+    if (slot !== void 0) {
+      gl.deleteTexture(slot.texture), slot.framebuffer !== null && gl.deleteFramebuffer(slot.framebuffer), this.textures[id] = void 0;
+      for (let i = this.passes.length - 1; i >= 0; i--) {
+        let pass = this.passes[i];
+        pass.depth !== id && !pass.colors.includes(id) || (gl.deleteFramebuffer(pass.framebuffer), this.passes.splice(i, 1));
+      }
+    }
+  }
+  upload(gl, at) {
+    let w = this.words, slot = this.textures[w[at + 1]];
+    if (slot === void 0) return;
+    let format = slot.format, pointer = w[at + 6];
+    gl.activeTexture(gl.TEXTURE0 + (16)), gl.bindTexture(gl.TEXTURE_2D, slot.texture), gl.pixelStorei(gl.UNPACK_ROW_LENGTH, w[at + 8]);
+    let flip = (w[at + 9] & (1)) !== 0;
+    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flip);
+    let x = w[at + 2], y = w[at + 3], width = w[at + 4], height = w[at + 5], type = format.type;
+    noteGuestRead(pointer, Math.max(w[at + 8], width) * height * (16)), type === gl.UNSIGNED_INT || type === gl.UNSIGNED_INT_2_10_10_10_REV || type === gl.UNSIGNED_INT_10F_11F_11F_REV || type === gl.UNSIGNED_INT_24_8 ? gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, width, height, format.format, type, this.words, pointer / (4)) : type === gl.HALF_FLOAT || type === gl.UNSIGNED_SHORT ? gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, width, height, format.format, type, this.halves, pointer / (2)) : type === gl.FLOAT ? gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, width, height, format.format, type, this.singles, pointer / (4)) : type === gl.BYTE ? gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, width, height, format.format, type, this.signed, pointer) : type === gl.UNSIGNED_BYTE && gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, width, height, format.format, type, this.bytes, pointer), flip && gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false), gl.pixelStorei(gl.UNPACK_ROW_LENGTH, 0);
+  }
+  target(gl, at) {
+    let w = this.words, id = w[at + 1], width = w[at + 2], height = w[at + 3];
+    if (id === (0)) {
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      let canvas = gl.canvas;
+      canvas.width !== width && (canvas.width = width), canvas.height !== height && (canvas.height = height);
+    } else {
+      let slot = this.textures[id];
+      if (slot === void 0) return;
+      slot.framebuffer === null ? (slot.framebuffer = gl.createFramebuffer(), gl.bindFramebuffer(gl.FRAMEBUFFER, slot.framebuffer), gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, slot.texture, 0), gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE && this.fail(`target ${id} is not renderable`)) : gl.bindFramebuffer(gl.FRAMEBUFFER, slot.framebuffer);
+    }
+    this.targetHeight = height, this.readsCanvas = id === (0), gl.viewport(0, 0, width, height);
+  }
+  uniforms(gl, at) {
+    let w = this.words, index = w[at + 1], count = w[at + 2], bytes = count * (4), block = this.blocks[index];
+    return block === void 0 && (block = gl.createBuffer(), this.blocks[index] = block, this.blockSizes[index] = 0), gl.bindBuffer(gl.UNIFORM_BUFFER, block), this.blockSizes[index] < bytes && (gl.bufferData(gl.UNIFORM_BUFFER, bytes, gl.DYNAMIC_DRAW), this.blockSizes[index] = bytes), gl.bufferSubData(gl.UNIFORM_BUFFER, 0, w, at + 3, count), gl.bindBufferBase(gl.UNIFORM_BUFFER, index, block), at + 3 + count;
+  }
+  read(gl, at) {
+    let w = this.words, x = w[at + 1], y = w[at + 2], width = w[at + 3], height = w[at + 4], pointer = w[at + 5], stride = width * (4);
+    if (w[at + 6] < stride * height) return;
+    if (!this.readsCanvas) {
+      gl.readPixels(x, y, width, height, gl.RGBA, gl.UNSIGNED_BYTE, this.bytes, pointer);
+      return;
+    }
+    gl.readPixels(x, this.targetHeight - y - height, width, height, gl.RGBA, gl.UNSIGNED_BYTE, this.bytes, pointer), this.row.length < stride && (this.row = new Uint8Array(stride));
+    let bytes = this.bytes;
+    for (let top = 0, bottom = height - 1; top < bottom; top++, bottom--) {
+      let a = pointer + top * stride, b = pointer + bottom * stride;
+      this.row.set(bytes.subarray(a, a + stride)), bytes.copyWithin(a, b, b + stride), bytes.set(this.row.subarray(0, stride), b);
+    }
+  }
+  makeBuffer(gl, at) {
+    let w = this.words, id = w[at + 1], old = this.buffers[id];
+    old !== void 0 && gl.deleteBuffer(old);
+    let buffer = gl.createBuffer(), target = w[at + 2] === (1) ? gl.ELEMENT_ARRAY_BUFFER : w[at + 2] === (2) ? gl.UNIFORM_BUFFER : gl.ARRAY_BUFFER;
+    gl.bindBuffer(target, buffer), gl.bufferData(target, w[at + 3], gl.DYNAMIC_DRAW), this.buffers[id] = buffer;
+  }
+  makeSampler(gl, at) {
+    let w = this.words, id = w[at + 1], old = this.samplers[id];
+    old !== void 0 && gl.deleteSampler(old);
+    let sampler = gl.createSampler(), linear = (value) => value === (1), mip = linear(w[at + 4]), min = linear(w[at + 2]) ? mip ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR_MIPMAP_NEAREST : mip ? gl.NEAREST_MIPMAP_LINEAR : gl.NEAREST_MIPMAP_NEAREST, wrap = (value) => value === (0) ? gl.REPEAT : value === (1) ? gl.MIRRORED_REPEAT : gl.CLAMP_TO_EDGE;
+    gl.samplerParameteri(sampler, gl.TEXTURE_MIN_FILTER, min), gl.samplerParameteri(sampler, gl.TEXTURE_MAG_FILTER, linear(w[at + 3]) ? gl.LINEAR : gl.NEAREST), gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, wrap(w[at + 5])), gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_T, wrap(w[at + 6])), w[at + 7] !== (0) && (gl.samplerParameteri(sampler, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE), gl.samplerParameteri(sampler, gl.TEXTURE_COMPARE_FUNC, this.compares[w[at + 7] - 1] ?? gl.ALWAYS));
+    let f = this.floats;
+    gl.samplerParameterf(sampler, gl.TEXTURE_MIN_LOD, f[at + 8]), gl.samplerParameterf(sampler, gl.TEXTURE_MAX_LOD, f[at + 9]), this.samplers[id] = sampler;
+  }
+  framebuffer(gl, colors, depth, stencil) {
+    for (let pass of this.passes) {
+      if (pass.depth !== depth || pass.colors.length !== colors.length) continue;
+      let same = true;
+      for (let i = 0; i < colors.length; i++) same && (same = pass.colors[i] === colors[i]);
+      if (same) return pass.framebuffer;
+    }
+    let framebuffer = gl.createFramebuffer();
+    if (framebuffer === null) return null;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+    for (let i = 0; i < colors.length; i++) {
+      let slot = this.textures[colors[i]];
+      slot !== void 0 && gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.TEXTURE_2D, slot.texture, 0);
+    }
+    let depthSlot = depth === (0) ? void 0 : this.textures[depth];
+    return depthSlot !== void 0 && gl.framebufferTexture2D(gl.FRAMEBUFFER, stencil ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, depthSlot.texture, 0), gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE && this.fail("script pass is not renderable"), this.passes.push({ colors: [...colors], depth, framebuffer }), framebuffer;
+  }
+  pass(gl, at) {
+    let w = this.words, count = Math.min(w[at + 1], (8)), cursor = at + 2, colors = [], first = cursor;
+    for (let i = 0; i < count; i++, cursor += (6)) colors.push(w[cursor]);
+    let depth = w[cursor], stencil = w[cursor + 1] !== 0, depthAt = cursor;
+    cursor += (6);
+    let width = w[cursor], height = w[cursor + 1];
+    for (cursor += 2, gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer(gl, colors, depth, stencil)); this.drawBuffers.length <= count; ) {
+      let list = [];
+      for (let i = 0; i < this.drawBuffers.length; i++) list.push(gl.COLOR_ATTACHMENT0 + i);
+      this.drawBuffers.push(list);
+    }
+    gl.drawBuffers(this.drawBuffers[count]), gl.viewport(0, 0, width, height), gl.depthRange(0, 1), gl.disable(gl.SCISSOR_TEST), gl.colorMask(true, true, true, true), gl.depthMask(true), gl.stencilMask(255), this.targetHeight = height, this.readsCanvas = false;
+    let f = this.floats;
+    for (let i = 0; i < count; i++) {
+      let c = first + i * (6);
+      w[c + 1] === (0) && (this.clearColor[0] = f[c + 2], this.clearColor[1] = f[c + 3], this.clearColor[2] = f[c + 4], this.clearColor[3] = f[c + 5], gl.clearBufferfv(gl.COLOR, i, this.clearColor));
+    }
+    return depth !== (0) && (w[depthAt + 2] === (0) && (this.clearDepth[0] = f[depthAt + 3], gl.clearBufferfv(gl.DEPTH, 0, this.clearDepth)), stencil && w[depthAt + 4] === (0) && (this.clearStencil[0] = w[depthAt + 5], gl.clearBufferiv(gl.STENCIL, 0, this.clearStencil))), cursor;
+  }
+  stencil(gl) {
+    let front = this.stencilFront, back = this.stencilBack;
+    gl.stencilFuncSeparate(gl.BACK, front[0], this.stencilReference, front[2]), gl.stencilFuncSeparate(gl.FRONT, back[0], this.stencilReference, back[2]);
+  }
+  state(gl, at) {
+    let w = this.words, s = at + 1;
+    w[s] !== 0 ? (gl.enable(gl.BLEND), gl.blendFuncSeparate(this.blendFactors[w[s + 1]], this.blendFactors[w[s + 2]], this.blendFactors[w[s + 4]], this.blendFactors[w[s + 5]]), gl.blendEquationSeparate(this.blendOps[w[s + 3]], this.blendOps[w[s + 6]])) : gl.disable(gl.BLEND);
+    let mask = w[s + 7];
+    gl.colorMask((mask & (1)) !== 0, (mask & (2)) !== 0, (mask & (4)) !== 0, (mask & (8)) !== 0), w[s + 26] !== 0 ? (gl.enable(gl.DEPTH_TEST), gl.depthFunc(w[s + 8] === (0) ? gl.ALWAYS : this.compares[w[s + 8] - 1]), gl.depthMask(w[s + 9] !== 0)) : gl.disable(gl.DEPTH_TEST);
+    let cull = w[s + 10];
+    if (cull === (1) || cull === (2) ? (gl.enable(gl.CULL_FACE), gl.cullFace(cull === (1) ? gl.FRONT : gl.BACK)) : gl.disable(gl.CULL_FACE), gl.frontFace(w[s + 11] !== 0 ? gl.CW : gl.CCW), w[s + 12] !== 0) {
+      gl.enable(gl.STENCIL_TEST);
+      let compare = (value) => value === (0) ? gl.ALWAYS : this.compares[value - 1];
+      this.stencilFront = [compare(w[s + 13]), 0, w[s + 21]], this.stencilBack = [compare(w[s + 17]), 0, w[s + 21]], this.stencil(gl), gl.stencilOpSeparate(gl.BACK, this.stencilOps[w[s + 14]], this.stencilOps[w[s + 15]], this.stencilOps[w[s + 16]]), gl.stencilOpSeparate(gl.FRONT, this.stencilOps[w[s + 18]], this.stencilOps[w[s + 19]], this.stencilOps[w[s + 20]]), gl.stencilMask(w[s + 22]);
+    } else
+      gl.disable(gl.STENCIL_TEST);
+    let constant = this.signedWord(w[s + 23]), slope = this.floats[s + 24];
+    constant !== 0 || slope !== 0 ? (gl.enable(gl.POLYGON_OFFSET_FILL), gl.polygonOffset(slope, constant)) : gl.disable(gl.POLYGON_OFFSET_FILL);
+  }
+  signedWord(value) {
+    return value | 0;
+  }
+  attribute(gl, at) {
+    let w = this.words, location = w[at + 1], buffer = this.buffers[w[at + 2]];
+    if (buffer === void 0 || location >= (16)) return;
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer), gl.enableVertexAttribArray(location), this.enabledAttributes |= 1 << location;
+    let type = this.attributeTypes[w[at + 4]];
+    w[at + 6] !== 0 ? gl.vertexAttribIPointer(location, w[at + 3], type, w[at + 7], w[at + 8]) : gl.vertexAttribPointer(location, w[at + 3], type, w[at + 5] !== 0, w[at + 7], w[at + 8]), gl.vertexAttribDivisor(location, w[at + 9]);
+  }
+  mode(gl, value) {
+    switch (value) {
+      case (1):
+        return gl.TRIANGLE_STRIP;
+      case (2):
+        return gl.POINTS;
+      case (3):
+        return gl.LINES;
+      case (4):
+        return gl.LINE_STRIP;
+      default:
+        return gl.TRIANGLES;
+    }
+  }
+  endPass(gl) {
+    for (let location = 0; location < (16); location++)
+      (this.enabledAttributes & 1 << location) !== 0 && (gl.vertexAttribDivisor(location, 0), gl.disableVertexAttribArray(location));
+    this.enabledAttributes = 0, gl.disable(gl.SCISSOR_TEST), gl.disable(gl.BLEND), gl.disable(gl.DEPTH_TEST), gl.disable(gl.STENCIL_TEST), gl.disable(gl.CULL_FACE), gl.disable(gl.POLYGON_OFFSET_FILL), gl.colorMask(true, true, true, true), gl.depthRange(0, 1), gl.frontFace(gl.CCW);
+    for (let unit = 0; unit < (15); unit++) gl.bindSampler(unit, this.sampler);
+  }
+  execute(pointer, length) {
+    let gl = this.gl;
+    if (gl === null) return;
+    this.views();
+    let w = this.words, end = pointer / (4) + length, at = pointer / (4);
+    for (; at < end; ) {
+      if (this.checked) {
+        let error = gl.getError();
+        error !== gl.NO_ERROR && this.fail(`GL error ${error} before op ${w[this.lastOp]} at ${this.lastOp}`), this.lastOp = at;
+      }
+      switch (w[at]) {
+        case (1):
+          at = this.program(gl, at);
+          break;
+        case (2):
+          this.texture(gl, at), at += 7;
+          break;
+        case (3):
+          this.upload(gl, at), at += 10;
+          break;
+        case (4):
+          this.deleteTexture(gl, w[at + 1]), at += 2;
+          break;
+        case (5):
+          this.target(gl, at), at += 4;
+          break;
+        case (6): {
+          let f = this.floats;
+          gl.clearColor(f[at + 1], f[at + 2], f[at + 3], f[at + 4]), gl.clear(gl.COLOR_BUFFER_BIT), at += 5;
+          break;
+        }
+        case (7):
+          w[at + 1] === (1) ? (gl.enable(gl.BLEND), gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA)) : gl.disable(gl.BLEND), at += 2;
+          break;
+        case (8): {
+          let program = this.programs[w[at + 1]], usable = program !== void 0 && this.ready(gl, program);
+          this.current = usable ? program : null, gl.useProgram(usable ? program.program : null), at += 2;
+          break;
+        }
+        case (9): {
+          let slot = w[at + 2] === (0) ? void 0 : this.textures[w[at + 2]];
+          gl.activeTexture(gl.TEXTURE0 + w[at + 1]), gl.bindTexture(gl.TEXTURE_2D, slot === void 0 ? this.fallback : slot.texture), at += 3;
+          break;
+        }
+        case (10):
+          at = this.uniforms(gl, at);
+          break;
+        case (11): {
+          let program = this.current;
+          program !== null && (program.firstInstance !== null && gl.uniform1ui(program.firstInstance, w[at + 5]), gl.drawArraysInstanced(w[at + 1] === (1) ? gl.TRIANGLE_STRIP : gl.TRIANGLES, w[at + 2], w[at + 3], w[at + 4])), at += 6;
+          break;
+        }
+        case (12): {
+          let slot = this.textures[w[at + 1]];
+          slot !== void 0 && (gl.activeTexture(gl.TEXTURE0 + (16)), gl.bindTexture(gl.TEXTURE_2D, slot.texture), gl.copyTexSubImage2D(gl.TEXTURE_2D, 0, w[at + 2], w[at + 3], w[at + 2], w[at + 3], w[at + 4], w[at + 5])), at += 6;
+          break;
+        }
+        case (13):
+          this.read(gl, at), at += 7;
+          break;
+        case (14): {
+          let slot = this.textures[w[at + 1]];
+          slot !== void 0 && (gl.activeTexture(gl.TEXTURE0 + (16)), gl.bindTexture(gl.TEXTURE_2D, slot.texture), gl.generateMipmap(gl.TEXTURE_2D)), at += 2;
+          break;
+        }
+        case (15):
+          this.makeBuffer(gl, at), at += 4;
+          break;
+        case (16): {
+          let buffer = this.buffers[w[at + 1]];
+          buffer !== void 0 && (gl.bindBuffer(gl.COPY_WRITE_BUFFER, buffer), noteGuestRead(w[at + 3], w[at + 4]), gl.bufferSubData(gl.COPY_WRITE_BUFFER, w[at + 2], this.bytes, w[at + 3], w[at + 4])), at += 5;
+          break;
+        }
+        case (17): {
+          let buffer = this.buffers[w[at + 1]];
+          buffer !== void 0 && gl.deleteBuffer(buffer), this.buffers[w[at + 1]] = void 0, at += 2;
+          break;
+        }
+        case (18):
+          this.makeSampler(gl, at), at += 10;
+          break;
+        case (19): {
+          let sampler = this.samplers[w[at + 1]];
+          sampler !== void 0 && gl.deleteSampler(sampler), this.samplers[w[at + 1]] = void 0, at += 2;
+          break;
+        }
+        case (20): {
+          let program = this.programs[w[at + 1]];
+          program !== void 0 && gl.deleteProgram(program.program), this.programs[w[at + 1]] = void 0, at += 2;
+          break;
+        }
+        case (21):
+          at = this.pass(gl, at);
+          break;
+        case (22):
+          this.state(gl, at), at += 1 + (27);
+          break;
+        case (23):
+          this.attribute(gl, at), at += 1 + (9);
+          break;
+        case (24): {
+          let buffer = this.buffers[w[at + 1]];
+          buffer !== void 0 && gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer), at += 2;
+          break;
+        }
+        case (25): {
+          let program = this.current;
+          if (program !== null) {
+            program.firstInstance !== null && gl.uniform1ui(program.firstInstance, w[at + 6]);
+            let type = w[at + 3] === (1) ? gl.UNSIGNED_SHORT : gl.UNSIGNED_INT;
+            gl.drawElementsInstanced(this.mode(gl, w[at + 1]), w[at + 2], type, w[at + 4], w[at + 5]);
+          }
+          at += 7;
+          break;
+        }
+        case (26): {
+          let f = this.floats;
+          gl.viewport(Math.round(f[at + 1]), Math.round(f[at + 2]), Math.round(f[at + 3]), Math.round(f[at + 4])), gl.depthRange(f[at + 5], f[at + 6]), at += 7;
+          break;
+        }
+        case (27):
+          gl.enable(gl.SCISSOR_TEST), gl.scissor(w[at + 1], w[at + 2], w[at + 3], w[at + 4]), at += 5;
+          break;
+        case (28):
+          this.stencilReference = w[at + 1], this.stencil(gl), at += 2;
+          break;
+        case (29): {
+          let f = this.floats;
+          gl.blendColor(f[at + 1], f[at + 2], f[at + 3], f[at + 4]), at += 5;
+          break;
+        }
+        case (30): {
+          let buffer = this.buffers[w[at + 2]];
+          buffer !== void 0 && gl.bindBufferRange(gl.UNIFORM_BUFFER, w[at + 1], buffer, w[at + 3], w[at + 4]), at += 5;
+          break;
+        }
+        case (31): {
+          let sampler = this.samplers[w[at + 2]];
+          gl.bindSampler(w[at + 1], sampler ?? null), at += 3;
+          break;
+        }
+        case (32):
+          this.endPass(gl), at += 1;
+          break;
+        default:
+          this.fail(`unknown op ${w[at]} at ${at}`);
+          return;
+      }
+    }
+    if (this.checked) {
+      let error = gl.getError();
+      error !== gl.NO_ERROR && this.fail(`GL error ${error} after op ${w[this.lastOp]} at ${this.lastOp}`);
+    }
+  }
+};
+
+// src/game/backends/engine/reserved-memory.ts
+var HELD = /* @__PURE__ */ new WeakMap();
+function isShared(buffer) {
+  return typeof SharedArrayBuffer == "function" && buffer instanceof SharedArrayBuffer;
+}
+function refuseGrowth() {
+  throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory is reserved in full at boot and never grows; reserve more with memoryPages");
+}
+function reserveEngineMemory(memory, pages) {
+  let bytes = pages * chunk2O2CG465_js.WASM_PAGE_BYTES, buffer = memory.buffer;
+  if (buffer.byteLength !== bytes)
+    throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `engine memory holds ${buffer.byteLength} bytes after boot, not the ${bytes} it reserves`);
+  Object.defineProperty(memory, "grow", { value: refuseGrowth, configurable: false, enumerable: false, writable: false }), HELD.set(memory, { buffer, bytes, shared: isShared(buffer) });
+}
+function holdEngineMemory(memory) {
+  if (HELD.has(memory)) return;
+  let buffer = memory.buffer;
+  HELD.set(memory, { buffer, bytes: buffer.byteLength, shared: isShared(buffer) });
+}
+function engineMemoryHeld(memory) {
+  let held = HELD.get(memory);
+  if (held === void 0) return true;
+  let buffer = memory.buffer;
+  return buffer === held.buffer ? true : held.shared && buffer.byteLength === held.bytes;
+}
+function requireEngineMemoryHeld(memory) {
+  if (!engineMemoryHeld(memory))
+    throw new chunk2V7IL4HC_js.GameError("engine_mismatch", "engine memory moved after boot, so views into it would read stale data; the frame stops instead");
+}
+
+// src/game/backends/engine/runtime.ts
+var EXPORT_NAMES = [
+  "engine_abi_version",
+  "engine_alloc",
+  "engine_free",
+  "engine_reserve",
+  "engine_world_create",
+  "engine_world_destroy",
+  "engine_world_registers",
+  "engine_world_desc",
+  "engine_world_commands",
+  "engine_contacts_a",
+  "engine_contacts_b",
+  "engine_contacts_started",
+  "engine_contact_count",
+  "engine_bind_transforms",
+  "engine_snapshot",
+  "engine_compute_render",
+  "engine_apply_commands",
+  "engine_step",
+  "engine_body_create",
+  "engine_body_destroy",
+  "engine_body_linear_velocity",
+  "engine_body_angular_velocity",
+  "engine_body_sleeping",
+  "engine_collider_create",
+  "engine_collider_destroy",
+  "engine_collider_enable",
+  "engine_joint_create",
+  "engine_joint_motor",
+  "engine_joint_destroy",
+  "engine_controller_create",
+  "engine_controller_destroy",
+  "engine_character_move",
+  "engine_raycast",
+  "engine_determinism_digest"
+], ABI_COMPATIBLE_EXPORT = "engine_abi_compatible", ABI_COMPATIBLE = 1, GPU_IMPORTS = "cimplify_gpu", GPU_MAPPED_EXPORT = "engine_gpu_mapped", GPU_ERROR_BUFFER_EXPORT = "engine_gpu_error_buffer", GPU_ERROR_EXPORT = "engine_gpu_error", PHYSICS_PROBE = "engine_step", NO_POINTER = 0, NO_CONTACTS = 0, IDLE = 0, PHYSICS_EXPORTS = /* @__PURE__ */ new Set([
+  "engine_contacts_a",
+  "engine_contacts_b",
+  "engine_contacts_started",
+  "engine_contact_count",
+  "engine_apply_commands",
+  "engine_step",
+  "engine_body_create",
+  "engine_body_destroy",
+  "engine_body_linear_velocity",
+  "engine_body_angular_velocity",
+  "engine_body_sleeping",
+  "engine_collider_create",
+  "engine_collider_destroy",
+  "engine_collider_enable",
+  "engine_joint_create",
+  "engine_joint_motor",
+  "engine_joint_destroy",
+  "engine_controller_create",
+  "engine_controller_destroy",
+  "engine_character_move",
+  "engine_raycast",
+  "engine_determinism_digest"
+]);
+function noPhysics(name) {
+  throw new chunk2V7IL4HC_js.GameError("unsupported_feature", `${name} needs the physics engine feature, which this game's engine build does not include`);
+}
+function physicsStub(name) {
+  switch (name) {
+    case "engine_contacts_a":
+    case "engine_contacts_b":
+    case "engine_contacts_started":
+      return () => (0);
+    case "engine_contact_count":
+      return () => (0);
+    case "engine_apply_commands":
+    case "engine_step":
+      return (_world, count) => count === (0) ? (0) : noPhysics(name);
+    default:
+      return () => noPhysics(name);
+  }
+}
+function hasPhysics(exports) {
+  return typeof exports[PHYSICS_PROBE] == "function";
+}
+function bindExports(exports) {
+  let bound = {}, physics = hasPhysics(exports);
+  for (let name of EXPORT_NAMES) {
+    let value = exports[name];
+    if (typeof value == "function") bound[name] = value;
+    else if (!physics && PHYSICS_EXPORTS.has(name)) bound[name] = physicsStub(name);
+    else throw new chunk2V7IL4HC_js.GameError("not_initialized", `engine module is missing ${name}`);
+  }
+  return bound;
+}
+function engineAbiCompatible(exports) {
+  let version = exports.engine_abi_version;
+  if (typeof version == "function" && version() === 1882262861) return true;
+  let compatible = exports[ABI_COMPATIBLE_EXPORT];
+  return typeof compatible == "function" && compatible(1882262861) === (1);
+}
+function checkAbi(exports, symbols) {
+  if (!engineAbiCompatible(symbols))
+    throw new chunk2V7IL4HC_js.GameError("engine_mismatch", `engine ABI ${exports.engine_abi_version()} does not cover ${1882262861}; the engine retired exports this SDK calls`);
+}
+function bindEngineRuntime(runtime) {
+  let exports = bindExports(runtime.exports);
+  return checkAbi(exports, runtime.exports), holdEngineMemory(runtime.memory), {
+    exports,
+    memory: runtime.memory,
+    symbols: runtime.exports,
+    gpu: runtime.gpu ?? null,
+    gl: runtime.gl ?? null,
+    decodeAudio: runtime.decode_audio ?? null,
+    audioContext: runtime.audio_context ?? null,
+    audioWorklet: runtime.audio_worklet ?? null
+  };
+}
+async function loadEngineRuntime(source, options = {}) {
+  let pages = options.memoryPages ?? chunk2O2CG465_js.DEFAULT_ENGINE_MEMORY_PAGES;
+  if (pages <= chunk2O2CG465_js.ENGINE_INITIAL_PAGES) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `engine memory needs more than ${chunk2O2CG465_js.ENGINE_INITIAL_PAGES} pages`);
+  let scope = options.scope ?? globalThis, threaded = options.threaded !== void 0 && chunkJ2U6PJSO_js.threadsAvailable(scope), chosen = threaded ? options.threaded : source, module = chosen instanceof WebAssembly.Module ? chosen : await WebAssembly.compile(chosen), memory = new WebAssembly.Memory({ initial: chunk2O2CG465_js.ENGINE_INITIAL_PAGES, maximum: pages, shared: threaded }), gpu = new WebGpuExecutor(), gl = new WebGl2Executor(), imports = { env: { memory }, [GPU_IMPORTS]: gpu.imports, [GL_IMPORTS]: gl.imports };
+  chunkFXVJ2HFU_js.importsWasi(module) && (imports[chunkFXVJ2HFU_js.WASI_IMPORTS] = chunkFXVJ2HFU_js.wasiStubs(() => memory));
+  let instance = await WebAssembly.instantiate(module, imports);
+  chunkFXVJ2HFU_js.initializeReactor(instance.exports);
+  let exports = bindExports(instance.exports);
+  checkAbi(exports, instance.exports);
+  let reserve = pages * chunk2O2CG465_js.WASM_PAGE_BYTES - memory.buffer.byteLength - chunk2O2CG465_js.ENGINE_RESERVE_SLACK_BYTES;
+  if (exports.engine_reserve(reserve) < 0) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory could not be reserved");
+  let headroom = pages - memory.buffer.byteLength / chunk2O2CG465_js.WASM_PAGE_BYTES;
+  headroom > 0 && memory.grow(headroom), reserveEngineMemory(memory, pages), options.session && presentEngineSession({ symbols: instance.exports, memory, exports }, options.session);
+  let mapped = instance.exports[GPU_MAPPED_EXPORT], errorBuffer = instance.exports[GPU_ERROR_BUFFER_EXPORT], error = instance.exports[GPU_ERROR_EXPORT], present = typeof mapped == "function" && typeof errorBuffer == "function" && typeof error == "function";
+  present && gpu.bindMemory(memory, {
+    mapped,
+    errorBuffer,
+    error
+  });
+  let webgl = typeof instance.exports[GL_ATTACH_EXPORT] == "function";
+  webgl && gl.bindMemory(memory);
+  let workers = options.workers ?? chunkJ2U6PJSO_js.workerCount(scope), threads = threaded ? await chunkJ2U6PJSO_js.startEngineThreads(module, memory, instance.exports, workers, options.workerFactory) : null;
+  return { exports, memory, symbols: instance.exports, gpu: present ? gpu : null, gl: webgl ? gl : null, threads, lanes: threads?.lanes ?? 1 };
+}
+async function wasmPlatformEngine(source, options = {}) {
+  return enginePlatformOf(await loadEngineRuntime(source, options));
+}
+function enginePlatformOf(runtime) {
+  return { kind: "engine", runtime: { exports: runtime.symbols, memory: runtime.memory, gpu: runtime.gpu, gl: runtime.gl } };
+}
+function engineDeterminismDigest(runtime, seed, steps) {
+  let out = runtime.exports.engine_alloc(chunk2O2CG465_js.U64_BYTES, chunk2O2CG465_js.U64_BYTES);
+  try {
+    if (runtime.exports.engine_determinism_digest(seed, steps, out) < 0)
+      throw new chunk2V7IL4HC_js.GameError("invalid_argument", "determinism scenario failed");
+    return new BigUint64Array(runtime.memory.buffer, out, 1)[0];
+  } finally {
+    runtime.exports.engine_free(out, chunk2O2CG465_js.U64_BYTES, chunk2O2CG465_js.U64_BYTES);
+  }
+}
+
+exports.EngineSessionError = EngineSessionError;
+exports.bindEngineRuntime = bindEngineRuntime;
+exports.engineDeterminismDigest = engineDeterminismDigest;
+exports.enginePlatformOf = enginePlatformOf;
+exports.engineSessionFailure = engineSessionFailure;
+exports.hasPhysics = hasPhysics;
+exports.loadEngineRuntime = loadEngineRuntime;
+exports.requireEngineMemoryHeld = requireEngineMemoryHeld;
+exports.wasmPlatformEngine = wasmPlatformEngine;