@cimplify/sdk 0.108.0 → 0.110.2

package/dist/game/conformance.mjs

@@ -0,0 +1,994 @@
+import { collectYoung, measureAllocations, warmUp, measureSteadyAllocations, profileAllocationSites } from '../chunk-6H254EVP.mjs';
+export { collectGarbage, createNodeHeapMeter, measureAllocations, profileAllocationSites, warmUp } from '../chunk-6H254EVP.mjs';
+import { kitPublicationGates } from '../chunk-XZSDGZX6.mjs';
+import '../chunk-3DAD2LDF.mjs';
+import '../chunk-4DYKAYFO.mjs';
+import { createTemplateHarness } from '../chunk-KGHJH5KJ.mjs';
+import { checkGameSources } from '../chunk-R56P64LB.mjs';
+import { sphereGeometry, boxGeometry } from '../chunk-GHPUYD4I.mjs';
+import { createGame, World } from '../chunk-KVFNRJOR.mjs';
+import { Ease, Repeat, TweenTarget } from '../chunk-KDTVOLHI.mjs';
+import { quantized, LoopbackTransport, MessageWriter, SnapshotBuffer } from '../chunk-RM2V4IND.mjs';
+import '../chunk-22BD3RHN.mjs';
+import { defineComponent } from '../chunk-ME6HGG4I.mjs';
+import '../chunk-5BYDGGWO.mjs';
+import { emptyClipState } from '../chunk-7ARSJPV3.mjs';
+import '../chunk-RUVGVNOF.mjs';
+import { RayHit, RayQuery, CharacterMove } from '../chunk-HF5HPS4T.mjs';
+import { Vec3, Quat } from '../chunk-XPG3N5CF.mjs';
+import { mat4ComposeArrays, mat4Compose, quatSlerpArrays } from '../chunk-KIZOA5LX.mjs';
+import '../chunk-7SXOHAIR.mjs';
+import '../chunk-ATAWRACV.mjs';
+import '../chunk-T3AFF3L7.mjs';
+import { createGpuStats, GPU_PASS_NAMES } from '../chunk-TL2SVO4P.mjs';
+import { FRAME_NOW_MS_SLOT, FrameTime, FRAME_ALPHA_SLOT, FRAME_STEP_SECONDS_SLOT } from '../chunk-IDLW4NWA.mjs';
+import '../chunk-73SGZLAQ.mjs';
+import '../chunk-M5EXQZYY.mjs';
+import '../chunk-TU5RYTYU.mjs';
+import '../chunk-EIB4OWVQ.mjs';
+import '../chunk-PBL6YL5L.mjs';
+import '../chunk-E65WCTIG.mjs';
+import '../chunk-5YFBGGCK.mjs';
+import '../chunk-K4UDGE3Z.mjs';
+import '../chunk-MOBSBXVE.mjs';
+import '../chunk-SMK6JU2F.mjs';
+import '../chunk-JURRXY2J.mjs';
+import '../chunk-GHS6MIL6.mjs';
+import '../chunk-GDCV4IWO.mjs';
+import '../chunk-Y66WVMO5.mjs';
+import '../chunk-A33OORT7.mjs';
+import '../chunk-LYEZZEEF.mjs';
+import '../chunk-HAGEIC2L.mjs';
+import '../chunk-K46SMZ66.mjs';
+import '../chunk-OQRVEM56.mjs';
+import '../chunk-SPCRQ6NO.mjs';
+import '../chunk-V7ZRH3PY.mjs';
+import '../chunk-MOMOZEUM.mjs';
+import '../chunk-N4RGGDEL.mjs';
+import { GameError } from '../chunk-XJIHN3BY.mjs';
+import '../chunk-25T4JHEA.mjs';
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+// src/game/conformance/harness.ts
+var SUSTAINED_BODIES = 48, SUSTAINED_INSTANCES = 512, SUSTAINED_SEED = 9, BOB_RATE = 0.05, KEY_TOGGLE_PERIOD = 7, FRAMES_PER_STAMP_CYCLE = 3, MS_PER_STAMP_CYCLE = 50, INSTANCE_POSITION = 0, INSTANCE_ROTATION = 3, INSTANCE_SCALE = 7, INSTANCE_POSE = 10, INSTANCE_ROW = 32, BODY_ROW = 8, GROUND_HALF_EXTENT = 50, SilentUiHost = class {
+  constructor() {
+    this.publishes = 0;
+  }
+  declareHud(_layout) {
+  }
+  publishHud(_numbers, _texts, _dirty, _dirtyCount) {
+    this.publishes++;
+  }
+  showPanel(_panel, _props) {
+  }
+  hidePanel(_panel) {
+  }
+  haptic(_pattern) {
+  }
+};
+function frameStamp(frame) {
+  return frame * (50) / (3) | 0;
+}
+function spawnAt(game, x, y, z) {
+  let e = game.world.spawn();
+  return game.transforms.add(e, x, y, z), e;
+}
+async function createSustainedHarness(backend, vendorQueries) {
+  let game = await createGame({ backend, seed: (9), ui: new SilentUiHost() }), floor = spawnAt(game, 0, -0.5, 0);
+  game.physics.addCollider(floor, { shape: { kind: "cuboid", halfExtents: [(50), 0.5, (50)] } });
+  let gfx = game.graphics, geometry = gfx.createGeometry(sphereGeometry(0.25, 8, 6)), material = gfx.createMaterial({ kind: "standard" }), camera = spawnAt(game, 0, 3, 10);
+  gfx.camera(camera), game.audio.setListener(camera);
+  let bodies = [], bodyKind = vendorQueries ? "dynamic" : "kinematic";
+  for (let i = 0; i < (48); i++) {
+    let e = spawnAt(game, i % (8) - (8) / 2, 1 + Math.floor(i / (8)), 0);
+    game.physics.addBody(e, { kind: bodyKind, canSleep: false }), game.physics.addCollider(e, { shape: { kind: "ball", radius: 0.25 }, restitution: 0.9 }), gfx.mesh(e, geometry, material), bodies.push(e);
+  }
+  let positions = game.transforms.store.fields.position, kinematic = spawnAt(game, 0, 0.6, 3);
+  game.physics.addBody(kinematic, { kind: "kinematic" });
+  let kinematicCollider = game.physics.addCollider(kinematic, { shape: { kind: "capsule", halfHeight: 0.3, radius: 0.3 } }), controller = game.physics.createCharacterController({ snapToGround: 0.2 }), batch = gfx.instanced({ geometry, material, capacity: (512), colors: true }), jump = game.input.defineButton("jump", [{ device: "key", code: "Space" }]), move = game.input.defineAxis("move", [{ device: "keys", negative: "KeyA", positive: "KeyD" }]), score = game.ui.hudNumber("score"), pulse = game.animation.createValue(0);
+  game.animation.tweenValue(pulse, 1, 0.5, Ease.InOutSine, 0, Repeat.PingPong), game.animation.tween(bodies[0], TweenTarget.ScaleUniform, 1.5, 0.75, Ease.OutBack, 0, Repeat.Loop);
+  let Pos = game.net.defineMessage("pos", {
+    id: "u16",
+    x: quantized(-50, 50, 16),
+    y: quantized(-50, 50, 16),
+    z: quantized(-50, 50, 16)
+  }), [local, remote] = LoopbackTransport.pair();
+  game.net.connect(local), remote.open("state", "latest");
+  let channel = game.net.channel("state", "latest"), reader = game.net.reader(), writer = new MessageWriter(), fx = Pos.field("x"), fy = Pos.field("y"), fz = Pos.field("z"), fid = Pos.field("id"), hit = new RayHit(), ray = new RayQuery().set(0, 10, 0, 0, -1, 0, 20), characterMove = new CharacterMove(), desired = new Vec3(), hop = new Vec3(0, 2, 0), position = new Vec3(), sound = await game.audio.load({ bytes: new ArrayBuffer(8) }), emitter = game.audio.playAt(bodies[1], sound, game.audio.effects, 1, 1, true), query = game.world.query(game.transforms.store.type), instance = new Float32Array((10));
+  instance[(3) + 3] = 1, instance[(7)] = 1, instance[(7) + 1] = 1, instance[(7) + 2] = 1;
+  let sink = new Float64Array(1), bob = (g) => {
+    for (let i = 0; i < (48); i++) {
+      let row = g.transforms.row(bodies[i]);
+      positions[row * 3 + 1] = 1 + Math.sin(g.tick * (0.05) + i);
+    }
+  }, vendor = (g) => {
+    let dt = g.clock[FRAME_STEP_SECONDS_SLOT];
+    g.input.justPressed(jump) && g.physics.applyImpulse(bodies[g.tick % (48)], hop), g.physics.moveCharacter(controller, kinematicCollider, desired.set(g.input.value(move) * dt, -dt, 0), characterMove), g.physics.raycast(ray, hit) && (sink[0] += hit.distance);
+    for (let i = 0; i < g.physics.contactCount(); i++) sink[0] += g.physics.contactColliderA(i);
+  };
+  game.addSystem({
+    fixedUpdate: vendorQueries ? vendor : bob,
+    update: (g) => {
+      let m = batch.matrices;
+      instance[(0) + 1] = g.animation.value(pulse);
+      for (let i = 0; i < (512); i++)
+        instance[(0)] = i % (32), instance[(0) + 2] = i / (32) | 0, mat4ComposeArrays(m, i * 16, instance, (0), instance, (3), instance, (7));
+      for (g.graphics.setInstanceCount(batch, (512)), g.graphics.markInstancesDirty(batch), g.ui.setNumber(score, g.tick), g.transforms.position(bodies[2], position), writer.begin(Pos).set(fid, 2).setVec3(fx, fy, fz, position), channel.send(writer), remote.send(0, writer.buffer, writer.length); channel.receive(reader); ) sink[0] += reader.get(fy);
+      sink[0] += query.update(), sink[0] += g.audio.isPlaying(emitter) ? 1 : 0;
+    }
+  });
+  let keys = ["Space", "KeyD", "KeyA"];
+  return {
+    game,
+    frame(index) {
+      let key = keys[index % keys.length];
+      index % (7) === 0 ? game.input.keyEvent(key, true, index) : index % (7) === 1 && game.input.keyEvent(key, false, index), game.clock[FRAME_NOW_MS_SLOT] = frameStamp(index), game.runFrame();
+    },
+    sink() {
+      return sink[0];
+    }
+  };
+}
+
+// src/game/conformance/load.ts
+var OS_MODULE = "node:os";
+var TIMING_BUDGETS_ENV = "CIMPLIFY_TIMING_BUDGETS", ADVISORY_TIMING_BUDGETS = "advisory";
+function timingBudgetsAdvisory() {
+  return globalThis.process?.env?.[TIMING_BUDGETS_ENV] === ADVISORY_TIMING_BUDGETS;
+}
+function isOs(value) {
+  let os = value;
+  return typeof os?.availableParallelism == "function" && typeof os.loadavg == "function";
+}
+async function busyMachine() {
+  let os;
+  try {
+    os = await import(
+      /* @vite-ignore */
+      OS_MODULE
+    );
+  } catch {
+    return null;
+  }
+  if (!isOs(os)) return null;
+  let cores = os.availableParallelism(), load = os.loadavg()[0];
+  return timingBudgetsAdvisory() ? { load, cores, advisory: true } : load > cores ? { load, cores, advisory: false } : null;
+}
+function loadSkipNotice(busy) {
+  return busy.advisory ? `::warning::timing budget is advisory on this runner (${TIMING_BUDGETS_ENV}=${ADVISORY_TIMING_BUDGETS}, 1-minute load ${busy.load.toFixed(2)} on ${busy.cores} cores); compare the measured numbers against the budgets` : `budget gate skipped: 1-minute load average ${busy.load.toFixed(2)} exceeds ${busy.cores} cores; rerun on a quiet machine`;
+}
+
+// src/game/conformance/microbench.ts
+var DEFAULT_MICROBENCH_BUDGETS_NS = {
+  mat4Compose: 50,
+  slerp: 200,
+  transformPerEntity: 200,
+  queryPerEntity: 30,
+  codecField: 100,
+  raycast: 5e3,
+  physicsStepPerBody: 1e4
+}, MATH_ITERATIONS = 5e5, FIELD_ITERATIONS = 5e5, ENTITY_PASSES = 100, RAYCASTS = 2e3, STEP_BODIES = 256, STEP_PASSES = 120, STEP_SETTLE = 60, STEP_ROW = 16, STEP_LAYERS = 3, STEP_SPACING = 1.1, STEP_BASE_HEIGHT = 0.6, STEP_RADIUS = 0.5, STEP_GROUND_HALF_EXTENT = 100, ENTITIES = 1e3, WARMUP_PASSES = 2, WARMUP_MIN_MS = 200, WARMUP_MAX_MS = 3e3, SETTLED_RATIO = 0.95, SAMPLED_PASSES = 4, MIN_SAMPLES = 64, SAMPLE_TARGET_NS = 1e5, SAMPLING_MIN_MS = 300, SAMPLING_MAX_MS = 2e3, NS_PER_MS = 1e6, POSE = [1, 2, 3, 0, 0, 0, 1, 1, 1, 1], ROTATIONS = [0, 0, 0, 1, 0, Math.SQRT1_2, 0, Math.SQRT1_2];
+function time(iterations, body) {
+  let i = 0, probe = Number.POSITIVE_INFINITY, warmupStart = performance.now();
+  for (let pass = 0; ; pass++) {
+    let passStart = performance.now();
+    for (let k = 0; k < iterations; k++) body(i++);
+    let now = performance.now(), perIteration = (now - passStart) * (1e6) / iterations, improving = perIteration < probe * (0.95);
+    perIteration < probe && (probe = perIteration);
+    let warm = now - warmupStart;
+    if (warm >= (3e3) || pass + 1 >= (2) && warm >= (200) && !improving) break;
+  }
+  let batch = Math.min(iterations, Math.max(1, Math.ceil((1e5) / Math.max(probe, Number.MIN_VALUE)))), samples = Math.max((64), Math.ceil((4) * iterations / batch)), floor = Number.POSITIVE_INFINITY, samplingStart = performance.now();
+  for (let sample = 0; ; sample++) {
+    let start = performance.now();
+    for (let k = 0; k < batch; k++) body(i++);
+    let end = performance.now(), perIteration = (end - start) * (1e6) / batch;
+    perIteration < floor && (floor = perIteration);
+    let sampled = end - samplingStart;
+    if (sampled >= (2e3) || sample + 1 >= samples && sampled >= (300)) break;
+  }
+  return floor;
+}
+async function runMicrobench(createBackend) {
+  let out = new Float32Array(64), pose = Float32Array.from(POSE), rotations = Float32Array.from(ROTATIONS), weight = new Float64Array([0.5]), mat4Compose2 = time((5e5), (i) => mat4ComposeArrays(out, (i & 3) * 16, pose, 0, pose, 3, pose, 7)), slerp = time((5e5), (i) => quatSlerpArrays(out, (i & 3) * 4, rotations, 0, rotations, 4, weight, 0)), game = await createGame({ backend: createBackend() }), ground2 = game.world.spawn();
+  game.transforms.add(ground2, 0, -0.5, 0), game.physics.addCollider(ground2, { shape: { kind: "cuboid", halfExtents: [50, 0.5, 50] } });
+  for (let i = 0; i < (1e3); i++) {
+    let e = game.world.spawn();
+    game.transforms.add(e, i, 0, 0);
+  }
+  let frame = new FrameTime();
+  frame.values[FRAME_ALPHA_SLOT] = 0.5;
+  let transformPerEntity = time((100), () => game.transforms.computeRender(frame)) / (1e3), query = game.world.query(game.transforms.store.type), queryPerEntity = time((100), () => query.update()) / (1e3), message = game.net.defineMessage("bench", { x: quantized(-10, 10, 12) }), writer = new MessageWriter();
+  writer.begin(message);
+  let field = message.field("x"), codecField = time((5e5), (i) => writer.set(field, (i & 15) - 8));
+  game.advance(1);
+  let hit = new RayHit(), ray = new RayQuery().set(0, 5, 0, 0, -1, 0, 10), raycast = time((2e3), () => game.physics.raycast(ray, hit));
+  game.dispose();
+  let physicsStepPerBody = await stepCost(createBackend);
+  return { mat4Compose: mat4Compose2, slerp, transformPerEntity, queryPerEntity, codecField, raycast, physicsStepPerBody };
+}
+async function stepCost(createBackend) {
+  let game = await createGame({ backend: createBackend() }), ground2 = game.world.spawn();
+  game.transforms.add(ground2, 0, -0.5, 0), game.physics.addCollider(ground2, { shape: { kind: "cuboid", halfExtents: [(100), 0.5, (100)] } });
+  for (let i = 0; i < (256); i++) {
+    let e = game.world.spawn();
+    game.transforms.add(e, i % (16) * (1.1), (0.6) + i % (3) * (1.1), (i / (16) | 0) * (1.1)), game.physics.addBody(e, { kind: "dynamic", canSleep: false }), game.physics.addCollider(e, { shape: { kind: "ball", radius: (0.5) } });
+  }
+  for (let i = 0; i < (60); i++) game.physics.step();
+  let perBody = time((120), () => game.physics.step()) / (256);
+  return game.dispose(), perBody;
+}
+
+// src/game/conformance/suite.ts
+async function measureSustainedAllocation(createBackend, heap, vendorQueries, sustainedFrames = (6e3), freshIsolate = false) {
+  let meter = await heap();
+  if (!meter) return null;
+  let harness = await createSustainedHarness(createBackend(), vendorQueries), start = (3e4);
+  if (freshIsolate) {
+    for (let i = 0; i < (3e4); i++) harness.frame(i);
+    collectYoung();
+    for (let block = 0; block < (8); block++) {
+      let settled = await measureAllocations(meter, (3e3), (i) => harness.frame(start + i));
+      if (start += (3e3), settled.bytes === 0) break;
+    }
+    collectYoung();
+  } else await warmUp((3e4), (i) => harness.frame(i));
+  let report = await measureAllocations(meter, sustainedFrames, (i) => harness.frame(start + i)), longer = await measureAllocations(meter, sustainedFrames * 2, (i) => harness.frame(start + sustainedFrames + i));
+  if (meter.dispose(), harness.game.dispose(), !Number.isFinite(harness.sink())) throw new Error("the sustained harness produced a non-finite sink");
+  return [report, longer];
+}
+var DEFAULT_SUSTAINED_FRAMES = 6e3, WARMUP_FRAMES = 3e4, QUIESCE_BLOCKS = 8, QUIESCE_BLOCK_FRAMES = 3e3, QUIESCE_PAST_V8_FRAME_CHAIN_TIER_UP = true, FRAME_MS = 1e3 / 60, RESIDUE_BYTES_PER_FRAME = 1, MICROBENCH_TIMEOUT_MS = 12e4, RecordingUiHost = class {
+  constructor() {
+    this.layout = [];
+    this.publishes = 0;
+    this.lastDirty = 0;
+    this.panels = [];
+    this.haptics = [];
+  }
+  declareHud(layout) {
+    this.layout = layout;
+  }
+  publishHud(_numbers, _texts, _dirty, dirtyCount) {
+    this.publishes++, this.lastDirty = dirtyCount;
+  }
+  showPanel(panel) {
+    this.panels.push(panel);
+  }
+  hidePanel(panel) {
+    this.panels.splice(this.panels.indexOf(panel), 1);
+  }
+  haptic(pattern) {
+    this.haptics.push(pattern);
+  }
+};
+function emptyStats() {
+  return { nodes: 0, geometries: 0, materials: 0, textures: 0, renderTargets: 0, postChains: 0, renderPasses: 0, frames: 0 };
+}
+function spawnAt2(game, x, y, z) {
+  let e = game.world.spawn();
+  return game.transforms.add(e, x, y, z), e;
+}
+function ground(game) {
+  let e = spawnAt2(game, 0, -0.5, 0);
+  return game.physics.addCollider(e, { shape: { kind: "cuboid", halfExtents: [50, 0.5, 50] } }), e;
+}
+function hostClocks() {
+  let clocks = [];
+  for (let scope of [globalThis, Reflect.get(globalThis, "self"), Reflect.get(globalThis, "window")]) {
+    if (typeof scope != "object" || scope === null) continue;
+    let clock = Reflect.get(scope, "performance");
+    clock instanceof Object && clocks.indexOf(clock) < 0 && clocks.push(clock);
+  }
+  return clocks;
+}
+function withFrozenHostClock(run2) {
+  let clocks = hostClocks(), saved = clocks.map((clock) => Object.getOwnPropertyDescriptor(clock, "now"));
+  for (let clock of clocks) Object.defineProperty(clock, "now", { configurable: true, writable: true, value: frozenNow });
+  return run2().finally(() => {
+    for (let i = 0; i < clocks.length; i++) {
+      let own = saved[i];
+      own ? Object.defineProperty(clocks[i], "now", own) : Reflect.deleteProperty(clocks[i], "now");
+    }
+  });
+}
+function defineGameConformanceSuite(options) {
+  let make = (seed = 1, ui = null) => createGame({ backend: options.createBackend(), seed, ui });
+  describe(`game API conformance: ${options.name}`, () => {
+    describe("entities and components", () => {
+      it("reuses indices with new generations and invalidates stale handles", () => {
+        let world = new World(8), a = world.spawn();
+        expect(world.despawn(a)).toBe(true);
+        let b = world.spawn();
+        expect(b).not.toBe(a), expect(world.isAlive(a)).toBe(false), expect(world.isAlive(b)).toBe(true), expect(world.despawn(a)).toBe(false);
+      }), it("stores fields as structure of arrays and swap-removes", () => {
+        let Health = defineComponent("conformance-health", { hp: "f32", armor: ["u8", 2] }), world = new World(16), store = world.register(Health), e = [];
+        for (let i = 0; i < 4; i++) {
+          e.push(world.spawn());
+          let row = world.add(e[i], Health);
+          store.fields.hp[row] = i * 10, store.fields.armor[row * 2 + 1] = i;
+        }
+        world.remove(e[1], Health), expect(store.count).toBe(3);
+        let moved = store.row(e[3]);
+        expect(store.fields.hp[moved]).toBe(30), expect(store.fields.armor[moved * 2 + 1]).toBe(3), expect(store.has(e[1])).toBe(false);
+      }), it("queries the intersection of components", () => {
+        let A = defineComponent("conformance-a", { v: "i32" }), B = defineComponent("conformance-b", { v: "i32" }), world = new World(32), q = world.query(A, B);
+        for (let i = 0; i < 10; i++) {
+          let e = world.spawn();
+          world.add(e, A), i % 2 === 0 && world.add(e, B);
+        }
+        expect(q.update()).toBe(5);
+        for (let i = 0; i < q.count; i++) expect(world.has(q.entityAt(i), B)).toBe(true);
+      }), it("refuses growth past declared capacity", () => {
+        let world = new World(2);
+        world.spawn(), world.spawn(), expect(() => world.spawn()).toThrow(GameError);
+      });
+    }), describe("loop, scenes and transforms", () => {
+      it("runs fixed steps with interpolation and clamps runaway frames", async () => {
+        let game = await make();
+        game.frame(0), game.frame(FRAME_MS * 2.5), expect(game.tick).toBe(2), expect(game.alpha).toBeCloseTo(0.5, 5), game.frame(FRAME_MS * 2.5 + 1e4), expect(game.tick).toBe(2 + game.loop.maxSubsteps), game.dispose();
+      }), it("switches scenes at step boundaries with enter and exit", async () => {
+        let game = await make(), log = [];
+        game.addScene({ name: "a", enter: () => log.push("enter a"), exit: () => log.push("exit a") }), game.addScene({ name: "b", enter: () => log.push("enter b"), fixedUpdate: () => log.push("step b") }), game.start("a"), game.scenes.switchTo("b"), game.advance(1), expect(log).toEqual(["enter a", "exit a", "enter b", "step b"]), game.dispose();
+      }), it("interpolates render matrices and composes hierarchies", async () => {
+        let game = await make(), parent = spawnAt2(game, 0, 0, 0), child = spawnAt2(game, 1, 0, 0);
+        game.transforms.setParent(child, parent), game.advance(1), game.transforms.snapshot(), game.transforms.setPosition(parent, 10, 0, 0), game.transforms.computeRender(halfway());
+        let out = new Vec3();
+        expect(game.transforms.renderPosition(parent, out).x).toBeCloseTo(5, 5), expect(game.transforms.renderPosition(child, out).x).toBeCloseTo(6, 5), game.dispose();
+      });
+    }), describe("graphics", () => {
+      it("creates every resource family and mirrors entity matrices onto nodes", async () => {
+        let game = await make(), gfx = game.graphics, geometry = gfx.createGeometry(boxGeometry(1, 2, 3)), material = gfx.createMaterial({ kind: "standard", color: 16711680, roughness: 0.5 }), e = spawnAt2(game, 1, 2, 3), node = gfx.mesh(e, geometry, material), camera = spawnAt2(game, 0, 1, 5);
+        gfx.camera(camera);
+        let light = spawnAt2(game, 0, 5, 0);
+        gfx.create(light, { kind: "light", light: "directional", intensity: 2 }), gfx.create(spawnAt2(game, 0, 0, 0), { kind: "light", light: "point", intensity: 1, distance: 10 }), gfx.create(spawnAt2(game, 0, 0, 0), { kind: "group" }), gfx.setEnvironment({ background: { color: 1052688 }, toneMapping: "aces", exposure: 1 }), game.advance(1);
+        let m = new Float32Array(16);
+        gfx.readNodeMatrix(node, m), expect(m[12]).toBeCloseTo(1, 5), expect(m[13]).toBeCloseTo(2, 5), expect(m[14]).toBeCloseTo(3, 5);
+        let stats = emptyStats();
+        gfx.stats(stats), expect(stats.nodes).toBeGreaterThanOrEqual(5), expect(stats.frames).toBeGreaterThan(0), game.world.despawn(e), gfx.stats(stats), expect(stats.nodes).toBeGreaterThanOrEqual(4), game.dispose();
+      }), it("updates custom vertex buffers and instance buffers in place", async () => {
+        let game = await make(), gfx = game.graphics, positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]), geometry = gfx.createGeometry({ attributes: { position: { data: positions, itemSize: 3, dynamic: true } } });
+        expect(gfx.geometryAttribute(geometry, "position")).toBe(positions), positions[0] = 5, gfx.markGeometryDirty(geometry, "position", 0, 3);
+        let material = gfx.createMaterial({ kind: "unlit", color: 16777215 }), batch = gfx.instanced({ geometry: gfx.createGeometry(sphereGeometry(0.5, 8, 4)), material, capacity: 16, colors: true });
+        expect(batch.matrices.length).toBe(256), expect(batch.colors?.length).toBe(48);
+        for (let i = 0; i < 4; i++) mat4Compose(batch.matrices, i * 16, i, 0, 0, 0, 0, 0, 1, 1, 1, 1);
+        gfx.setInstanceCount(batch, 4), gfx.markInstancesDirty(batch), expect(() => gfx.setInstanceCount(batch, 17)).toThrow(GameError), game.dispose();
+      }), it("drives morph targets and skeletons", async () => {
+        let game = await make(), gfx = game.graphics, base = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]), geometry = gfx.createGeometry({
+          attributes: {
+            position: { data: base, itemSize: 3 },
+            skinIndex: { data: new Uint16Array(12), itemSize: 4 },
+            skinWeight: { data: new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]), itemSize: 4 }
+          },
+          morphTargets: [{ name: "smile", position: new Float32Array([0, 0.1, 0, 0, 0.1, 0, 0, 0.1, 0]) }]
+        }), material = gfx.createMaterial({ kind: "standard" }), morphNode = gfx.mesh(spawnAt2(game, 0, 0, 0), geometry, material), weights = gfx.morphWeights(morphNode);
+        expect(weights.length).toBe(1), weights[0] = 0.5, gfx.markMorphWeightsDirty(morphNode);
+        let bindPose = new Float32Array(20);
+        bindPose[6] = 1, bindPose[7] = 1, bindPose[8] = 1, bindPose[9] = 1, bindPose[11] = 1, bindPose[16] = 1, bindPose[17] = 1, bindPose[18] = 1, bindPose[19] = 1;
+        let skinned = gfx.create(spawnAt2(game, 0, 0, 0), {
+          kind: "skinned",
+          geometry,
+          material,
+          skeleton: { parents: new Int16Array([-1, 0]), bindPose }
+        }), pose = gfx.skeletonPose(skinned);
+        expect(pose.length).toBe(20), pose[11] = 2, gfx.markSkeletonDirty(skinned), game.advance(1), game.dispose();
+      }), it("compiles shader materials through the backend's shader language", async () => {
+        let game = await make(), gfx = game.graphics, wgslOnly = { wgsl: { fragment: "@fragment fn main() -> @location(0) vec4f { return vec4f(1.0); }" } };
+        gfx.capabilities.shaderLanguages.indexOf("wgsl") < 0 && expect(() => gfx.createMaterial({ kind: "shader", shader: wgslOnly })).toThrow(GameError);
+        let material = gfx.createMaterial({
+          kind: "shader",
+          shader: {
+            wgsl: wgslOnly.wgsl,
+            glsl: {
+              vertex: "void main() { gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }",
+              fragment: "uniform float glow; uniform vec3 tint; void main() { gl_FragColor = vec4(tint * glow, 1.0); }"
+            }
+          },
+          uniforms: { glow: { type: "f32", value: 1 }, tint: { type: "vec3", value: new Float32Array([1, 0, 0]) } }
+        });
+        gfx.setUniform(material, "glow", 2), gfx.setUniformVector(material, "tint", new Float32Array([0, 1, 0])), expect(() => gfx.setUniform(material, "missing", 1)).toThrow(GameError), game.dispose();
+      }), it("builds render targets, passes and post-processing chains", async () => {
+        let game = await make(), gfx = game.graphics, camera = spawnAt2(game, 0, 0, 5), cameraNode = gfx.camera(camera), target = gfx.createRenderTarget({ width: 128, height: 128, format: "rgba16f" }), texture = gfx.renderTargetTexture(target);
+        expect(texture).toBeGreaterThan(0);
+        let pass = gfx.createRenderPass({ camera: cameraNode, target, layers: 1, clearColor: 0, order: -1 });
+        gfx.setRenderPassEnabled(pass, false);
+        let chain = gfx.createPostChain({
+          effects: [{ kind: "bloom", strength: 0.8 }, { kind: "fxaa" }, { kind: "vignette" }, { kind: "color_grade", contrast: 1.1 }]
+        });
+        gfx.setPostChain(chain), gfx.setPostUniform(chain, 3, "contrast", 1.2), game.advance(1);
+        let stats = emptyStats();
+        gfx.stats(stats), expect(stats.renderTargets).toBe(1), expect(stats.postChains).toBe(1), expect(stats.renderPasses).toBe(1), expect(gfx.gpu === null).toBe(!gfx.capabilities.compute), game.dispose();
+      }), it("expresses toon, matcap, anisotropy, fat lines, area and probe lights, LOD, sky and GPU stats", async () => {
+        let game = await make(), gfx = game.graphics, caps = gfx.capabilities, geometry = gfx.createGeometry(boxGeometry(1, 1, 1)), ramp = gfx.createTexture({ source: { kind: "pixels", width: 2, height: 1, data: new Uint8Array([64, 64, 64, 255, 255, 255, 255, 255]) } }), toon = gfx.createMaterial({ kind: "toon", color: 3385941, gradientMap: ramp }), matcap = gfx.createMaterial({ kind: "matcap", matcap: ramp }), brushed = gfx.createMaterial({ kind: "physical", metalness: 1, roughness: 0.3, anisotropy: 0.8, anisotropyRotation: 0.5 });
+        gfx.setMaterialTexture(toon, "gradientMap", ramp);
+        let near = gfx.mesh(spawnAt2(game, 0, 0, -2), geometry, toon), far = gfx.mesh(spawnAt2(game, 0, 0, -2), geometry, matcap);
+        gfx.mesh(spawnAt2(game, 2, 0, -2), geometry, brushed), gfx.lodLevels([
+          { node: near, distance: 0 },
+          { node: far, distance: 20 }
+        ]);
+        let line = gfx.createGeometry({ attributes: { position: { data: new Float32Array([0, 0, 0, 1, 0, 0, 1, 1, 0]), itemSize: 3 } } });
+        gfx.create(spawnAt2(game, 0, 0, 0), { kind: "lines", geometry: line, material: gfx.createMaterial({ kind: "lines", width: 3, dashSize: 0.1, gapSize: 0.05 }) }), gfx.create(spawnAt2(game, 0, 3, 0), { kind: "light", light: "rectArea", width: 2, height: 1, intensity: 4 }), gfx.create(spawnAt2(game, 0, 0, 0), { kind: "light", light: "probe", sh: new Float32Array(27).fill(0.1) }), gfx.create(spawnAt2(game, 0, 4, 0), {
+          kind: "light",
+          light: "directional",
+          castShadow: true,
+          shadow: { type: "pcss", cascades: 2 }
+        }), gfx.camera(spawnAt2(game, 0, 1, 5)), gfx.setEnvironment({ sky: { turbidity: 6, clouds: { coverage: 0.5 } }, background: { sky: true }, toneMapping: "agx" }), gfx.setTimeOfDay(17, 30, 120), game.advance(2);
+        let stats = createGpuStats();
+        gfx.gpuStats(stats), expect(stats.passNs.length).toBe(GPU_PASS_NAMES.length), expect(typeof caps.lod).toBe("boolean");
+        let counts = emptyStats();
+        gfx.stats(counts), expect(counts.materials).toBeGreaterThanOrEqual(4), game.dispose();
+      }), it("loads glTF models, finds nodes and plays their clips", async () => {
+        let game = await make(), gfx = game.graphics, model = await gfx.loadModel({ bytes: buildTriangleGlb() });
+        expect(model.nodeNames).toContain("Tri"), expect(model.clipNames).toEqual(["spin"]), expect(model.materialNames).toEqual(["Grass"]), expect(model.materials).toHaveLength(1);
+        let grass = model.materials[0];
+        gfx.setMaterialColor(grass, 3368473), gfx.setMaterialState(grass, { envMapIntensity: 0 });
+        let root = gfx.instantiate(spawnAt2(game, 0, 0, 0), model.id), tri = gfx.findNode(root, "Tri");
+        expect(tri).not.toBeNull();
+        let action = gfx.playClip(root, "spin", true);
+        game.advance(30);
+        let m = new Float32Array(16);
+        gfx.readNodeMatrix(tri, m), expect(Math.abs(m[0] - 1)).toBeGreaterThan(1e-3), gfx.stopClip(action), game.dispose();
+      });
+    }), describe("clip animation", () => {
+      let rig = async () => {
+        let game = await make(), gfx = game.graphics;
+        if (!gfx.hasClipAnimation)
+          return game.dispose(), null;
+        let model = await gfx.loadModel({ bytes: buildRigGlb() }), root = gfx.instantiate(spawnAt2(game, 0, 0, 0), model.id);
+        return { game, gfx, clips: gfx.clips, root, model, step: game.loop.stepSeconds };
+      }, hipsX = (gfx, root) => {
+        let m = new Float32Array(16);
+        return gfx.readNodeMatrix(gfx.findNode(root, RIG_HIPS), m), m[12];
+      };
+      it("reports clip info and seeks actions", async () => {
+        let r = await rig();
+        if (r === null) return;
+        let info = r.clips.clipInfo(r.root, "run");
+        expect(info.duration).toBeCloseTo(2, 5), expect(info.tracks).toBe(1);
+        let action = r.gfx.playClip(r.root, "run", true);
+        r.clips.setClipTime(action, 0.5), r.game.advance(1);
+        let state = emptyClipState();
+        r.clips.readClipState(action, state), expect(Math.abs(state.time - (0.5 + r.step))).toBeLessThan(1e-3), expect(state.running).toBe(true), r.game.dispose();
+      }), it("cross fades weights linearly", async () => {
+        let r = await rig();
+        if (r === null) return;
+        let low = r.gfx.playClip(r.root, "low", true), high = r.gfx.playClip(r.root, "high", true);
+        r.clips.crossFade(low, high, 1, false), r.game.advance(30);
+        let a = emptyClipState(), b = emptyClipState();
+        r.clips.readClipState(low, a), r.clips.readClipState(high, b), expect(Math.abs(a.weight - 0.5)).toBeLessThan(0.05), expect(Math.abs(b.weight - 0.5)).toBeLessThan(0.05), r.game.dispose();
+      }), it("fires clip events in order with loop notifications", async () => {
+        let r = await rig();
+        if (r === null) return;
+        r.clips.setClipEvents(r.root, "walk", [
+          { time: 0.75, id: 9 },
+          { time: 0.25, id: 7 }
+        ]), r.gfx.playClip(r.root, "walk", true);
+        let buffer = [], ids = [], loops = 0;
+        for (let frame = 0; frame < 19; frame++) {
+          r.game.advance(6);
+          let count = r.clips.readClipEvents(buffer);
+          for (let i = 0; i < count; i++)
+            buffer[i].kind === "event" && ids.push(buffer[i].id), buffer[i].kind === "loop" && loops++;
+        }
+        expect(ids).toEqual([7, 9, 7, 9]), expect(loops).toBe(1), r.game.dispose();
+      }), it("keeps synced clips of different length in phase", async () => {
+        let r = await rig();
+        if (r === null) return;
+        let walk = r.gfx.playClip(r.root, "walk", true), run2 = r.gfx.playClip(r.root, "run", true);
+        r.clips.setClipSync(walk, 3), r.clips.setClipSync(run2, 3), r.gfx.setClipWeight(walk, 0.5), r.gfx.setClipWeight(run2, 0.5);
+        let a = emptyClipState(), b = emptyClipState();
+        for (let frame = 0; frame < 8; frame++)
+          r.game.advance(7), r.clips.readClipState(walk, a), r.clips.readClipState(run2, b), expect(Math.abs(a.time - b.time / 2)).toBeLessThan(1e-3);
+        expect(a.time).toBeGreaterThan(0), r.game.dispose();
+      }), it("weights 1D blend space members at a midpoint", async () => {
+        let r = await rig();
+        if (r === null) return;
+        let low = r.gfx.playClip(r.root, "low", true), high = r.gfx.playClip(r.root, "high", true), space = r.clips.createBlendSpace(r.root, {
+          kind: "1d",
+          members: [
+            { action: low, x: 0 },
+            { action: high, x: 1 }
+          ]
+        });
+        r.clips.setBlendParameter(space, 0.5, 0, 1), r.game.advance(1);
+        let a = emptyClipState(), b = emptyClipState();
+        r.clips.readClipState(low, a), r.clips.readClipState(high, b), expect(Math.abs(a.weight - 0.5)).toBeLessThan(1e-3), expect(Math.abs(b.weight - 0.5)).toBeLessThan(1e-3), expect(Math.abs(hipsX(r.gfx, r.root) - 2)).toBeLessThan(1e-3), r.game.dispose();
+      }), it("maps Mixamo style names to the humanoid rig", async () => {
+        let r = await rig();
+        if (r === null) return;
+        let map = r.clips.humanoid(r.root);
+        expect(map.hips).toBe(RIG_HIPS), expect(map.spine).toBe("mixamorig_Spine"), expect(map.chest).toBe("mixamorig_Spine1"), r.game.dispose();
+      }), it("extracts root motion across loops", async () => {
+        let r = await rig();
+        if (r === null) return;
+        r.gfx.playClip(r.root, "walk", true);
+        let motion = r.clips.enableRootMotion(r.root, { bone: RIG_HIPS }), delta = new Float32Array(4), travelled = 0;
+        for (let frame = 0; frame < 25; frame++)
+          r.game.advance(3), r.clips.readRootMotion(motion, delta, 0), travelled += delta[0];
+        expect(Math.abs(travelled - 75 * r.step * (2))).toBeLessThan(0.01), expect(Math.abs(hipsX(r.gfx, r.root))).toBeLessThan(1e-4), r.game.dispose();
+      }), it("scales masked bones by fractional mask weights", async () => {
+        let r = await rig();
+        if (r === null) return;
+        let action = r.gfx.playClip(r.root, "high", true), mask = r.clips.createClipMask(r.root, { [RIG_HIPS]: 0.5 });
+        r.clips.setClipMask(action, mask), r.game.advance(2), expect(Math.abs(hipsX(r.gfx, r.root) - 2)).toBeLessThan(1e-3), r.clips.setClipMask(action, null), r.game.advance(2), expect(Math.abs(hipsX(r.gfx, r.root) - 4)).toBeLessThan(1e-3), r.game.dispose();
+      }), it("keeps cubic splines exact inside clip ranges", async () => {
+        let r = await rig();
+        if (r === null) return;
+        let other = r.gfx.instantiate(spawnAt2(r.game, 0, 0, 0), r.model.id), whole = r.gfx.playClip(r.root, "curve", true), ranged = r.gfx.playClip(other, "curve", true);
+        r.clips.setClipRange(ranged, 0.3, 1.7), r.clips.setClipPaused(whole, true), r.clips.setClipPaused(ranged, true);
+        for (let time2 of [0.3, 0.5, 1.2, 1.7])
+          r.clips.setClipTime(whole, time2), r.clips.setClipTime(ranged, time2), r.game.advance(1), expect(Math.abs(hipsX(r.gfx, r.root) - hipsX(r.gfx, other))).toBeLessThan(1e-4);
+        r.game.dispose();
+      });
+    }), describe("input", () => {
+      it("maps keys, gamepad and virtual controls to actions with step edges", async () => {
+        let game = await make(), input = game.input, jump = input.defineButton("jump", [{ device: "key", code: "Space" }, { device: "gamepad", button: 0 }]), move = input.defineAxis("move", [
+          { device: "keys", negative: "KeyA", positive: "KeyD" },
+          { device: "gamepad", axis: 0 },
+          { device: "virtual", control: "stick-x" }
+        ]);
+        input.keyEvent("Space", true, 0), input.keyEvent("Space", false, 1), input.keyEvent("KeyD", true, 2);
+        let pressedSeen = 0;
+        game.addSystem({ fixedUpdate: (g) => {
+          pressedSeen += g.input.justPressed(jump) ? 1 : 0;
+        } }), game.advance(2), expect(pressedSeen).toBe(1), expect(input.value(move)).toBe(1), input.gamepadAxisEvent(0, -0.9, 3), input.keyEvent("KeyD", false, 3), game.advance(1), expect(input.value(move)).toBeLessThan(-0.8), input.gamepadAxisEvent(0, 0, 4), input.virtualEvent("stick-x", 0.4, 4), game.advance(1), expect(input.value(move)).toBeCloseTo(0.4, 5), game.dispose();
+      }), it("recognises swipes with curl and taps", async () => {
+        let game = await make(), input = game.input;
+        input.pointerEvent("down", 3, 0.5, 0.9, 0), input.pointerEvent("move", 3, 0.6, 0.6, 80), input.pointerEvent("up", 3, 0.5, 0.3, 160);
+        let swipes = 0, curl = 0;
+        game.addSystem({
+          fixedUpdate: (g) => {
+            g.input.swipe.ready && (swipes++, curl = g.input.swipe.curl);
+          }
+        }), game.advance(3), expect(swipes).toBe(1), expect(Math.abs(curl)).toBeGreaterThan(0.1), input.pointerEvent("down", 4, 0.2, 0.2, 200), input.pointerEvent("up", 4, 0.2, 0.2, 260);
+        let taps = 0;
+        game.addSystem({ fixedUpdate: (g) => {
+          taps += g.input.tap.ready ? 1 : 0;
+        } }), game.advance(2), expect(taps).toBe(1), game.dispose();
+      });
+    }), describe("physics", () => {
+      it("rests dynamic bodies on the ground and responds to impulses", async () => {
+        let game = await make();
+        ground(game);
+        let ball = spawnAt2(game, 0, 3, 0);
+        game.physics.addBody(ball, { kind: "dynamic" }), game.physics.addCollider(ball, { shape: { kind: "ball", radius: 0.5 } }), game.advance(180);
+        let p = game.transforms.position(ball, new Vec3());
+        expect(p.y).toBeCloseTo(0.5, 1), game.physics.applyImpulse(ball, new Vec3(0, 0, -5)), game.advance(10);
+        let v = game.physics.linearVelocity(ball, new Vec3());
+        expect(v.z).toBeLessThan(-0.5), game.dispose();
+      }), it("casts rays with distances and surface normals", async () => {
+        let game = await make();
+        ground(game);
+        let box = spawnAt2(game, 0, 1, -5);
+        game.transforms.setRotationQuat(box, new Quat().setEuler(0, 0.5, 0)), game.physics.addCollider(box, { shape: { kind: "cuboid", halfExtents: [1, 1, 1] } });
+        let mesh = spawnAt2(game, 10, 0.5, 0);
+        game.physics.addCollider(mesh, {
+          shape: {
+            kind: "trimesh",
+            vertices: new Float32Array([-1, 0, -1, 1, 0, -1, 0, 0, 1]),
+            indices: new Uint32Array([0, 2, 1])
+          }
+        }), game.advance(1);
+        let hit = new RayHit(), ray = new RayQuery();
+        expect(game.physics.raycast(ray.set(0, 5, 0, 0, -1, 0, 10), hit)).toBe(true), expect(hit.distance).toBeCloseTo(5, 3), expect(hit.normalY).toBeCloseTo(1, 3), expect(game.physics.raycast(ray.set(0, 1, 5, 0, 0, -1, 20), hit)).toBe(true), expect(game.physics.entityOfCollider(hit.collider)).toBe(box), expect(hit.normalZ).toBeGreaterThan(0.5), expect(game.physics.raycast(ray.set(10, 3, 0, 0, -1, 0, 10), hit)).toBe(true), expect(game.physics.entityOfCollider(hit.collider)).toBe(mesh), expect(hit.normalY).toBeCloseTo(1, 2), expect(game.physics.raycast(ray.set(0, 5, 0, 0, 1, 0, 10), hit)).toBe(false), game.dispose();
+      }), it("reports sensor and contact events", async () => {
+        let game = await make();
+        ground(game);
+        let zone = spawnAt2(game, 0, 1, 0);
+        game.physics.addCollider(zone, { shape: { kind: "cuboid", halfExtents: [1, 1, 1] }, sensor: true });
+        let ball = spawnAt2(game, 0, 4, 0);
+        game.physics.addBody(ball, { kind: "dynamic" }), game.physics.addCollider(ball, { shape: { kind: "ball", radius: 0.25 }, events: true });
+        let entered = false;
+        game.addSystem({
+          fixedUpdate: (g) => {
+            for (let i = 0; i < g.physics.contactCount(); i++) {
+              let a = g.physics.contactEntityA(i), b = g.physics.contactEntityB(i);
+              g.physics.contactStarted(i) && (a === zone || b === zone) && (entered = true);
+            }
+          }
+        }), game.advance(120), expect(entered).toBe(true), game.dispose();
+      }), it("constrains bodies with joints", async () => {
+        let game = await make(), anchor = spawnAt2(game, 0, 5, 0);
+        game.physics.addBody(anchor, { kind: "fixed" }), game.physics.addCollider(anchor, { shape: { kind: "ball", radius: 0.1 } });
+        let bob = spawnAt2(game, 2, 5, 0);
+        game.physics.addBody(bob, { kind: "dynamic" }), game.physics.addCollider(bob, { shape: { kind: "ball", radius: 0.2 } }), game.physics.joint(anchor, bob, { kind: "spherical", anchorA: [0, 0, 0], anchorB: [-2, 0, 0] }), game.advance(90);
+        let p = game.transforms.position(bob, new Vec3());
+        expect(Math.hypot(p.x, p.y - 5, p.z)).toBeCloseTo(2, 1), expect(p.y).toBeLessThan(5), game.dispose();
+      }), it("walks a character controller, stays grounded and slides along walls", async () => {
+        let game = await make();
+        ground(game);
+        let wall = spawnAt2(game, 2, 1, 0);
+        game.physics.addCollider(wall, { shape: { kind: "cuboid", halfExtents: [0.1, 1, 5] } });
+        let hero = spawnAt2(game, 0, 0.9, 0);
+        game.physics.addBody(hero, { kind: "kinematic" });
+        let collider = game.physics.addCollider(hero, { shape: { kind: "capsule", halfHeight: 0.5, radius: 0.3 } }), controller = game.physics.createCharacterController({ snapToGround: 0.3, maxSlopeClimbDegrees: 45 }), move = new CharacterMove(), desired = new Vec3(), grounded = false;
+        game.advance(1), game.addSystem({
+          fixedUpdate: (g) => {
+            let dt = g.stepSeconds;
+            g.physics.moveCharacter(controller, collider, desired.set(2 * dt, -9.81 * dt, dt), move), grounded = move.grounded;
+          }
+        }), game.advance(120);
+        let p = game.transforms.position(hero, new Vec3());
+        expect(p.x).toBeGreaterThan(1.4), expect(p.x).toBeLessThan(1.65), expect(p.z).toBeGreaterThan(1.5), expect(p.y).toBeCloseTo(0.81, 1), expect(grounded).toBe(true), game.dispose();
+      });
+    }), describe("animation", () => {
+      it("tweens transforms and values with easing, delay and repeat", async () => {
+        let game = await make(), e = spawnAt2(game, 0, 0, 0), anim = game.animation, t = anim.tween(e, TweenTarget.PositionY, 3, 0.5, Ease.OutQuad), slot = anim.createValue(0);
+        anim.tweenValue(slot, 1, 0.25, Ease.Linear, 0.25);
+        let loop = anim.createValue(0);
+        anim.tweenValue(loop, 1, 0.5, Ease.Linear, 0, Repeat.PingPong), game.advance(15), expect(anim.value(slot)).toBeCloseTo(0, 5), game.advance(15), expect(game.transforms.position(e, new Vec3()).y).toBeCloseTo(3, 4), expect(anim.isActive(t)).toBe(false), expect(anim.value(slot)).toBeCloseTo(1, 4), game.advance(15), expect(anim.value(loop)).toBeCloseTo(0.5, 1), game.dispose();
+      }), it("samples keyframe clips including rotation", async () => {
+        let { Clip } = await import('../animation-6DICNWUP.mjs'), game = await make(), e = spawnAt2(game, 0, 0, 0), half = Math.SQRT1_2, clip = new Clip({
+          duration: 1,
+          tracks: [
+            { target: TweenTarget.PositionX, times: new Float32Array([0, 1]), values: new Float32Array([0, 10]) },
+            { target: TweenTarget.Rotation, times: new Float32Array([0, 1]), values: new Float32Array([0, 0, 0, 1, 0, half, 0, half]) }
+          ]
+        });
+        game.animation.playClip(e, clip), game.advance(30), expect(game.transforms.position(e, new Vec3()).x).toBeCloseTo(5, 0), game.advance(60);
+        let q = game.transforms.rotation(e, new Quat());
+        expect(q.y).toBeCloseTo(half, 3), game.dispose();
+      });
+    }), describe("audio and game UI", () => {
+      it("plays voices on buses and tracks spatial voices", async () => {
+        let game = await make(), sound = await game.audio.load({ bytes: new ArrayBuffer(8) }), voice = game.audio.play(sound, game.audio.effects, 0.5, 1, true);
+        expect(game.audio.isPlaying(voice)).toBe(true), game.audio.setBusGain(game.audio.music, 0.2), game.audio.duck(game.audio.music, 0.5, 0.1, 0.05);
+        let emitter = spawnAt2(game, 3, 0, 0), spatial = game.audio.playAt(emitter, sound, game.audio.effects, 1, 1, true);
+        game.advance(10), game.audio.stop(voice), expect(game.audio.isPlaying(voice)).toBe(false), expect(game.audio.isPlaying(spatial)).toBe(true), game.dispose();
+      }), it("batches HUD updates to the native host once per frame", async () => {
+        let host = new RecordingUiHost(), game = await make(1, host), score = game.ui.hudNumber("score"), label = game.ui.hudText("label", "Go");
+        game.advance(1), expect(host.layout.map((s) => s.name)).toEqual(["score", "label"]);
+        let before = host.publishes;
+        game.ui.setNumber(score, 1), game.ui.setNumber(score, 2), game.ui.setText(label, "Goal"), game.advance(1), expect(host.publishes).toBe(before + 1), expect(host.lastDirty).toBe(2), game.advance(1), expect(host.publishes).toBe(before + 1);
+        let restart = game.ui.defineAction("restart");
+        expect(game.ui.dispatch("restart")).toBe(true), expect(game.ui.pollAction()).toBe(restart), game.ui.show("pause", { score: 2 }), game.ui.haptic("success"), expect(host.panels).toEqual(["pause"]), expect(host.haptics).toEqual(["success"]), game.dispose();
+      });
+    }), describe("networking", () => {
+      it("bit-packs messages and decodes them in place", async () => {
+        let game = await make(), Move = game.net.defineMessage("move", {
+          seq: "u16",
+          dx: quantized(-1, 1, 10),
+          jump: "bool",
+          yaw: "f32",
+          tick: "u32",
+          delta: "i16"
+        });
+        expect(Move.bytes).toBe(Math.ceil(115 / 8));
+        let writer = new MessageWriter();
+        writer.begin(Move).set(Move.field("seq"), 513).set(Move.field("dx"), -0.25).setBool(Move.field("jump"), true).set(Move.field("yaw"), 1.5).set(Move.field("tick"), 4e9).set(Move.field("delta"), -300);
+        let [a, b] = LoopbackTransport.pair();
+        game.net.connect(a);
+        let peer = await make();
+        peer.net.defineMessage("move", { seq: "u16", dx: quantized(-1, 1, 10), jump: "bool", yaw: "f32", tick: "u32", delta: "i16" }), peer.net.connect(b);
+        let inbound = peer.net.channel("inputs", "reliable");
+        game.net.channel("inputs", "reliable").send(writer);
+        let reader = peer.net.reader();
+        expect(inbound.receive(reader)).toBe(true), expect(reader.get(Move.field("seq"))).toBe(513), expect(reader.get(Move.field("dx"))).toBeCloseTo(-0.25, 2), expect(reader.getBool(Move.field("jump"))).toBe(true), expect(reader.get(Move.field("yaw"))).toBeCloseTo(1.5, 6), expect(reader.get(Move.field("tick"))).toBe(4e9), expect(reader.get(Move.field("delta"))).toBe(-300), expect(inbound.receive(reader)).toBe(false), game.dispose(), peer.dispose();
+      }), it("keeps only the newest message on latest-value channels", async () => {
+        let game = await make(), Pos = game.net.defineMessage("pos", { x: "f32" }), [a, b] = LoopbackTransport.pair();
+        game.net.connect(a);
+        let peer = await make();
+        peer.net.defineMessage("pos", { x: "f32" }), peer.net.connect(b);
+        let inbound = peer.net.channel("state", "latest"), outbound = game.net.channel("state", "latest"), writer = new MessageWriter();
+        for (let i = 0; i < 5; i++) outbound.send(writer.begin(Pos).set(Pos.field("x"), i));
+        let reader = peer.net.reader();
+        expect(inbound.receive(reader)).toBe(true), expect(reader.get(Pos.field("x"))).toBe(4), expect(inbound.receive(reader)).toBe(false), game.dispose(), peer.dispose();
+      }), it("interpolates remote snapshots", () => {
+        let buffer = new SnapshotBuffer(2, 8), identity = new Float32Array([0, 0, 0, 1]);
+        buffer.push(1, 10, new Float32Array([0, 0, 0]), 0, identity, 0), buffer.push(1, 12, new Float32Array([4, 0, 0]), 0, identity, 0);
+        let p = new Float32Array(3), r = new Float32Array(4);
+        expect(buffer.sample(1, 11, p, 0, r, 0)).toBe(true), expect(p[0]).toBeCloseTo(2, 5), expect(buffer.sample(0, 11, p, 0, r, 0)).toBe(false);
+      });
+    }), describe("determinism", () => {
+      let simulate = async (seed) => {
+        let game = await make(seed);
+        ground(game);
+        let bodies = [];
+        for (let i = 0; i < 12; i++) {
+          let e = spawnAt2(game, game.random.range(-3, 3), 2 + i * 0.6, game.random.range(-3, 3));
+          game.physics.addBody(e, { kind: "dynamic" }), game.physics.addCollider(e, { shape: i % 2 === 0 ? { kind: "ball", radius: 0.3 } : { kind: "cuboid", halfExtents: [0.3, 0.3, 0.3] } }), bodies.push(e);
+        }
+        let kick = new Vec3();
+        game.addSystem({
+          fixedUpdate: (g) => {
+            if (g.tick % 20 !== 0) return;
+            let target = bodies[g.random.int(0, bodies.length - 1)];
+            g.physics.applyImpulse(target, kick.set(g.random.range(-1, 1), g.random.range(0, 2), g.random.range(-1, 1)));
+          }
+        }), game.advance(240);
+        let out = Float32Array.from(game.transforms.store.fields.position.subarray(0, game.transforms.store.count * 3));
+        return game.dispose(), out;
+      };
+      it("reproduces identical state from the same seed", async () => {
+        let a = await simulate(42), b = await simulate(42);
+        expect(sameBits(a, b)).toBe(true);
+      }), it("diverges for a different seed", async () => {
+        let a = await simulate(42), c = await simulate(43);
+        expect(sameBits(a, c)).toBe(false);
+      });
+    }), describe("frame-loop allocation", () => {
+      let measure = (vendorQueries) => options.allocation ? options.allocation(vendorQueries) : measureSustainedAllocation(
+        options.createBackend,
+        options.heap,
+        vendorQueries,
+        options.sustainedFrames,
+        (true)
+      ), withClock = (run2) => options.hostClock === "frozen" ? withFrozenHostClock(run2) : run2();
+      it("allocates nothing and never collects garbage across a sustained headless run", async () => {
+        let result = await withClock(() => measure(false));
+        if (!result) return;
+        let [report, longer] = result;
+        options.report?.("sustained", report), options.report?.("sustained-2x", longer), expect(report.collections).toBe(0), expect(longer.collections).toBe(0), expect(report.bytesPerFrame).toBeLessThan((1)), expect(longer.bytesPerFrame).toBeLessThan((1));
+      }, 12e4), it("keeps physics queries and dynamic body readback within the backend's declared boundary budget", async () => {
+        let result = await withClock(() => measure(true));
+        if (!result) return;
+        let [report, longer] = result;
+        options.report?.("physics-queries", report), options.report?.("physics-queries-2x", longer);
+        let budget = options.physicsBoundaryBudget ?? NO_BOUNDARY_BUDGET, perFrame = (48) * budget.bytesPerAwakeBodyStep + budget.bytesPerRaycast + budget.bytesPerCharacterMove;
+        expect(report.bytesPerFrame).toBeLessThanOrEqual(perFrame + (1)), expect(longer.bytesPerFrame).toBeLessThanOrEqual(perFrame + (1)), perFrame === 0 && expect(longer.collections).toBe(0);
+      }, 12e4);
+    }), describe("hot-path microbenchmarks", () => {
+      it("keeps math, transform, query, codec and raycast calls within their nanosecond budgets", async (context) => {
+        let results = await (options.microbench ?? (() => runMicrobench(options.createBackend)))();
+        options.reportMicrobench?.(results);
+        let busy = await busyMachine();
+        busy !== null && (console.info(`${loadSkipNotice(busy)}: ${JSON.stringify(results, (_key, value) => typeof value == "number" ? Math.round(value * 10) / 10 : value)}`), context.skip());
+        for (let name of Object.keys(results)) {
+          let budget = options.microbenchBudgetsNs?.[name] ?? DEFAULT_MICROBENCH_BUDGETS_NS[name];
+          expect(results[name], `${name} ${results[name].toFixed(1)}ns`).toBeLessThan(budget);
+        }
+      }, (12e4));
+    });
+  });
+}
+var FROZEN_HOST_TIME = 0;
+function frozenNow() {
+  return (0);
+}
+var NO_BOUNDARY_BUDGET = { bytesPerAwakeBodyStep: 0, bytesPerRaycast: 0, bytesPerCharacterMove: 0 };
+function halfway() {
+  let time2 = new FrameTime();
+  return time2.values[FRAME_ALPHA_SLOT] = 0.5, time2;
+}
+function sameBits(a, b) {
+  if (a.length !== b.length) return false;
+  let x = new Uint32Array(a.buffer, a.byteOffset, a.length), y = new Uint32Array(b.buffer, b.byteOffset, b.length);
+  for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false;
+  return true;
+}
+var GLB_MAGIC = 1179937895, GLB_VERSION = 2, GLB_CHUNK_JSON = 1313821514, GLB_CHUNK_BIN = 5130562, GLB_HEADER_BYTES = 12, GLB_CHUNK_HEADER_BYTES = 8, GLB_ALIGN = 4, SPACE = 32, RIG_HIPS = "mixamorig_Hips", RIG_WALK_SPEED = 2;
+function glbFrom(json, bin) {
+  let text = new TextEncoder().encode(JSON.stringify(json)), jsonLength = Math.ceil(text.length / (4)) * (4), binLength = Math.ceil(bin.length / (4)) * (4), total = (12) + (8) * 2 + jsonLength + binLength, out = new ArrayBuffer(total), view = new DataView(out), bytes = new Uint8Array(out);
+  view.setUint32(0, (1179937895), true), view.setUint32(4, (2), true), view.setUint32(8, total, true);
+  let o = (12);
+  return view.setUint32(o, jsonLength, true), view.setUint32(o + 4, (1313821514), true), o += (8), bytes.fill((32), o, o + jsonLength), bytes.set(text, o), o += jsonLength, view.setUint32(o, binLength, true), view.setUint32(o + 4, (5130562), true), o += (8), bytes.set(bin, o), out;
+}
+function buildRigGlb() {
+  let streams = [
+    new Float32Array([0, 1]),
+    new Float32Array([0, 2]),
+    new Float32Array([0, 0, 0, (2), 0, 0]),
+    new Float32Array([0, 0, 0, (2) * 2, 0, 0]),
+    new Float32Array([0, 0, 0, 0, 0, 0]),
+    new Float32Array([4, 0, 0, 4, 0, 0]),
+    new Float32Array([0, 1, 2]),
+    new Float32Array([0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 0, -1, 0, 0, 0.5, 0, 0, 1, 0, 0, 0, 0, 0])
+  ], bin = new Uint8Array(streams.reduce((sum, s) => sum + s.byteLength, 0)), bufferViews = [], offset = 0;
+  for (let stream of streams)
+    bin.set(new Uint8Array(stream.buffer), offset), bufferViews.push({ buffer: 0, byteOffset: offset, byteLength: stream.byteLength }), offset += stream.byteLength;
+  let clip = (name, input, output, interpolation = "LINEAR") => ({
+    name,
+    samplers: [{ input, output, interpolation }],
+    channels: [{ sampler: 0, target: { node: 0, path: "translation" } }]
+  });
+  return glbFrom(
+    {
+      asset: { version: "2.0" },
+      scene: 0,
+      scenes: [{ nodes: [0] }],
+      nodes: [
+        { name: RIG_HIPS, children: [1] },
+        { name: "mixamorig_Spine", translation: [0, 0.2, 0], children: [2] },
+        { name: "mixamorig_Spine1", translation: [0, 0.2, 0] }
+      ],
+      buffers: [{ byteLength: bin.byteLength }],
+      bufferViews,
+      accessors: [
+        { bufferView: 0, componentType: 5126, count: 2, type: "SCALAR", min: [0], max: [1] },
+        { bufferView: 1, componentType: 5126, count: 2, type: "SCALAR", min: [0], max: [2] },
+        { bufferView: 2, componentType: 5126, count: 2, type: "VEC3" },
+        { bufferView: 3, componentType: 5126, count: 2, type: "VEC3" },
+        { bufferView: 4, componentType: 5126, count: 2, type: "VEC3" },
+        { bufferView: 5, componentType: 5126, count: 2, type: "VEC3" },
+        { bufferView: 6, componentType: 5126, count: 3, type: "SCALAR", min: [0], max: [2] },
+        { bufferView: 7, componentType: 5126, count: 9, type: "VEC3" }
+      ],
+      animations: [
+        clip("walk", 0, 2),
+        clip("run", 1, 3),
+        clip("low", 0, 4),
+        clip("high", 0, 5),
+        clip("curve", 6, 7, "CUBICSPLINE")
+      ]
+    },
+    bin
+  );
+}
+function buildTriangleGlb() {
+  let positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]), times = new Float32Array([0, 1]), rotations = new Float32Array([0, 0, 0, 1, 0, 0.7071068, 0, 0.7071068]), bin = new Uint8Array(positions.byteLength + times.byteLength + rotations.byteLength);
+  bin.set(new Uint8Array(positions.buffer), 0), bin.set(new Uint8Array(times.buffer), positions.byteLength), bin.set(new Uint8Array(rotations.buffer), positions.byteLength + times.byteLength);
+  let json = new TextEncoder().encode(triangleJson(bin.length, positions.byteLength, times.byteLength, rotations.byteLength)), jsonLength = Math.ceil(json.length / (4)) * (4), binLength = Math.ceil(bin.length / (4)) * (4), total = (12) + (8) * 2 + jsonLength + binLength, out = new ArrayBuffer(total), view = new DataView(out), bytes = new Uint8Array(out);
+  view.setUint32(0, (1179937895), true), view.setUint32(4, (2), true), view.setUint32(8, total, true);
+  let o = (12);
+  return view.setUint32(o, jsonLength, true), view.setUint32(o + 4, (1313821514), true), o += (8), bytes.fill((32), o, o + jsonLength), bytes.set(json, o), o += jsonLength, view.setUint32(o, binLength, true), view.setUint32(o + 4, (5130562), true), o += (8), bytes.set(bin, o), out;
+}
+function triangleJson(byteLength, positionBytes, timeBytes, rotationBytes) {
+  return JSON.stringify({
+    asset: { version: "2.0" },
+    scene: 0,
+    scenes: [{ nodes: [0] }],
+    nodes: [{ name: "Tri", mesh: 0 }],
+    meshes: [{ primitives: [{ attributes: { POSITION: 0 }, material: 0 }] }],
+    materials: [{ name: "Grass", pbrMetallicRoughness: { baseColorFactor: [0, 1, 0, 1], roughnessFactor: 0.5 } }],
+    buffers: [{ byteLength }],
+    bufferViews: [
+      { buffer: 0, byteOffset: 0, byteLength: positionBytes },
+      { buffer: 0, byteOffset: positionBytes, byteLength: timeBytes },
+      { buffer: 0, byteOffset: positionBytes + timeBytes, byteLength: rotationBytes }
+    ],
+    accessors: [
+      { bufferView: 0, componentType: 5126, count: 3, type: "VEC3", min: [0, 0, 0], max: [1, 1, 0] },
+      { bufferView: 1, componentType: 5126, count: 2, type: "SCALAR", min: [0], max: [1] },
+      { bufferView: 2, componentType: 5126, count: 2, type: "VEC4" }
+    ],
+    animations: [
+      {
+        name: "spin",
+        samplers: [{ input: 1, output: 2, interpolation: "LINEAR" }],
+        channels: [{ sampler: 0, target: { node: 0, path: "rotation" } }]
+      }
+    ]
+  });
+}
+var LOCK_DIR = join(tmpdir(), "cimplify-engine-measurement.lock"), OWNER_FILE = join(LOCK_DIR, "owner"), POLL_MS = 5, NO_SIGNAL = 0, pause = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function alive(pid) {
+  try {
+    return process.kill(pid, (0)), !0;
+  } catch {
+    return false;
+  }
+}
+function owner() {
+  try {
+    return Number(readFileSync(OWNER_FILE, "utf8"));
+  } catch {
+    return Number.NaN;
+  }
+}
+function acquire() {
+  for (; ; )
+    try {
+      mkdirSync(LOCK_DIR), writeFileSync(OWNER_FILE, String(process.pid));
+      return;
+    } catch {
+      let pid = owner();
+      Number.isInteger(pid) && !alive(pid) ? rmSync(LOCK_DIR, { recursive: true, force: true }) : Atomics.wait(pause, 0, 0, (5));
+    }
+}
+function exclusiveMeasurement(run2) {
+  acquire();
+  try {
+    return run2();
+  } finally {
+    rmSync(LOCK_DIR, { recursive: true, force: true });
+  }
+}
+
+// src/game/conformance/isolated.ts
+var ISOLATED_RESULT_PREFIX = "isolated-result:", ISOLATED_TIMEOUT_MS = 6e5, CHILD_BUFFER_BYTES = 1 << 24, ISOLATION_FLAGS = ["--expose-gc", "--no-concurrent-recompilation", "--no-concurrent-osr", "--no-concurrent-sparkplug"], NUMERIC_VAR = /^var ([A-Za-z_$][\w$]*) = (-?(?:0x[0-9a-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?));$/gm, REGEX_SPECIAL = /[$]/g, bundles = /* @__PURE__ */ new Map();
+function writes(code, name) {
+  let id = name.replace(REGEX_SPECIAL, "\\$&"), assigned = new RegExp(`(?<![\\w$.])${id}\\s*(?:[-+*/%&|^]|\\*\\*|<<|>>>?|\\?\\?|&&|\\|\\|)?=(?!=)`, "g"), stepped = new RegExp(`(?:\\+\\+|--)\\s*${id}(?![\\w$])|(?<![\\w$.])${id}\\s*(?:\\+\\+|--)`, "g");
+  return (code.match(assigned)?.length ?? 0) + (code.match(stepped)?.length ?? 0);
+}
+function restoreConstants(code) {
+  return code.replace(NUMERIC_VAR, (line, name, value) => writes(code, name) === 1 ? `const ${name} = ${value};` : line);
+}
+function bundle(key, write) {
+  let known = bundles.get(key);
+  if (known !== void 0) return known;
+  let dir = mkdtempSync(join(tmpdir(), "cimplify-isolated-")), entry = write(dir), outfile = join(dir, "isolated.mjs");
+  return execFileSync("bun", ["build", entry, "--target=node", "--format=esm", "--outfile", outfile], { stdio: "pipe" }), writeFileSync(outfile, restoreConstants(readFileSync(outfile, "utf8"))), bundles.set(key, outfile), outfile;
+}
+function run(script, args) {
+  let output = exclusiveMeasurement(
+    () => execFileSync("node", [...ISOLATION_FLAGS, script, ...args], { encoding: "utf8", maxBuffer: CHILD_BUFFER_BYTES, timeout: (6e5) })
+  ), line = output.split(`
+`).find((l) => l.startsWith(ISOLATED_RESULT_PREFIX));
+  if (!line) throw new Error(`the isolated measurement produced no result: ${output}`);
+  return JSON.parse(line.slice(ISOLATED_RESULT_PREFIX.length));
+}
+function isolatedModule(source, args) {
+  return run(
+    bundle(source, (dir) => {
+      let entry = join(dir, "entry.ts");
+      return writeFileSync(entry, source), entry;
+    }),
+    args
+  );
+}
+
+// src/game/conformance/template-suite.ts
+var FILE_PROTOCOL = "file:";
+function sourcePath(relative, base) {
+  let url = new URL(relative, base), pathname = decodeURIComponent(url.pathname), host = globalThis.process;
+  return url.protocol === FILE_PROTOCOL || host === void 0 ? pathname : `${host.cwd()}${pathname}`;
+}
+var TEMPLATE_ALLOCATION_MODULE = sourcePath("./template-allocation.ts", import.meta.url); sourcePath("../backends/prepared.ts", import.meta.url);
+function isolatedSource(isolated) {
+  return [
+    `import { runTemplateAllocationChild } from ${JSON.stringify(TEMPLATE_ALLOCATION_MODULE)};`,
+    `import { ${isolated.exportName} as template } from ${JSON.stringify(isolated.module)};`,
+    `import { ${isolated.backendExport} as createBackend } from ${JSON.stringify(isolated.backendModule)};`,
+    "await runTemplateAllocationChild(template, createBackend);",
+    ""
+  ].join(`
+`);
+}
+var FS_MODULE = "node:fs", UTF8 = "utf8", DEFAULT_SEED = 11, DEFAULT_WARMUP_FRAMES = 3e4, DEFAULT_SUSTAINED_FRAMES2 = 6e3, RESIDUE_BYTES_PER_FRAME2 = 1, SUSTAINED_TIMEOUT_MS = 12e4;
+function defineTemplateConformance(options) {
+  let template = options.template, seed = options.seed ?? (11), play = async (frames, runSeed) => {
+    let h = await createTemplateHarness(template, options.createBackend(), runSeed);
+    for (let i = 0; i < frames; i++) h.frame(i);
+    let result = [template.progress(h.scene), template.digest(h.scene, h.game)];
+    return h.game.dispose(), result;
+  };
+  describe(`genre template conformance: ${template.id}`, () => {
+    it("uses only the game API", async () => {
+      let fs = await import(
+        /* @vite-ignore */
+        FS_MODULE
+      ), root = options.sourceRoot ?? "", files = template.sources.map((path) => ({ path, source: fs.readFileSync(root + path, UTF8) })), result = checkGameSources({ profile: "game_api" }, files);
+      expect(result.violations).toEqual([]);
+    }), it("passes the kit publication gates", () => {
+      let failed = kitPublicationGates(template.economy).filter((g) => !g.passed);
+      expect(failed).toEqual([]);
+    }), it("reaches its progress condition under the playtest bot", async () => {
+      let [progress] = await play(options.playtestFrames, seed);
+      expect(progress).toBeGreaterThanOrEqual(options.progressTarget);
+    }), it("replays identically from the same seed and inputs", async () => {
+      let a = await play(options.playtestFrames, seed), b = await play(options.playtestFrames, seed);
+      expect(b).toEqual(a);
+    }), it(
+      "allocates nothing and never collects garbage on the frame path across a sustained run",
+      async () => {
+        let isolated = options.isolated;
+        if (isolated !== void 0) {
+          let warmup = options.warmupFrames ?? (3e4), frames = options.sustainedFrames ?? (6e3), boundary = options.boundaryBytesPerFrame ?? 0, budget = boundary + (1), { report, sites } = isolatedModule(isolatedSource(isolated), [String(seed), String(warmup), String(frames), String(budget)]);
+          options.report?.(template.id, report);
+          let busy = await busyMachine();
+          busy !== null && console.info(`${template.id}: collection count ${loadSkipNotice(busy)}`), boundary === 0 && busy === null && expect(report.collections).toBe(0), expect(report.bytesPerFrame, `allocation sites:${sites}`).toBeLessThan(budget);
+          return;
+        }
+        await withFrozenHostClock(async () => {
+          let meter = await options.heap();
+          if (!meter) return;
+          let h = await createTemplateHarness(template, options.createBackend(), seed), warmup = options.warmupFrames ?? (3e4);
+          await warmUp(warmup, (i) => h.frame(i));
+          let frames = options.sustainedFrames ?? (6e3), report = await measureSteadyAllocations(meter, frames, (i) => h.frame(warmup + i));
+          meter.dispose(), options.report?.(template.id, report);
+          let boundary = options.boundaryBytesPerFrame ?? 0, budget = boundary + (1), sites = "";
+          report.bytesPerFrame >= budget && (sites = (await profileAllocationSites(frames, (i) => h.frame(warmup + frames + i)) ?? []).map((s) => `
+  ${s.bytes} B  ${s.stack}`).join("")), h.game.dispose();
+          let busy = await busyMachine();
+          busy !== null && console.info(`${template.id}: collection count ${loadSkipNotice(busy)}`), boundary === 0 && busy === null && expect(report.collections).toBe(0), expect(report.bytesPerFrame, `allocation sites:${sites}`).toBeLessThan(budget);
+        });
+      },
+      options.isolated === void 0 ? (12e4) : (6e5)
+    );
+  });
+}
+
+export { DEFAULT_MICROBENCH_BUDGETS_NS, busyMachine, createSustainedHarness, defineGameConformanceSuite, defineTemplateConformance, frameStamp, loadSkipNotice, measureSustainedAllocation, runMicrobench, withFrozenHostClock };