@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-VBGHBL3E.mjs

@@ -0,0 +1,1394 @@
+import { replayFlags } from './chunk-DDJLDOUX.mjs';
+import { luauVmRunsHere, verifyChunk, PartialChunk, LUAU_SCRIPTS_GROUP, DEFAULT_PART_ZONE, twinned, twinCaps, unmetEngineFeature, chunkRefMessage, fetchVerified, chunkMessage, SCRIPTS_CORE_GROUP } from './chunk-BU6OK542.mjs';
+import { engineHeapFor, ENGINE_HEAP_REQUIREMENT } from './chunk-JURRXY2J.mjs';
+import { threadsAvailable } from './chunk-Y66WVMO5.mjs';
+import { TreeMirror, replayMessage, DEFAULT_CLIP_ARM } from './chunk-UGH37BQW.mjs';
+import { METERS_OFF, StudioSender, StudioAssembler, STUDIO_GRANT_TOPIC } from './chunk-HAGEIC2L.mjs';
+import { NETWORK_MESSAGE_BYTES, webNetworkHint, watchWebNetwork, writeNetworkHint } from './chunk-K46SMZ66.mjs';
+import { GL_CORE_GROUP } from './chunk-DS2VU4WW.mjs';
+import { sha256Into, SHA256_BYTES } from './chunk-5YWN6H5Q.mjs';
+import './chunk-SPCRQ6NO.mjs';
+import { ChunkPriority, MessageTag, ENGINE_CORE_UNIT, hex, unhex, CHUNK_FAILED_BYTES, prefetchSlots, forEachChunkEntry, CHUNK_REQUEST_ENTRY_BYTES, CHUNK_RELEASE_ENTRY_BYTES, PREFETCH_BUDGET_SHARE, writeChunkFailed, MessageWriter, readJson, ENGINE_CORE_THREADS_UNIT, TAG_BYTES, PING_BYTES, LIFECYCLE_BYTES, INSPECTOR_BYTES, CHUNK_REQUESTS_VERSION, INSPECTOR_SHOWN, INSPECTOR_HIDDEN, BRIDGE_LIMITS, readFrameMark, readSessionComplete, MILESTONE_BY_CODE, LifecycleCode } from './chunk-V7ZRH3PY.mjs';
+import { encodeBase64, decodeBase64 } from './chunk-2IC4H6OV.mjs';
+
+// src/interactives/content/origin.ts
+var SHELL_PREFIX = "/g/", RUNTIME_PREFIX = "/r/", WASM_PREFIX = "/w/", JOINED_PREFIX = "/j/", JOINED_PARTS_PARAM = "p", JOINED_PART_SEPARATOR = ",", MAX_JOINED_PARTS = 16, RUNTIME_SUFFIX = ".js", WASM_SUFFIX = ".wasm", SRI_PREFIX = "sha256-", FORBIDDEN_PARENT = "cimplify.io", HOST_PAGE_ISOLATION_HEADERS = {
+  "cross-origin-opener-policy": "same-origin",
+  "cross-origin-embedder-policy": "require-corp",
+  "cross-origin-resource-policy": "same-origin"
+}, LABEL_BYTES = 20, BASE32 = "abcdefghijklmnopqrstuvwxyz234567", BASE32_BITS = 5, BYTE_BITS = 8, BASE32_MASK = 31, HOST_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/, SECURE_SCHEME = "https:", LOCAL_SCHEME = "http:", LOCAL_SUFFIXES = [".test", ".localhost"], MIN_LABELS = 2, HEX_DIGEST = /^[0-9a-f]{64}$/;
+function local(host) {
+  return LOCAL_SUFFIXES.some((suffix) => host.endsWith(suffix));
+}
+function parseContentOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  let scheme = url.protocol;
+  if (scheme !== SECURE_SCHEME && scheme !== LOCAL_SCHEME || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || url.pathname !== "/" && url.pathname !== "") return null;
+  let host = url.hostname.toLowerCase(), labels = host.split(".");
+  return labels.length < (2) || !labels.every((label) => HOST_LABEL.test(label)) || host === FORBIDDEN_PARENT || host.endsWith(`.${FORBIDDEN_PARENT}`) || scheme === LOCAL_SCHEME && !local(host) ? null : { scheme, host, port: url.port };
+}
+function base32(bytes) {
+  let out = "", buffer = 0, bits = 0;
+  for (let i = 0; i < bytes.length; i++)
+    for (buffer = buffer << (8) | bytes[i], bits += (8); bits >= (5); )
+      bits -= (5), out += BASE32[buffer >>> bits & (31)];
+  return bits > 0 && (out += BASE32[buffer << (5) - bits & (31)]), out;
+}
+function interactiveLabel(interactiveId) {
+  let digest = new Uint8Array(SHA256_BYTES);
+  return sha256Into(new TextEncoder().encode(interactiveId), digest), base32(digest.subarray(0, (20)));
+}
+function guestOrigin(origin, interactiveId) {
+  let port = origin.port === "" ? "" : `:${origin.port}`;
+  return `${origin.scheme}//${interactiveLabel(interactiveId)}.${origin.host}${port}`;
+}
+function servesContent(origin, host) {
+  let name = host.toLowerCase().split(":")[0];
+  return name.endsWith(`.${origin.host}`) ? HOST_LABEL.test(name.slice(0, name.length - origin.host.length - 1)) : false;
+}
+function sha256Hex(bytes) {
+  let digest = new Uint8Array(SHA256_BYTES);
+  return sha256Into(bytes, digest), hex(digest);
+}
+function isDigestHex(value) {
+  return HEX_DIGEST.test(value);
+}
+function sri(digestHex) {
+  let bytes = new Uint8Array(SHA256_BYTES);
+  return !isDigestHex(digestHex) || !unhex(digestHex, bytes) ? null : SRI_PREFIX + encodeBase64(bytes);
+}
+function shellPath(runtimeDigest) {
+  return SHELL_PREFIX + runtimeDigest;
+}
+function runtimePath(runtimeDigest) {
+  return RUNTIME_PREFIX + runtimeDigest + RUNTIME_SUFFIX;
+}
+
+// src/interactives/hosts/lazy.ts
+var DEFAULT_LAZY_BUDGET_BYTES = 64 * 1024 * 1024, DEFAULT_LAZY_CONCURRENCY = 4, DEFAULT_RUN_BYTES = 256 * 1024, PRIORITIES = ChunkPriority.prefetch + 1, LazyChunkServer = class {
+  constructor(refs, options, sink = null) {
+    this.options = options;
+    this.sink = sink;
+    this.known = /* @__PURE__ */ new Map();
+    this.queues = Array.from({ length: PRIORITIES }, () => []);
+    this.queued = /* @__PURE__ */ new Map();
+    this.flying = /* @__PURE__ */ new Map();
+    this.held = /* @__PURE__ */ new Map();
+    this.partials = /* @__PURE__ */ new Map();
+    this.failure = new Uint8Array(CHUNK_FAILED_BYTES);
+    this.heldBytes = 0;
+    this.generation = 0;
+    this.preemptions = 0;
+    this.runs = 0;
+    for (let ref of refs) this.known.set(ref.digest, ref);
+    this.budget = options.budget_bytes ?? DEFAULT_LAZY_BUDGET_BYTES, this.concurrency = Math.max(1, options.concurrency ?? (4)), this.prefetchSlots = prefetchSlots(this.concurrency);
+  }
+  get bytesHeld() {
+    return this.heldBytes;
+  }
+  get pending() {
+    return this.queued.size + this.flying.size;
+  }
+  get preempted() {
+    return this.preemptions;
+  }
+  get ranged() {
+    return this.runs;
+  }
+  priorityOf(digest) {
+    return this.queued.get(digest) ?? this.flying.get(digest)?.priority ?? null;
+  }
+  attach(sink) {
+    this.sink = sink, this.generation++;
+    for (let queue of this.queues) queue.length = 0;
+    this.queued.clear();
+    for (let flight of this.flying.values()) flight.controller?.abort();
+    this.flying.clear(), this.held.clear(), this.partials.clear(), this.heldBytes = 0;
+  }
+  request(bytes) {
+    forEachChunkEntry(bytes, CHUNK_REQUEST_ENTRY_BYTES, (digest, priority) => this.enqueue(digest, priority)), this.preempt(), this.pump();
+  }
+  requestOne(digest, priority) {
+    this.enqueue(digest, priority), this.preempt(), this.pump();
+  }
+  requestMany(entries) {
+    for (let [digest, priority] of entries) this.enqueue(digest, priority);
+    this.preempt(), this.pump();
+  }
+  enqueue(digest, requested) {
+    if (!this.known.has(digest)) {
+      this.fail(digest, "unknown");
+      return;
+    }
+    let priority = Math.min(Math.max(0, requested), PRIORITIES - 1), flight = this.flying.get(digest);
+    if (flight !== void 0) {
+      priority < flight.priority && (flight.priority = priority);
+      return;
+    }
+    let queued = this.queued.get(digest);
+    if (queued !== void 0) {
+      if (priority >= queued) return;
+      this.unqueue(digest, queued);
+    }
+    this.queued.set(digest, priority), this.queues[priority].push(digest);
+  }
+  unqueue(digest, priority) {
+    let queue = this.queues[priority], at = queue.indexOf(digest);
+    at >= 0 && queue.splice(at, 1), this.queued.delete(digest);
+  }
+  release(bytes) {
+    forEachChunkEntry(bytes, CHUNK_RELEASE_ENTRY_BYTES, (digest) => {
+      let queued = this.queued.get(digest);
+      if (queued !== void 0) {
+        this.unqueue(digest, queued), this.partials.delete(digest);
+        return;
+      }
+      let size = this.held.get(digest);
+      size !== void 0 && (this.held.delete(digest), this.heldBytes -= size);
+    }), this.pump();
+  }
+  top() {
+    let top = null;
+    for (let priority = 0; priority < PRIORITIES; priority++)
+      if (this.queues[priority].length > 0) {
+        top = priority;
+        break;
+      }
+    for (let flight of this.flying.values()) (top === null || flight.priority < top) && (top = flight.priority);
+    return top;
+  }
+  preempt() {
+    let top = this.top();
+    if (top === null) return;
+    let aborted = /* @__PURE__ */ new Set();
+    for (let flight of this.flying.values())
+      flight.priority <= top || flight.controller === null || aborted.add(flight.controller);
+    if (aborted.size !== 0) {
+      for (let [digest, flight] of this.flying)
+        flight.controller === null || !aborted.has(flight.controller) || (flight.preempted = true, this.flying.delete(digest), this.preemptions++, this.queued.set(digest, flight.priority), this.queues[flight.priority].unshift(digest));
+      for (let controller of aborted) controller.abort();
+    }
+  }
+  next() {
+    let top = this.top();
+    if (top === null) return null;
+    let queue = this.queues[top];
+    return queue.length === 0 || top === ChunkPriority.prefetch && this.prefetchFlying() >= this.prefetchSlots ? null : queue.shift() ?? null;
+  }
+  requestsFlying(priority) {
+    let count = 0, counted = /* @__PURE__ */ new Set();
+    for (let flight of this.flying.values())
+      if (!(priority !== null && flight.priority !== priority)) {
+        if (flight.controller !== null) {
+          if (counted.has(flight.controller)) continue;
+          counted.add(flight.controller);
+        }
+        count++;
+      }
+    return count;
+  }
+  prefetchFlying() {
+    return this.requestsFlying(ChunkPriority.prefetch);
+  }
+  pump() {
+    for (; this.requestsFlying(null) < this.concurrency; ) {
+      let digest = this.next();
+      if (digest === null) return;
+      let priority = this.queued.get(digest) ?? ChunkPriority.now;
+      this.queued.delete(digest);
+      let controller = typeof AbortController == "function" ? new AbortController() : null, run = this.gather(digest, priority);
+      if (run.length > 1) {
+        let flights = run.map((member) => {
+          let flight2 = { priority, preempted: false, controller };
+          return this.flying.set(member, flight2), flight2;
+        });
+        this.runs++, this.serveRun(run, flights, this.generation);
+        continue;
+      }
+      let flight = { priority, preempted: false, controller };
+      this.flying.set(digest, flight), this.serve(digest, flight, this.generation);
+    }
+  }
+  gather(digest, priority) {
+    let spans = this.options.spans;
+    if (spans === void 0 || this.options.source.fetchRun === void 0 || this.partials.has(digest)) return [digest];
+    let run = [digest], bytes = spans.locate(digest)?.size ?? 0, limit = this.options.run_bytes ?? DEFAULT_RUN_BYTES;
+    for (let step of [1, -1]) {
+      let at = digest;
+      for (; bytes < limit; ) {
+        let next = spans.neighbour(at, step);
+        if (next === null || this.queued.get(next) !== priority || this.partials.has(next)) break;
+        this.unqueue(next, priority), step === 1 ? run.push(next) : run.unshift(next), bytes += spans.locate(next)?.size ?? 0, at = next;
+      }
+    }
+    return run;
+  }
+  async serveRun(run, flights, generation) {
+    let live = (k) => generation === this.generation && !flights[k].preempted, fetchRun = this.options.source.fetchRun;
+    try {
+      let wanted = [];
+      for (let k = 0; k < run.length; k++) {
+        let declared = this.known.get(run[k])?.size;
+        declared !== void 0 && !this.fits(run[k], declared, flights[k].priority) ? this.fail(run[k], "budget") : wanted.push(k);
+      }
+      if (wanted.length === 0 || fetchRun === void 0) return;
+      let bodies;
+      try {
+        bodies = await fetchRun(
+          wanted.map((k) => run[k]),
+          flights[0].controller?.signal
+        );
+      } catch {
+        for (let k of wanted) live(k) && this.fail(run[k], "network");
+        return;
+      }
+      for (let m = 0; m < wanted.length; m++) {
+        let k = wanted[m];
+        if (!live(k)) continue;
+        let body = bodies[m] ?? null;
+        if (body === null || !await verifyChunk(run[k], body)) {
+          live(k) && this.fail(run[k], body === null ? "network" : "verify");
+          continue;
+        }
+        if (live(k)) {
+          if (!this.fits(run[k], body.length, flights[k].priority)) {
+            this.fail(run[k], "budget");
+            continue;
+          }
+          this.heldBytes += body.length - (this.held.get(run[k]) ?? 0), this.held.set(run[k], body.length), this.sink?.deliver(run[k], body);
+        }
+      }
+    } finally {
+      for (let k = 0; k < run.length; k++)
+        generation === this.generation && this.flying.get(run[k]) === flights[k] && this.flying.delete(run[k]);
+      generation === this.generation && this.pump();
+    }
+  }
+  fits(digest, size, priority) {
+    let already = this.held.get(digest) ?? 0, limit = priority === ChunkPriority.prefetch ? Math.floor(this.budget * PREFETCH_BUDGET_SHARE) : this.budget;
+    return this.heldBytes - already + size <= limit;
+  }
+  async serve(digest, flight, generation) {
+    let live = () => generation === this.generation && !flight.preempted;
+    try {
+      let declared = this.known.get(digest)?.size;
+      if (declared !== void 0 && !this.fits(digest, declared, flight.priority)) {
+        this.fail(digest, "budget");
+        return;
+      }
+      let partial = this.partials.get(digest);
+      partial === void 0 && (partial = new PartialChunk(), this.partials.set(digest, partial));
+      let body;
+      try {
+        body = await this.options.source.fetch(digest, flight.controller?.signal, partial);
+      } catch {
+        live() && (this.partials.delete(digest), this.fail(digest, "network"));
+        return;
+      }
+      if (!live()) return;
+      if (this.partials.delete(digest), !await verifyChunk(digest, body)) {
+        live() && this.fail(digest, "verify");
+        return;
+      }
+      if (!live()) return;
+      if (!this.fits(digest, body.length, flight.priority)) {
+        this.fail(digest, "budget");
+        return;
+      }
+      this.heldBytes += body.length - (this.held.get(digest) ?? 0), this.held.set(digest, body.length), this.sink?.deliver(digest, body);
+    } finally {
+      generation === this.generation && this.flying.get(digest) === flight && this.flying.delete(digest), generation === this.generation && this.pump();
+    }
+  }
+  fail(digest, reason) {
+    let length = writeChunkFailed(this.failure, digest, reason);
+    this.sink?.send(this.failure, length);
+  }
+};
+
+// src/interactives/hosts/chrome/mediator.ts
+var HOST_REQUEST_PREFIX = "host-", NO_ARGUMENTS = {};
+function trackingOf(consents, interactive_id) {
+  let state = consents.state(interactive_id, "tracking");
+  return state === "granted" ? "authorized" : state === "denied" ? "denied" : "not_asked";
+}
+var HostMediator = class {
+  constructor(options) {
+    this.options = options;
+    this.writer = new MessageWriter();
+    this.offers = /* @__PURE__ */ new Map();
+    this.offerRequests = /* @__PURE__ */ new Set();
+    this.hostCalls = /* @__PURE__ */ new Map();
+    this.asking = /* @__PURE__ */ new Set();
+    this.outlet = null;
+    this.program = null;
+    this.stopConsents = null;
+    this.nextHostCall = 0;
+  }
+  start(program, outlet) {
+    this.program = program, this.outlet = outlet, this.stopConsents?.(), this.stopConsents = this.options.consents.subscribe((interactive_id) => {
+      interactive_id === this.options.interactive_id && this.sendConsents();
+    }), this.sendConsents();
+  }
+  stop() {
+    this.stopConsents?.(), this.stopConsents = null, this.outlet = null, this.hostCalls.clear();
+  }
+  send(length) {
+    this.outlet?.toSession(this.writer.bytes, length);
+  }
+  sendConsents() {
+    this.send(this.writer.json(MessageTag.consent, { granted: [...this.options.consents.granted(this.options.interactive_id)] }));
+  }
+  relay(bytes) {
+    this.outlet?.toSession(bytes, bytes.length);
+  }
+  fromGuest(bytes) {
+    if (bytes[0] !== MessageTag.request) return false;
+    let envelope = readJson(bytes);
+    switch (envelope.call.operation) {
+      case "wallet.offers":
+        return this.offerRequests.add(envelope.request_id), false;
+      case "wallet.spend":
+        return this.spend(bytes.slice(), envelope.call.arguments), true;
+      case "ads.placement":
+        return this.options.registry === null ? false : (this.placement(bytes.slice(), envelope.call.arguments, this.options.registry), true);
+      default:
+        return false;
+    }
+  }
+  fromSession(bytes) {
+    if (bytes[0] !== MessageTag.response) return false;
+    let envelope = readJson(bytes), hostCall = this.hostCalls.get(envelope.request_id);
+    if (hostCall !== void 0)
+      return this.hostCalls.delete(envelope.request_id), hostCall(envelope), true;
+    let outcome = envelope.outcome;
+    return this.offerRequests.delete(envelope.request_id) && outcome.status === "ok" && this.remember(outcome.response.result), outcome.status === "error" && this.consentRequired(outcome.error), false;
+  }
+  remember(offers) {
+    for (let offer of offers.offers) this.offers.set(offer.offer_id, { display_name: offer.display_name, price_cimples: offer.price_cimples });
+  }
+  consentRequired(error) {
+    if (error.code !== "consent_required") return;
+    let kind = error.consent;
+    this.asking.has(kind) || this.options.consents.state(this.options.interactive_id, kind) !== "undecided" || (this.asking.add(kind), this.options.controller.requestConsent(kind).then((granted) => {
+      this.asking.delete(kind), this.options.consents.decide(this.options.interactive_id, kind, granted);
+    }));
+  }
+  /** Sends one ctx call on the host's own behalf, such as posting a clip the player saved from host chrome. */
+  hostCall(operation, args = NO_ARGUMENTS) {
+    let program = this.program;
+    if (program === null) return Promise.reject(new Error("the host session has not started"));
+    let request_id = `${HOST_REQUEST_PREFIX}${this.nextHostCall++}`, envelope = {
+      contract_version: 1,
+      request_id,
+      interactive_id: program.interactive_id,
+      revision: program.revision,
+      deadline_ms: null,
+      call: { operation, arguments: args }
+    };
+    return new Promise((resolve) => {
+      this.hostCalls.set(request_id, resolve), this.send(this.writer.json(MessageTag.request, envelope));
+    });
+  }
+  async offer(offer_id) {
+    let known = this.offers.get(offer_id);
+    if (known !== void 0) return known;
+    let envelope = await this.hostCall("wallet.offers");
+    return envelope.outcome.status === "ok" && this.remember(envelope.outcome.response.result), this.offers.get(offer_id) ?? null;
+  }
+  async spend(request, spend) {
+    let offer = await this.offer(spend.offer_id).catch(() => null), price_cimples = offer === null ? 0 : offer.price_cimples * spend.quantity, decision = offer === null ? "cancelled" : await this.options.controller.confirmSpend({
+      offer_id: spend.offer_id,
+      display_name: offer.display_name,
+      quantity: spend.quantity,
+      price_cimples
+    }), confirmation = {
+      request_key: spend.request_key,
+      offer_id: spend.offer_id,
+      quantity: spend.quantity,
+      price_cimples,
+      decision
+    };
+    this.send(this.writer.json(MessageTag.confirm, confirmation)), this.relay(request);
+  }
+  async placement(request, placement, registry) {
+    let interactive_id = this.options.interactive_id;
+    try {
+      let served = await registry.decideAd(interactive_id, {
+        request_key: placement.request_key,
+        format: placement.format,
+        slot: placement.slot,
+        tracking: trackingOf(this.options.consents, interactive_id)
+      });
+      served.status === "decided" && served.creative !== null && await this.options.controller.showAd(served.creative) === "completed" && await registry.completeAd(interactive_id, served.placement_id, !1);
+    } catch {
+      this.relay(request);
+      return;
+    }
+    this.relay(request);
+  }
+};
+
+// src/interactives/hosts/gpu.ts
+var GPU_REQUIREMENT_NAMES = [
+  "sampled_textures_per_stage",
+  "samplers_per_stage",
+  "storage_buffers_per_stage",
+  "compute_workgroup_invocations",
+  "compute_workgroup_storage_bytes"
+], WEBGPU_LIMITS = {
+  sampled_textures_per_stage: "maxSampledTexturesPerShaderStage",
+  samplers_per_stage: "maxSamplersPerShaderStage",
+  storage_buffers_per_stage: "maxStorageBuffersPerShaderStage",
+  compute_workgroup_invocations: "maxComputeInvocationsPerWorkgroup",
+  compute_workgroup_storage_bytes: "maxComputeWorkgroupStorageSize"
+}, NO_GPU = {
+  sampled_textures_per_stage: 0,
+  samplers_per_stage: 0,
+  storage_buffers_per_stage: 0,
+  compute_workgroup_invocations: 0,
+  compute_workgroup_storage_bytes: 0
+}, WEBGL2 = "webgl2", MAX_TEXTURE_IMAGE_UNITS = 34930, decoder = new TextDecoder();
+function unmetGpuRequirement(requirements, limits) {
+  for (let name of GPU_REQUIREMENT_NAMES) {
+    let floor = requirements[name];
+    if (floor !== void 0 && floor > limits[name]) return name;
+  }
+  return null;
+}
+function manifestGpuRequirements(manifest) {
+  return JSON.parse(decoder.decode(manifest)).gpu?.requirements ?? {};
+}
+function webglLimits(scope) {
+  let gl = scope.document?.createElement("canvas").getContext(WEBGL2) ?? null;
+  if (gl === null) return NO_GPU;
+  let units = Number(gl.getParameter((34930))) || 0;
+  return { ...NO_GPU, sampled_textures_per_stage: units, samplers_per_stage: units };
+}
+async function deviceGpuLimits(scope = globalThis) {
+  let adapter = await scope.navigator?.gpu?.requestAdapter().catch(() => null);
+  if (adapter == null) return webglLimits(scope);
+  let limits = { ...NO_GPU };
+  for (let name of GPU_REQUIREMENT_NAMES) limits[name] = adapter.limits[WEBGPU_LIMITS[name]] ?? 0;
+  return limits;
+}
+
+// src/interactives/parts/brotli.ts
+var BROTLI_FORMAT = "brotli";
+function brotliStream() {
+  try {
+    return new DecompressionStream(BROTLI_FORMAT);
+  } catch {
+    return null;
+  }
+}
+async function inflateCapped(body, inflate, cap) {
+  let reader = body.pipeThrough(inflate).getReader(), pieces = [], length = 0;
+  for (; ; ) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (length += value.length, length > cap)
+      return await reader.cancel(), null;
+    pieces.push(value);
+  }
+  let out = new Uint8Array(length), at = 0;
+  for (let piece of pieces)
+    out.set(piece, at), at += piece.length;
+  return out;
+}
+async function fetchTwin(fetcher, url, cap, signal) {
+  let inflate = brotliStream();
+  if (inflate === null) return null;
+  try {
+    let response = await fetcher(`${url}.br`, { signal });
+    if (!response.ok || response.body === null) return null;
+    let wire = Number(response.headers.get("content-length") ?? 0), bytes = await inflateCapped(response.body, inflate, cap);
+    return bytes === null ? null : { bytes, wire };
+  } catch {
+    if (signal?.aborted === true) throw signal.reason;
+    return null;
+  }
+}
+
+// src/interactives/hosts/session.ts
+var SESSION_PATH_SUFFIX = "/session", OPEN = 1, NORMAL_CLOSE = 1e3;
+function sessionUrl(target) {
+  let url = new URL(`/v1/interactives/${encodeURIComponent(target.interactive_id)}${SESSION_PATH_SUFFIX}`, target.base_url);
+  return url.protocol = url.protocol === "https:" ? "wss:" : url.protocol === "http:" ? "ws:" : url.protocol, url.searchParams.set("revision", target.revision), url.searchParams.set("channel", target.channel ?? "live"), url.href;
+}
+function bytesOf(data) {
+  return data instanceof ArrayBuffer ? new Uint8Array(data) : ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : null;
+}
+function openSession(target, connect) {
+  let socket = connect(sessionUrl(target));
+  socket.binaryType = "arraybuffer";
+  let listener = () => {
+  }, closers = [], closed = null, finish = (close) => {
+    if (closed === null) {
+      closed = close;
+      for (let closer of closers) closer(close);
+    }
+  }, transport = {
+    send(bytes, length) {
+      socket.readyState === (1) && socket.send(bytes.subarray(0, length));
+    },
+    on_message(next) {
+      listener = next;
+    },
+    on_close(next) {
+      closed !== null ? next(closed) : closers.push(next);
+    },
+    close() {
+      finish({ reason: "closed_by_host", detail: null }), socket.close((1e3));
+    }
+  };
+  return new Promise((resolve, reject) => {
+    socket.onmessage = (event) => {
+      let bytes = bytesOf(event.data);
+      if (!(bytes === null || bytes.length === 0)) {
+        if (bytes[0] === MessageTag.hello) {
+          let hello = readJson(bytes);
+          if (hello.protocol !== 1) {
+            reject(new Error(`session protocol ${hello.protocol} is not ${1}`)), socket.close((1e3));
+            return;
+          }
+          resolve({ transport, hello });
+          return;
+        }
+        if (bytes[0] === MessageTag.close) {
+          let close = readJson(bytes);
+          reject(new Error(close.detail ?? close.reason)), finish(close);
+          return;
+        }
+        listener(bytes);
+      }
+    }, socket.onclose = (event) => {
+      let close = { reason: "disconnected", detail: event.reason || String(event.code) };
+      reject(new Error(close.detail)), finish(close);
+    }, socket.onerror = () => {
+    };
+  });
+}
+var PARTIAL_CONTENT = 206;
+function httpChunks(base, fetcher = fetch) {
+  return {
+    fetchTwin: async (digest, cap, signal) => (await fetchTwin(fetcher, new URL(digest, base).href, cap, signal))?.bytes ?? null,
+    async fetch(digest, signal, partial) {
+      let from = partial?.received ?? 0, init = { signal, headers: from > 0 ? { Range: `bytes=${from}-` } : void 0 }, response = await fetcher(new URL(digest, base).href, init);
+      if (!response.ok) throw new Error(`chunk ${digest} answered ${response.status}`);
+      if (partial === void 0 || response.body === null) {
+        partial?.reset();
+        let body = new Uint8Array(await response.arrayBuffer());
+        return partial?.append(body), body;
+      }
+      from > 0 && response.status !== (206) && partial.reset();
+      let reader = response.body.getReader();
+      for (; ; ) {
+        let { done, value } = await reader.read();
+        if (done) break;
+        partial.append(value);
+      }
+      return partial.join();
+    }
+  };
+}
+
+// src/interactives/hosts/zones.ts
+var PARTIAL_CONTENT2 = 206, ZoneSpans = class _ZoneSpans {
+  constructor() {
+    this.spans = /* @__PURE__ */ new Map();
+    this.members = /* @__PURE__ */ new Map();
+  }
+  static of(chunks, files) {
+    let spans = new _ZoneSpans();
+    for (let file of files) {
+      let members = chunks.filter((chunk) => chunk.asset_group === file.asset_group);
+      if (members.length !== file.parts || members.some((chunk) => chunk.size === void 0) || members.reduce((sum, chunk) => sum + (chunk.size ?? 0), 0) !== file.bytes) continue;
+      let offset = 0;
+      members.forEach((chunk, index) => {
+        let size = chunk.size ?? 0;
+        spans.spans.has(chunk.digest) || spans.spans.set(chunk.digest, { file: file.digest, offset, size, index }), offset += size;
+      }), spans.members.set(
+        file.digest,
+        members.map((chunk) => chunk.digest)
+      );
+    }
+    return spans;
+  }
+  get size() {
+    return this.spans.size;
+  }
+  locate(digest) {
+    return this.spans.get(digest);
+  }
+  neighbour(digest, step) {
+    let span = this.spans.get(digest);
+    return span === void 0 ? null : this.members.get(span.file)?.[span.index + step] ?? null;
+  }
+  runs(digests) {
+    let runs = [], current = [], last;
+    for (let k = 0; k < digests.length; k++) {
+      let span = this.spans.get(digests[k]);
+      !(span !== void 0 && last !== void 0 && span.file === last.file && span.index === last.index + 1) && current.length > 0 && (runs.push(current), current = []), current.push(k), last = span;
+    }
+    return current.length > 0 && runs.push(current), runs;
+  }
+};
+function rangedChunks(base, spans, fetcher = fetch) {
+  let single = httpChunks(base, fetcher), range = async (digests, signal) => {
+    let first = spans.locate(digests[0]), last = spans.locate(digests[digests.length - 1]);
+    if (first === void 0 || last === void 0) return Promise.all(digests.map((digest) => single.fetch(digest, signal).catch(() => null)));
+    let start = first.offset, end = last.offset + last.size, response = await fetcher(new URL(first.file, base).href, { signal, headers: { Range: `bytes=${start}-${end - 1}` } });
+    if (!response.ok) throw new Error(`zone file ${first.file} answered ${response.status}`);
+    let whole = new Uint8Array(await response.arrayBuffer()), at = response.status === (206) ? 0 : start;
+    if (whole.length < at + end - start) throw new Error(`zone file ${first.file} answered ${whole.length} bytes for ${end - start}`);
+    return digests.map((digest) => {
+      let span = spans.locate(digest);
+      if (span === void 0) return null;
+      let from = at + span.offset - start;
+      return whole.slice(from, from + span.size);
+    });
+  };
+  return {
+    fetch: single.fetch,
+    fetchTwin: single.fetchTwin,
+    async fetchRun(digests, signal) {
+      let out = new Array(digests.length).fill(null);
+      return await Promise.all(
+        spans.runs(digests).map(async (run) => {
+          let bodies = await range(
+            run.map((k) => digests[k]),
+            signal
+          ).catch(() => run.map(() => null));
+          run.forEach((k, m) => {
+            out[k] = bodies[m];
+          });
+        })
+      ), out;
+    }
+  };
+}
+
+// src/interactives/hosts/webgpu.ts
+var probed = null, probing = null;
+function gpuOf() {
+  let gpu = globalThis.navigator?.gpu;
+  return gpu !== void 0 && typeof gpu.requestAdapter == "function" ? gpu : null;
+}
+function probeHostWebGpu() {
+  if (probing !== null) return probing;
+  let gpu = gpuOf();
+  return probing = gpu === null ? Promise.resolve(false) : gpu.requestAdapter().then(
+    (adapter) => adapter != null,
+    () => false
+  ), probing.then((found) => {
+    probed = found;
+  }), probing;
+}
+function hostWebGpu() {
+  return probed ?? gpuOf() !== null;
+}
+function forgetHostWebGpu() {
+  probed = null, probing = null;
+}
+
+// src/interactives/hosts/clips.ts
+var CLIP_CAMERA = "clip_camera", REPLAY_MEDIA_TYPE = "application/vnd.cimplify.replay", CLIP_COMMANDS = /* @__PURE__ */ new Set(["clip_start", "clip_stop", "clip_cancel", "clip_keep", "replay_save"]);
+function isClipCommand(command) {
+  return CLIP_COMMANDS.has(command.kind);
+}
+function clipArm(options) {
+  return {
+    window_ms: options.window_ms ?? DEFAULT_CLIP_ARM.window_ms,
+    fps: options.fps ?? DEFAULT_CLIP_ARM.fps,
+    video_bits_per_second: options.video_bits_per_second ?? DEFAULT_CLIP_ARM.video_bits_per_second,
+    audio: options.audio ?? DEFAULT_CLIP_ARM.audio,
+    max_long_edge: options.max_long_edge ?? DEFAULT_CLIP_ARM.max_long_edge
+  };
+}
+function keptMs(window_ms, started, now, max_ms) {
+  return Math.max(0, Math.min(now - started, max_ms, window_ms));
+}
+function failure(code) {
+  return { error: code };
+}
+function replyOf(outcome) {
+  return "media" in outcome ? { media_id: outcome.media.media_id } : { error: { code: outcome.error } };
+}
+var HostClips = class {
+  constructor(options, interactive_id, consent, now) {
+    this.options = options;
+    this.interactive_id = interactive_id;
+    this.consent = consent;
+    this.now = now;
+    this.guest = null;
+    this.recordings = /* @__PURE__ */ new Map();
+    this.nextRecording = 1;
+    this.paused = false;
+    this.stopConsents = null;
+    this.asking = null;
+    this.arm = clipArm(options);
+  }
+  get available() {
+    return this.guest !== null;
+  }
+  attach(guest) {
+    if (this.detach(), this.guest = guest, guest === null) return;
+    this.paused = false, guest.arm(this.arm), guest.on_camera_live(() => this.update());
+    let consents = this.consent?.consents;
+    consents !== void 0 && (this.stopConsents = consents.subscribe((interactive_id) => {
+      interactive_id === this.interactive_id && this.update();
+    })), this.update();
+  }
+  detach() {
+    this.stopConsents?.(), this.stopConsents = null, this.guest?.arm(null), this.guest = null, this.recordings.clear();
+  }
+  cameraAllowed() {
+    return this.consent?.consents.state(this.interactive_id, CLIP_CAMERA) === "granted";
+  }
+  update() {
+    let guest = this.guest;
+    if (guest === null) return;
+    let paused = guest.camera_live && !this.cameraAllowed();
+    paused !== this.paused && (this.paused = paused, guest.pause(paused));
+  }
+  /** Asks for camera in clips from host chrome; the answer lifts the pause for later saves. */
+  askCamera() {
+    let consent = this.consent;
+    return consent === null ? Promise.resolve(false) : (this.asking ?? (this.asking = consent.controller.requestConsent(CLIP_CAMERA).then((granted) => (consent.consents.decide(this.interactive_id, CLIP_CAMERA, granted), this.asking = null, this.update(), granted))), this.asking);
+  }
+  async keep(keep_ms) {
+    let guest = this.guest;
+    if (guest === null) return failure("unavailable");
+    if (guest.camera_live && !this.cameraAllowed())
+      return this.consent?.consents.state(this.interactive_id, CLIP_CAMERA) === "undecided" && this.askCamera(), failure("camera_consent");
+    let saved = await guest.save(Math.min(Math.max(0, keep_ms), this.arm.window_ms));
+    return saved === null ? failure("nothing_recorded") : this.upload("video", saved);
+  }
+  async saveReplay(bytes) {
+    let blob = new Blob([bytes], { type: REPLAY_MEDIA_TYPE });
+    return this.upload("replay", { blob, type: REPLAY_MEDIA_TYPE, duration_ms: 0, width: 0, height: 0 });
+  }
+  async upload(kind, saved) {
+    try {
+      return { media: await this.options.upload({ kind, interactive_id: this.interactive_id, ...saved }) };
+    } catch {
+      return failure("failed");
+    }
+  }
+  async command(command) {
+    switch (command.kind) {
+      case "clip_start": {
+        let clip = this.nextRecording++;
+        return this.recordings.set(clip, { started: this.now(), max_ms: Math.min(Math.max(0, command.max_ms), this.arm.window_ms) }), { clip };
+      }
+      case "clip_stop": {
+        let recording = this.recordings.get(command.clip);
+        return recording === void 0 ? { error: { code: "unknown_clip" } } : (this.recordings.delete(command.clip), replyOf(await this.keep(keptMs(this.arm.window_ms, recording.started, this.now(), recording.max_ms))));
+      }
+      case "clip_cancel":
+        return this.recordings.delete(command.clip), null;
+      case "clip_keep":
+        return replyOf(await this.keep(command.ms));
+      case "replay_save":
+        return replyOf(await this.saveReplay(decodeBase64(command.replay)));
+    }
+  }
+};
+
+// src/interactives/hosts/web.ts
+var FIRST_FRAME_MILESTONE = "first_frame_scheduled";
+function referable(ref) {
+  return typeof ref.payload_digest == "string" && isDigestHex(ref.payload_digest);
+}
+function never() {
+  return false;
+}
+var ENGINE_GROUP_PREFIX = "engine:", SINGLE_THREAD_GROUP = "threads:single", ISOLATED_THREAD_GROUP = "threads:isolated", TIER_GROUP_PREFIX = "tier:", DEFAULT_HOST_TIER = "mid", ALTERNATIVE_RUNTIMES = { [ENGINE_CORE_THREADS_UNIT]: ENGINE_CORE_UNIT };
+function standsInFor(chunk) {
+  let name = chunk.runtime?.name;
+  return name === void 0 ? null : chunk.asset_group === SCRIPTS_CORE_GROUP || chunk.asset_group === GL_CORE_GROUP ? name === ENGINE_CORE_UNIT ? ENGINE_CORE_UNIT : null : chunk.asset_group !== ISOLATED_THREAD_GROUP ? null : ALTERNATIVE_RUNTIMES[name] ?? null;
+}
+function chunksForHost(chunks, engine, isolated = false, tier = DEFAULT_HOST_TIER, threads = false, scripts = luauVmRunsHere, webgpu = hostWebGpu()) {
+  let skipped = isolated ? SINGLE_THREAD_GROUP : ISOLATED_THREAD_GROUP, tierGroup = `${TIER_GROUP_PREFIX}${tier}`, offers = (group) => chunks.some((chunk) => chunk.asset_group === group && standsInFor(chunk) !== null), scripted = offers(SCRIPTS_CORE_GROUP), glCore = !webgpu && offers(GL_CORE_GROUP) && (!scripted || scripts()), scriptsCore = !glCore && scripted && scripts(), chosen = (chunk) => chunk.asset_group === GL_CORE_GROUP ? glCore : chunk.asset_group === SCRIPTS_CORE_GROUP ? scriptsCore : threads && !scriptsCore && !glCore, replaced = /* @__PURE__ */ new Set();
+  for (let chunk of chunks) {
+    let unit = standsInFor(chunk);
+    unit !== null && chosen(chunk) && replaced.add(unit);
+  }
+  return chunks.filter((chunk) => {
+    if (standsInFor(chunk) !== null) return chosen(chunk);
+    let runtime = chunk.runtime?.name;
+    if (runtime !== void 0 && replaced.has(runtime)) return false;
+    let group = chunk.asset_group;
+    return group === void 0 ? true : group === skipped ? false : group.startsWith(TIER_GROUP_PREFIX) ? group === tierGroup : group === LUAU_SCRIPTS_GROUP ? luauVmRunsHere() : group.startsWith(ENGINE_GROUP_PREFIX) ? engine !== null && group === `${ENGINE_GROUP_PREFIX}${engine}` : true;
+  });
+}
+var CODE_GROUP = "code";
+function linksBeforeStart(chunk) {
+  if (!chunk.before_play) return false;
+  if (standsInFor(chunk) !== null) return true;
+  let group = chunk.asset_group;
+  return group === void 0 || group === CODE_GROUP || group.startsWith(ENGINE_GROUP_PREFIX);
+}
+function swappable(chunk) {
+  if (chunk.lazy === true || (chunk.runtime ?? null) !== null || standsInFor(chunk) !== null) return false;
+  let group = chunk.asset_group;
+  return group === void 0 || !(group.startsWith(ENGINE_GROUP_PREFIX) || group.startsWith(TIER_GROUP_PREFIX) || group === SINGLE_THREAD_GROUP || group === ISOLATED_THREAD_GROUP);
+}
+async function swapInPlace(host, build) {
+  if (host === null) return { swapped: false, reason: "the Interactive is not running" };
+  let next;
+  try {
+    next = await build();
+  } catch (error) {
+    return { swapped: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+  return !next.ok || next.host !== true || next.chunks === void 0 || next.chunks === null ? { swapped: false, reason: "the new build cannot run here" } : host.hotSwap(next.chunks);
+}
+function hostIsolated() {
+  return globalThis.crossOriginIsolated === true;
+}
+function hostThreads() {
+  return hostIsolated() && threadsAvailable();
+}
+var DEFAULT_HOST_LIMITS = {
+  ping_ms: 250,
+  cpu_slice_ms: 2e3,
+  memory_bytes: 128 * 1024 * 1024,
+  boot_ms: 1e4,
+  restarts_per_window: 3,
+  restart_window_ms: 6e4
+}, HostFaultError = class extends Error {
+  constructor(fault) {
+    super(fault.message);
+    this.fault = fault;
+    this.name = "HostFaultError";
+  }
+}, RELAYED_FROM_GUEST = /* @__PURE__ */ new Set([MessageTag.request, MessageTag.frames]), RELAYED_FROM_SESSION = /* @__PURE__ */ new Set([MessageTag.response, MessageTag.event, MessageTag.frames]), PARTS_SUBSCRIPTION = "sub_host_parts";
+function workerEngines(script) {
+  return {
+    spawn() {
+      let worker = new Worker(script, { type: "module" }), listener = () => {
+      };
+      return worker.onmessage = (event) => listener(new Uint8Array(event.data)), {
+        send(bytes, length) {
+          let copy = bytes.slice(0, length);
+          worker.postMessage(copy.buffer, [copy.buffer]);
+        },
+        on_message(next) {
+          listener = next;
+        },
+        on_crash(next) {
+          worker.onerror = (event) => {
+            event.preventDefault(), next(event.message || "the guest engine stopped");
+          };
+        },
+        terminate() {
+          worker.terminate();
+        }
+      };
+    }
+  };
+}
+var GuestPool = class {
+  constructor(factory, size) {
+    this.factory = factory;
+    this.size = size;
+    this.ready = [];
+    this.waiting = [];
+    for (let i = 0; i < size; i++) this.warm();
+  }
+  warm() {
+    let engine = this.factory.spawn();
+    engine.on_crash(() => {
+      engine.terminate(), this.warm();
+    }), engine.on_message((bytes) => {
+      if (bytes[0] !== MessageTag.ready) return;
+      engine.on_message(() => {
+      });
+      let next = this.waiting.shift();
+      next !== void 0 ? next(engine) : this.ready.push(engine);
+    });
+  }
+  acquire() {
+    this.warm();
+    let engine = this.ready.shift();
+    return engine !== void 0 ? Promise.resolve(engine) : new Promise((resolve) => this.waiting.push(resolve));
+  }
+  drain() {
+    for (let engine of this.ready) engine.terminate();
+    this.ready.length = 0;
+  }
+  get warmed() {
+    return this.ready.length;
+  }
+}, TreeStore = class {
+  constructor() {
+    this.mirror = new TreeMirror();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (listener) => (this.listeners.add(listener), () => this.listeners.delete(listener));
+    this.snapshot = () => this.mirror.root;
+  }
+  apply(patches) {
+    this.mirror.apply(patches);
+    for (let listener of this.listeners) listener();
+  }
+  reset() {
+    this.mirror.apply([{ op: "root", node: null }]);
+    for (let listener of this.listeners) listener();
+  }
+}, WebHost = class {
+  constructor(options) {
+    this.options = options;
+    this.tree = new TreeStore();
+    this.writer = new MessageWriter();
+    this.stepMessage = new Uint8Array(TAG_BYTES);
+    this.supplying = 0;
+    this.ping = new Uint8Array(PING_BYTES);
+    this.pingView = new DataView(this.ping.buffer);
+    this.lifecycleMessage = new Uint8Array(LIFECYCLE_BYTES);
+    this.partsSequence = 0;
+    this.engine = null;
+    this.watchdog = null;
+    this.pingSequence = 0;
+    this.pingSentAt = -1;
+    this.restarts = [];
+    this.started = null;
+    this.failed = null;
+    this.phase = "idle";
+    this.outlet = { toSession: (bytes, length) => this.options.transport.send(bytes, length) };
+    this.networkMessage = new Uint8Array(NETWORK_MESSAGE_BYTES);
+    this.unwatchNetwork = null;
+    this.inspectorMessage = new Uint8Array(INSPECTOR_BYTES);
+    this.inspectorShown = false;
+    this.meterRequest = METERS_OFF;
+    this.studioOut = new StudioSender(MessageTag.studio, (frame) => this.engine?.send(frame, frame.length));
+    this.hotDone = null;
+    options.webgpu === void 0 && probeHostWebGpu(), this.networkHint = options.network === void 0 ? webNetworkHint() : options.network, options.network === void 0 && (this.unwatchNetwork = watchWebNetwork((hint) => this.setNetwork(hint))), this.limits = { ...DEFAULT_HOST_LIMITS, ...options.limits }, this.studioIn = options.on_studio === void 0 ? null : new StudioAssembler();
+    let isolated = hostIsolated(), threads = options.threads ?? hostThreads(), webgpu = options.webgpu ?? hostWebGpu();
+    this.hosted = (chunks) => chunksForHost(chunks, null, isolated, options.device_tier ?? DEFAULT_HOST_TIER, threads, luauVmRunsHere, webgpu);
+    let hosted = this.hosted(options.package.chunks);
+    this.known = new Set(hosted.map((chunk) => chunk.digest)), this.chunks = hosted.filter((chunk) => chunk.lazy !== true), this.parts = options.part_store === void 0 ? null : options.part_store.session(
+      options.hello.program.interactive_id,
+      hosted.map((chunk) => ({ digest: chunk.digest, zone: chunk.asset_group ?? DEFAULT_PART_ZONE })),
+      { keep_on_device: options.package.keep_on_device === true }
+    ), this.parts?.on_evicted((eviction) => this.evicted(eviction));
+    let upstream = twinned(options.chunks, twinCaps(options.package.chunks));
+    this.source = this.parts === null ? upstream : this.parts.source(upstream);
+    let spans = ZoneSpans.of(options.package.chunks, options.package.zone_files ?? []);
+    this.afterFirstFrame = hosted.filter((chunk) => chunk.lazy === true && chunk.asset_group === LUAU_SCRIPTS_GROUP).map((chunk) => chunk.digest), this.lazyChunks = new LazyChunkServer(hosted.filter((chunk) => chunk.lazy === true), {
+      source: this.source,
+      budget_bytes: options.lazy_budget_bytes,
+      concurrency: options.lazy_concurrency,
+      spans: spans.size > 0 ? spans : void 0
+    }), this.mediator = options.chrome === void 0 ? null : new HostMediator(options.chrome), this.now = options.now ?? (() => Date.now());
+    let chrome = options.chrome;
+    this.clips = options.clips === void 0 ? null : new HostClips(options.clips, options.hello.program.interactive_id, chrome === void 0 ? null : { consents: chrome.consents, controller: chrome.controller }, this.now), this.ping[0] = MessageTag.ping, this.lifecycleMessage[0] = MessageTag.lifecycle, this.inspectorMessage[0] = MessageTag.inspector, options.transport.on_message((bytes) => this.fromSession(bytes)), options.transport.on_close((close) => this.fail({ source: "session", message: `${close.reason}${close.detail ? `: ${close.detail}` : ""}` }));
+  }
+  engineHeap() {
+    return engineHeapFor(this.options.package.engine_heap, this.options.device_tier ?? DEFAULT_HOST_TIER);
+  }
+  deviceRefusal() {
+    let gpu = this.options.gpu, unmet = gpu === void 0 ? null : unmetGpuRequirement(gpu.requirements, gpu.limits);
+    if (unmet !== null) return { source: "device", requirement: unmet, message: `this device's GPU is below the game's ${unmet} requirement` };
+    let features = this.options.engine_features, missing = features === void 0 ? null : unmetEngineFeature(features.required, features.available);
+    if (missing !== null) return { source: "device", requirement: missing, message: `this device's engine does not provide ${missing}, which the game uses` };
+    let heap = this.engineHeap();
+    return "refused" in heap ? { source: "device", requirement: ENGINE_HEAP_REQUIREMENT, message: heap.refused } : null;
+  }
+  async start() {
+    if (this.phase !== "idle" && this.phase !== "crashed") throw new Error(`the host is ${this.phase}`);
+    let refused = this.deviceRefusal();
+    if (refused !== null)
+      throw this.options.on_fault?.(refused), new HostFaultError(refused);
+    this.phase = "booting", this.mediator?.start(this.options.hello.program, this.outlet);
+    let engines = this.options.engines, runtimes = this.options.runtimes, interactive = this.options.hello.program.interactive_id, warm = runtimes === void 0 ? null : await runtimes.take(this.chunks, interactive), pooled = warm !== null || engines instanceof GuestPool, engine = warm?.engine ?? (engines instanceof GuestPool ? await engines.acquire() : engines.spawn(interactive));
+    this.engine = engine;
+    let settled = new Promise((resolve, reject) => {
+      this.started = resolve, this.failed = reject;
+    }), booted = pooled ? Promise.resolve() : this.awaitReady(engine);
+    engine.on_crash((message) => this.fail({ source: "crash", message }));
+    let unstaged = warm === null ? this.chunks : this.chunks.filter((chunk) => !warm.staged.has(chunk.digest)), deferred = engine.may_fetch_wasm === true ? (ref) => referable(ref) && !this.holdsPart(ref.digest) : never, playable = unstaged.filter(linksBeforeStart), eager = playable.filter((ref) => !deferred(ref)), linked = playable.filter(deferred), chunks = this.fetchChunks(eager);
+    chunks.catch(() => {
+    });
+    let following = unstaged.filter((chunk) => !linksBeforeStart(chunk)), followingBodies = following.map((ref) => deferred(ref) ? null : ref.before_play ? this.fetchChunks([ref]) : chunks.then(() => this.fetchChunks([ref])));
+    for (let body of followingBodies) body?.catch(() => {
+    });
+    if (await Promise.race([booted, settled]), this.engine !== engine) return settled;
+    engine.on_message((bytes) => this.fromGuest(bytes)), this.lazyChunks.attach({ deliver: (digest, body) => this.sendChunk(engine, digest, body), send: (bytes, length) => engine.send(bytes, length) }), this.boot(engine);
+    try {
+      let bodies = await Promise.race([chunks, settled.then(() => [])]);
+      if (this.engine !== engine) return settled;
+      for (let i = 0; i < bodies.length; i++) this.sendChunk(engine, eager[i].digest, bodies[i]);
+      for (let ref of linked) await this.deliver(engine, ref);
+    } catch (error) {
+      return this.engine !== engine || this.fail({ source: "package", message: error instanceof Error ? error.message : String(error) }), settled;
+    }
+    return engine.send(this.writer.bytes, this.writer.tag(MessageTag.start)), this.clips?.attach(engine.clips ?? null), this.openReplay(engine), this.armWatchdog(), this.streamChunks(engine, following, followingBodies).then(() => this.keepRuntimes(engine, linked)), settled;
+  }
+  holdsPart(digest) {
+    return this.parts !== null && this.options.part_store?.has(digest) === true;
+  }
+  /**
+   * Copies the runtime wasm the guest fetched itself into the shared part store once the start-time
+   * chunks are in, so the next game on this device reads it from the store instead of the network.
+   * Skipped on a metered or data-saver link, where the copy would cost the player a second download.
+   */
+  async keepRuntimes(engine, refs) {
+    let hint = this.networkHint;
+    if (!(this.parts === null || hint !== null && (hint.metered || hint.saver)))
+      for (let ref of refs) {
+        if (this.engine !== engine) return;
+        if (!(!referable(ref) || this.holdsPart(ref.digest)))
+          try {
+            await this.fetchChunks([ref]);
+          } catch {
+            return;
+          }
+      }
+  }
+  async deliver(engine, ref) {
+    if (engine.fetches_wasm === true && referable(ref) && !this.holdsPart(ref.digest)) {
+      let message = chunkRefMessage(MessageTag.chunk_ref, ref.digest, ref.payload_digest);
+      engine.send(message, message.length);
+      return;
+    }
+    let [bytes] = await this.fetchChunks([ref]);
+    this.engine === engine && this.sendChunk(engine, ref.digest, bytes);
+  }
+  async supply(engine, digest) {
+    let ref = this.chunks.find((chunk) => chunk.digest === digest);
+    if (ref !== void 0) {
+      this.supplying++;
+      try {
+        let [bytes] = await this.fetchChunks([ref]);
+        this.engine === engine && this.sendChunk(engine, digest, bytes);
+      } catch (error) {
+        if (this.engine !== engine) return;
+        this.fail({ source: "package", message: error instanceof Error ? error.message : String(error) });
+      } finally {
+        this.supplying--;
+      }
+    }
+  }
+  async stepWhenSettled(engine, settled) {
+    for (; this.engine === engine && (this.supplying > 0 || this.lazyChunks.pending > 0); ) await new Promise((resolve) => setTimeout(resolve, 0));
+    this.engine === engine && (settled(), this.stepMessage[0] = MessageTag.frame_step, engine.send(this.stepMessage, TAG_BYTES));
+  }
+  async streamChunks(engine, refs, bodies) {
+    for (let i = 0; i < refs.length; i++)
+      try {
+        let body = bodies[i];
+        if (body === null) {
+          await this.deliver(engine, refs[i]);
+          continue;
+        }
+        let [bytes] = await body;
+        if (this.engine !== engine) return;
+        this.sendChunk(engine, refs[i].digest, bytes);
+      } catch (error) {
+        if (this.engine !== engine) return;
+        this.fail({ source: "package", message: error instanceof Error ? error.message : String(error) });
+        return;
+      }
+  }
+  awaitReady(engine) {
+    return new Promise((resolve) => {
+      let timer = setTimeout(() => this.fail({ source: "watchdog", message: "the guest engine did not start in time" }), this.limits.boot_ms);
+      engine.on_message((bytes) => {
+        bytes[0] === MessageTag.ready && (clearTimeout(timer), resolve());
+      });
+    });
+  }
+  boot(engine) {
+    let heap = this.engineHeap(), boot = {
+      program: this.options.hello.program,
+      locale: this.options.locale,
+      clock_offset_ms: this.options.hello.server_time_ms - this.now(),
+      deadline_ms: null,
+      chunk_requests: CHUNK_REQUESTS_VERSION,
+      ..."bytes" in heap ? { engine_heap_bytes: heap.bytes } : {},
+      ...this.networkHint === null ? {} : { network: this.networkHint }
+    };
+    engine.send(this.writer.bytes, this.writer.json(MessageTag.boot, boot)), this.inspectorShown && this.sendInspector(engine), this.meterRequest.on && engine.send(this.writer.bytes, this.writer.json(MessageTag.meters, this.meterRequest)), this.studioIn !== null && (this.studioIn.reset(), this.studioOut.post({ topic: STUDIO_GRANT_TOPIC }));
+  }
+  get studio() {
+    return this.studioIn !== null;
+  }
+  sendStudio(message) {
+    if (this.studioIn === null) throw new Error("this host was not opened as a studio viewer");
+    return this.engine === null || this.phase === "disposed" ? false : (this.studioOut.post(message), true);
+  }
+  studioReport(bytes) {
+    let assembler = this.studioIn, deliver = this.options.on_studio;
+    if (assembler === null || deliver === void 0) return;
+    let message;
+    try {
+      message = assembler.accept(bytes);
+    } catch (error) {
+      this.fail({ source: "guest", phase: "run", message: error instanceof Error ? error.message : String(error), stack: null });
+      return;
+    }
+    message !== null && deliver(message);
+  }
+  get inspector() {
+    return this.inspectorShown;
+  }
+  get meters() {
+    return this.meterRequest;
+  }
+  setMeters(request) {
+    this.meterRequest = request;
+    let engine = this.engine;
+    engine === null || this.phase === "disposed" || engine.send(this.writer.bytes, this.writer.json(MessageTag.meters, request));
+  }
+  setInspector(shown) {
+    this.inspectorShown = shown;
+    let engine = this.engine;
+    engine === null || this.phase === "disposed" || this.sendInspector(engine);
+  }
+  sendInspector(engine) {
+    this.inspectorMessage[TAG_BYTES] = this.inspectorShown ? INSPECTOR_SHOWN : INSPECTOR_HIDDEN, engine.send(this.inspectorMessage, INSPECTOR_BYTES);
+  }
+  get network() {
+    return this.networkHint;
+  }
+  setNetwork(hint) {
+    this.networkHint = hint;
+    let engine = this.engine;
+    engine === null || this.phase === "disposed" || engine.send(this.networkMessage, writeNetworkHint(this.networkMessage, MessageTag.network, hint));
+  }
+  fetchChunks(refs) {
+    return fetchVerified(this.source, refs.map((ref) => ref.digest));
+  }
+  sendChunk(engine, digest, body) {
+    let message = chunkMessage(MessageTag.chunk, digest, body);
+    engine.send(message, message.length);
+  }
+  armWatchdog() {
+    this.disarmWatchdog(), this.pingSentAt = -1, this.watchdog = setInterval(() => this.tick(), this.limits.ping_ms);
+  }
+  disarmWatchdog() {
+    this.watchdog !== null && clearInterval(this.watchdog), this.watchdog = null;
+  }
+  tick() {
+    let engine = this.engine;
+    if (engine === null) return;
+    let now = this.now();
+    if (this.pingSentAt >= 0) {
+      now - this.pingSentAt > this.limits.cpu_slice_ms && this.fail({ source: "watchdog", message: `the guest ran longer than ${this.limits.cpu_slice_ms} ms without yielding` });
+      return;
+    }
+    this.pingSequence = this.pingSequence + 1 >>> 0, this.pingView.setUint32(1, this.pingSequence, true), this.pingSentAt = now, engine.send(this.ping, PING_BYTES);
+  }
+  pong(bytes) {
+    let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.getUint32(1, true) !== this.pingSequence) return;
+    this.pingSentAt = -1;
+    let heap = view.getFloat64(5, true);
+    heap > this.limits.memory_bytes && this.fail({ source: "memory", message: `the guest heap reached ${heap} bytes, over its ${this.limits.memory_bytes} byte cap` });
+  }
+  fromGuest(bytes) {
+    if (bytes.length > BRIDGE_LIMITS.max_message_bytes) {
+      this.fail({ source: "guest", phase: "run", message: "the guest sent an oversized message", stack: null });
+      return;
+    }
+    let tag = bytes[0];
+    if (RELAYED_FROM_GUEST.has(tag)) {
+      if (this.mediator?.fromGuest(bytes) === true) return;
+      this.options.transport.send(bytes, bytes.length);
+      return;
+    }
+    switch (tag) {
+      case MessageTag.pong:
+        this.pong(bytes);
+        return;
+      case MessageTag.render:
+        if (bytes.length > BRIDGE_LIMITS.max_render_bytes) {
+          this.fail({ source: "guest", phase: "render", message: "a tree update exceeded the render budget", stack: null });
+          return;
+        }
+        this.tree.apply(readJson(bytes));
+        return;
+      case MessageTag.ui_command:
+        this.command(readJson(bytes));
+        return;
+      case MessageTag.fault:
+        this.fail({ source: "guest", ...readJson(bytes) });
+        return;
+      case MessageTag.hot_done:
+        this.finishHot(readJson(bytes));
+        return;
+      case MessageTag.meter_report:
+        this.meterRequest.on && this.options.on_meters?.(readJson(bytes));
+        return;
+      case MessageTag.studio_report:
+        this.studioReport(bytes);
+        return;
+      case MessageTag.started:
+        this.phase = "running", this.started?.(), this.started = null;
+        return;
+      case MessageTag.disposed:
+        this.teardown("disposed");
+        return;
+      case MessageTag.chunk_request: {
+        let engine = this.engine;
+        if (engine === null) return;
+        let lazy = [];
+        forEachChunkEntry(bytes, CHUNK_REQUEST_ENTRY_BYTES, (digest, priority) => {
+          this.chunks.some((chunk) => chunk.digest === digest) ? this.supply(engine, digest) : lazy.push([digest, priority]);
+        }), lazy.length > 0 && this.lazyChunks.requestMany(lazy);
+        return;
+      }
+      case MessageTag.chunk_release:
+        this.lazyChunks.release(bytes), this.parts !== null && forEachChunkEntry(bytes, CHUNK_RELEASE_ENTRY_BYTES, (digest) => this.parts?.release(digest));
+        return;
+      case MessageTag.milestone: {
+        let name = MILESTONE_BY_CODE[bytes[TAG_BYTES]] ?? null;
+        if (name === FIRST_FRAME_MILESTONE) for (let digest of this.afterFirstFrame) this.lazyChunks.requestOne(digest, ChunkPriority.soon);
+        name !== null && this.options.on_milestone?.(name, this.now());
+        return;
+      }
+      case MessageTag.session_complete: {
+        let completion = readSessionComplete(bytes);
+        completion !== null && this.options.on_complete?.(completion, this.now());
+        return;
+      }
+      case MessageTag.frame_mark: {
+        let engine = this.engine, marked = this.options.on_frame_mark, mark = readFrameMark(bytes);
+        if (engine === null || marked === void 0 || mark === null) return;
+        this.stepWhenSettled(engine, () => marked(mark));
+        return;
+      }
+    }
+  }
+  fromSession(bytes) {
+    let engine = this.engine;
+    this.mediator?.fromSession(bytes) !== true && (engine === null || !RELAYED_FROM_SESSION.has(bytes[0]) || engine.send(bytes, bytes.length));
+  }
+  openReplay(engine) {
+    let opened = this.options.replay ?? null;
+    if (opened === null) return;
+    let flags = replayFlags(opened.bytes);
+    if (flags === null) return;
+    let mode = opened.mode === "play" && flags.play_from_here ? "play" : "watch", message = replayMessage(opened.bytes, mode);
+    engine.send(message, message.length);
+  }
+  get clipsEnabled() {
+    return this.clips !== null;
+  }
+  /** Saves the host's rolling window (the last 15 s by default) and uploads it, or says why it could not. */
+  saveClip(keep_ms) {
+    let clips = this.clips;
+    return clips === null ? Promise.resolve({ error: "unavailable" }) : clips.keep(keep_ms ?? clips.arm.window_ms);
+  }
+  /** Asks the player, in host chrome, whether clips may include the camera while it is on. */
+  askClipCamera() {
+    return this.clips?.askCamera() ?? Promise.resolve(false);
+  }
+  /** Posts a saved clip as a Flick through the session, as the game's own `social.post` would. */
+  async postClip(media, score = null) {
+    let mediator = this.mediator;
+    if (mediator === null) return null;
+    let envelope = await mediator.hostCall("social.post", { kind: "clip", media, score });
+    return envelope.outcome.status === "ok" ? envelope.outcome.response.result : null;
+  }
+  async shareClip(media) {
+    let mediator = this.mediator;
+    if (mediator === null) return null;
+    let envelope = await mediator.hostCall("share.open", { target: { kind: "clip", media }, audience_hint: null });
+    return envelope.outcome.status === "ok" ? envelope.outcome.response.result : null;
+  }
+  async command(message) {
+    let command = message.command, clips = this.clips, value = clips !== null && isClipCommand(command) ? await clips.command(command) : await this.options.on_command?.(command);
+    if (message.id === 0 || this.engine === null) return;
+    let reply = { id: message.id, value: value ?? null };
+    this.engine.send(this.writer.bytes, this.writer.json(MessageTag.ui_reply, reply));
+  }
+  grantConsents(granted) {
+    let consent = { granted: [...new Set(granted)] };
+    this.options.transport.send(this.writer.bytes, this.writer.json(MessageTag.consent, consent));
+  }
+  evicted(eviction) {
+    if (this.engine === null) return;
+    let envelope = {
+      contract_version: 1,
+      subscription_id: PARTS_SUBSCRIPTION,
+      sequence: ++this.partsSequence,
+      emitted_at: this.now(),
+      event: { family: "parts", event: { kind: "evicted", zone: eviction.zone, parts: eviction.parts, bytes: eviction.bytes, reason: eviction.reason, kept: eviction.kept } }
+    };
+    this.engine.send(this.writer.bytes, this.writer.json(MessageTag.event, envelope));
+  }
+  dispatch(event) {
+    this.engine?.send(this.writer.bytes, this.writer.json(MessageTag.ui_event, event));
+  }
+  lifecycle(name) {
+    this.engine !== null && (this.lifecycleMessage[1] = LifecycleCode[name], this.engine.send(this.lifecycleMessage, LIFECYCLE_BYTES));
+  }
+  dispose() {
+    if (this.phase === "disposed") return;
+    if (this.engine === null) {
+      this.teardown("disposed");
+      return;
+    }
+    this.lifecycle("dispose");
+    let engine = this.engine;
+    setTimeout(() => {
+      this.engine === engine && this.teardown("disposed");
+    }, this.limits.ping_ms);
+  }
+  async hotSwap(chunks) {
+    let engine = this.engine;
+    if (engine === null || this.phase !== "running") return { swapped: false, reason: "the Interactive is not running" };
+    if (this.hotDone !== null) return { swapped: false, reason: "a swap is already in progress" };
+    let unseen = this.hosted(chunks).filter((chunk) => !this.known.has(chunk.digest)), fresh = unseen.filter((chunk) => swappable(chunk));
+    if (fresh.length !== unseen.length) return { swapped: false, reason: "more than the code and assets changed" };
+    if (fresh.length === 0) return { swapped: false, reason: "no code changed" };
+    let bodies;
+    try {
+      bodies = await this.fetchChunks(fresh);
+    } catch (error) {
+      return { swapped: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    if (this.engine !== engine) return { swapped: false, reason: "the Interactive stopped" };
+    for (let i = 0; i < fresh.length; i++)
+      this.sendChunk(engine, fresh[i].digest, bodies[i]), this.chunks.push(fresh[i]), this.known.add(fresh[i].digest);
+    let result = new Promise((resolve) => {
+      this.hotDone = resolve;
+    }), request = { chunks: fresh.map((chunk) => chunk.digest) };
+    return engine.send(this.writer.bytes, this.writer.json(MessageTag.hot, request)), result;
+  }
+  finishHot(result) {
+    let done = this.hotDone;
+    this.hotDone = null, done?.(result);
+  }
+  async restart() {
+    let now = this.now();
+    if (this.restarts = this.restarts.filter((at) => now - at < this.limits.restart_window_ms), this.restarts.length >= this.limits.restarts_per_window)
+      throw new Error("the Interactive crashed too often to restart");
+    return this.restarts.push(now), this.tree.reset(), this.phase = "crashed", this.start();
+  }
+  fail(fault) {
+    if (this.phase !== "disposed") {
+      if (this.options.on_fault?.(fault), fault.source === "session")
+        this.teardown("disposed");
+      else {
+        if (fault.source === "guest" && fault.phase === "run")
+          return;
+        this.teardown("crashed");
+      }
+      this.failed?.(new HostFaultError(fault)), this.failed = null, this.started = null;
+    }
+  }
+  teardown(phase) {
+    this.finishHot({ swapped: false, reason: "the Interactive stopped" }), this.lazyChunks.attach(null), this.parts?.close(), this.clips?.detach(), this.disarmWatchdog(), this.engine?.terminate(), this.engine = null, this.phase = phase, phase === "disposed" && (this.unwatchNetwork?.(), this.unwatchNetwork = null, this.options.runtimes?.warm(this.chunks), this.mediator?.stop(), this.options.chrome?.controller.dismissAll(), this.options.transport.close());
+  }
+};
+
+export { ALTERNATIVE_RUNTIMES, CLIP_CAMERA, DEFAULT_HOST_LIMITS, DEFAULT_HOST_TIER, DEFAULT_LAZY_BUDGET_BYTES, DEFAULT_LAZY_CONCURRENCY, ENGINE_GROUP_PREFIX, GPU_REQUIREMENT_NAMES, GuestPool, HOST_PAGE_ISOLATION_HEADERS, HostClips, HostFaultError, HostMediator, ISOLATED_THREAD_GROUP, JOINED_PARTS_PARAM, JOINED_PART_SEPARATOR, JOINED_PREFIX, LazyChunkServer, MAX_JOINED_PARTS, REPLAY_MEDIA_TYPE, RUNTIME_PREFIX, RUNTIME_SUFFIX, SHELL_PREFIX, SINGLE_THREAD_GROUP, TIER_GROUP_PREFIX, TreeStore, WASM_PREFIX, WASM_SUFFIX, WebHost, ZoneSpans, chunksForHost, deviceGpuLimits, fetchTwin, forgetHostWebGpu, guestOrigin, hostIsolated, hostThreads, hostWebGpu, httpChunks, interactiveLabel, isDigestHex, linksBeforeStart, manifestGpuRequirements, openSession, parseContentOrigin, probeHostWebGpu, rangedChunks, referable, runtimePath, servesContent, sessionUrl, sha256Hex, shellPath, sri, swapInPlace, swappable, unmetGpuRequirement, workerEngines };