@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-KDQOR4QQ.mjs

@@ -0,0 +1,350 @@
+import { hex } from './chunk-V7ZRH3PY.mjs';
+import { wasmAvailable, compileApproved, approveCompiled } from './chunk-N4RGGDEL.mjs';
+
+// src/interactives/runtime/modules.ts
+var CHUNK_MAGIC = 1262701891, CHUNK_FORMAT_VERSION = 1, CHUNK_HEADER_BYTES = 64, MODULE_INDEX_FORMAT = 4, VERBOSE_MODULE_INDEX_FORMAT = 3, NO_NAME = -1, IMPORT_TUPLE_LIBRARY = 2, IMPORT_TUPLE_SAME_EXPORT = 4, IMPORT_TUPLE = 5, IMPORT_TUPLE_SPECIFIED = 6, SAME_AS_LIBRARY = -2, MODULE_PARAMETERS = ["require", "exports", "module", "__cimplify_tick"], ChunkKind = {
+  code: 0,
+  texture: 1,
+  mesh: 2,
+  audio: 3,
+  font: 4,
+  data: 5,
+  wasm: 6,
+  index: 7,
+  bytecode: 8
+}, OFFSET_MAGIC = 0, OFFSET_VERSION = 4, OFFSET_KIND = 6, OFFSET_LENGTH = 8, OFFSET_PAYLOAD = 16, TWO_32 = 4294967296, PackageError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "PackageError";
+  }
+};
+function decodeChunk(bytes) {
+  if (bytes.length < (64)) throw new PackageError("a chunk is shorter than its header");
+  let view = new DataView(bytes.buffer, bytes.byteOffset, (64));
+  if (view.getUint32((0), true) !== (1262701891)) throw new PackageError("not a Cimplify chunk");
+  if (view.getUint16((4), true) !== (1)) throw new PackageError("unsupported chunk format");
+  let length = view.getUint32((8) + 4, true) * (4294967296) + view.getUint32((8), true), offset = view.getUint32((16), true);
+  if (offset < (64) || length > bytes.length - offset) throw new PackageError("a chunk payload is truncated");
+  return { kind: view.getUint8((6)), payload: bytes.subarray(offset, offset + length) };
+}
+var NO_ASSETS = [], NO_ALTERNATIVES = [], NO_LATE_RUNTIMES = [], decoder = new TextDecoder();
+function expandIndex(compact) {
+  let names = compact.names;
+  if (!Array.isArray(names)) throw new PackageError("the module index has no name table");
+  let name = (id) => {
+    if (id === (-1)) return null;
+    let value = id === void 0 ? void 0 : names[id];
+    if (typeof value != "string") throw new PackageError("the module index names an import it does not list");
+    return value;
+  }, imports = (list) => list.map((tuple) => {
+    if (tuple.length === (2)) {
+      let library2 = name(tuple[1]);
+      if (library2 === null) throw new PackageError("the module index holds a malformed import");
+      return { at: tuple[0], end: tuple[0] + library2.length, module: null, library: library2, export: library2, specifier: library2 };
+    }
+    if (tuple.length !== (5) && tuple.length !== (4) && tuple.length !== (6)) throw new PackageError("the module index holds a malformed import");
+    let library = name(tuple[3]), exported = tuple.length === (4) || tuple[4] === (-2) ? library : name(tuple[4]), specifier = tuple.length === (6) ? name(tuple[5]) : null;
+    return { at: tuple[0], end: tuple[1], module: name(tuple[2]), library, export: exported, ...specifier === null ? {} : { specifier } };
+  }), assets = compact.assets?.map((a) => {
+    let lazy = new Set(a.lazy_parts ?? []), base = { path: a.path, chunk: a.chunk, ...a.lazy === true ? { lazy: true } : {}, ...a.progressive === true ? { progressive: true } : {} };
+    return a.parts === void 0 ? base : { ...base, parts: a.parts.map((chunk, k) => lazy.has(k) ? { chunk, lazy: true } : { chunk }) };
+  });
+  return {
+    format: compact.format,
+    entries: compact.entries,
+    modules: compact.modules.map((m) => ({ ...m, imports: imports(m.imports) })),
+    runtimes: compact.runtimes.map((r) => ({ ...r, imports: imports(r.imports) })),
+    ...assets === void 0 ? {} : { assets },
+    ...compact.alternatives === void 0 ? {} : { alternatives: compact.alternatives },
+    ...compact.late === void 0 ? {} : { late: compact.late },
+    ...compact.more === void 0 ? {} : { more: compact.more }
+  };
+}
+function readIndex(chunk) {
+  if (chunk.kind !== ChunkKind.index) throw new PackageError("the package's first chunk is not its module index");
+  let parsed = JSON.parse(decoder.decode(chunk.payload));
+  if (parsed.format === (4)) return expandIndex(parsed);
+  if (parsed.format === (3)) return parsed;
+  throw new PackageError(`module index format ${parsed.format} is not supported`);
+}
+var NO_MODULES = /* @__PURE__ */ new Set(), NO_SOURCE = "";
+function namedSpecifiers(path, imports) {
+  return imports.map((i) => {
+    if (i.specifier === void 0) throw new PackageError(`module ${path} has no source and its index does not name its imports`);
+    return { specifier: i.specifier, module: i.module, library: i.library, export: i.export };
+  });
+}
+function specifiers(path, code, imports) {
+  return imports.map((i) => {
+    if (i.at < 0 || i.end > code.length || i.end < i.at) throw new PackageError(`${path} has an import outside its code`);
+    let specifier = code.slice(i.at, i.end);
+    if (i.specifier !== void 0 && i.specifier !== specifier) throw new PackageError(`${path} names an import its code does not hold`);
+    return { specifier, module: i.module, library: i.library, export: i.export };
+  });
+}
+function runtimeChunks(index) {
+  return index.runtimes.map((runtime) => `${runtime.unit}=${runtime.chunk}`).join(",");
+}
+var PackageAssembler = class {
+  constructor(onWasm = null, native = null, assets = null) {
+    this.onWasm = onWasm;
+    this.native = native;
+    this.assets = assets;
+    this.index = null;
+    this.moreCatalogued = false;
+    this.nextIndexes = /* @__PURE__ */ new Map();
+    this.code = /* @__PURE__ */ new Map();
+    this.wasm = /* @__PURE__ */ new Map();
+  }
+  accept(digest, bytes) {
+    let chunk = decodeChunk(bytes);
+    if (this.index === null) {
+      this.index = readIndex(chunk), this.assets?.catalog(this.index.assets ?? NO_ASSETS), this.index.more !== void 0 && this.assets?.awaitCatalog?.();
+      for (let [held, wasm] of this.wasm) this.announce(held, wasm);
+      return;
+    }
+    if (chunk.kind === ChunkKind.index) {
+      let id = hex(digest);
+      if (this.index.more === void 0 || id !== this.index.more) {
+        this.nextIndexes.set(id, { kind: chunk.kind, payload: chunk.payload.slice() });
+        return;
+      }
+      if (this.moreCatalogued) return;
+      this.moreCatalogued = true, this.assets?.catalog(readIndex(chunk).assets ?? NO_ASSETS), this.assets?.catalogued?.();
+      return;
+    }
+    switch (chunk.kind) {
+      case ChunkKind.code:
+        this.code.set(hex(digest), decoder.decode(chunk.payload));
+        return;
+      case ChunkKind.wasm:
+        this.acceptWasm(hex(digest), chunk.payload.slice());
+        return;
+      case ChunkKind.texture:
+      case ChunkKind.mesh:
+      case ChunkKind.audio:
+      case ChunkKind.font:
+      case ChunkKind.data:
+        this.assets?.accept(hex(digest), chunk.payload);
+        return;
+    }
+  }
+  swapIndex(candidates) {
+    for (let digest of candidates) {
+      let chunk = this.nextIndexes.get(digest);
+      if (chunk === void 0) continue;
+      let next = readIndex(chunk), current = this.index;
+      if (current === null || next.entries.client !== current.entries.client || runtimeChunks(next) !== runtimeChunks(current)) return null;
+      let before = /* @__PURE__ */ new Map();
+      for (let asset of current.assets ?? NO_ASSETS) before.set(asset.path, asset.chunk);
+      let changed = [];
+      for (let asset of next.assets ?? NO_ASSETS) before.get(asset.path) !== asset.chunk && changed.push(asset.path);
+      return this.index = next, this.nextIndexes.clear(), changed.length > 0 && this.assets?.catalog(next.assets ?? NO_ASSETS), changed;
+    }
+    return null;
+  }
+  stageCode(digest, bytes) {
+    let code = decoder.decode(bytes);
+    return this.code.set(digest, code), code;
+  }
+  stage(digest, bytes) {
+    let held = bytes.slice();
+    return this.wasm.set(digest, held), held;
+  }
+  lateRuntime(unit) {
+    for (let late of this.index?.late ?? NO_LATE_RUNTIMES) if (late.unit === unit) return late.chunk;
+    return null;
+  }
+  holdsWasm(digest) {
+    return this.wasm.has(digest);
+  }
+  acceptWasmPayload(digest, bytes) {
+    this.acceptWasm(digest, bytes);
+  }
+  acceptWasm(digest, bytes) {
+    this.wasm.set(digest, bytes), this.announce(digest, bytes);
+  }
+  announce(digest, bytes) {
+    if (this.onWasm === null || this.index === null) return;
+    let runtimes = this.index.runtimes;
+    for (let i = 0; i < runtimes.length; i++) runtimes[i].chunk === digest && this.onWasm(runtimes[i].unit, bytes, digest);
+    let alternatives = this.index.alternatives ?? NO_ALTERNATIVES;
+    for (let i = 0; i < alternatives.length; i++) alternatives[i].chunk === digest && this.onWasm(alternatives[i].unit, bytes, digest);
+    let late = this.index.late ?? NO_LATE_RUNTIMES;
+    for (let i = 0; i < late.length; i++) late[i].chunk === digest && this.onWasm(late[i].unit, bytes, digest);
+  }
+  standIn(unit) {
+    for (let alternative of this.index?.alternatives ?? NO_ALTERNATIVES) {
+      if (alternative.replaces !== unit) continue;
+      let bytes = this.wasm.get(alternative.chunk);
+      if (bytes !== void 0) return bytes;
+    }
+  }
+  modules(registered = NO_MODULES) {
+    let index = this.index;
+    if (index === null) throw new PackageError("the package has no module index");
+    let modules = [];
+    for (let module of index.modules) {
+      let code = this.code.get(module.chunk);
+      if (code !== void 0) {
+        modules.push({ path: module.path, code, imports: specifiers(module.path, code, module.imports) });
+        continue;
+      }
+      if (!registered.has(module.path)) throw new PackageError(`module ${module.path} did not arrive`);
+      modules.push({ path: module.path, code: NO_SOURCE, imports: namedSpecifiers(module.path, module.imports) });
+    }
+    let runtimes = [];
+    for (let runtime of index.runtimes) runtimes.push(this.runtime(runtime));
+    return { entry: index.entries.client, modules, runtimes };
+  }
+  runtime(runtime) {
+    if (runtime.kind === "wasm") {
+      let value = this.native?.(runtime.unit);
+      if (value !== void 0) return { unit: runtime.unit, kind: "native", value };
+      let bytes = this.wasm.get(runtime.chunk) ?? this.standIn(runtime.unit);
+      if (bytes === void 0) throw new PackageError(`runtime ${runtime.unit} did not arrive`);
+      return { unit: runtime.unit, kind: "wasm", bytes };
+    }
+    let code = this.code.get(runtime.chunk);
+    if (code === void 0) throw new PackageError(`runtime ${runtime.unit} did not arrive`);
+    return { unit: runtime.unit, kind: "code", code, imports: specifiers(runtime.unit, code, runtime.imports) };
+  }
+};
+function linkOrder(modules, entry, units) {
+  let byPath = /* @__PURE__ */ new Map();
+  for (let m of modules) byPath.set(m.path, m);
+  let state = /* @__PURE__ */ new Map(), order = [], visit = (path, from) => {
+    let seen = state.get(path);
+    if (seen === 2) return;
+    if (seen === 1) throw new PackageError(`modules import each other in a cycle through ${path}`);
+    let module = byPath.get(path);
+    if (module === void 0) throw new PackageError(`${from ?? "the entry"} imports ${path}, which is not in the package`);
+    state.set(path, 1);
+    for (let i of module.imports)
+      if (i.module !== null) visit(i.module, path);
+      else if (i.library === null || i.export === null || !units.has(i.library))
+        throw new PackageError(`${path} imports library ${i.library ?? i.specifier}, which this host does not provide`);
+    state.set(path, 2), order.push(module);
+  };
+  return visit(entry, null), order;
+}
+var RUNTIME_PATH_PREFIX = "runtime:", RuntimeUnits = class {
+  constructor(compiler, tick, runtimes, compiled) {
+    this.compiler = compiler;
+    this.tick = tick;
+    this.compiled = compiled;
+    this.sources = /* @__PURE__ */ new Map();
+    this.factories = /* @__PURE__ */ new Map();
+    this.wasm = /* @__PURE__ */ new Map();
+    this.evaluated = /* @__PURE__ */ new Map();
+    for (let runtime of runtimes) this.sources.set(runtime.unit, runtime);
+  }
+  get names() {
+    return new Set(this.sources.keys());
+  }
+  async prepare() {
+    let pending = [];
+    for (let source of this.sources.values())
+      if (source.kind === "native")
+        this.wasm.set(source.unit, source.value);
+      else if (source.kind === "wasm") {
+        if (!wasmAvailable()) throw new PackageError(`runtime ${source.unit} needs WebAssembly, which this host does not provide`);
+        let ready = this.compiled?.(source.unit, source.bytes) ?? null, module = ready === null ? compileApproved(source.bytes) : approveCompiled(ready);
+        pending.push(module.then((compiled) => {
+          this.wasm.set(source.unit, compiled);
+        }));
+      } else if (this.compiler.ahead) {
+        let path = RUNTIME_PATH_PREFIX + source.unit;
+        pending.push(Promise.resolve(this.compiler.compile(path, source.code)).then((factory) => {
+          this.factories.set(source.unit, factory);
+        }));
+      }
+    await Promise.all(pending);
+  }
+  resolve(dependency) {
+    let unit = dependency.library, compiled = this.wasm.get(unit);
+    return compiled !== void 0 ? compiled : this.load(unit)[dependency.export];
+  }
+  load(unit) {
+    let done = this.evaluated.get(unit);
+    if (done !== void 0) return done;
+    let source = this.sources.get(unit);
+    if (source === void 0 || source.kind !== "code") throw new PackageError(`runtime ${unit} is not in the package`);
+    let factory = this.factories.get(unit);
+    factory === void 0 && (factory = this.compiler.compile(RUNTIME_PATH_PREFIX + unit, source.code), this.factories.set(unit, factory));
+    let table = /* @__PURE__ */ new Map();
+    for (let dependency of source.imports) table.set(dependency.specifier, dependency);
+    let require2 = (specifier) => {
+      let dependency = table.get(specifier);
+      if (dependency === void 0) throw new PackageError(`runtime ${unit} may not require ${specifier}`);
+      return this.resolve(dependency);
+    }, record = { exports: {} };
+    factory(require2, record.exports, record, this.tick);
+    let exported = record.exports.default;
+    return this.evaluated.set(unit, exported), exported;
+  }
+};
+function commonJsLinker(compiler, compiled = null) {
+  let linkedUnits = null, evaluate = async (units, prepare, modules, entry, tick) => {
+    let order = linkOrder(modules, entry, units.names), prepared = prepare(), byPath = /* @__PURE__ */ new Map();
+    for (let module of order) byPath.set(module.path, module);
+    let factories = /* @__PURE__ */ new Map();
+    if (compiler.ahead) {
+      let compiled2 = await Promise.all(order.map((m) => compiler.compile(m.path, m.code)));
+      for (let i = 0; i < order.length; i++) factories.set(order[i].path, compiled2[i]);
+    }
+    await prepared;
+    let evaluated = /* @__PURE__ */ new Map(), load = (path) => {
+      let done = evaluated.get(path);
+      if (done !== void 0) return done.exports;
+      let module = byPath.get(path), factory = factories.get(path);
+      factory === void 0 && (factory = compiler.compile(path, module.code), factories.set(path, factory));
+      let table = /* @__PURE__ */ new Map();
+      for (let dependency of module.imports) table.set(dependency.specifier, dependency);
+      let require2 = (specifier) => {
+        let dependency = table.get(specifier);
+        if (dependency === void 0) throw new PackageError(`${path} may not require ${specifier}`);
+        return dependency.module !== null ? load(dependency.module) : units.resolve(dependency);
+      }, record = { exports: {} };
+      return evaluated.set(path, record), factory(require2, record.exports, record, tick), record.exports;
+    };
+    return load(entry);
+  };
+  return {
+    link(modules, entry, tick, runtimes = []) {
+      let units = new RuntimeUnits(compiler, tick, runtimes, compiled);
+      return linkedUnits = units, evaluate(units, () => units.prepare(), modules, entry, tick);
+    },
+    relink(modules, entry, tick) {
+      return linkedUnits === null ? Promise.reject(new PackageError("nothing has been linked to swap")) : evaluate(linkedUnits, () => Promise.resolve(), modules, entry, tick);
+    }
+  };
+}
+function moduleWrapper(code) {
+  return `export default function (${MODULE_PARAMETERS.join(", ")}) {
+${code}
+}
+`;
+}
+var BLOB_URLS = {
+  create(code) {
+    return URL.createObjectURL(new Blob([code], { type: "text/javascript" }));
+  },
+  revoke(url) {
+    URL.revokeObjectURL(url);
+  }
+};
+function blobCompiler(urls, importer) {
+  return {
+    ahead: true,
+    async compile(_path, code) {
+      let url = urls.create(moduleWrapper(code));
+      try {
+        return (await importer(url)).default;
+      } finally {
+        urls.revoke(url);
+      }
+    }
+  };
+}
+
+export { BLOB_URLS, ChunkKind, MODULE_INDEX_FORMAT, MODULE_PARAMETERS, PackageAssembler, PackageError, RUNTIME_PATH_PREFIX, VERBOSE_MODULE_INDEX_FORMAT, blobCompiler, commonJsLinker, decodeChunk, linkOrder, moduleWrapper, readIndex };

package/dist/chunk-KDTVOLHI.mjs

@@ -0,0 +1,288 @@
+import { quatSlerpArrays } from './chunk-KIZOA5LX.mjs';
+import { FRAME_STEP_SECONDS_SLOT } from './chunk-IDLW4NWA.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/animation/easing.ts
+var Ease = {
+  Linear: 0,
+  InQuad: 1,
+  OutQuad: 2,
+  InOutQuad: 3,
+  InCubic: 4,
+  OutCubic: 5,
+  InOutCubic: 6,
+  OutBack: 7,
+  OutElastic: 8,
+  OutBounce: 9,
+  InSine: 10,
+  OutSine: 11,
+  InOutSine: 12,
+  OutExpo: 13
+}, BACK_OVERSHOOT = 1.70158, ELASTIC_PERIOD = 2 * Math.PI / 3, ELASTIC_DECAY = 10, ELASTIC_PHASE = 0.75, BOUNCE_N = 7.5625, BOUNCE_D = 2.75, EXPO_BASE = 2, easeScratch = new Float64Array(1);
+function ease(id, t) {
+  return easeScratch[0] = t, easeInPlace(id, easeScratch, 0), easeScratch[0];
+}
+function easeInPlace(id, registers, slot) {
+  let t = registers[slot];
+  if (t <= 0) {
+    registers[slot] = 0;
+    return;
+  }
+  if (t >= 1) {
+    registers[slot] = 1;
+    return;
+  }
+  let u;
+  switch (id) {
+    case Ease.InQuad:
+      registers[slot] = t * t;
+      return;
+    case Ease.OutQuad:
+      registers[slot] = t * (2 - t);
+      return;
+    case Ease.InOutQuad:
+      registers[slot] = t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+      return;
+    case Ease.InCubic:
+      registers[slot] = t * t * t;
+      return;
+    case Ease.OutCubic:
+      u = t - 1, registers[slot] = u * u * u + 1;
+      return;
+    case Ease.InOutCubic:
+      registers[slot] = t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+      return;
+    case Ease.OutBack:
+      u = t - 1, registers[slot] = 1 + ((1.70158) + 1) * u * u * u + (1.70158) * u * u;
+      return;
+    case Ease.OutElastic:
+      registers[slot] = Math.pow((2), -(10) * t) * Math.sin((t * (10) - (0.75)) * ELASTIC_PERIOD) + 1;
+      return;
+    case Ease.OutBounce:
+      t < 1 / (2.75) ? registers[slot] = (7.5625) * t * t : t < 2 / (2.75) ? (u = t - 1.5 / (2.75), registers[slot] = (7.5625) * u * u + 0.75) : t < 2.5 / (2.75) ? (u = t - 2.25 / (2.75), registers[slot] = (7.5625) * u * u + 0.9375) : (u = t - 2.625 / (2.75), registers[slot] = (7.5625) * u * u + 0.984375);
+      return;
+    case Ease.InSine:
+      registers[slot] = 1 - Math.cos(t * Math.PI / 2);
+      return;
+    case Ease.OutSine:
+      registers[slot] = Math.sin(t * Math.PI / 2);
+      return;
+    case Ease.InOutSine:
+      registers[slot] = -(Math.cos(Math.PI * t) - 1) / 2;
+      return;
+    case Ease.OutExpo:
+      registers[slot] = 1 - Math.pow((2), -(10) * t);
+      return;
+    default:
+      return;
+  }
+}
+
+// src/game/animation/animation.ts
+var REG_DT = 0, REG_T = 1, REG_VALUE = 2, REG_TIME = 3, REGISTER_COUNT = 4, TweenTarget = {
+  PositionX: 0,
+  PositionY: 1,
+  PositionZ: 2,
+  ScaleX: 3,
+  ScaleY: 4,
+  ScaleZ: 5,
+  ScaleUniform: 6,
+  Rotation: 7,
+  Value: 8
+}, Repeat = { Once: 0, Loop: 1, PingPong: 2 }, INDEX_BITS = 16, INDEX_MASK = (1 << (16)) - 1, GENERATION_MASK = 32767, NO_SLOT = -1, Clip = class {
+  constructor(desc) {
+    for (let track of desc.tracks) {
+      let stride = track.target === TweenTarget.Rotation ? 4 : 1;
+      if (track.times.length === 0 || track.values.length !== track.times.length * stride)
+        throw new GameError("invalid_argument", "clip track values must match its keyframe times");
+    }
+    this.duration = desc.duration, this.tracks = desc.tracks;
+  }
+}, Animation = class {
+  constructor(world, transforms, options = {}) {
+    this.tweenHigh = 0;
+    this.valueCount = 0;
+    this.registers = new Float64Array((4));
+    this.transforms = transforms;
+    let tweens = options.maxTweens ?? 1024;
+    if (tweens > INDEX_MASK) throw new GameError("invalid_argument", "too many tweens");
+    this.tweenCapacity = tweens, this.tweenActive = new Uint8Array(tweens), this.tweenGeneration = new Uint16Array(tweens), this.tweenTarget = new Uint8Array(tweens), this.tweenEase = new Uint8Array(tweens), this.tweenRepeat = new Uint8Array(tweens), this.tweenEntity = new Uint32Array(tweens), this.tweenSlot = new Int32Array(tweens), this.tweenFrom = new Float32Array(tweens * 4), this.tweenTo = new Float32Array(tweens * 4), this.tweenDuration = new Float32Array(tweens), this.tweenElapsed = new Float32Array(tweens), this.tweenDelay = new Float32Array(tweens), this.tweenFree = new Uint16Array(tweens), this.tweenFreeCount = 0, this.values = new Float32Array(options.maxValueSlots ?? 256);
+    let players = options.maxClipPlayers ?? 256;
+    this.clips = Array.from({ length: players }, () => null), this.clipEntity = new Uint32Array(players).fill(4294967295), this.clipTime = new Float32Array(players), this.clipSpeed = new Float32Array(players), this.clipRepeat = new Uint8Array(players), world.onDespawn(this);
+  }
+  createValue(initial = 0) {
+    if (this.valueCount >= this.values.length)
+      throw new GameError("capacity_exceeded", "animation value slots exhausted");
+    let slot = this.valueCount++;
+    return this.values[slot] = initial, slot;
+  }
+  value(slot) {
+    return this.values[slot];
+  }
+  setValue(slot, value) {
+    this.values[slot] = value;
+  }
+  tween(entity, target, to, durationSeconds, easing, delaySeconds = 0, repeat = Repeat.Once) {
+    let i = this.allocTween(target, easing, durationSeconds, delaySeconds, repeat);
+    return this.tweenEntity[i] = entity, this.loadScalar(entity, target), this.tweenFrom[i * 4] = this.registers[(2)], this.tweenTo[i * 4] = to, this.handle(i);
+  }
+  tweenValue(slot, to, durationSeconds, easing, delaySeconds = 0, repeat = Repeat.Once) {
+    let i = this.allocTween(TweenTarget.Value, easing, durationSeconds, delaySeconds, repeat);
+    return this.tweenSlot[i] = slot, this.tweenFrom[i * 4] = this.values[slot], this.tweenTo[i * 4] = to, this.handle(i);
+  }
+  tweenRotation(entity, to, durationSeconds, easing, delaySeconds = 0, repeat = Repeat.Once) {
+    let i = this.allocTween(TweenTarget.Rotation, easing, durationSeconds, delaySeconds, repeat);
+    this.tweenEntity[i] = entity;
+    let row = this.transforms.row(entity), r = this.transforms.store.fields.rotation, o = i * 4;
+    for (let k = 0; k < 4; k++) this.tweenFrom[o + k] = r[row * 4 + k];
+    return to.writeTo(this.tweenTo, o), this.handle(i);
+  }
+  isActive(id) {
+    let i = id & INDEX_MASK;
+    return this.tweenActive[i] === 1 && this.tweenGeneration[i] === id >>> (16);
+  }
+  cancel(id) {
+    this.isActive(id) && this.releaseTween(id & INDEX_MASK);
+  }
+  playClip(entity, clip, repeat = Repeat.Once, speed = 1) {
+    for (let p = 0; p < this.clips.length; p++)
+      if (this.clips[p] === null)
+        return this.clips[p] = clip, this.clipEntity[p] = entity, this.clipTime[p] = 0, this.clipSpeed[p] = speed, this.clipRepeat[p] = repeat, p;
+    throw new GameError("capacity_exceeded", "clip players exhausted");
+  }
+  stopClip(player) {
+    this.clips[player] = null, this.clipEntity[player] = 4294967295;
+  }
+  isClipPlaying(player) {
+    return this.clips[player] !== null;
+  }
+  onDespawn(entity) {
+    for (let i = 0; i < this.tweenHigh; i++)
+      this.tweenActive[i] === 1 && this.tweenEntity[i] === entity && this.tweenTarget[i] !== TweenTarget.Value && this.releaseTween(i);
+    for (let p = 0; p < this.clips.length; p++)
+      this.clipEntity[p] === entity && this.stopClip(p);
+  }
+  update(time) {
+    this.registers[(0)] = time.values[FRAME_STEP_SECONDS_SLOT];
+    for (let i = 0; i < this.tweenHigh; i++)
+      this.tweenActive[i] === 1 && this.advanceTween(i);
+    for (let p = 0; p < this.clips.length; p++) {
+      let clip = this.clips[p];
+      clip !== null && this.advanceClip(p, clip);
+    }
+  }
+  handle(i) {
+    return this.tweenGeneration[i] << (16) | i;
+  }
+  allocTween(target, easing, duration, delay, repeat) {
+    let i;
+    if (this.tweenFreeCount > 0) i = this.tweenFree[--this.tweenFreeCount];
+    else if (this.tweenHigh < this.tweenCapacity) i = this.tweenHigh++;
+    else throw new GameError("capacity_exceeded", "tween pool exhausted");
+    return this.tweenActive[i] = 1, this.tweenTarget[i] = target, this.tweenEase[i] = easing, this.tweenRepeat[i] = repeat, this.tweenDuration[i] = duration > 0 ? duration : Number.MIN_VALUE, this.tweenElapsed[i] = 0, this.tweenDelay[i] = delay, this.tweenSlot[i] = (-1), this.tweenEntity[i] = 4294967295, i;
+  }
+  releaseTween(i) {
+    this.tweenActive[i] = 0, this.tweenGeneration[i] = this.tweenGeneration[i] + 1 & (32767), this.tweenFree[this.tweenFreeCount++] = i;
+  }
+  advanceTween(i) {
+    let reg = this.registers, dt = reg[(0)];
+    if (this.tweenDelay[i] > 0) {
+      if (this.tweenDelay[i] -= dt, this.tweenDelay[i] > 0) return;
+      dt = -this.tweenDelay[i], this.tweenDelay[i] = 0, this.tweenTarget[i] !== TweenTarget.Value && this.tweenTarget[i] !== TweenTarget.Rotation && (this.loadScalar(this.tweenEntity[i], this.tweenTarget[i]), this.tweenFrom[i * 4] = reg[(2)]);
+    }
+    let duration = this.tweenDuration[i], elapsed = this.tweenElapsed[i] + dt, finished = false, repeat = this.tweenRepeat[i];
+    elapsed >= duration && (repeat === Repeat.Once ? (elapsed = duration, finished = true) : repeat === Repeat.Loop ? elapsed %= duration : elapsed %= duration * 2), this.tweenElapsed[i] = elapsed;
+    let t = elapsed / duration;
+    repeat === Repeat.PingPong && t > 1 && (t = 2 - t), reg[(1)] = t, easeInPlace(this.tweenEase[i], reg, (1));
+    let applied = this.applyTween(i);
+    (finished || !applied) && this.releaseTween(i);
+  }
+  applyTween(i) {
+    let reg = this.registers, k = reg[(1)], o = i * 4, target = this.tweenTarget[i];
+    if (target === TweenTarget.Value)
+      return this.values[this.tweenSlot[i]] = this.tweenFrom[o] + (this.tweenTo[o] - this.tweenFrom[o]) * k, true;
+    let entity = this.tweenEntity[i], row = this.transforms.store.row(entity);
+    return row === -1 ? false : target === TweenTarget.Rotation ? (quatSlerpArrays(this.transforms.store.fields.rotation, row * 4, this.tweenFrom, o, this.tweenTo, o, reg, (1)), true) : (reg[(2)] = this.tweenFrom[o] + (this.tweenTo[o] - this.tweenFrom[o]) * k, this.writeScalar(row, target), true);
+  }
+  advanceClip(p, clip) {
+    let reg = this.registers, time = this.clipTime[p] + reg[(0)] * this.clipSpeed[p], done = false;
+    time >= clip.duration && (this.clipRepeat[p] === Repeat.Once ? (time = clip.duration, done = true) : time %= clip.duration), this.clipTime[p] = time, reg[(3)] = time;
+    let row = this.transforms.store.row(this.clipEntity[p]);
+    if (row === -1) {
+      this.stopClip(p);
+      return;
+    }
+    for (let t = 0; t < clip.tracks.length; t++) this.sampleTrack(clip.tracks[t], row);
+    done && this.stopClip(p);
+  }
+  sampleTrack(track, row) {
+    let reg = this.registers, time = reg[(3)], times = track.times, values = track.values, last = times.length - 1, lo = 0, hi = last;
+    if (time <= times[0]) hi = 0;
+    else if (time >= times[last]) lo = last;
+    else
+      for (; hi - lo > 1; ) {
+        let mid = lo + hi >>> 1;
+        times[mid] <= time ? lo = mid : hi = mid;
+      }
+    let a = Math.min(lo, hi), b = Math.max(lo, hi), span = times[b] - times[a];
+    if (reg[(1)] = span > 0 ? (time - times[a]) / span : 0, track.target === TweenTarget.Rotation) {
+      quatSlerpArrays(this.transforms.store.fields.rotation, row * 4, values, a * 4, values, b * 4, reg, (1));
+      return;
+    }
+    reg[(2)] = values[a] + (values[b] - values[a]) * reg[(1)], this.writeScalar(row, track.target);
+  }
+  loadScalar(entity, target) {
+    let row = this.transforms.row(entity), f = this.transforms.store.fields, o = row * 3, reg = this.registers;
+    switch (target) {
+      case TweenTarget.PositionX:
+        reg[(2)] = f.position[o];
+        return;
+      case TweenTarget.PositionY:
+        reg[(2)] = f.position[o + 1];
+        return;
+      case TweenTarget.PositionZ:
+        reg[(2)] = f.position[o + 2];
+        return;
+      case TweenTarget.ScaleX:
+      case TweenTarget.ScaleUniform:
+        reg[(2)] = f.scale[o];
+        return;
+      case TweenTarget.ScaleY:
+        reg[(2)] = f.scale[o + 1];
+        return;
+      case TweenTarget.ScaleZ:
+        reg[(2)] = f.scale[o + 2];
+        return;
+      default:
+        throw new GameError("invalid_argument", `tween target ${target} is not a transform scalar`);
+    }
+  }
+  writeScalar(row, target) {
+    let v = this.registers[(2)], f = this.transforms.store.fields, o = row * 3;
+    switch (target) {
+      case TweenTarget.PositionX:
+        f.position[o] = v;
+        break;
+      case TweenTarget.PositionY:
+        f.position[o + 1] = v;
+        break;
+      case TweenTarget.PositionZ:
+        f.position[o + 2] = v;
+        break;
+      case TweenTarget.ScaleX:
+        f.scale[o] = v;
+        break;
+      case TweenTarget.ScaleY:
+        f.scale[o + 1] = v;
+        break;
+      case TweenTarget.ScaleZ:
+        f.scale[o + 2] = v;
+        break;
+      case TweenTarget.ScaleUniform:
+        f.scale[o] = v, f.scale[o + 1] = v, f.scale[o + 2] = v;
+        break;
+    }
+  }
+};
+
+export { Animation, Clip, Ease, Repeat, TweenTarget, ease, easeInPlace };

package/dist/chunk-KGHJH5KJ.mjs

@@ -0,0 +1,35 @@
+import { createGame } from './chunk-KVFNRJOR.mjs';
+import { FRAME_NOW_MS_SLOT } from './chunk-IDLW4NWA.mjs';
+
+// src/game/kit/templates/template.ts
+var MS_PER_STAMP_CYCLE = 50, FRAMES_PER_STAMP_CYCLE = 3;
+function templateFrameStamp(frame) {
+  return frame * (50) / (3) | 0;
+}
+async function createTemplateHarness(template, backend, seed, ui = null) {
+  let game = await createGame({ backend, seed, ui }), scene = template.scene();
+  game.addScene(scene), game.start(scene.name);
+  let bot = template.bot();
+  return {
+    game,
+    scene,
+    frame(index) {
+      bot.drive(scene, game, index), game.clock[FRAME_NOW_MS_SLOT] = templateFrameStamp(index), game.runFrame();
+    }
+  };
+}
+var FNV_OFFSET = 2166136261, FNV_PRIME = 16777619;
+function digestFloats(values, count, seed = (2166136261)) {
+  let h = seed >>> 0;
+  for (let i = 0; i < count; i++)
+    h ^= Math.round(values[i] * 1e3) | 0, h = Math.imul(h, (16777619));
+  return h >>> 0;
+}
+function digestInts(values, count, seed = (2166136261)) {
+  let h = seed >>> 0;
+  for (let i = 0; i < count; i++)
+    h ^= values[i] | 0, h = Math.imul(h, (16777619));
+  return h >>> 0;
+}
+
+export { createTemplateHarness, digestFloats, digestInts, templateFrameStamp };