@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-BU6OK542.mjs

@@ -0,0 +1,818 @@
+import { ENGINE_RAGDOLL_POLICY_EXPORT_NAMES } from './chunk-PRSR4FAV.mjs';
+import { GENESIS_EXPORT_NAMES } from './chunk-TM63CYGN.mjs';
+import { ENGINE_VOXEL_FACET_EXPORT_NAMES } from './chunk-3OY3VYNF.mjs';
+import { GPU_KERNEL_EXPORT_NAMES, GPU_KERNEL_OPTIONAL_EXPORT_NAMES } from './chunk-EIB4OWVQ.mjs';
+import { ENGINE_RAGDOLL_EXPORT_NAMES, ENGINE_JOINT_EXPORT_NAMES, ENGINE_VECTOR_SURFACE_EXPORT_NAMES, ENGINE_AUDIO_WORKLET_EXPORTS, ENGINE_AUDIO_LOCKSTEP_EXPORTS, ENGINE_ROLLBACK_EXPORT_NAMES, ENGINE_ARENA_EXPORT_NAMES } from './chunk-GXKI64OT.mjs';
+import { ENGINE_STREAM_EXPORT_NAMES, ENGINE_SPLAT_EXPORT_NAMES } from './chunk-NHJUGZUR.mjs';
+import { ENGINE_DESTRUCTION_STRUCTURE_EXPORT_NAMES, ENGINE_REACTIVE_EXPORT_NAMES, ENGINE_SMOKE_EXPORT_NAMES, ENGINE_FLUID_EXPORT_NAMES, ENGINE_COMPUTE_EXPORT_NAMES, ENGINE_ENCODE_EXPORT_NAMES, ENGINE_RELOAD_EXPORT_NAMES, TRANSFORM_EXPORT_NAMES, CHEMISTRY_EXPORT_NAMES, ENGINE_DESTRUCTION_EXPORT_NAMES } from './chunk-E65WCTIG.mjs';
+import { ENGINE_RIGID_COUPLING_EXPORT_NAMES, ENGINE_CLOTH_EXPORT_NAMES, ENGINE_SOFT_BODY_EXPORT_NAMES, ENGINE_CRUMPLE_EXPORT_NAMES } from './chunk-5YFBGGCK.mjs';
+import { KERNEL_EXPORT_NAMES, KERNEL_CALL_EXPORT_NAMES, KERNEL_WRITE_EXPORT_NAMES, KERNEL_STAGE_EXPORT_NAMES } from './chunk-SMK6JU2F.mjs';
+import { sha256Into, SHA256_BYTES } from './chunk-5YWN6H5Q.mjs';
+import { unhex, TAG_BYTES, DIGEST_BYTES } from './chunk-V7ZRH3PY.mjs';
+import { ENGINE_INSPECTOR_EXPORT_NAMES } from './chunk-MOMOZEUM.mjs';
+import { approveCompiled } from './chunk-N4RGGDEL.mjs';
+
+// src/game/backends/engine/ui.ts
+var ENGINE_VECTOR_EXPORT_NAMES = [
+  "engine_ui_vector_load",
+  "engine_ui_vector_unload",
+  "engine_ui_vector_attach",
+  "engine_ui_vector_detach",
+  "engine_ui_vector_play",
+  "engine_ui_vector_input_index",
+  "engine_ui_vector_input"
+];
+var ENGINE_VECTOR_DATA_EXPORT_NAMES = ["engine_ui_vector_data_index", "engine_ui_vector_data_set"];
+
+// src/interactives/engine-features.ts
+var ENGINE_COMPATIBILITY_EXPORT_NAMES = ["engine_export_prototype_of", "engine_abi_compatible"], ENGINE_FEATURE_NAMES = ["particles", "raw_compute", "raw_render", "text", "pick", "post_shaders", "audio", "physics", "models", "images", "ai", "ui", "animation", "render_targets", "kernel_isa_1", "kernel_gpu_1", "kernel_isa_2", "fluid_1", "destruction_1", "chemistry_1", "genesis_1", "kernel_isa_3", "kernel_isa_4", "transforms_1", "scenery_1", "world_lazy_packs_1", "kernel_gather_1", "render_kernel_instances_1", "asset_reload_1", "kernel_scan_1", "texture_encode_1", "vector_1", "arena_commit_1", "vector_data_1", "compute_budget_1", "rollback_1", "inspector_1", "soft_body_1", "fluid_elastic_1", "render_feed_pose_1", "audio_lockstep_1", "audio_worklet_1", "kernel_mlp_1", "voxel_facet_1", "kernel_simd_1", "media_volume_1", "gpu_smoke_1", "reactive_fluid_1", "cloth_1", "script_shaders_1", "vector_world_1", "joints_6dof_1", "ragdoll_1", "shapes_compound_1", "rigid_coupling_1", "destruction_2", "ragdoll_policy_1", "kernel_query_rank_1", "kernel_moe_1"];
+function engineFeatureMember(call) {
+  let dot = call.lastIndexOf(".");
+  return dot < 0 ? call : call.slice(dot + 1);
+}
+var ENGINE_FEATURES = {
+  particles: { exports: ["engine_render_create_emitter"], calls: ["Graphics.createEmitter"] },
+  raw_compute: {
+    exports: ["engine_render_raw_buffer", "engine_render_raw_pipeline", "engine_render_raw_bindings", "engine_render_raw_read", "engine_render_raw_poll"],
+    calls: ["RawGpu.createComputePipeline", "RawGpu.readBuffer"]
+  },
+  raw_render: {
+    exports: ["engine_render_raw_texture", "engine_render_raw_sampler", "engine_render_raw_read_texture"],
+    calls: ["RawGpu.createRenderPipeline", "RawGpu.createSampler", "RawGpu.readTexture"]
+  },
+  text: {
+    exports: ["engine_render_load_font", "engine_render_set_text", "engine_render_set_text_style", "engine_render_text_bounds"],
+    calls: ["Graphics.loadFont", "Graphics.setTextStyle", "Graphics.textBounds"]
+  },
+  pick: { exports: ["engine_render_raycast"], calls: ["Graphics.raycast"] },
+  post_shaders: { exports: ["engine_render_set_chain_shader"], calls: ["Graphics.setPostChain"] },
+  audio: { exports: ["engine_audio_bound", "engine_audio_play"], calls: ["Audio.setListener", "AudioPort.setListener", "AudioPort.setVoicePosition"] },
+  physics: {
+    exports: ["engine_body_create", "engine_collider_create", "engine_controller_create", "engine_joint_create", "engine_step", "engine_raycast"],
+    calls: ["Physics.addBody", "Physics.addCollider", "Physics.joint", "Physics.createCharacterController", "Physics.raycast", "CtxGame.create_physics", "PhysicsWorld.add_body", "PhysicsWorld.raycast"]
+  },
+  models: { exports: ["engine_render_load_model", "engine_render_instantiate"], calls: ["Graphics.loadModel"] },
+  images: { exports: ["engine_render_decode_texture"], calls: ["Graphics.loadTexture", "Graphics.loadFont", "Graphics.loadModel"] },
+  ai: { exports: ["engine_ai_create", "engine_ai_step"], calls: ["encodeArchetype", "GameAi.drainEvents", "GameAi.setFocus"] },
+  ui: {
+    exports: ["engine_ui_create", "engine_ui_apply", "engine_ui_frame", "engine_ui_render", "engine_ui_pointer", "engine_ui_accessibility_export"],
+    calls: ["CtxUi.game"]
+  },
+  animation: { exports: ["engine_render_animation", "engine_render_load_clips", "engine_render_node_poses"], calls: ["Graphics.clips", "Graphics.loadClips"] },
+  render_targets: { exports: ["engine_render_read_target"], calls: ["Graphics.readRenderTarget"], web: ["engine_render_texture_object"] },
+  kernel_isa_1: { exports: [...KERNEL_EXPORT_NAMES], calls: ["kernel"] },
+  kernel_gpu_1: { exports: [...GPU_KERNEL_EXPORT_NAMES, ...GPU_KERNEL_OPTIONAL_EXPORT_NAMES], calls: ["onGpu"] },
+  kernel_isa_2: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES], calls: ["World.kernelServices", "KernelRunner.kernelServices"] },
+  fluid_1: { exports: [...ENGINE_FLUID_EXPORT_NAMES], calls: ["Game.fluid"] },
+  destruction_1: { exports: [...ENGINE_DESTRUCTION_EXPORT_NAMES], calls: ["Game.destructible"] },
+  chemistry_1: { exports: [...CHEMISTRY_EXPORT_NAMES], calls: ["ChemistrySandbox", "proposeReaction", "Chemistry.loadRegion", "Chemistry.materialInfo"] },
+  genesis_1: { exports: [...GENESIS_EXPORT_NAMES], calls: ["LocalGenesis"] },
+  kernel_isa_3: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES], calls: ["spawnInto"] },
+  kernel_isa_4: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES, ...KERNEL_STAGE_EXPORT_NAMES], calls: [] },
+  kernel_gather_1: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES, ...KERNEL_STAGE_EXPORT_NAMES], calls: [] },
+  transforms_1: { exports: [...TRANSFORM_EXPORT_NAMES], calls: [] },
+  scenery_1: { exports: [...ENGINE_SPLAT_EXPORT_NAMES], calls: [] },
+  world_lazy_packs_1: { exports: [...ENGINE_STREAM_EXPORT_NAMES], calls: [] },
+  render_kernel_instances_1: { exports: [], calls: [] },
+  asset_reload_1: { exports: [...ENGINE_RELOAD_EXPORT_NAMES], calls: [] },
+  kernel_scan_1: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES, ...KERNEL_STAGE_EXPORT_NAMES], calls: [] },
+  texture_encode_1: { exports: [...ENGINE_ENCODE_EXPORT_NAMES], calls: [] },
+  vector_1: { exports: [...ENGINE_VECTOR_EXPORT_NAMES], calls: ["GameUi.vector", "UiElement.vector"] },
+  arena_commit_1: { exports: [...ENGINE_ARENA_EXPORT_NAMES], calls: [] },
+  vector_data_1: { exports: [...ENGINE_VECTOR_DATA_EXPORT_NAMES], calls: ["UiElement.setData", "UiElement.setDataColor", "UiElement.fireData"] },
+  compute_budget_1: { exports: [...ENGINE_COMPUTE_EXPORT_NAMES], calls: [] },
+  rollback_1: { exports: [...ENGINE_ROLLBACK_EXPORT_NAMES], calls: [] },
+  inspector_1: { exports: [...ENGINE_INSPECTOR_EXPORT_NAMES], calls: [] },
+  soft_body_1: { exports: [...ENGINE_SOFT_BODY_EXPORT_NAMES, ...ENGINE_CRUMPLE_EXPORT_NAMES], calls: ["Game.softBody", "Craft.crumple", "CraftSystem.crumple"] },
+  fluid_elastic_1: {
+    exports: [...ENGINE_FLUID_EXPORT_NAMES],
+    calls: [],
+    uses: [{ types: ["FluidDesc", "FluidGridDesc"], property: "material", values: ["jelly", "snow", "mud"] }]
+  },
+  render_feed_pose_1: { exports: [], calls: ["Graphics.setInstancePalette"] },
+  audio_lockstep_1: { exports: [...ENGINE_AUDIO_LOCKSTEP_EXPORTS], calls: ["Audio.feedEmitters"] },
+  audio_worklet_1: { exports: [...ENGINE_AUDIO_WORKLET_EXPORTS], calls: [] },
+  kernel_mlp_1: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES, ...KERNEL_STAGE_EXPORT_NAMES], calls: [] },
+  voxel_facet_1: { exports: [...ENGINE_VOXEL_FACET_EXPORT_NAMES], calls: ["EngineVoxels.applyDelta", "EngineVoxels.rootHash"] },
+  kernel_simd_1: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES, ...KERNEL_STAGE_EXPORT_NAMES], calls: [] },
+  media_volume_1: { exports: [], calls: ["Graphics.mediaVolume"] },
+  gpu_smoke_1: { exports: [...ENGINE_SMOKE_EXPORT_NAMES], calls: ["Game.smokeVolume"] },
+  reactive_fluid_1: { exports: [...ENGINE_REACTIVE_EXPORT_NAMES], calls: ["Game.reactiveFluid"] },
+  cloth_1: { exports: [...ENGINE_CLOTH_EXPORT_NAMES], calls: ["Game.cloth"] },
+  script_shaders_1: { exports: [], calls: [] },
+  vector_world_1: { exports: [...ENGINE_VECTOR_SURFACE_EXPORT_NAMES], calls: ["Graphics.vectorSurface", "Graphics.pickVectorSurface"] },
+  joints_6dof_1: {
+    exports: [...ENGINE_JOINT_EXPORT_NAMES],
+    calls: ["Physics.joints", "JointPort.setDrive", "JointPort.clearDrive", "JointPort.setTarget", "JointPort.setBreakable"],
+    uses: [{ types: ["JointDesc"], property: "kind", values: ["cone", "six_dof"] }]
+  },
+  ragdoll_1: { exports: [...ENGINE_RAGDOLL_EXPORT_NAMES], calls: ["Physics.ragdoll", "JointPort.createRagdoll"] },
+  rigid_coupling_1: { exports: [...ENGINE_RIGID_COUPLING_EXPORT_NAMES], calls: ["Cloths.couple", "SoftBodies.couple"] },
+  destruction_2: { exports: [...ENGINE_DESTRUCTION_STRUCTURE_EXPORT_NAMES], calls: ["Destructible.configure"] },
+  ragdoll_policy_1: { exports: [...ENGINE_RAGDOLL_POLICY_EXPORT_NAMES], calls: ["RagdollPolicies.create", "RagdollPolicies.mjcf"] },
+  kernel_query_rank_1: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES, ...KERNEL_STAGE_EXPORT_NAMES], calls: [] },
+  kernel_moe_1: { exports: [...KERNEL_EXPORT_NAMES, ...KERNEL_CALL_EXPORT_NAMES, ...KERNEL_WRITE_EXPORT_NAMES, ...KERNEL_STAGE_EXPORT_NAMES], calls: [] },
+  shapes_compound_1: {
+    exports: [],
+    calls: [],
+    uses: [{ types: ["ShapeDesc", "PrimitiveShapeDesc"], property: "kind", values: ["compound", "round_cuboid", "round_cylinder", "round_cone", "round_convex_hull"] }]
+  }
+}, ENGINE_ARENA_FEATURE = "arena_commit_1", ENGINE_ARENA_BASELINE_BYTES = 512 * 1024 * 1024, ENGINE_ARENA_CHUNK_BYTES = 16 * 1024 * 1024, ENGINE_ARENA_MAX_CEILING_BYTES = 1968 * 1024 * 1024, ENGINE_OPTIONAL_EXPORTS = /* @__PURE__ */ new Set([...ENGINE_RELOAD_EXPORT_NAMES, ...ENGINE_ENCODE_EXPORT_NAMES, ...ENGINE_VECTOR_EXPORT_NAMES, ...ENGINE_VECTOR_DATA_EXPORT_NAMES, ...ENGINE_COMPATIBILITY_EXPORT_NAMES, ...ENGINE_ARENA_EXPORT_NAMES, ...ENGINE_COMPUTE_EXPORT_NAMES, ...ENGINE_ROLLBACK_EXPORT_NAMES, ...ENGINE_INSPECTOR_EXPORT_NAMES, ...ENGINE_AUDIO_LOCKSTEP_EXPORTS, ...ENGINE_AUDIO_WORKLET_EXPORTS, ...ENGINE_VOXEL_FACET_EXPORT_NAMES, ...ENGINE_DESTRUCTION_STRUCTURE_EXPORT_NAMES]), ENGINE_EXPORT_NAME = /\bengine_[a-z0-9_]+\b/g;
+function engineExportsUsed(glue, engine) {
+  let named = /* @__PURE__ */ new Set();
+  for (let code of glue) for (let match of code.matchAll(ENGINE_EXPORT_NAME)) named.add(match[0]);
+  let used = [];
+  for (let name of [...named].sort()) {
+    let prototype = engine.get(name);
+    prototype !== void 0 && !ENGINE_OPTIONAL_EXPORTS.has(name) && used.push({ name, prototype });
+  }
+  return used;
+}
+function unmetEngineExport(required, advertised) {
+  for (let use of required) if (advertised.get(use.name) !== use.prototype) return use.name;
+  return null;
+}
+function engineFeatureExports(feature, web) {
+  return web && feature.web !== void 0 ? [...feature.exports, ...feature.web] : feature.exports;
+}
+function unmetEngineFeature(required, available) {
+  for (let feature of required) if (available.indexOf(feature) < 0) return feature;
+  return null;
+}
+
+// src/interactives/scripting/luau-web/exceptions.ts
+var LUAU_VM_EXCEPTIONS = "legacy", LEGACY_THROW_PROBE = new Uint8Array([
+  0,
+  97,
+  115,
+  109,
+  1,
+  0,
+  0,
+  0,
+  1,
+  4,
+  1,
+  96,
+  0,
+  0,
+  3,
+  2,
+  1,
+  0,
+  13,
+  3,
+  1,
+  0,
+  0,
+  10,
+  11,
+  1,
+  9,
+  0,
+  6,
+  64,
+  8,
+  0,
+  7,
+  0,
+  11,
+  11
+]), EXNREF_THROW_PROBE = new Uint8Array([
+  0,
+  97,
+  115,
+  109,
+  1,
+  0,
+  0,
+  0,
+  1,
+  4,
+  1,
+  96,
+  0,
+  0,
+  3,
+  2,
+  1,
+  0,
+  13,
+  3,
+  1,
+  0,
+  0,
+  10,
+  15,
+  1,
+  13,
+  0,
+  2,
+  64,
+  31,
+  64,
+  1,
+  2,
+  0,
+  8,
+  0,
+  11,
+  11,
+  11
+]);
+function accepts(validate, probe) {
+  try {
+    return validate(probe);
+  } catch {
+    return false;
+  }
+}
+var HOST_WASM = globalThis.WebAssembly, HOST_VALIDATOR = typeof HOST_WASM?.validate == "function" ? HOST_WASM.validate.bind(HOST_WASM) : null;
+function exceptionSupport(validate = HOST_VALIDATOR) {
+  return validate === null ? { legacy: false, exnref: false } : {
+    legacy: accepts(validate, LEGACY_THROW_PROBE),
+    exnref: accepts(validate, EXNREF_THROW_PROBE)
+  };
+}
+function runsEncoding(support, encoding) {
+  return encoding === "legacy" ? support.legacy : support.exnref;
+}
+
+// src/interactives/scripting/luau-web/modules.ts
+var WASM_MEDIA_TYPE = "application/wasm", CONTENT_TYPE = "content-type", HOST_WASM2 = typeof WebAssembly > "u" ? null : WebAssembly, streamingCompiler = (response) => {
+  let wasm = HOST_WASM2;
+  if (wasm === null) return Promise.reject(new Error("this browser cannot run the script runtime"));
+  let streams = typeof wasm.compileStreaming == "function" && (response.headers.get(CONTENT_TYPE) ?? "").startsWith(WASM_MEDIA_TYPE);
+  return approveCompiled(
+    streams ? wasm.compileStreaming(response) : response.arrayBuffer().then((bytes) => wasm.compile(bytes))
+  );
+}, LuauVmModules = class {
+  constructor(compile = streamingCompiler) {
+    this.compile = compile;
+    this.compiled = /* @__PURE__ */ new Map();
+    this.started = 0;
+  }
+  get compilations() {
+    return this.started;
+  }
+  has(address) {
+    return this.compiled.has(address);
+  }
+  get(address) {
+    return this.compiled.get(address) ?? null;
+  }
+  streamed(address, open) {
+    return this.remember(
+      address,
+      () => open().then((response) => {
+        if (!response.ok) throw new Error(`the script runtime answered ${response.status}`);
+        return this.compile(response);
+      })
+    );
+  }
+  adopt(address, compiled) {
+    return this.remember(address, () => approveCompiled(compiled()));
+  }
+  remember(address, start) {
+    let known = this.compiled.get(address);
+    if (known !== void 0) return known;
+    this.started++;
+    let compiled = start();
+    return this.compiled.set(address, compiled), compiled.catch(() => {
+      this.compiled.get(address) === compiled && this.compiled.delete(address);
+    }), compiled;
+  }
+}, luauVmModules = new LuauVmModules();
+
+// src/interactives/scripting/luau-web/index.ts
+var ENGINE_LUAU_UNIT = "@cimplify/engine-luau", LUAU_SCRIPTS_GROUP = "scripts:luau", LUAU_VM_PATH = "runtime/engine-luau.wasm", LUAU_VM_FILE = "engine_luau.wasm", ENGINE_CORE_SCRIPTS_UNIT = "@cimplify/engine-core-scripts", SCRIPTS_CORE_GROUP = "scripts:engine", SCRIPTS_CORE_PATH = "runtime/engine-core-scripts.wasm", hostSupport = null;
+function luauVmRunsHere() {
+  return hostSupport ?? (hostSupport = exceptionSupport()), runsEncoding(hostSupport, LUAU_VM_EXCEPTIONS);
+}
+async function openLuauScripts(request) {
+  if (request.support === void 0 ? luauVmRunsHere() : runsEncoding(request.support, LUAU_VM_EXCEPTIONS)) {
+    let [{ createLuauVm }, module] = await Promise.all([import('./vm-IUARFFAI.mjs'), request.vm()]);
+    return createLuauVm(module, request.options);
+  }
+  let { blobEvaluator, createLuauFallback } = await import('./fallback-KDB4Y2CE.mjs');
+  return createLuauFallback(request.options, request.evaluate ?? blobEvaluator());
+}
+
+// src/interactives/hosts/chunks.ts
+var PartialChunk = class {
+  constructor() {
+    this.parts = [];
+    this.length = 0;
+  }
+  get received() {
+    return this.length;
+  }
+  append(bytes) {
+    bytes.length !== 0 && (this.parts.push(bytes), this.length += bytes.length);
+  }
+  reset() {
+    this.parts.length = 0, this.length = 0;
+  }
+  join() {
+    if (this.parts.length === 1) return this.parts[0];
+    let out = new Uint8Array(this.length), at = 0;
+    for (let part of this.parts)
+      out.set(part, at), at += part.length;
+    return out;
+  }
+}, SHA256 = "SHA-256";
+async function verified(digest, bytes, scratch, expected) {
+  if (!unhex(digest, expected)) return false;
+  let subtle = globalThis.crypto?.subtle;
+  subtle === void 0 ? sha256Into(bytes, scratch) : scratch.set(new Uint8Array(await subtle.digest(SHA256, bytes)));
+  for (let i = 0; i < SHA256_BYTES; i++) if (scratch[i] !== expected[i]) return false;
+  return true;
+}
+function verifyChunk(digest, bytes) {
+  return verified(digest, bytes, new Uint8Array(SHA256_BYTES), new Uint8Array(SHA256_BYTES));
+}
+async function fetchVerified(source, digests) {
+  let scratch = new Uint8Array(SHA256_BYTES), expected = new Uint8Array(SHA256_BYTES), bodies = await Promise.all(digests.map((digest) => source.fetch(digest)));
+  for (let i = 0; i < digests.length; i++)
+    if (!await verified(digests[i], bodies[i], scratch, expected)) throw new Error(`chunk ${digests[i]} does not match its digest`);
+  return bodies;
+}
+function chunkRefMessage(tag, digest, payloadDigest) {
+  let message = new Uint8Array(TAG_BYTES + DIGEST_BYTES * 2);
+  return message[0] = tag, unhex(digest, message.subarray(TAG_BYTES, TAG_BYTES + DIGEST_BYTES)), unhex(payloadDigest, message.subarray(TAG_BYTES + DIGEST_BYTES)), message;
+}
+function chunkMessage(tag, digest, body) {
+  let message = new Uint8Array(TAG_BYTES + DIGEST_BYTES + body.length);
+  return message[0] = tag, unhex(digest, message.subarray(TAG_BYTES, TAG_BYTES + DIGEST_BYTES)), message.set(body, TAG_BYTES + DIGEST_BYTES), message;
+}
+var MAX_CHUNK_BYTES = 16 * 1024 * 1024;
+function twinCaps(chunks) {
+  let out = /* @__PURE__ */ new Map();
+  for (let chunk of chunks) {
+    let runtime = chunk.runtime !== void 0 && chunk.runtime !== null, measured = typeof chunk.brotli_bytes == "number" && chunk.brotli_bytes > 0 || chunk.twinned === true;
+    (runtime || measured) && out.set(chunk.digest, chunk.size ?? MAX_CHUNK_BYTES);
+  }
+  return out;
+}
+function localFirstChunks(local, held, upstream) {
+  let fetchTwin = upstream.fetchTwin?.bind(upstream);
+  return {
+    ...upstream,
+    async fetch(digest, signal, partial) {
+      if ((await held).has(digest) && (partial?.received ?? 0) === 0) {
+        let bytes = await local.fetch(digest, signal).catch(() => null);
+        if (bytes !== null && await verifyChunk(digest, bytes))
+          return partial?.append(bytes), bytes;
+      }
+      return upstream.fetch(digest, signal, partial);
+    },
+    ...fetchTwin === void 0 ? {} : {
+      fetchTwin: async (digest, cap, signal) => (await held).has(digest) ? null : fetchTwin(digest, cap, signal)
+    }
+  };
+}
+function twinned(upstream, caps) {
+  let fetchTwin = upstream.fetchTwin?.bind(upstream);
+  return fetchTwin === void 0 || caps.size === 0 ? upstream : {
+    ...upstream,
+    async fetch(digest, signal, partial) {
+      let cap = caps.get(digest);
+      if (cap !== void 0 && (partial?.received ?? 0) === 0) {
+        let bytes = await fetchTwin(digest, cap, signal);
+        if (bytes !== null && await verifyChunk(digest, bytes))
+          return partial?.append(bytes), bytes;
+      }
+      return upstream.fetch(digest, signal, partial);
+    }
+  };
+}
+
+// src/interactives/parts/store.ts
+var PART_STORE_VERSION = 2, LEGACY_PART_STORE_VERSION = 1, MIB = 1024 * 1024, GIB = 1024 * MIB, DEFAULT_PART_STORE_BUDGET_BYTES = 512 * MIB, DEFAULT_KEPT_BUDGET_BYTES = 16 * GIB, DEFAULT_DISK_RESERVE_BYTES = GIB, DEFAULT_PART_ZONE = "", KEEP_REASONS = ["manifest", "user"], PartVerifyError = class extends Error {
+  constructor(digest) {
+    super(`part ${digest} does not match its digest`);
+    this.digest = digest;
+    this.name = "PartVerifyError";
+  }
+}, MemoryPartBackend = class {
+  constructor() {
+    this.bodies = /* @__PURE__ */ new Map();
+    this.snapshot = null;
+  }
+  read(digest) {
+    return Promise.resolve(this.bodies.get(digest) ?? null);
+  }
+  write(digest, bytes) {
+    return this.bodies.set(digest, bytes), Promise.resolve();
+  }
+  remove(digest) {
+    return this.bodies.delete(digest), Promise.resolve();
+  }
+  load() {
+    return Promise.resolve(this.snapshot);
+  }
+  save(snapshot) {
+    return this.snapshot = snapshot, Promise.resolve();
+  }
+};
+function compareText(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function zonesOf(parts) {
+  let zones = /* @__PURE__ */ new Map();
+  for (let part of parts) {
+    let zone = typeof part == "string" ? DEFAULT_PART_ZONE : part.zone, digests = zones.get(zone);
+    digests === void 0 && (digests = /* @__PURE__ */ new Set(), zones.set(zone, digests)), digests.add(typeof part == "string" ? part : part.digest);
+  }
+  return zones;
+}
+function upgrade(snapshot) {
+  return snapshot.games.map(([game, digests]) => [game, [[DEFAULT_PART_ZONE, 0, digests]], []]);
+}
+var PartSession = class {
+  constructor(store, game, parts, options = {}) {
+    this.store = store;
+    this.game = game;
+    this.held = /* @__PURE__ */ new Set();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.installed = store.install(game, parts, options).catch(() => {
+    }), this.unwatch = store.on_evicted((eviction) => {
+      if (eviction.game === this.game)
+        for (let listener of this.listeners) listener(eviction);
+    });
+  }
+  source(upstream) {
+    return {
+      fetch: async (digest, signal, partial) => {
+        this.store.played(this.game, digest);
+        let body = await this.store.fetch(digest, upstream, signal, partial);
+        return this.hold(digest), body;
+      },
+      fetchRun: async (digests, signal) => {
+        for (let digest of digests) this.store.played(this.game, digest);
+        let bodies = await this.store.fetchRun(digests, upstream, signal);
+        for (let k = 0; k < digests.length; k++) bodies[k] !== null && this.hold(digests[k]);
+        return bodies;
+      }
+    };
+  }
+  on_evicted(listener) {
+    return this.listeners.add(listener), () => this.listeners.delete(listener);
+  }
+  hold(digest) {
+    this.held.has(digest) || (this.held.add(digest), this.store.pin(digest));
+  }
+  release(digest) {
+    this.held.delete(digest) && this.store.unpin(digest);
+  }
+  close() {
+    for (let digest of this.held) this.store.unpin(digest);
+    this.held.clear(), this.listeners.clear(), this.unwatch();
+  }
+}, SharedPartStore = class _SharedPartStore {
+  constructor(backend, options) {
+    this.backend = backend;
+    this.entries = /* @__PURE__ */ new Map();
+    this.games = /* @__PURE__ */ new Map();
+    this.refs = /* @__PURE__ */ new Map();
+    this.keptRefs = /* @__PURE__ */ new Map();
+    this.pins = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.clock = 0;
+    this.total = 0;
+    this.kept = 0;
+    this.hits = 0;
+    this.misses = 0;
+    this.downloaded = 0;
+    this.evicted = 0;
+    this.saving = Promise.resolve();
+    this.dirty = false;
+    this.budget = options.budget_bytes ?? DEFAULT_PART_STORE_BUDGET_BYTES, this.keptBudget = options.kept_budget_bytes ?? DEFAULT_KEPT_BUDGET_BYTES, this.reserve = options.disk_reserve_bytes ?? DEFAULT_DISK_RESERVE_BYTES, this.disk = options.disk ?? null;
+  }
+  static async open(backend, options = {}) {
+    let store = new _SharedPartStore(backend, options), snapshot = await backend.load().catch(() => null);
+    return snapshot?.version === (2) ? store.restore(snapshot, snapshot.games) : snapshot?.version === (1) && store.restore(snapshot, upgrade(snapshot)), store;
+  }
+  restore(snapshot, games) {
+    this.clock = snapshot.clock;
+    for (let [digest, bytes, used] of snapshot.parts)
+      this.entries.set(digest, { bytes, used }), this.total += bytes;
+    for (let [game, zones, keep] of games) {
+      let digests = new Map(zones.map(([zone, , parts]) => [zone, new Set(parts)])), played = new Map(zones.map(([zone, at]) => [zone, at]));
+      this.setGame(game, digests, new Set(keep), played);
+    }
+  }
+  snapshot() {
+    let parts = [...this.entries.entries()].sort((a, b) => compareText(a[0], b[0])).map(([digest, e]) => [digest, e.bytes, e.used]), games = [...this.games.entries()].sort((a, b) => compareText(a[0], b[0])).map(([game, record]) => [
+      game,
+      [...record.zones.entries()].sort((a, b) => compareText(a[0], b[0])).map(([zone, z]) => [zone, z.played, [...z.digests].sort(compareText)]),
+      KEEP_REASONS.filter((reason) => record.keep.has(reason))
+    ]);
+    return { version: (2), clock: this.clock, parts, games };
+  }
+  persist() {
+    return this.dirty ? this.saving : (this.dirty = true, this.saving = this.saving.then(() => (this.dirty = false, this.backend.save(this.snapshot()))), this.saving);
+  }
+  flush() {
+    return this.saving;
+  }
+  setGame(game, zones, keep, played) {
+    let previous = this.games.get(game);
+    if (previous !== void 0 && this.unlink(previous), zones.size === 0 && keep.size === 0) {
+      this.games.delete(game);
+      return;
+    }
+    let recordZones = /* @__PURE__ */ new Map(), digests = /* @__PURE__ */ new Set(), zoneOf = /* @__PURE__ */ new Map();
+    for (let [zone, parts] of zones) {
+      recordZones.set(zone, { digests: parts, played: played.get(zone) ?? 0 });
+      for (let digest of parts)
+        digests.add(digest), zoneOf.has(digest) || zoneOf.set(digest, zone);
+    }
+    let record = { zones: recordZones, digests, zoneOf, keep };
+    this.games.set(game, record), this.link(record);
+  }
+  link(record) {
+    let kept = record.keep.size > 0;
+    for (let digest of record.digests)
+      this.refs.set(digest, (this.refs.get(digest) ?? 0) + 1), kept && this.keepRef(digest);
+  }
+  unlink(record) {
+    let kept = record.keep.size > 0;
+    for (let digest of record.digests) {
+      let n = (this.refs.get(digest) ?? 0) - 1;
+      n <= 0 ? this.refs.delete(digest) : this.refs.set(digest, n), kept && this.unkeepRef(digest);
+    }
+  }
+  keepRef(digest) {
+    let n = this.keptRefs.get(digest) ?? 0;
+    this.keptRefs.set(digest, n + 1), n === 0 && (this.kept += this.entries.get(digest)?.bytes ?? 0);
+  }
+  unkeepRef(digest) {
+    let n = (this.keptRefs.get(digest) ?? 0) - 1;
+    if (n > 0) {
+      this.keptRefs.set(digest, n);
+      return;
+    }
+    this.keptRefs.delete(digest), this.kept -= this.entries.get(digest)?.bytes ?? 0;
+  }
+  async install(game, parts, options = {}) {
+    let previous = this.games.get(game), keep = new Set(previous?.keep ?? []);
+    options.keep_on_device === true ? keep.add("manifest") : options.keep_on_device === false && keep.delete("manifest");
+    let played = /* @__PURE__ */ new Map();
+    for (let [zone, z] of previous?.zones ?? []) played.set(zone, z.played);
+    return this.setGame(game, zonesOf(parts), keep, played), await this.enforce(null), this.persist();
+  }
+  async uninstall(game) {
+    let record = this.games.get(game);
+    return record !== void 0 && (this.unlink(record), this.games.delete(game), await this.enforce(null)), this.persist();
+  }
+  installed(game) {
+    return [...this.games.get(game)?.digests ?? []].sort(compareText);
+  }
+  async keep(game, reason = "user") {
+    let record = this.games.get(game);
+    if (record === void 0)
+      return this.setGame(game, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set([reason]), /* @__PURE__ */ new Map()), this.persist();
+    if (record.keep.has(reason)) return;
+    let wasKept = record.keep.size > 0;
+    if (record.keep.add(reason), !wasKept) for (let digest of record.digests) this.keepRef(digest);
+    return this.persist();
+  }
+  async release(game, reason = "user") {
+    let record = this.games.get(game);
+    if (!(record === void 0 || !record.keep.delete(reason))) {
+      if (record.keep.size === 0) {
+        for (let digest of record.digests) this.unkeepRef(digest);
+        record.zones.size === 0 && this.games.delete(game), await this.enforce(null);
+      }
+      return this.persist();
+    }
+  }
+  keptReasons(game) {
+    let record = this.games.get(game);
+    return record === void 0 ? [] : KEEP_REASONS.filter((reason) => record.keep.has(reason));
+  }
+  isKept(game) {
+    return (this.games.get(game)?.keep.size ?? 0) > 0;
+  }
+  played(game, digest) {
+    let record = this.games.get(game), name = record?.zoneOf.get(digest), zone = name === void 0 ? void 0 : record?.zones.get(name);
+    zone !== void 0 && (zone.played = ++this.clock, this.persist());
+  }
+  resident(game, zone) {
+    let record = this.games.get(game), digests = zone === void 0 ? record?.digests : record?.zones.get(zone)?.digests;
+    if (digests === void 0) return false;
+    for (let digest of digests) if (!this.entries.has(digest)) return false;
+    return true;
+  }
+  on_evicted(listener) {
+    return this.listeners.add(listener), () => this.listeners.delete(listener);
+  }
+  pin(digest) {
+    this.pins.set(digest, (this.pins.get(digest) ?? 0) + 1);
+  }
+  unpin(digest) {
+    let n = (this.pins.get(digest) ?? 0) - 1;
+    n <= 0 ? this.pins.delete(digest) : this.pins.set(digest, n);
+  }
+  pinned(digest) {
+    return this.pins.has(digest);
+  }
+  has(digest) {
+    return this.entries.has(digest);
+  }
+  size(digest) {
+    return this.entries.get(digest)?.bytes ?? null;
+  }
+  refcount(digest) {
+    return this.refs.get(digest) ?? 0;
+  }
+  missingBytes(refs) {
+    let seen = /* @__PURE__ */ new Set(), bytes = 0;
+    for (let r of refs)
+      this.entries.has(r.digest) || seen.has(r.digest) || (seen.add(r.digest), bytes += r.size);
+    return bytes;
+  }
+  uniqueBytes(game) {
+    let bytes = 0;
+    for (let d of this.games.get(game)?.digests ?? []) {
+      let entry = this.entries.get(d);
+      entry !== void 0 && this.refcount(d) === 1 && (bytes += entry.bytes);
+    }
+    return bytes;
+  }
+  stats() {
+    let referenced = 0, pinned = 0;
+    for (let [digest, e] of this.entries)
+      this.refs.has(digest) && (referenced += e.bytes), this.pins.has(digest) && (pinned += e.bytes);
+    let games = 0, keptGames = 0;
+    for (let record of this.games.values())
+      record.digests.size > 0 && games++, record.keep.size > 0 && keptGames++;
+    return {
+      bytes: this.total,
+      parts: this.entries.size,
+      budget_bytes: this.budget,
+      feed_bytes: this.total - this.kept,
+      kept_bytes: this.kept,
+      kept_budget_bytes: this.keptBudget,
+      referenced_bytes: referenced,
+      pinned_bytes: pinned,
+      games,
+      kept_games: keptGames,
+      hits: this.hits,
+      misses: this.misses,
+      downloaded_bytes: this.downloaded,
+      evicted_bytes: this.evicted
+    };
+  }
+  async read(digest) {
+    let entry = this.entries.get(digest);
+    if (entry === void 0) return null;
+    let bytes = await this.backend.read(digest);
+    return bytes === null ? (this.drop(digest), this.persist(), null) : (entry.used = ++this.clock, this.hits++, this.persist(), bytes);
+  }
+  fetch(digest, upstream, signal, partial) {
+    let flying = this.inflight.get(digest);
+    if (flying !== void 0) return flying;
+    let pending = this.load(digest, upstream, signal, partial);
+    this.inflight.set(digest, pending);
+    let settle = () => this.inflight.delete(digest);
+    return pending.then(settle, settle), pending;
+  }
+  async load(digest, upstream, signal, partial) {
+    let stored = await this.read(digest);
+    if (stored !== null) return stored;
+    this.misses++;
+    let body = await upstream.fetch(digest, signal, partial);
+    if (!await verifyChunk(digest, body)) throw new PartVerifyError(digest);
+    return this.downloaded += body.length, await this.admit(digest, body), body;
+  }
+  async fetchRun(digests, upstream, signal) {
+    let out = new Array(digests.length).fill(null), waits = [], missing = [];
+    for (let k = 0; k < digests.length; k++) {
+      let flying = this.inflight.get(digests[k]);
+      if (flying !== void 0) {
+        waits.push(flying.then((body) => {
+          out[k] = body;
+        }, () => {
+        }));
+        continue;
+      }
+      missing.push(k);
+    }
+    let stored = await Promise.all(missing.map((k) => this.read(digests[k]))), fetch = [];
+    for (let m = 0; m < missing.length; m++) {
+      let body = stored[m];
+      body !== null ? out[missing[m]] = body : fetch.push(missing[m]);
+    }
+    if (fetch.length > 0) {
+      this.misses += fetch.length;
+      let wanted = fetch.map((k) => digests[k]), loaded = this.loadRun(wanted, upstream, signal);
+      for (let m = 0; m < fetch.length; m++) {
+        let digest = wanted[m], one = loaded.then((bodies2) => {
+          let body = bodies2[m];
+          if (body === null) throw new PartVerifyError(digest);
+          return body;
+        });
+        this.inflight.set(digest, one);
+        let settle = () => this.inflight.delete(digest);
+        one.then(settle, settle);
+      }
+      let bodies = await loaded;
+      for (let m = 0; m < fetch.length; m++) out[fetch[m]] = bodies[m];
+    }
+    return await Promise.all(waits), out;
+  }
+  async loadRun(digests, upstream, signal) {
+    let raw = upstream.fetchRun === void 0 ? await Promise.all(digests.map((digest) => upstream.fetch(digest, signal).catch(() => null))) : await upstream.fetchRun(digests, signal), out = [];
+    for (let k = 0; k < digests.length; k++) {
+      let body = raw[k] ?? null;
+      if (body === null || !await verifyChunk(digests[k], body)) {
+        out.push(null);
+        continue;
+      }
+      this.downloaded += body.length, await this.admit(digests[k], body), out.push(body);
+    }
+    return out;
+  }
+  async peek(digest) {
+    let entry = this.entries.get(digest);
+    if (entry === void 0) return null;
+    let bytes = await this.backend.read(digest);
+    return bytes === null ? (this.drop(digest), this.persist(), null) : (entry.used = ++this.clock, this.hits++, bytes);
+  }
+  async admit(digest, body) {
+    this.entries.has(digest) || (await this.backend.write(digest, body), !this.entries.has(digest) && (this.entries.set(digest, { bytes: body.length, used: ++this.clock }), this.total += body.length, this.keptRefs.has(digest) && (this.kept += body.length), await this.enforce(digest), await this.persist()));
+  }
+  source(upstream) {
+    return {
+      fetch: (digest, signal, partial) => this.fetch(digest, upstream, signal, partial),
+      fetchRun: (digests, signal) => this.fetchRun(digests, upstream, signal)
+    };
+  }
+  session(game, parts, options = {}) {
+    return new PartSession(this, game, parts, options);
+  }
+  drop(digest) {
+    let entry = this.entries.get(digest);
+    entry !== void 0 && (this.entries.delete(digest), this.total -= entry.bytes, this.keptRefs.has(digest) && (this.kept -= entry.bytes));
+  }
+  async remove(digest, bytes) {
+    this.drop(digest), this.evicted += bytes, await this.backend.remove(digest);
+  }
+  async enforce(keep) {
+    let tallies = /* @__PURE__ */ new Map();
+    await this.evictFeed(keep, this.budget, "budget", tallies), this.kept > this.keptBudget && await this.evictKept(keep, this.keptBudget, "kept_quota", tallies);
+    let free = this.disk === null ? null : await this.disk.free_bytes().catch(() => null);
+    if (free !== null && free < this.reserve) {
+      let deficit = this.reserve - free;
+      deficit -= await this.evictFeed(keep, Math.max(0, this.total - this.kept - deficit), "disk_pressure", tallies), deficit > 0 && await this.evictKept(keep, Math.max(0, this.kept - deficit), "disk_pressure", tallies);
+    }
+    for (let tally of tallies.values()) {
+      let eviction = { game: tally.game, zone: tally.zone, parts: tally.parts, bytes: tally.bytes, reason: tally.reason, kept: tally.kept };
+      for (let listener of this.listeners) listener(eviction);
+    }
+  }
+  tally(tallies, game, zone, bytes, reason, kept) {
+    let key = `${reason}
+${game}
+${zone}`, tally = tallies.get(key);
+    tally === void 0 ? tallies.set(key, { game, zone, reason, kept, parts: 1, bytes }) : (tally.parts++, tally.bytes += bytes);
+  }
+  async evictFeed(keep, target, reason, tallies) {
+    if (this.total - this.kept <= target) return 0;
+    let victims = [...this.entries.entries()].filter(([digest]) => digest !== keep && !this.pins.has(digest) && !this.keptRefs.has(digest)).sort((a, b) => Number(this.refs.has(a[0])) - Number(this.refs.has(b[0])) || a[1].used - b[1].used || compareText(a[0], b[0])), freed = 0;
+    for (let [digest, entry] of victims) {
+      if (this.total - this.kept <= target) break;
+      if (this.refs.has(digest))
+        for (let [game, record] of this.games) {
+          let zone = record.zoneOf.get(digest);
+          zone !== void 0 && this.tally(tallies, game, zone, entry.bytes, reason, false);
+        }
+      freed += entry.bytes, await this.remove(digest, entry.bytes);
+    }
+    return freed;
+  }
+  async evictKept(keep, target, reason, tallies) {
+    let zones = [], newest = /* @__PURE__ */ new Map();
+    for (let [game, record] of this.games)
+      if (record.keep.size !== 0)
+        for (let [name, zone] of record.zones) {
+          zones.push({ game, name, zone });
+          for (let digest of zone.digests) zone.played > (newest.get(digest) ?? -1) && newest.set(digest, zone.played);
+        }
+    zones.sort((a, b) => a.zone.played - b.zone.played || compareText(a.game, b.game) || compareText(a.name, b.name));
+    let freed = 0;
+    for (let { game, name, zone } of zones) {
+      if (this.kept <= target) break;
+      for (let digest of zone.digests) {
+        let entry = this.entries.get(digest);
+        entry === void 0 || digest === keep || this.pins.has(digest) || (newest.get(digest) ?? 0) > zone.played || (this.tally(tallies, game, name, entry.bytes, reason, true), freed += entry.bytes, await this.remove(digest, entry.bytes));
+      }
+    }
+    return freed;
+  }
+};
+
+export { DEFAULT_DISK_RESERVE_BYTES, DEFAULT_KEPT_BUDGET_BYTES, DEFAULT_PART_STORE_BUDGET_BYTES, DEFAULT_PART_ZONE, ENGINE_ARENA_BASELINE_BYTES, ENGINE_ARENA_CHUNK_BYTES, ENGINE_ARENA_FEATURE, ENGINE_ARENA_MAX_CEILING_BYTES, ENGINE_COMPATIBILITY_EXPORT_NAMES, ENGINE_CORE_SCRIPTS_UNIT, ENGINE_FEATURES, ENGINE_FEATURE_NAMES, ENGINE_LUAU_UNIT, ENGINE_OPTIONAL_EXPORTS, KEEP_REASONS, LUAU_SCRIPTS_GROUP, LUAU_VM_EXCEPTIONS, LUAU_VM_FILE, LUAU_VM_PATH, LuauVmModules, MemoryPartBackend, PartSession, PartVerifyError, PartialChunk, SCRIPTS_CORE_GROUP, SCRIPTS_CORE_PATH, SharedPartStore, chunkMessage, chunkRefMessage, engineExportsUsed, engineFeatureExports, engineFeatureMember, exceptionSupport, fetchVerified, localFirstChunks, luauVmModules, luauVmRunsHere, openLuauScripts, twinCaps, twinned, unmetEngineExport, unmetEngineFeature, verifyChunk };