@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-EIB4OWVQ.mjs

@@ -0,0 +1,620 @@
+import { dataTables, hasData, COMPUTE_SPACE_GPU, writeWideArg, COMPUTE_DEFERRED, routeEvents } from './chunk-E65WCTIG.mjs';
+import { Op, crossRow, XOP, stageEnds, RING_HEADER_WORDS, DEFAULT_EVENT_CAPACITY, XOP_GATHER, XOP_FIELD, DATA_TABLES } from './chunk-SMK6JU2F.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/kernel/route.ts
+var GPU_DEVICE_CLASSES = ["unknown", "mobile", "desktop", "discrete"], CPU_BACKENDS = ["interpreter", "cranelift", "wasm"];
+var PRESSURE_SCALE = [64, 44, 28], MIN_JOB_TILES = 4, LANE_GAIN = 3, LANE_UNIT = 4, MOBILE_SCALE = 5, MOBILE_UNIT = 4, DESKTOP_CPU = {
+  interpreter: { op: 47, pair: 12e3, math: 3e3, gridRow: 2e4, launch: 5e6 },
+  cranelift: { op: 40, pair: 12e3, math: 3400, gridRow: 2e4, launch: 5e6 },
+  wasm: { op: 30, pair: 8e3, math: 3500, gridRow: 25e3, launch: 0 }
+};
+function mobile(c) {
+  let m = (v) => Math.floor(v * (5) / (4));
+  return { op: m(c.op), pair: m(c.pair), math: m(c.math), gridRow: m(c.gridRow), launch: m(c.launch) };
+}
+var MOBILE_CPU = { interpreter: mobile(DESKTOP_CPU.interpreter), cranelift: mobile(DESKTOP_CPU.cranelift), wasm: mobile(DESKTOP_CPU.wasm) }, DESKTOP_GPU = {
+  setFixed: 9e8,
+  setOp: 1,
+  gather: 1,
+  launch: 4e7,
+  batchedLaunch: 3e7,
+  stage: 1e7,
+  grid: 15e7,
+  op: 5,
+  pair: 25,
+  math: 700,
+  uploadWord: 80,
+  sync: 1e8,
+  readbackWord: 50,
+  enter: 51,
+  leave: 70
+}, DISCRETE_GPU = {
+  setFixed: 1e9,
+  setOp: 1,
+  gather: 1,
+  launch: 5e7,
+  batchedLaunch: 38e6,
+  stage: 1e7,
+  grid: 12e7,
+  op: 2,
+  pair: 10,
+  math: 300,
+  uploadWord: 300,
+  sync: 2e8,
+  readbackWord: 300,
+  enter: 51,
+  leave: 70
+}, MOBILE_GPU = {
+  setFixed: 12e8,
+  setOp: 3,
+  gather: 3,
+  launch: 35e6,
+  batchedLaunch: 25e6,
+  stage: 15e6,
+  grid: 2e8,
+  op: 12,
+  pair: 60,
+  math: 1700,
+  uploadWord: 120,
+  sync: 15e7,
+  readbackWord: 90,
+  enter: 48,
+  leave: 70
+};
+function cpuCosts(machine) {
+  let family = machine.class === "desktop" || machine.class === "discrete" ? DESKTOP_CPU : MOBILE_CPU;
+  return family[machine.backend] ?? family.interpreter;
+}
+function gpuCosts(device) {
+  return device === "desktop" ? DESKTOP_GPU : device === "discrete" ? DISCRETE_GPU : MOBILE_GPU;
+}
+var V8_AGENT = /Chrome\/|Chromium\/|Edg\//, JSC_AGENT = /AppleWebKit\//, detectedEngine = null;
+function detectEngine() {
+  let g = globalThis;
+  if (g.HermesInternal !== void 0) return "jsc-nojit";
+  let versions = g.process?.versions;
+  if (versions?.bun !== void 0) return "jsc";
+  if (versions?.v8 !== void 0) return "v8";
+  let agent = g.navigator?.userAgent;
+  return typeof agent == "string" ? V8_AGENT.test(agent) ? "v8" : JSC_AGENT.test(agent) ? "jsc" : "v8" : "jsc-nojit";
+}
+var WASM_PROBE = Uint8Array.from([0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 7, 5, 1, 1, 102, 0, 0, 10, 6, 1, 4, 0, 65, 42, 11]), WASM_PROBE_RESULT = 42, wasmWorks = null;
+function wasmInstantiates() {
+  if (wasmWorks !== null) return wasmWorks;
+  let wasm = globalThis.WebAssembly;
+  try {
+    let run = wasm === void 0 ? null : new wasm.Instance(new wasm.Module(WASM_PROBE)).exports.f;
+    wasmWorks = typeof run == "function" && run() === (42);
+  } catch {
+    wasmWorks = false;
+  }
+  return wasmWorks;
+}
+function hostEngine() {
+  return (detectedEngine ?? (detectedEngine = detectEngine()), detectedEngine);
+}
+function gpuDeviceClass(code) {
+  return GPU_DEVICE_CLASSES[code] ?? "unknown";
+}
+function kernelMachine(device, backend = "interpreter", budgetNs = 0, pressure = 0) {
+  return { class: device, backend, budgetNs, pressure };
+}
+function clamp(value, low, high) {
+  return Math.min(Math.max(value, low), high);
+}
+function rowPs(value) {
+  return Math.min(value, 2097152);
+}
+function fixedPs(value) {
+  return Math.min(value, 68719476736);
+}
+function scale(value, permille) {
+  return Math.floor(value * permille / 1e3);
+}
+function modelRows(rows) {
+  return Math.min(rows, 16777216);
+}
+function emptyEstimate() {
+  return { cpuLaunch: 0, cpuRow: 0, cpuSerialRow: 0, lanes: 1, gpuFixed: 0, gpuRow: 0 };
+}
+function fillEstimate(work, machine, out) {
+  let cpu = cpuCosts(machine), gpu = gpuCosts(machine.class), instructions = clamp(work.instructions, 1, 4096), columns = Math.min(work.columns, 256), math = Math.min(work.transcendentals, 256), lanes = machine.backend === "wasm" ? 1 : clamp(work.lanes, 1, 64), pairs = work.pairs ? 24 : 0, gpuFixed = (work.batched && !work.readback ? gpu.batchedLaunch : gpu.launch) + Math.min(work.stages, 64) * gpu.stage, gpuRow = instructions * gpu.op + math * gpu.math + pairs * gpu.pair;
+  return work.pairs && (gpuFixed += gpu.grid), work.resident || (gpuRow += columns * gpu.uploadWord), work.readback && (gpuFixed += gpu.sync, gpuRow += columns * gpu.readbackWord), out.cpuLaunch = fixedPs(cpu.launch), out.cpuRow = rowPs(instructions * cpu.op + pairs * cpu.pair + math * cpu.math), out.cpuSerialRow = rowPs(work.pairs ? cpu.gridRow : 0), out.lanes = lanes, out.gpuFixed = fixedPs(gpuFixed), out.gpuRow = rowPs(gpuRow), out;
+}
+function estimateRoute(work, machine) {
+  return fillEstimate(work, machine, emptyEstimate());
+}
+function scaleEstimate(e, pin, rowBound = 2097152) {
+  return e.cpuLaunch = fixedPs(scale(e.cpuLaunch, pin.cpu)), e.cpuRow = Math.min(scale(e.cpuRow, pin.cpu), rowBound), e.cpuSerialRow = Math.min(scale(e.cpuSerialRow, pin.cpu), rowBound), e.gpuFixed = fixedPs(scale(e.gpuFixed, pin.gpu)), e.gpuRow = Math.min(scale(e.gpuRow, pin.gpu), rowBound), e;
+}
+var SET_ROW_BOUND = 16777216;
+function copyEstimate(from, out) {
+  return out.cpuLaunch = from.cpuLaunch, out.cpuRow = from.cpuRow, out.cpuSerialRow = from.cpuSerialRow, out.lanes = from.lanes, out.gpuFixed = from.gpuFixed, out.gpuRow = from.gpuRow, out;
+}
+var ENGINE_CPU = {
+  v8: { op: 30, gather: 1400, math: 3500, step: 8e3 },
+  jsc: { op: 195, gather: 4300, math: 22e3, step: 4300 },
+  "jsc-nojit": { op: 1370, gather: 12300, math: 16e4, step: 50800 }
+};
+function setRowPs(value) {
+  return Math.min(value, 16777216);
+}
+function engineRow(cpuSet, form, engine, machine) {
+  let c = ENGINE_CPU[engine], row = form === "script" ? cpuSet.steps * c.step : cpuSet.instructions * c.op + cpuSet.gathers * c.gather + cpuSet.transcendentals * c.math;
+  return machine.class === "desktop" || machine.class === "discrete" ? row : Math.floor(row * (5) / (4));
+}
+function fillSetEstimate(cpuSet, gpuSet, machine, out, form = "wasm", engine = hostEngine()) {
+  let gpu = gpuCosts(machine.class), parts = clamp(gpuSet.parts, 1, 256);
+  out.cpuLaunch = 0, out.cpuRow = setRowPs(engineRow(cpuSet, form, engine, machine)), out.cpuSerialRow = 0, out.lanes = 1;
+  let gpuFixed = gpu.setFixed + (parts - 1) * gpu.batchedLaunch + Math.min(gpuSet.stages, 64 * 256) * gpu.stage, gpuRow = gpuSet.instructions * gpu.setOp + gpuSet.gathers * gpu.gather + gpuSet.transcendentals * gpu.math + gpuSet.upload * gpu.uploadWord + gpuSet.readback * gpu.readbackWord;
+  return out.gpuFixed = fixedPs(gpuFixed), out.gpuRow = setRowPs(gpuRow), out;
+}
+function lanesFor(rows, lanes) {
+  let tiles = Math.ceil(rows / 2048);
+  return tiles < (4) || lanes <= 1 ? 1 : Math.min(tiles, lanes);
+}
+function estimatedCpu(e, rows) {
+  let n = modelRows(rows), lanes = lanesFor(n, e.lanes), speedup = (4) + (3) * (lanes - 1);
+  return (lanes > 1 ? e.cpuLaunch : 0) + Math.floor(n * e.cpuRow * (4) / speedup) + n * e.cpuSerialRow;
+}
+function estimatedGpu(e, rows) {
+  return e.gpuFixed + modelRows(rows) * e.gpuRow;
+}
+function want(e, rows, machine, current) {
+  let margins = gpuCosts(machine.class), cpu = estimatedCpu(e, rows), gpu = estimatedGpu(e, rows), damp = PRESSURE_SCALE[Math.min(Math.max(machine.pressure | 0, 0), 2)];
+  if (current === "gpu") return gpu * 64 > cpu * Math.floor(margins.leave * damp / 64) ? "cpu" : "gpu";
+  let over = machine.budgetNs > 0 && cpu > machine.budgetNs * 1e3, enter = Math.floor((over ? Math.max(margins.enter, 64) : margins.enter) * damp / 64);
+  return gpu * 64 < cpu * enter ? "gpu" : "cpu";
+}
+function chooseDevice(work, machine) {
+  return want(estimateRoute(work, machine), work.rows, machine, "cpu");
+}
+function threshold(work, machine, from) {
+  let e = estimateRoute(work, machine), at = (rows) => want(e, rows, machine, from);
+  if (at(16777216) === "cpu") return null;
+  if (at(1) === "gpu") return 1;
+  let low = 1, high = 16777216;
+  for (; high - low > 1; ) {
+    let mid = low + Math.floor((high - low) / 2);
+    at(mid) === "gpu" ? high = mid : low = mid;
+  }
+  return high;
+}
+function crossoverRows(work, machine) {
+  return threshold(work, machine, "cpu");
+}
+function leaveBelowRows(work, machine) {
+  return threshold(work, machine, "gpu");
+}
+function medianOf(samples, length) {
+  if (length === 0) return 1e3;
+  for (let i = 1; i < length; i++) {
+    let value = samples[i], j = i - 1;
+    for (; j >= 0 && samples[j] > value; )
+      samples[j + 1] = samples[j], j--;
+    samples[j + 1] = value;
+  }
+  return samples[length >> 1];
+}
+function calibrationRuns(runs) {
+  return runs <= 0 ? 0 : runs < 4 ? 4 : runs > 32 ? 32 : runs & -2;
+}
+var KernelRouter = class _KernelRouter {
+  constructor(machineState, runs, pin, preset) {
+    this.machineState = machineState;
+    this.preset = preset;
+    this.current = "cpu";
+    this.decided = false;
+    this.streak = 0;
+    this.switched = 0;
+    this.taken = 0;
+    this.pending = false;
+    this.cpuSamples = new Uint32Array(16);
+    this.gpuSamples = new Uint32Array(16);
+    this.cpuLength = 0;
+    this.gpuLength = 0;
+    this.scratch = emptyEstimate();
+    this.base = emptyEstimate();
+    this.runs = calibrationRuns(runs), this.pinned = pin;
+  }
+  static model(machine) {
+    return new _KernelRouter(machine, 0, null, null);
+  }
+  static calibrating(machine, runs) {
+    return new _KernelRouter(machine, runs, null, null);
+  }
+  static pinned(machine, pin) {
+    return new _KernelRouter(machine, 0, pin, null);
+  }
+  static replaying(machine, runs, pin) {
+    return new _KernelRouter(machine, runs, null, pin);
+  }
+  get machine() {
+    return this.machineState;
+  }
+  set machine(next) {
+    this.machineState = next;
+  }
+  get device() {
+    return this.current;
+  }
+  get pin() {
+    return this.pinned;
+  }
+  get switches() {
+    return this.switched;
+  }
+  get calibrating() {
+    return this.pinned === null && this.taken < this.runs;
+  }
+  get calibrationRuns() {
+    return this.runs;
+  }
+  get sampling() {
+    return this.pending;
+  }
+  route(work) {
+    return this.routeEstimate(fillEstimate(work, this.machineState, this.base), work.rows);
+  }
+  routeEstimate(e, rows, rowBound = 2097152) {
+    if (this.pending = false, this.calibrating) {
+      let cpu = estimatedCpu(e, rows), gpu = estimatedGpu(e, rows);
+      if (gpu * 16 >= cpu && cpu * 16 >= gpu) {
+        let device = this.taken < this.runs / 2 ? "cpu" : "gpu";
+        return this.taken++, this.pending = true, this.current = device, this.streak = 0, this.decided = false, device;
+      }
+    }
+    let next = want(this.pinned === null ? e : scaleEstimate(copyEstimate(e, this.scratch), this.pinned, rowBound), rows, this.machineState, this.current);
+    return this.decided ? (next === this.current ? this.streak = 0 : (this.streak++, this.streak >= 3 && (this.current = next, this.streak = 0, this.switched++)), this.current) : (this.decided = true, this.streak = 0, this.current = next, next);
+  }
+  record(device, work, ns) {
+    this.pending && this.recordEstimate(device, fillEstimate(work, this.machineState, this.base), work.rows, ns);
+  }
+  recordEstimate(device, e, rows, ns) {
+    if (!this.pending) return;
+    this.pending = false;
+    let half = this.runs / 2;
+    if (!(this.taken === 1 || this.taken === half + 1)) {
+      let model = Math.max(device === "cpu" ? estimatedCpu(e, rows) : estimatedGpu(e, rows), 1), measured = Math.min(Math.max(Math.floor(ns), 0), 4294967296) * 1e3, ratio = clamp(Math.floor(measured * 1e3 / model), 250, 4e3);
+      device === "cpu" && this.cpuLength < 16 ? this.cpuSamples[this.cpuLength++] = ratio : device === "gpu" && this.gpuLength < 16 && (this.gpuSamples[this.gpuLength++] = ratio);
+    }
+    if (this.taken >= this.runs) {
+      let cpu = medianOf(this.cpuSamples, this.cpuLength), gpu = medianOf(this.gpuSamples, this.gpuLength);
+      this.pinned = this.preset ?? { cpu, gpu }, this.decided = false, this.streak = 0;
+    }
+  }
+};
+
+// src/game/kernel/rowops.ts
+var KERNEL_ARRAY_PREFIX = "#", KERNEL_TABLE_PREFIX = "%", MAX_ARRAY_LENGTH = 1 << 24, arrays = /* @__PURE__ */ new Map();
+function kernelArray(name, desc) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new GameError("invalid_argument", `kernel array name "${name}" must be letters, digits and underscores`);
+  if (!Number.isInteger(desc.length) || desc.length < 1 || desc.length > MAX_ARRAY_LENGTH) throw new GameError("invalid_argument", `kernel array ${name} needs a whole length from 1 to ${MAX_ARRAY_LENGTH}`);
+  let data = desc.kind === "f32" ? new Float32Array(desc.length) : desc.kind === "i32" ? new Int32Array(desc.length) : new Uint32Array(desc.length), array = { name, kind: desc.kind, length: desc.length, data };
+  return arrays.set(name, array), array;
+}
+function kernelArrayNamed(name) {
+  return arrays.get(name) ?? null;
+}
+function compiledOnly(name) {
+  throw new GameError("unsupported_feature", `${name}() combines every row, so it runs only in a compiled kernel; build the game (cimplify build or cimplify dev) so the kernel has bytecode`);
+}
+function rowSum(value) {
+  return compiledOnly("rowSum");
+}
+function rowMin(value) {
+  return compiledOnly("rowMin");
+}
+function rowMax(value) {
+  return compiledOnly("rowMax");
+}
+function rowCount(when) {
+  return compiledOnly("rowCount");
+}
+function rowArgMin(value) {
+  return compiledOnly("rowArgMin");
+}
+function rowArgMax(value) {
+  return compiledOnly("rowArgMax");
+}
+function rowPrefixSum(value, exclusive) {
+  return compiledOnly("rowPrefixSum");
+}
+function rowScan(value, op, exclusive) {
+  return compiledOnly("rowScan");
+}
+function rowRecur(a, b, exclusive) {
+  return compiledOnly("rowRecur");
+}
+function rowFeedback(b, a1, a2) {
+  return compiledOnly("rowFeedback");
+}
+function rowPhase(increment, period, exclusive) {
+  return compiledOnly("rowPhase");
+}
+function rowPhase64(increment, period, exclusive) {
+  return compiledOnly("rowPhase64");
+}
+function histogram(bins, bin) {
+  compiledOnly("histogram");
+}
+function scatterAdd(target, index, value) {
+  compiledOnly("scatterAdd");
+}
+function compactRows(list) {
+  return compiledOnly("compactRows");
+}
+function sortRows(list, key, descending) {
+  return compiledOnly("sortRows");
+}
+function topRows(list, key, k, smallest) {
+  return compiledOnly("topRows");
+}
+function groupRows(key) {
+  return compiledOnly("groupRows");
+}
+function dedupRows(key) {
+  return compiledOnly("dedupRows");
+}
+
+// src/game/kernel/gpu.ts
+var GPU_KERNEL_EXPORT_NAMES = [
+  "engine_kernel_gpu_ready",
+  "engine_kernel_gpu_bind",
+  "engine_kernel_gpu_unbind",
+  "engine_kernel_gpu_run",
+  "engine_kernel_gpu_frame",
+  "engine_kernel_gpu_sync",
+  "engine_kernel_gpu_touch",
+  "engine_kernel_gpu_events",
+  "engine_kernel_gpu_clear_events"
+], GPU_KERNEL_OPTIONAL_EXPORT_NAMES = ["engine_kernel_gpu_mirror", "engine_kernel_gpu_class"], SAMPLER_PREFIX = "@", OP_MASK = 255, DST_SHIFT = 8, TRANSCENDENTAL_OPS = /* @__PURE__ */ new Set([Op.FPOW, Op.FATAN2, Op.FLOG2, Op.FSIN, Op.FCOS, Op.FTAN, Op.FASIN, Op.FACOS, Op.FATAN, Op.FEXP, Op.FLOG]), shapes = /* @__PURE__ */ new WeakMap();
+function programShape(program) {
+  let known = shapes.get(program);
+  if (known !== void 0) return known;
+  let shape = { instructions: 0, pairs: false, stages: 1, transcendentals: 0, gathers: 0 };
+  if (program.byteLength >= 16 * (4)) {
+    let view = new DataView(program.buffer, program.byteOffset, program.byteLength), word = (at) => view.getUint32(at * (4), true), start = 16 + word(4) + word(5) + word(6) + word(9) * 4 + word(14) * 4, total = program.byteLength / (4), stages = 1, previous = false, transcendentals = 0, gathers = 0;
+    for (let at = start; at + 4 <= total; at += 4) {
+      let head = word(at), op = head & (255);
+      TRANSCENDENTAL_OPS.has(op) && transcendentals++, op === XOP && (head >>> (8) === XOP_GATHER || head >>> (8) === XOP_FIELD) && gathers++;
+      let ends = crossRow(op) || op === XOP && stageEnds(head >>> (8));
+      ends && !previous && stages++, previous = ends || previous && op === Op.EXT;
+    }
+    shape = { instructions: word(8), pairs: (word(2) & 1) !== 0, stages, transcendentals, gathers };
+  }
+  return shapes.set(program, shape), shape;
+}
+var NO_FIELDS = Object.freeze([]), WIDTHS = { vec2: 2, vec3: 3, vec4: 4 }, NO_LIST = 255, ALL_COLUMNS = 255, WORD = 4, MAX_ARG_WORDS = 64, TRUE_BITS = 4294967295, UNSUPPORTED = -5, OVER_LIMITS = -1, GPU_TABLES_LOG_PREFIX = "[kernel tables] ", GPU_JOINED_TABLE_WORDS = DATA_TABLES, DEVICE_UNKNOWN = 0, DEVICE_READY = 1, DEVICE_NONE = 2, AXES = ["x", "y", "z", "w"];
+function gpuTablesLogLine(route) {
+  let how = route.path === "gpu" ? "table reads run on the GPU (nine storage buffers per stage)" : route.path === "cpu-limits" ? "table reads run on the CPU: this device allows fewer than nine storage buffers per stage, or the tables exceed its binding size" : "table reads run on the CPU: the kernel writes other tables or uses lists, tallies or picks";
+  return `${GPU_TABLES_LOG_PREFIX}${route.kernel}: ${how}`;
+}
+function sameJoined(a, b) {
+  if (a === null || b === null) return a === b;
+  if (a.length !== b.length) return false;
+  for (let k = 0; k < a.length; k++) if (a[k] !== b[k] || a[k] !== void 0 && !a[k].valid) return false;
+  return true;
+}
+function scalarPositions(meta) {
+  let tables = meta.data?.tables;
+  if (tables === void 0 || tables.length === 0) return null;
+  let positions = [];
+  for (let k = 0; positions.length < meta.args.length; k++) tables.some((t) => t.position === k) || positions.push(k);
+  return Int32Array.from(positions);
+}
+var NO_ARRAYS = Object.freeze([]);
+function arraySlots(meta) {
+  let out = null;
+  for (let slot of meta.slots) {
+    let table = slot.field.startsWith(KERNEL_TABLE_PREFIX);
+    if (!table && !slot.field.startsWith(KERNEL_ARRAY_PREFIX)) continue;
+    let name = slot.field.slice(1);
+    out ?? (out = []), out.push({ name, arg: table ? meta.args.findIndex((a) => a.name === name) : -1, write: slot.write });
+  }
+  return out ?? NO_ARRAYS;
+}
+function columnField(field) {
+  return field.startsWith(KERNEL_TABLE_PREFIX) || field.startsWith(KERNEL_ARRAY_PREFIX) ? field.slice(1) : field;
+}
+function sameMemory(a, b) {
+  return a.buffer === b.buffer && a.byteOffset === b.byteOffset;
+}
+var GpuKernels = class _GpuKernels {
+  constructor(exports, memory) {
+    this.exports = exports;
+    this.memory = memory;
+    this.entries = /* @__PURE__ */ new Map();
+    this.routes = [];
+    this.touched = /* @__PURE__ */ new Set();
+    this.resident = /* @__PURE__ */ new WeakSet();
+    this.pending = /* @__PURE__ */ new Set();
+    this.engineClass = null;
+    this.argsAt = 0;
+    this.argsBuffer = null;
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.priority = 0;
+    this.compute = null;
+    this.onTables = (route) => console.info(gpuTablesLogLine(route));
+    this.device = (0);
+    this.mirrored = /* @__PURE__ */ new WeakMap();
+  }
+  static bind(symbols, memory) {
+    for (let name of GPU_KERNEL_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+    return typeof symbols.engine_alloc != "function" || typeof symbols.engine_free != "function" ? null : new _GpuKernels(symbols, memory);
+  }
+  available() {
+    return this.device === (0) && (this.device = this.exports.engine_kernel_gpu_ready() === 1 ? (1) : (2)), this.device === (1);
+  }
+  deviceClass(fallback) {
+    if (this.engineClass === null) {
+      let ask = this.exports.engine_kernel_gpu_class;
+      this.engineClass = typeof ask == "function" && this.available() ? gpuDeviceClass(ask()) : "unknown";
+    }
+    return this.engineClass === "unknown" ? fallback : this.engineClass;
+  }
+  hostBackend() {
+    return wasmInstantiates() && this.memory instanceof WebAssembly.Memory ? "wasm" : "interpreter";
+  }
+  work(meta, program, table, rows, lanes, readback, batched = false) {
+    let shape = programShape(program);
+    return { rows, instructions: shape.instructions, pairs: shape.pairs, stages: shape.stages, columns: meta.slots.length, resident: this.resident.has(table), readback, lanes, transcendentals: shape.transcendentals, batched };
+  }
+  beforeCpu(table) {
+    this.pending.has(table) && this.sync();
+  }
+  afterCpu(table, meta) {
+    if (this.resident.has(table)) {
+      if (meta === null) {
+        this.exports.engine_kernel_gpu_touch(table.id, (255)), this.resident.delete(table);
+        return;
+      }
+      for (let slot of meta.slots) slot.write && slot.field in table.schema && this.exports.engine_kernel_gpu_touch(table.id, table.column(slot.field, slot.component));
+    }
+  }
+  tablesRoute(entry, meta, path) {
+    entry.routed || (entry.routed = true, this.onTables?.({ kernel: meta.name, path }));
+  }
+  joinedOf(entry, meta, table, args) {
+    let known = entry.joined, list = meta.data?.tables;
+    if (known === null || list === void 0)
+      return entry.joined = dataTables(meta, table, args), entry.joined;
+    known[0] = table;
+    for (let k = 0; k < list.length; k++) {
+      let value = args[list[k].position];
+      if (typeof value != "object" || value === null || !("schema" in value))
+        return entry.joined = dataTables(meta, table, args), entry.joined;
+      known[list[k].table] = value;
+    }
+    return known;
+  }
+  binding(meta, bytes, table, args) {
+    let entry = this.entries.get(bytes);
+    if (entry === void 0 && (entry = { eligible: true, routed: false, bound: [], arrays: arraySlots(meta), scalars: scalarPositions(meta), data: hasData(meta), joined: null }, this.entries.set(bytes, entry)), !entry.eligible) return (-5);
+    let data = entry.data, joined = data ? this.joinedOf(entry, meta, table, args) : null;
+    if (joined !== null && joined.some((t, k) => k > 0 && t !== void 0 && !t.native)) return (-5);
+    for (let b of entry.bound) if (b.table === table && table.valid && sameJoined(b.joined, joined)) return b.binding;
+    for (let k = entry.bound.length - 1; k >= 0; k--)
+      entry.bound[k].table.valid || (this.exports.engine_kernel_gpu_unbind(entry.bound[k].binding), this.compute?.unbound(COMPUTE_SPACE_GPU, entry.bound[k].binding), entry.bound.splice(k, 1));
+    if (meta.slots.some((slot) => slot.field.startsWith(SAMPLER_PREFIX)) || entry.arrays.some((a) => !this.carries(table, a, meta)))
+      return entry.eligible = false, (-5);
+    let columns = new Uint32Array(meta.slots.length + (joined === null ? 0 : GPU_JOINED_TABLE_WORDS));
+    for (let k = 0; k < meta.slots.length; k++) {
+      let slot = meta.slots[k];
+      if (slot.pool !== void 0) {
+        columns[k] = 4294967295;
+        continue;
+      }
+      let source = joined !== null && slot.table !== void 0 && slot.table > 0 ? joined[slot.table] : table, field = columnField(slot.field);
+      if (!(field in source.schema)) throw new GameError("invalid_argument", `kernel ${meta.name} reads ${slot.field}, which ${source === table ? "this" : "the joined"} table does not have`);
+      columns[k] = source.column(field, field === slot.field ? slot.component : 0);
+    }
+    if (joined !== null) for (let t = 0; t < GPU_JOINED_TABLE_WORDS; t++) columns[meta.slots.length + t] = t < joined.length && joined[t] !== void 0 ? joined[t].id : 4294967295;
+    let programAt = this.copyIn(bytes), columnsAt = this.copyIn(new Uint8Array(columns.buffer)), binding = this.exports.engine_kernel_gpu_bind(programAt, bytes.byteLength, table.id, columnsAt, columns.length);
+    if (this.exports.engine_free(programAt, Math.max(bytes.byteLength, (4)), (4)), this.exports.engine_free(columnsAt, Math.max(columns.byteLength, (4)), (4)), binding === (-5) || data && binding === (-1))
+      return entry.eligible = false, data && this.tablesRoute(entry, meta, binding === (-5) ? "cpu-ineligible" : "cpu-limits"), (-5);
+    if (binding < 0) throw new GameError("invalid_argument", `the engine refused GPU kernel ${meta.name} (${binding})`);
+    return data && this.tablesRoute(entry, meta, "gpu"), entry.bound.push({ table, joined: joined === null ? null : joined.slice(), binding }), this.compute?.bound(COMPUTE_SPACE_GPU, binding, meta.name, this.priority), meta.channels !== void 0 && meta.channels.length > 0 && this.routes.push({ binding, meta }), binding;
+  }
+  carries(table, array, meta) {
+    let kind = table.schema[array.name];
+    if (kind !== "f32" && kind !== "i32" && kind !== "u32") return false;
+    let slot = meta.slots.find((s) => columnField(s.field) === array.name && s.field !== array.name);
+    return slot !== void 0 && slot.kind === kind;
+  }
+  stage(entry, table, args) {
+    for (let array of entry.arrays) {
+      let column = table.values(array.name), source = array.arg >= 0 ? args[array.arg] : kernelArrayNamed(array.name)?.data;
+      if (!(source instanceof column.constructor)) return false;
+      let data = source;
+      if (!sameMemory(data, column)) {
+        if (array.write || data.length > column.length) return false;
+        column.set(data), this.touched.has(table) && this.exports.engine_kernel_gpu_touch(table.id, table.column(array.name, 0));
+      }
+    }
+    return true;
+  }
+  copyIn(bytes) {
+    let at = this.exports.engine_alloc(Math.max(bytes.byteLength, (4)), (4));
+    if (at === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold a GPU kernel binding");
+    return new Uint8Array(this.memory.buffer, at, bytes.byteLength).set(bytes), at;
+  }
+  argViews() {
+    let buffer = this.memory.buffer;
+    if (this.argsAt === 0 && (this.argsAt = this.exports.engine_alloc((64) * (4), (4)), this.argsAt === 0))
+      throw new GameError("capacity_exceeded", "engine memory cannot hold kernel arguments");
+    this.argsBuffer !== buffer && (this.words = new Uint32Array(buffer, this.argsAt, (64)), this.floats = new Float32Array(buffer, this.argsAt, (64)), this.argsBuffer = buffer);
+  }
+  writeArg(at, arg, value) {
+    if (arg.kind === "f64" || arg.kind === "u64") return writeWideArg(this.words, at, arg.kind, value);
+    if (arg.width === 1 && ArrayBuffer.isView(value))
+      return this.words[at] = value.length >>> 0, at + 1;
+    if (arg.width > 1 && (Array.isArray(value) || ArrayBuffer.isView(value))) {
+      let items = value;
+      for (let k = 0; k < arg.width; k++)
+        arg.kind === "f32" ? this.floats[at + k] = items[k] : this.words[at + k] = items[k] >>> 0;
+      return at + arg.width;
+    }
+    if (arg.width > 1) {
+      let vector = value;
+      for (let k = 0; k < arg.width; k++) this.floats[at + k] = vector[AXES[k]];
+      return at + arg.width;
+    }
+    return arg.kind === "f32" ? this.floats[at] = value : arg.kind === "bool" ? this.words[at] = value ? (4294967295) : 0 : this.words[at] = value >>> 0, at + 1;
+  }
+  eligible(bytes) {
+    return this.device !== (2) && this.entries.get(bytes)?.eligible !== false;
+  }
+  mirror(table, fields) {
+    let known = this.mirrored.get(table);
+    if (known === fields || known !== void 0 && known.length === fields.length && known.every((f, k) => f === fields[k])) return;
+    let set = this.exports.engine_kernel_gpu_mirror;
+    if (typeof set == "function") {
+      this.mirrored.set(table, fields), set(table.id, (255), 0);
+      for (let field of fields) {
+        if (!(field in table.schema)) throw new GameError("invalid_argument", `onGpu mirrors ${field}, which this table does not have`);
+        let width = WIDTHS[table.schema[field]] ?? 1;
+        for (let k = 0; k < width; k++) set(table.id, table.column(field, k), 1);
+      }
+    }
+  }
+  run(meta, bytes, table, selection, args, now, mirror = NO_FIELDS) {
+    if (!table.native || meta.argWords > (64) || !this.available()) return null;
+    let binding = this.binding(meta, bytes, table, args);
+    if (binding === (-5)) return null;
+    let entry = this.entries.get(bytes);
+    if (entry.arrays.length > 0 && !this.stage(entry, table, args)) return null;
+    this.mirror(table, mirror), this.argViews();
+    let at = 0, scalars = entry.scalars;
+    for (let k = 0; k < meta.args.length; k++) at = this.writeArg(at, meta.args[k], args[scalars === null ? k : scalars[k]]);
+    let list = selection ? selection.index : (255);
+    this.compute?.prioritise(COMPUTE_SPACE_GPU, binding, this.priority);
+    let ran = this.exports.engine_kernel_gpu_run(binding, list, this.argsAt, at);
+    if (ran === COMPUTE_DEFERRED && this.priority !== 0) return 0;
+    if (ran < 0) throw new GameError("invalid_argument", `GPU kernel ${meta.name} failed (${ran})`);
+    return this.touched.add(table), this.resident.add(table), now ? (this.exports.engine_kernel_gpu_sync(), this.pending.clear(), this.route()) : this.pending.add(table), ran;
+  }
+  touch(table, field, component = 0) {
+    this.touched.has(table) && (field === void 0 && this.resident.delete(table), this.exports.engine_kernel_gpu_touch(table.id, field === void 0 ? (255) : table.column(field, component)));
+  }
+  sync() {
+    this.touched.size !== 0 && (this.exports.engine_kernel_gpu_sync(), this.pending.clear(), this.route());
+  }
+  frame() {
+    this.touched.size !== 0 && (this.exports.engine_kernel_gpu_frame(), this.route());
+  }
+  route() {
+    for (let { binding, meta } of this.routes) {
+      let at = this.exports.engine_kernel_gpu_events(binding);
+      at === 0 || meta.channels === void 0 || (routeEvents(new Uint32Array(this.memory.buffer, at, RING_HEADER_WORDS + DEFAULT_EVENT_CAPACITY * 10), meta.channels), this.exports.engine_kernel_gpu_clear_events(binding));
+    }
+  }
+  dispose() {
+    for (let entry of this.entries.values()) for (let b of entry.bound) this.exports.engine_kernel_gpu_unbind(b.binding);
+    this.argsAt !== 0 && this.exports.engine_free(this.argsAt, (64) * (4), (4)), this.entries.clear(), this.routes.length = 0, this.touched.clear(), this.pending.clear(), this.argsAt = 0;
+  }
+};
+
+export { CPU_BACKENDS, GPU_KERNEL_EXPORT_NAMES, GPU_KERNEL_OPTIONAL_EXPORT_NAMES, GpuKernels, KERNEL_ARRAY_PREFIX, KERNEL_TABLE_PREFIX, KernelRouter, NO_FIELDS, SET_ROW_BOUND, chooseDevice, compactRows, crossoverRows, dedupRows, emptyEstimate, fillSetEstimate, groupRows, histogram, hostEngine, kernelArray, kernelArrayNamed, kernelMachine, leaveBelowRows, programShape, rowArgMax, rowArgMin, rowCount, rowFeedback, rowMax, rowMin, rowPhase, rowPhase64, rowPrefixSum, rowRecur, rowScan, rowSum, scatterAdd, sortRows, topRows, wasmInstantiates };