@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives-web.mjs

@@ -0,0 +1,4628 @@
+import './chunk-GVTI6UJQ.mjs';
+import './chunk-Y3XWP5XW.mjs';
+import { identityCapturePolicy, identityFromCapture, IdentityFitter } from './chunk-KK6HYVBI.mjs';
+import { WebFaceColours } from './chunk-FQBFWJBS.mjs';
+import { referable, chunksForHost, hostIsolated, DEFAULT_HOST_TIER, hostThreads, shellPath, sha256Hex, linksBeforeStart, guestOrigin, ENGINE_GROUP_PREFIX, isDigestHex, WASM_SUFFIX, JOINED_PREFIX, JOINED_PARTS_PARAM, JOINED_PART_SEPARATOR, MAX_JOINED_PARTS, SHELL_PREFIX, sri, runtimePath, RUNTIME_SUFFIX, RUNTIME_PREFIX, WASM_PREFIX, fetchTwin } from './chunk-VBGHBL3E.mjs';
+export { ALTERNATIVE_RUNTIMES, CLIP_CAMERA, DEFAULT_HOST_LIMITS, DEFAULT_LAZY_BUDGET_BYTES, DEFAULT_LAZY_CONCURRENCY, ENGINE_GROUP_PREFIX, GPU_REQUIREMENT_NAMES, GuestPool, HOST_PAGE_ISOLATION_HEADERS, HostClips, HostFaultError, HostMediator, LazyChunkServer, REPLAY_MEDIA_TYPE, TreeStore, WebHost, ZoneSpans, chunksForHost, deviceGpuLimits, forgetHostWebGpu, guestOrigin, hostThreads, hostWebGpu, httpChunks, interactiveLabel, manifestGpuRequirements, openSession, parseContentOrigin, probeHostWebGpu, rangedChunks, servesContent, sessionUrl, sha256Hex, swapInPlace, swappable, unmetGpuRequirement, workerEngines } from './chunk-VBGHBL3E.mjs';
+import './chunk-DDJLDOUX.mjs';
+import './chunk-HMWYTXCY.mjs';
+export { CANNOT_REWIND, NOT_RECORDING, TIMELINE_PREFIX, TIMELINE_REPORT, TIMELINE_TOPIC } from './chunk-KVFNRJOR.mjs';
+import './chunk-KDTVOLHI.mjs';
+import './chunk-RM2V4IND.mjs';
+import './chunk-22BD3RHN.mjs';
+import './chunk-ME6HGG4I.mjs';
+import './chunk-5BYDGGWO.mjs';
+import './chunk-Y65LXQGA.mjs';
+import './chunk-7ARSJPV3.mjs';
+import './chunk-7BHW5GTC.mjs';
+import './chunk-RUVGVNOF.mjs';
+import './chunk-HF5HPS4T.mjs';
+import './chunk-XPG3N5CF.mjs';
+import './chunk-KIZOA5LX.mjs';
+import './chunk-7SXOHAIR.mjs';
+import './chunk-ATAWRACV.mjs';
+import './chunk-T3AFF3L7.mjs';
+import './chunk-TL2SVO4P.mjs';
+import './chunk-IDLW4NWA.mjs';
+import { woven, openWeaveHead, chunkWeaveSource, storeWeaveSource, unweaveIndex } from './chunk-ZR5ULMN2.mjs';
+import './chunk-3GXH2NFD.mjs';
+import { chunkRefMessage, chunkMessage, fetchVerified, MemoryPartBackend, SharedPartStore, verifyChunk } from './chunk-BU6OK542.mjs';
+export { DEFAULT_DISK_RESERVE_BYTES, DEFAULT_KEPT_BUDGET_BYTES, DEFAULT_PART_STORE_BUDGET_BYTES, DEFAULT_PART_ZONE, KEEP_REASONS, MemoryPartBackend, PartSession, PartVerifyError, SharedPartStore, localFirstChunks } from './chunk-BU6OK542.mjs';
+import './chunk-PRSR4FAV.mjs';
+import './chunk-TM63CYGN.mjs';
+import './chunk-X6CN6KQF.mjs';
+import './chunk-MN3YETVN.mjs';
+import './chunk-73SGZLAQ.mjs';
+import { Transport, WebTransportDialer, WebSocketDialer, SizedViews } from './chunk-M5EXQZYY.mjs';
+import { PACKET_BYTES } from './chunk-TU5RYTYU.mjs';
+import './chunk-3OY3VYNF.mjs';
+import './chunk-EIB4OWVQ.mjs';
+import './chunk-PBL6YL5L.mjs';
+import './chunk-GXKI64OT.mjs';
+import './chunk-NHJUGZUR.mjs';
+import './chunk-E65WCTIG.mjs';
+import './chunk-5YFBGGCK.mjs';
+import './chunk-K4UDGE3Z.mjs';
+import './chunk-MOBSBXVE.mjs';
+import './chunk-SMK6JU2F.mjs';
+import './chunk-UG5BTOTF.mjs';
+export { ENGINE_HEAP_CEILING_BYTES, ENGINE_HEAP_HEADROOM, declareEngineHeap, engineHeapFor } from './chunk-JURRXY2J.mjs';
+export { EngineSessionError } from './chunk-GHS6MIL6.mjs';
+import './chunk-GDCV4IWO.mjs';
+import './chunk-Y66WVMO5.mjs';
+import './chunk-U6UVWEAK.mjs';
+import './chunk-A33OORT7.mjs';
+export { ClipError } from './chunk-3VEH23I5.mjs';
+import { FACE_FRAME, CAMERA_PLACE_BYTES, readFloat, CAMERA_PLACE_X_AT, CAMERA_WORD_BYTES, CAMERA_PLACE_FLAGS_AT, CameraViewFlag, FACE_PAYLOAD_BYTES, FACE_FLOATS_AT, FACE_FLOATS, FACE_ARKIT_AT, FACE_POSE_AT, CAMERA_HANDLE_BYTES, readWord, CAMERA_ID_AT, CAMERA_PAIR_BYTES, CAMERA_SECOND_AT, CAMERA_OPEN_BYTES, CAMERA_PURPOSE_AT, NO_CAMERA, CameraRefusal, CameraOpenPurpose, CAMERA_IDENTIFIED_BYTES, writeWord, IDENTITY_CAPTURED, CAMERA_IDENTITY_CODE_AT, identityCodeByte, CAMERA_FACE_BYTES, CAMERA_COLOURED_BYTES, NO_FACE_COLOUR } from './chunk-5C3C7VDM.mjs';
+import { CLIP_PAUSE_BYTES, CLIP_SAVE_BYTES, writeClipPause, writeClipSave, readClipSaved, ClipStatus } from './chunk-UGH37BQW.mjs';
+export { DEFAULT_CLIP_ARM } from './chunk-UGH37BQW.mjs';
+import './chunk-KDQOR4QQ.mjs';
+import './chunk-LYEZZEEF.mjs';
+export { STUDIO_MESSAGE_MAX_BYTES } from './chunk-HAGEIC2L.mjs';
+import { webNetworkHint, prefetchDepth } from './chunk-K46SMZ66.mjs';
+import './chunk-OKC2B4O3.mjs';
+import './chunk-PPF2BYFL.mjs';
+import './chunk-WLMINRC4.mjs';
+import { UiRole, UiTrait } from './chunk-RFVRPYR2.mjs';
+import './chunk-DS2VU4WW.mjs';
+import { sha256Into, SHA256_BYTES } from './chunk-5YWN6H5Q.mjs';
+import './chunk-F6XRYEM3.mjs';
+import './chunk-OQRVEM56.mjs';
+import { FACE_LAYOUT, CAMERA_LAYOUT, CTX_CAPABILITIES } from './chunk-SPCRQ6NO.mjs';
+import { MessageWriter, MessageTag, forEachChunkEntry, CHUNK_REQUEST_ENTRY_BYTES, readJson, LifecycleCode, unhex, ENGINE_CORE_UNIT, PONG_BYTES, hex } from './chunk-V7ZRH3PY.mjs';
+export { CHUNK_FAILED_BYTES, CHUNK_RELEASE_ENTRY_BYTES, CHUNK_REQUESTS_VERSION, CHUNK_REQUEST_ENTRY_BYTES, ChunkBatch, ChunkFailure, ChunkPriority, FrameTouchKind, LifecycleCode, MessageTag, forEachChunkEntry, readChunkFailed, writeChunkFailed } from './chunk-V7ZRH3PY.mjs';
+import './chunk-GYLP6UG4.mjs';
+import './chunk-XJA2NGTI.mjs';
+import { encodeBase64 } from './chunk-2IC4H6OV.mjs';
+import './chunk-MOMOZEUM.mjs';
+import './chunk-N4RGGDEL.mjs';
+import './chunk-XJIHN3BY.mjs';
+export { CONSENT_KINDS, ConsentStore, browserStore, memoryStore } from './chunk-XVZ2NKSU.mjs';
+import { encodeIdentity } from './chunk-XD2PMH46.mjs';
+import './chunk-25T4JHEA.mjs';
+
+// src/interactives/hosts/credits.ts
+var decoder = new TextDecoder(), CONTENT_BLOCKED_ERROR = "INTERACTIVES_CONTENT_BLOCKED", CONTENT_BLOCKED_CLOSE = "content_blocked", CONTENT_BLOCKED_STATUS = 451;
+function text(value) {
+  return typeof value == "string" && value.length > 0 ? value : null;
+}
+function credit(raw) {
+  let title = text(raw.title), licence = text(raw.licence);
+  return title === null || licence === null ? null : {
+    title,
+    authors: Array.isArray(raw.authors) ? raw.authors.filter((a) => typeof a == "string") : [],
+    licence,
+    licenceUrl: text(raw.licence_url),
+    sourceUrl: text(raw.source_url),
+    modified: raw.modified === true,
+    item: text(raw.item),
+    ai: text(raw.ai)
+  };
+}
+function manifestCredits(manifest) {
+  let parsed = JSON.parse(decoder.decode(manifest));
+  if (!Array.isArray(parsed.credits)) return [];
+  let out = [];
+  for (let raw of parsed.credits) {
+    if (typeof raw != "object" || raw === null) continue;
+    let found = credit(raw);
+    found !== null && out.push(found);
+  }
+  return out;
+}
+function blockedItems(detail) {
+  return detail === null || detail.length === 0 ? [] : detail.split(",").filter((item) => item.length > 0);
+}
+
+// src/interactives/hosts/warm.ts
+var DEFAULT_WARM_BOOT_MS = 1e4, PART_SUFFIX = /\.(\d+)$/, KEY_SEPARATOR = ",", INTERACTIVE_SEPARATOR = "@";
+function engineCore(chunk) {
+  return chunk.runtime?.name === ENGINE_CORE_UNIT;
+}
+function staged(chunk) {
+  let group = chunk.asset_group;
+  return engineCore(chunk) ? true : chunk.runtime != null && group !== void 0 && !group.startsWith(ENGINE_GROUP_PREFIX);
+}
+function runtimeImage(chunks) {
+  let digests = [], payloads = /* @__PURE__ */ new Map(), named = /* @__PURE__ */ new Map();
+  for (let chunk of chunks) {
+    if (!staged(chunk)) continue;
+    digests.push(chunk.digest), referable(chunk) && payloads.set(chunk.digest, chunk.payload_digest);
+    let name = chunk.runtime.name, part = engineCore(chunk) ? null : PART_SUFFIX.exec(name), base = part === null ? name : name.slice(0, part.index), parts = named.get(base) ?? [];
+    parts.push({ index: part === null ? 0 : Number(part[1]), digest: chunk.digest }), named.set(base, parts);
+  }
+  let files = {};
+  for (let [name, parts] of named) files[name] = parts.sort((a, b) => a.index - b.index).map((p) => p.digest);
+  return { key: digests.join(KEY_SEPARATOR), chunks: digests, payloads, warm: { files } };
+}
+var RuntimePool = class {
+  constructor(factory, source, boot_ms = (1e4)) {
+    this.factory = factory;
+    this.source = source;
+    this.boot_ms = boot_ms;
+    this.slots = /* @__PURE__ */ new Map();
+    this.bodies = /* @__PURE__ */ new Map();
+    this.writer = new MessageWriter();
+  }
+  keyOf(image, interactive) {
+    return this.factory.isolates_interactives === true ? `${image.key}${INTERACTIVE_SEPARATOR}${interactive ?? ""}` : image.key;
+  }
+  warm(chunks, interactive) {
+    let image = runtimeImage(chunksForHost(chunks, null, hostIsolated(), DEFAULT_HOST_TIER, hostThreads())), key = this.keyOf(image, interactive), slot = this.slots.get(key) ?? { guest: null };
+    if (this.slots.set(key, slot), slot.guest !== null) return;
+    let guest = this.stage(image, slot, interactive);
+    slot.guest = guest, guest.then((engine) => {
+      engine === null && slot.guest === guest && (slot.guest = null);
+    });
+  }
+  async warmed(chunks, interactive) {
+    let guest = this.slots.get(this.keyOf(runtimeImage(chunksForHost(chunks, null, hostIsolated(), DEFAULT_HOST_TIER, hostThreads())), interactive))?.guest ?? null;
+    return guest !== null && await guest !== null;
+  }
+  async take(chunks, interactive) {
+    let image = runtimeImage(chunksForHost(chunks, null, hostIsolated(), DEFAULT_HOST_TIER, hostThreads())), slot = this.slots.get(this.keyOf(image, interactive)), guest = slot?.guest ?? null;
+    if (slot === void 0 || guest === null) return null;
+    slot.guest = null;
+    let engine = await guest;
+    return engine === null ? null : { engine, staged: new Set(image.chunks) };
+  }
+  drain() {
+    for (let slot of this.slots.values())
+      slot.guest?.then((engine) => engine?.terminate()), slot.guest = null;
+    this.slots.clear(), this.bodies.clear();
+  }
+  async stage(image, slot, interactive) {
+    let engine = this.factory.spawn(interactive), alive = true, lose = () => {
+    }, lost = new Promise((_, reject) => {
+      lose = reject;
+    });
+    lost.catch(() => {
+    }), engine.on_crash((message) => {
+      alive = false, lose(new Error(message)), engine.terminate();
+      let current = slot.guest;
+      current?.then((held) => {
+        held === engine && slot.guest === current && (slot.guest = null);
+      });
+    });
+    try {
+      let deferred = engine.may_fetch_wasm === !0, eager = deferred ? image.chunks.filter((digest) => !image.payloads.has(digest)) : image.chunks, late = deferred ? image.chunks.filter((digest) => image.payloads.has(digest)) : [], [, bodies] = await Promise.race([Promise.all([this.ready(engine), this.fetch(eager)]), lost]), byUrl = engine.fetches_wasm === !0, lateBodies = byUrl ? [] : await Promise.race([this.fetch(late), lost]), warmed = image.chunks.length > 0 ? this.warmedReply(engine) : null;
+      for (let i = 0; i < bodies.length; i++) this.stageBody(engine, eager[i], bodies[i]);
+      for (let i = 0; i < lateBodies.length; i++) this.stageBody(engine, late[i], lateBodies[i]);
+      if (byUrl)
+        for (let digest of late) {
+          let message = chunkRefMessage(MessageTag.stage_ref, digest, image.payloads.get(digest));
+          engine.send(message, message.length);
+        }
+      return warmed !== null && (engine.send(this.writer.bytes, this.writer.json(MessageTag.warm, image.warm)), await Promise.race([warmed, lost])), alive ? engine : null;
+    } catch {
+      return engine.terminate(), null;
+    }
+  }
+  ready(engine) {
+    return new Promise((resolve, reject) => {
+      let timer = setTimeout(() => reject(new Error("the warm guest did not start in time")), this.boot_ms);
+      engine.on_message((bytes) => {
+        bytes[0] === MessageTag.ready && (clearTimeout(timer), engine.on_message(() => {
+        }), resolve());
+      });
+    });
+  }
+  stageBody(engine, digest, body) {
+    let message = chunkMessage(MessageTag.stage, digest, body);
+    engine.send(message, message.length);
+  }
+  warmedReply(engine) {
+    return new Promise((resolve) => {
+      engine.on_message((bytes) => {
+        if (bytes[0] === MessageTag.chunk_request) {
+          forEachChunkEntry(bytes, CHUNK_REQUEST_ENTRY_BYTES, (digest) => {
+            this.fetch([digest]).then(
+              ([body]) => this.stageBody(engine, digest, body),
+              () => engine.terminate()
+            );
+          });
+          return;
+        }
+        bytes[0] === MessageTag.warmed && (engine.on_message(() => {
+        }), resolve());
+      });
+    });
+  }
+  fetch(digests) {
+    let missing2 = digests.filter((digest) => !this.bodies.has(digest));
+    if (missing2.length > 0) {
+      let fetched = fetchVerified(this.source, missing2);
+      missing2.forEach((digest, i) => {
+        let body = fetched.then((all) => all[i]);
+        body.catch(() => this.bodies.delete(digest)), this.bodies.set(digest, body);
+      });
+    }
+    return Promise.all(digests.map((digest) => this.bodies.get(digest)));
+  }
+};
+
+// src/interactives/hosts/part-store-web.ts
+var PART_STORE_NAME = "cimplify-parts", WEB_DISK_RESERVE_BYTES = 64 * 1024 * 1024, DB_VERSION = 1, BODIES = "bodies", META = "meta", INDEX_KEY = "index", CACHE_PREFIX = "/cimplify-parts/", CACHE_INDEX = `${CACHE_PREFIX}index.json`, OCTETS = "application/octet-stream";
+function request(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result), req.onerror = () => reject(req.error);
+  });
+}
+function done(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve(), tx.onerror = () => reject(tx.error), tx.onabort = () => reject(tx.error);
+  });
+}
+var IndexedDbPartBackend = class _IndexedDbPartBackend {
+  constructor(db) {
+    this.db = db;
+  }
+  static async open(factory, name = PART_STORE_NAME) {
+    let req = factory.open(name, (1));
+    return req.onupgradeneeded = () => {
+      let db = req.result;
+      db.objectStoreNames.contains(BODIES) || db.createObjectStore(BODIES), db.objectStoreNames.contains(META) || db.createObjectStore(META);
+    }, new _IndexedDbPartBackend(await request(req));
+  }
+  async read(digest) {
+    let value = await request(this.db.transaction(BODIES, "readonly").objectStore(BODIES).get(digest));
+    return value === void 0 ? null : new Uint8Array(value);
+  }
+  async write(digest, bytes) {
+    let tx = this.db.transaction(BODIES, "readwrite");
+    tx.objectStore(BODIES).put(bytes.slice().buffer, digest), await done(tx);
+  }
+  async remove(digest) {
+    let tx = this.db.transaction(BODIES, "readwrite");
+    tx.objectStore(BODIES).delete(digest), await done(tx);
+  }
+  async load() {
+    return await request(this.db.transaction(META, "readonly").objectStore(META).get(INDEX_KEY)) ?? null;
+  }
+  async save(snapshot) {
+    let tx = this.db.transaction(META, "readwrite");
+    tx.objectStore(META).put(snapshot, INDEX_KEY), await done(tx);
+  }
+}, CacheStoragePartBackend = class _CacheStoragePartBackend {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  static async open(storage, name = PART_STORE_NAME) {
+    return new _CacheStoragePartBackend(await storage.open(name));
+  }
+  async read(digest) {
+    let hit = await this.cache.match(`${CACHE_PREFIX}${digest}`);
+    return hit === void 0 ? null : new Uint8Array(await hit.arrayBuffer());
+  }
+  write(digest, bytes) {
+    return this.cache.put(`${CACHE_PREFIX}${digest}`, new Response(bytes.slice(), { headers: { "content-type": OCTETS } }));
+  }
+  async remove(digest) {
+    await this.cache.delete(`${CACHE_PREFIX}${digest}`);
+  }
+  async load() {
+    let hit = await this.cache.match(CACHE_INDEX);
+    return hit === void 0 ? null : await hit.json();
+  }
+  save(snapshot) {
+    return this.cache.put(CACHE_INDEX, new Response(JSON.stringify(snapshot), { headers: { "content-type": "application/json" } }));
+  }
+};
+function webStorageDisk(storage = globalThis.navigator?.storage) {
+  if (storage?.estimate !== void 0)
+    return {
+      free_bytes: async () => {
+        let estimate = await storage.estimate();
+        return estimate.quota === void 0 || estimate.usage === void 0 ? null : Math.max(0, estimate.quota - estimate.usage);
+      }
+    };
+}
+async function openWebPartStore(options = {}) {
+  let scope = globalThis, backend = scope.indexedDB !== void 0 ? await IndexedDbPartBackend.open(scope.indexedDB).catch(() => new MemoryPartBackend()) : scope.caches !== void 0 ? await CacheStoragePartBackend.open(scope.caches).catch(() => new MemoryPartBackend()) : new MemoryPartBackend();
+  return SharedPartStore.open(backend, { disk: webStorageDisk(), disk_reserve_bytes: WEB_DISK_RESERVE_BYTES, ...options });
+}
+
+// src/interactives/rooms/links/bridge.ts
+var ROOM_LINK_HEADER_BYTES = 3, ROOM_FRAME_HEADER_BYTES = 4, ROOM_DIAL_HEADER_BYTES = 6, MAX_BRIDGE_LINKS = 64;
+var ROOM_DIALED_OK = 1;
+var TRANSPORT_CODES = [Transport.WebTransport, Transport.WebSocket];
+function transportOf(code) {
+  return TRANSPORT_CODES[code] ?? null;
+}
+function linkOf(bytes) {
+  return bytes[1] | bytes[2] << 8;
+}
+function writeLinkHeader(out, at, tag, link) {
+  out[at] = tag, out[at + 1] = link & 255, out[at + 2] = link >>> 8;
+}
+function writeRoomFrame(port, tag, link, lane, bytes) {
+  let at = port.reserve((4) + bytes.length), out = port.out;
+  writeLinkHeader(out, at, tag, link), out[at + (3)] = lane, out.set(bytes, at + (4)), port.commitFrame();
+}
+function writeRoomSignal(port, tag, link) {
+  writeLinkHeader(port.out, port.reserve((3)), tag, link), port.commitTask();
+}
+new TextEncoder();
+
+// src/interactives/runtime/camera-bridge.ts
+new TextEncoder(); new TextDecoder();
+
+// src/interactives/clips/mp4.ts
+var CLIP_MP4_TYPE = "video/mp4";
+var UNITY_MATRIX = [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824], BRANDS = ["isom", "iso6", "avc1", "mp41"], VIDEO_HANDLER = "VideoHandler", AUDIO_HANDLER = "SoundHandler";
+function clipDurationMs(plan) {
+  let { ring, from, to } = plan.video.range;
+  return to <= from ? 0 : Math.round((ring.time(to - 1) + ring.duration(to - 1) - ring.time(from)) / 1e3);
+}
+var BoxWriter = class {
+  constructor() {
+    this.at = 0;
+    this.view = null;
+    this.bytes = null;
+    this.base = 0;
+  }
+  target(bytes, base) {
+    this.bytes = bytes, this.view = bytes === null ? null : new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), this.base = base, this.at = 0;
+  }
+  u8(value) {
+    this.view?.setUint8(this.base + this.at, value), this.at += 1;
+  }
+  u16(value) {
+    this.view?.setUint16(this.base + this.at, value, false), this.at += 2;
+  }
+  i16(value) {
+    this.view?.setInt16(this.base + this.at, value, false), this.at += 2;
+  }
+  u24(value) {
+    this.u8(value >>> 16 & 255), this.u16(value & 65535);
+  }
+  u32(value) {
+    this.view?.setUint32(this.base + this.at, value >>> 0, false), this.at += 4;
+  }
+  i32(value) {
+    this.view?.setInt32(this.base + this.at, value, false), this.at += 4;
+  }
+  u64(value) {
+    this.u32(Math.floor(value / 4294967296)), this.u32(value >>> 0);
+  }
+  zeros(count) {
+    this.bytes !== null && this.bytes.fill(0, this.base + this.at, this.base + this.at + count), this.at += count;
+  }
+  ascii(text2) {
+    for (let i = 0; i < text2.length; i++) this.u8(text2.charCodeAt(i));
+  }
+  bytesFrom(source, from, length) {
+    this.bytes !== null && this.bytes.set(source.subarray(from, from + length), this.base + this.at), this.at += length;
+  }
+  box(type, body) {
+    let start = this.at;
+    this.u32(0), this.ascii(type), body(), this.view?.setUint32(this.base + start, this.at - start, false);
+  }
+  full(type, version, flags, body) {
+    this.box(type, () => {
+      this.u8(version), this.u24(flags), body();
+    });
+  }
+  patch32(at, value) {
+    this.view?.setInt32(this.base + at, value, false);
+  }
+};
+function scaled(us, timescale) {
+  return Math.round(us * timescale / 1e6);
+}
+function audioTimescale(track) {
+  return track.codec === "opus" ? 48e3 : track.sample_rate;
+}
+function descriptorLength(w, length) {
+  if (length <= 127) {
+    w.u8(length);
+    return;
+  }
+  w.u8(128 | length >>> 21 & 127), w.u8(128 | length >>> 14 & 127), w.u8(128 | length >>> 7 & 127), w.u8(length & 127);
+}
+function descriptorBytes(length) {
+  return length <= 127 ? 1 : 4;
+}
+var Mp4Writer = class {
+  constructor(plan) {
+    this.plan = plan;
+    this.w = new BoxWriter();
+  }
+  size() {
+    return this.w.target(null, 0), this.write(), this.w.at;
+  }
+  into(out, at) {
+    return this.w.target(out, at), this.write(), this.w.at;
+  }
+  write() {
+    let w = this.w;
+    w.box("ftyp", () => {
+      w.ascii("isom"), w.u32(512);
+      for (let brand of BRANDS) w.ascii(brand);
+    }), this.moov();
+    let moofAt = w.at, offsets = this.moof(), mdatPayload = w.at + 8 - moofAt;
+    w.patch32(offsets.video, mdatPayload), offsets.audio >= 0 && w.patch32(offsets.audio, mdatPayload + this.rangeBytes(this.plan.video.range)), this.mdat();
+  }
+  durationMs() {
+    return clipDurationMs(this.plan);
+  }
+  moov() {
+    let w = this.w, plan = this.plan;
+    w.box("moov", () => {
+      w.full("mvhd", 0, 0, () => {
+        w.u32(0), w.u32(0), w.u32(1e3), w.u32(0), w.u32(65536), w.u16(256), w.zeros(10);
+        for (let value of UNITY_MATRIX) w.u32(value);
+        w.zeros(24), w.u32(plan.audio === null ? 2 : 3);
+      }), this.videoTrak(), plan.audio !== null && this.audioTrak(plan.audio.track), w.box("mvex", () => {
+        w.full("mehd", 0, 0, () => w.u32(this.durationMs())), this.trex(1), plan.audio !== null && this.trex(2);
+      });
+    });
+  }
+  trex(track) {
+    let w = this.w;
+    w.full("trex", 0, 0, () => {
+      w.u32(track), w.u32(1), w.u32(0), w.u32(0), w.u32(0);
+    });
+  }
+  tkhd(track, audio, width, height) {
+    let w = this.w;
+    w.full("tkhd", 0, 3, () => {
+      w.u32(0), w.u32(0), w.u32(track), w.u32(0), w.u32(0), w.zeros(8), w.u16(0), w.u16(audio ? 1 : 0), w.u16(audio ? 256 : 0), w.u16(0);
+      for (let value of UNITY_MATRIX) w.u32(value);
+      w.u32(width * 65536), w.u32(height * 65536);
+    });
+  }
+  mdhd(timescale) {
+    let w = this.w;
+    w.full("mdhd", 0, 0, () => {
+      w.u32(0), w.u32(0), w.u32(timescale), w.u32(0), w.u16(21956), w.u16(0);
+    });
+  }
+  hdlr(handler, name) {
+    let w = this.w;
+    w.full("hdlr", 0, 0, () => {
+      w.u32(0), w.ascii(handler), w.zeros(12), w.ascii(name), w.u8(0);
+    });
+  }
+  dinf() {
+    let w = this.w;
+    w.box("dinf", () => {
+      w.full("dref", 0, 0, () => {
+        w.u32(1), w.full("url ", 0, 1, () => {
+        });
+      });
+    });
+  }
+  emptyTables() {
+    let w = this.w;
+    w.full("stts", 0, 0, () => w.u32(0)), w.full("stsc", 0, 0, () => w.u32(0)), w.full("stsz", 0, 0, () => {
+      w.u32(0), w.u32(0);
+    }), w.full("stco", 0, 0, () => w.u32(0));
+  }
+  videoTrak() {
+    let w = this.w, track = this.plan.video.track;
+    w.box("trak", () => {
+      this.tkhd(1, false, track.width, track.height), w.box("mdia", () => {
+        this.mdhd(9e4), this.hdlr("vide", VIDEO_HANDLER), w.box("minf", () => {
+          w.full("vmhd", 0, 1, () => w.zeros(8)), this.dinf(), w.box("stbl", () => {
+            w.full("stsd", 0, 0, () => {
+              w.u32(1), w.box("avc1", () => {
+                w.zeros(6), w.u16(1), w.zeros(16), w.u16(track.width), w.u16(track.height), w.u32(4718592), w.u32(4718592), w.u32(0), w.u16(1), w.zeros(32), w.u16(24), w.u16(65535), w.box("avcC", () => w.bytesFrom(track.description, 0, track.description.length));
+              });
+            }), this.emptyTables();
+          });
+        });
+      });
+    });
+  }
+  audioTrak(track) {
+    let w = this.w;
+    w.box("trak", () => {
+      this.tkhd(2, true, 0, 0), w.box("mdia", () => {
+        this.mdhd(audioTimescale(track)), this.hdlr("soun", AUDIO_HANDLER), w.box("minf", () => {
+          w.full("smhd", 0, 0, () => w.zeros(4)), this.dinf(), w.box("stbl", () => {
+            w.full("stsd", 0, 0, () => {
+              w.u32(1), w.box(track.codec === "opus" ? "Opus" : "mp4a", () => {
+                w.zeros(6), w.u16(1), w.zeros(8), w.u16(track.channels), w.u16(16), w.u32(0), w.u32((track.codec === "opus" ? 48e3 : track.sample_rate) * 65536), track.codec === "opus" ? this.dops(track) : this.esds(track);
+              });
+            }), this.emptyTables();
+          });
+        });
+      });
+    });
+  }
+  esds(track) {
+    let w = this.w, config = track.description ?? new Uint8Array(0), decoder7 = 13 + (1 + descriptorBytes(config.length) + config.length), es = 4 + descriptorBytes(decoder7) + decoder7 + 3;
+    w.full("esds", 0, 0, () => {
+      w.u8(3), descriptorLength(w, es), w.u16(2), w.u8(0), w.u8(4), descriptorLength(w, decoder7), w.u8(64), w.u8(21), w.u24(0), w.u32(0), w.u32(0), w.u8(5), descriptorLength(w, config.length), w.bytesFrom(config, 0, config.length), w.u8(6), w.u8(1), w.u8(2);
+    });
+  }
+  dops(track) {
+    let w = this.w, head = track.description, parsed = head !== null && head.length >= 19 ? new DataView(head.buffer, head.byteOffset, head.byteLength) : null;
+    w.box("dOps", () => {
+      w.u8(0), w.u8(parsed === null ? track.channels : parsed.getUint8(9)), w.u16(parsed === null ? 312 : parsed.getUint16(10, true)), w.u32(parsed === null ? track.sample_rate : parsed.getUint32(12, true)), w.i16(parsed === null ? 0 : parsed.getInt16(16, true)), w.u8(parsed === null ? 0 : parsed.getUint8(18));
+    });
+  }
+  rangeBytes(range) {
+    let total = 0;
+    for (let i = range.from; i < range.to; i++) total += range.ring.length(i);
+    return total;
+  }
+  moof() {
+    let w = this.w, plan = this.plan, start = plan.video.range.ring.time(plan.video.range.from), video = 0, audio = -1;
+    return w.box("moof", () => {
+      w.full("mfhd", 0, 0, () => w.u32(1)), video = this.traf(1, plan.video.range, 9e4, start, true), plan.audio !== null && (audio = this.traf(2, plan.audio.range, audioTimescale(plan.audio.track), start, false));
+    }), { video, audio };
+  }
+  traf(track, range, timescale, start_us, video) {
+    let w = this.w, ring = range.ring, dataOffset = 0;
+    return w.box("traf", () => {
+      w.full("tfhd", 0, 131072, () => w.u32(track));
+      let first = range.to > range.from ? ring.time(range.from) : start_us;
+      w.full("tfdt", 1, 0, () => w.u64(Math.max(0, scaled(first - start_us, timescale)))), w.full("trun", 0, video ? 1793 : 769, () => {
+        w.u32(range.to - range.from), dataOffset = w.at, w.i32(0);
+        for (let i = range.from; i < range.to; i++) {
+          let at = scaled(ring.time(i) - first, timescale), end = i + 1 < range.to ? scaled(ring.time(i + 1) - first, timescale) : scaled(ring.time(i) + ring.duration(i) - first, timescale);
+          w.u32(Math.max(1, end - at)), w.u32(ring.length(i)), video && w.u32(ring.key(i) ? 33554432 : 16842752);
+        }
+      });
+    }), dataOffset;
+  }
+  mdat() {
+    let w = this.w, plan = this.plan;
+    w.box("mdat", () => {
+      this.samples(plan.video.range), plan.audio !== null && this.samples(plan.audio.range);
+    });
+  }
+  samples(range) {
+    let ring = range.ring;
+    for (let i = range.from; i < range.to; i++) this.w.bytesFrom(ring.arena, ring.offset(i), ring.length(i));
+  }
+};
+function muxMp4(plan) {
+  let writer = new Mp4Writer(plan), out = new Uint8Array(writer.size());
+  return writer.into(out, 0), out;
+}
+
+// src/interactives/clips/ring.ts
+var EncodedRing = class {
+  constructor(options) {
+    this.head = 0;
+    this.size = 0;
+    this.writePage = 0;
+    this.dropped = 0;
+    let pageBytes = options.page_bytes ?? 1024, pageCount = Math.max(1, Math.ceil(options.capacity_bytes / pageBytes));
+    this.pageBytes = pageBytes, this.arena = new Uint8Array(pageCount * pageBytes), this.pages = [];
+    for (let page = 0; page < pageCount; page++) this.pages.push(this.arena.subarray(page * pageBytes));
+    this.maxSamples = options.max_samples, this.starts = new Uint32Array(options.max_samples), this.lengths = new Uint32Array(options.max_samples), this.times = new Float64Array(options.max_samples), this.durations = new Float64Array(options.max_samples), this.keys = new Uint8Array(options.max_samples);
+  }
+  get count() {
+    return this.size;
+  }
+  get pageCount() {
+    return this.pages.length;
+  }
+  slot(index) {
+    return (this.head + index) % this.maxSamples;
+  }
+  push(sample, time_us, duration_us, key) {
+    let length = sample.byteLength, pageCount = this.pages.length, need = Math.ceil(length / this.pageBytes) || 1;
+    if (need > pageCount)
+      return this.dropped++, false;
+    this.size === 0 && (this.writePage = 0);
+    let from = this.writePage, wraps = from + need > pageCount, span = wraps ? pageCount - from + need : need;
+    for (; this.size > 0 && (this.size === this.maxSamples || (this.starts[this.head] - from + pageCount) % pageCount < span); ) this.evict();
+    let start = wraps ? 0 : from;
+    sample.copyTo(this.pages[start]);
+    let slot = this.slot(this.size);
+    this.starts[slot] = start, this.lengths[slot] = length, this.times[slot] = time_us, this.durations[slot] = duration_us, this.keys[slot] = key ? 1 : 0, this.size++;
+    let end = start + need;
+    return this.writePage = end === pageCount ? 0 : end, true;
+  }
+  evict() {
+    this.head = (this.head + 1) % this.maxSamples, this.size--;
+  }
+  retain(window_us) {
+    if (this.size === 0) return;
+    let cutoff = this.endUs() - window_us;
+    for (; ; ) {
+      let next = this.nextKey(1);
+      if (next === -1 || this.times[this.slot(next)] > cutoff) return;
+      for (let i = 0; i < next; i++) this.evict();
+    }
+  }
+  nextKey(from) {
+    for (let i = from; i < this.size; i++) if (this.keys[this.slot(i)] === 1) return i;
+    return -1;
+  }
+  endUs() {
+    if (this.size === 0) return 0;
+    let last = this.slot(this.size - 1);
+    return this.times[last] + this.durations[last];
+  }
+  startFor(keep_us) {
+    if (this.size === 0) return -1;
+    let target = this.endUs() - keep_us, chosen = this.nextKey(0);
+    if (chosen === -1) return -1;
+    for (let i = chosen + 1; i < this.size; i++) {
+      let slot = this.slot(i);
+      if (this.times[slot] > target) break;
+      this.keys[slot] === 1 && (chosen = i);
+    }
+    return chosen;
+  }
+  firstAtOrAfter(time_us) {
+    for (let i = 0; i < this.size; i++) if (this.times[this.slot(i)] >= time_us) return i;
+    return -1;
+  }
+  offset(index) {
+    return this.starts[this.slot(index)] * this.pageBytes;
+  }
+  length(index) {
+    return this.lengths[this.slot(index)];
+  }
+  time(index) {
+    return this.times[this.slot(index)];
+  }
+  duration(index) {
+    return this.durations[this.slot(index)];
+  }
+  key(index) {
+    return this.keys[this.slot(index)] === 1;
+  }
+  clear() {
+    this.head = 0, this.size = 0, this.writePage = 0;
+  }
+};
+
+// src/interactives/runtime/font-bridge.ts
+var FONT_TAG_BYTES = 1, FONT_WORD_BYTES = 4, FONT_ID_AT = (1), FONT_CODEPOINT_AT = FONT_ID_AT + (4), FONT_REQUEST_BYTES = FONT_CODEPOINT_AT + (4), FONT_REPLY_HEADER_BYTES = FONT_ID_AT + (4);
+
+// src/game/text/fallback-fonts.ts
+var MANIFEST_VERSION = 1, MANIFEST_FILE = "manifest.json", NOTO_FALLBACK_PATH = `fonts/noto/v${(1)}/`, HEX = 16, HEX_DIGITS = 2, SECURE_PROTOCOL = "https:", LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+function notoFallbackBase(cdnBase) {
+  return new URL(NOTO_FALLBACK_PATH, cdnBase.endsWith("/") ? cdnBase : `${cdnBase}/`).href;
+}
+function hex2(bytes) {
+  let out = "";
+  for (let byte of bytes) out += byte.toString((16)).padStart((2), "0");
+  return out;
+}
+function sha256Hex2(bytes) {
+  let digest = new Uint8Array(SHA256_BYTES);
+  return sha256Into(bytes, digest), hex2(digest);
+}
+function covers(face, codepoint) {
+  let ranges = face.ranges, low = 0, high = ranges.length;
+  for (; low < high; ) {
+    let middle = low + high >>> 1;
+    ranges[middle][1] < codepoint ? low = middle + 1 : high = middle;
+  }
+  return low < ranges.length && ranges[low][0] <= codepoint;
+}
+function languageRank(face, language) {
+  if (face.language === null) return 1;
+  let wanted = language.toLowerCase(), own = face.language.toLowerCase();
+  return wanted === own || wanted.startsWith(`${own}-`) || own === "zh-hant" && (wanted === "zh-tw" || wanted === "zh-hk" || wanted === "zh-mo") || own === "zh-hans" && wanted === "zh" ? 0 : 2;
+}
+function pickNotoFace(manifest, codepoint, language = "") {
+  let best = null, bestRank = Number.POSITIVE_INFINITY;
+  for (let face of manifest.faces) {
+    if (!covers(face, codepoint)) continue;
+    let rank = languageRank(face, language);
+    rank < bestRank && (best = face, bestRank = rank);
+  }
+  return best;
+}
+function checkBase(base) {
+  let url = new URL(base);
+  if (url.protocol !== SECURE_PROTOCOL && !LOOPBACK_HOSTS.includes(url.hostname))
+    throw new Error(`fallback faces come only from the CDN over TLS, not ${base}`);
+}
+function notoFallbackSource(base, fetcher, options = {}) {
+  checkBase(base);
+  let root = base.endsWith("/") ? base : `${base}/`, manifest = null, loaded = /* @__PURE__ */ new Map(), readManifest = () => {
+    manifest ?? (manifest = fetcher(new URL(MANIFEST_FILE, root).href).then(
+      async (response) => {
+        if (!response.ok) return null;
+        let parsed = JSON.parse(new TextDecoder().decode(await response.arrayBuffer()));
+        return parsed.version === (1) ? parsed : null;
+      },
+      () => null
+    ));
+    let current = manifest;
+    return current.then((found) => {
+      found === null && manifest === current && (manifest = null);
+    }), current;
+  };
+  return async (codepoint) => {
+    let found = await readManifest();
+    if (found === null) return null;
+    let face = pickNotoFace(found, codepoint, options.language);
+    if (face === null) return null;
+    let pending = loaded.get(face.file);
+    if (pending === void 0) {
+      pending = fetcher(new URL(face.file, root).href).then(
+        async (response) => {
+          if (!response.ok) return null;
+          let bytes = new Uint8Array(await response.arrayBuffer());
+          return bytes.byteLength === face.bytes && sha256Hex2(bytes) === face.sha256 ? bytes : null;
+        },
+        () => null
+      ), loaded.set(face.file, pending);
+      let current = pending;
+      current.then((bytes) => {
+        bytes === null && loaded.get(face.file) === current && loaded.delete(face.file);
+      });
+    }
+    return pending;
+  };
+}
+new TextEncoder(); new TextDecoder();
+var TRUE = "true", LIVE_POLITE = "polite";
+(() => {
+  let roles = [];
+  return roles[UiRole.none] = null, roles[UiRole.group] = "group", roles[UiRole.text] = null, roles[UiRole.button] = "button", roles[UiRole.image] = "img", roles[UiRole.header] = "heading", roles[UiRole.link] = "link", roles[UiRole.adjustable] = "slider", roles[UiRole.tab] = "tab", roles[UiRole.tab_list] = "tablist", roles[UiRole.progress] = "progressbar", roles[UiRole.text_field] = "textbox", roles[UiRole.scroll_view] = "region", roles[UiRole.alert] = "alert", roles;
+})(); [
+  [UiTrait.selected, "aria-selected", TRUE],
+  [UiTrait.disabled, "aria-disabled", TRUE],
+  [UiTrait.hidden, "aria-hidden", TRUE],
+  [UiTrait.live, "aria-live", LIVE_POLITE],
+  [UiTrait.modal, "aria-modal", TRUE]
+];
+new TextDecoder();
+
+// src/interactives/runtime/game-ui/host.ts
+new TextDecoder(); new TextEncoder();
+
+// src/interactives/runtime/port-bridge.ts
+function animationFrameScheduler(scope = globalThis) {
+  let raf = scope.requestAnimationFrame?.bind(scope);
+  return {
+    task: (flush) => queueMicrotask(flush),
+    frame: raf === void 0 ? (flush) => queueMicrotask(flush) : (flush) => {
+      raf(flush);
+    }
+  };
+}
+var PortBridge = class {
+  constructor(port, scheduler) {
+    this.port = port;
+    this.scheduler = scheduler;
+    this.free = [];
+    this.transfer = [new ArrayBuffer(0)];
+    this.listener = () => {
+    };
+    this.buffer = null;
+    this.bytes = new Uint8Array(0);
+    this.view = new DataView(new ArrayBuffer(4));
+    this.used = 4;
+    this.taskPending = false;
+    this.framePending = false;
+    this.allocatedCount = 0;
+    this.batchCount = 0;
+    this.recordCount = 0;
+    this.flushTask = () => {
+      this.taskPending = false, this.flush();
+    };
+    this.flushFrame = () => {
+      this.framePending = false, this.flush();
+    };
+    port.addEventListener("message", (event) => this.receive(event.data)), port.start?.();
+  }
+  get stats() {
+    return { allocated: this.allocatedCount, batches: this.batchCount, records: this.recordCount };
+  }
+  get pooled() {
+    return this.free.length;
+  }
+  on_message(listener) {
+    this.listener = listener;
+  }
+  send(bytes, length) {
+    this.write(bytes, length), this.scheduleTask();
+  }
+  sendFrame(bytes, length) {
+    this.write(bytes, length), this.scheduleFrame();
+  }
+  write(bytes, length) {
+    let at = this.reserve(length);
+    this.bytes.set(bytes.subarray(0, length), at);
+  }
+  reserve(length) {
+    let needed = 4 + length;
+    if (4 + needed > 65536) return this.dedicated(length);
+    (this.buffer === null || this.used + needed > 65536) && (this.flush(), this.open()), this.view.setUint32(this.used, length, true);
+    let at = this.used + 4;
+    return this.used += needed, this.recordCount++, at;
+  }
+  get out() {
+    return this.bytes;
+  }
+  commitFrame() {
+    this.scheduleFrame();
+  }
+  commitTask() {
+    this.scheduleTask();
+  }
+  dedicated(length) {
+    this.flush();
+    let buffer = new ArrayBuffer(8 + length);
+    return this.buffer = buffer, this.bytes = new Uint8Array(buffer), this.view = new DataView(buffer), this.view.setUint32(4, length, true), this.used = buffer.byteLength, this.recordCount++, 8;
+  }
+  open() {
+    let buffer = this.free.pop();
+    buffer === void 0 && (buffer = new ArrayBuffer(65536), this.allocatedCount++), this.buffer = buffer, this.bytes = new Uint8Array(buffer), this.view = new DataView(buffer), this.used = 4;
+  }
+  scheduleTask() {
+    this.taskPending || (this.taskPending = true, this.scheduler.task(this.flushTask));
+  }
+  scheduleFrame() {
+    this.framePending || this.taskPending || (this.framePending = true, this.scheduler.frame(this.flushFrame));
+  }
+  flush() {
+    let buffer = this.buffer;
+    buffer === null || this.used === 4 || (this.view.setUint32(0, this.used, true), this.buffer = null, this.used = 4, this.batchCount++, this.post(buffer));
+  }
+  post(buffer) {
+    this.transfer[0] = buffer, this.port.postMessage(buffer, this.transfer);
+  }
+  receive(buffer) {
+    if (buffer.byteLength < 4) return;
+    let view = new DataView(buffer), header = view.getUint32(0, true);
+    if (header === 0) {
+      buffer.byteLength === 65536 && this.free.push(buffer);
+      return;
+    }
+    let used = Math.min(header, buffer.byteLength), at = 4;
+    for (; at + 4 <= used; ) {
+      let length = view.getUint32(at, true);
+      at += 4, this.listener(new Uint8Array(buffer, at, length)), at += length;
+    }
+    buffer.byteLength === 65536 && (view.setUint32(0, 0, true), this.post(buffer));
+  }
+};
+
+// src/interactives/runtime/canvas-entry.ts
+var HEARTBEAT_BYTES = 16, HEARTBEAT_COUNT_WORD = 0, HEARTBEAT_HEAP_OFFSET = 8;
+
+// src/interactives/hosts/clip-relay.ts
+var ClipRelay = class {
+  constructor(port) {
+    this.port = port;
+    this.writer = new MessageWriter(256);
+    this.pauseMessage = new Uint8Array(CLIP_PAUSE_BYTES);
+    this.saveMessage = new Uint8Array(CLIP_SAVE_BYTES);
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.live = false;
+    this.listener = () => {
+    };
+    this.closed = false;
+  }
+  get camera_live() {
+    return this.live;
+  }
+  on_camera_live(listener) {
+    this.listener = listener;
+  }
+  cameraLive(live) {
+    this.live !== live && (this.live = live, this.listener(live));
+  }
+  arm(config) {
+    if (!this.closed) {
+      if (config === null) {
+        this.writer.bytes[0] = MessageTag.clip_arm, this.port.send(this.writer.bytes, 1);
+        return;
+      }
+      this.port.send(this.writer.bytes, this.writer.json(MessageTag.clip_arm, config));
+    }
+  }
+  pause(paused) {
+    this.closed || this.port.send(this.pauseMessage, writeClipPause(this.pauseMessage, paused));
+  }
+  save(keep_ms) {
+    if (this.closed) return Promise.resolve(null);
+    let id = this.nextId;
+    return this.nextId = this.nextId + 1 >>> 0 || 1, new Promise((resolve) => {
+      this.pending.set(id, resolve), this.port.send(this.saveMessage, writeClipSave(this.saveMessage, id, keep_ms));
+    });
+  }
+  handle(bytes) {
+    if (bytes[0] !== MessageTag.clip_saved) return false;
+    let saved = readClipSaved(bytes);
+    if (saved === null) return true;
+    let header = saved.header, resolve = this.pending.get(header.id);
+    return resolve === void 0 ? true : (this.pending.delete(header.id), header.status !== ClipStatus.saved || saved.body.length === 0 ? (resolve(null), true) : (resolve({
+      blob: new Blob([saved.body], { type: header.type }),
+      type: header.type,
+      duration_ms: header.duration_ms,
+      width: header.width,
+      height: header.height
+    }), true));
+  }
+  shutdown() {
+    this.closed = true;
+    for (let resolve of this.pending.values()) resolve(null);
+    this.pending.clear();
+  }
+};
+
+// src/interactives/runtime/face-arkit.ts
+var expression = (name) => FACE_LAYOUT.expressions.indexOf(name), weight = (name) => FACE_LAYOUT.arkit.indexOf(name), ARKIT_WEIGHTS = FACE_LAYOUT.arkit.length, DERIVED_WEIGHTS = Int32Array.of(
+  weight("mouth_smile_left"),
+  weight("mouth_smile_right"),
+  weight("jaw_open"),
+  weight("eye_blink_left"),
+  weight("eye_blink_right"),
+  weight("brow_inner_up"),
+  weight("brow_outer_up_left"),
+  weight("brow_outer_up_right"),
+  weight("mouth_pucker")
+), DERIVED_SOURCES = Int32Array.of(
+  expression("smile"),
+  expression("smile"),
+  expression("jaw_open"),
+  expression("blink_left"),
+  expression("blink_right"),
+  expression("brow_raise"),
+  expression("brow_raise"),
+  expression("brow_raise"),
+  expression("pucker")
+);
+function deriveArkit(expressions, out) {
+  out.fill(0, 0, ARKIT_WEIGHTS);
+  for (let i = 0; i < DERIVED_WEIGHTS.length; i++) out[DERIVED_WEIGHTS[i]] = expressions[DERIVED_SOURCES[i]];
+}
+var UPPER = /[A-Z]/g;
+function arkitIndex(blendshape) {
+  let snake = blendshape.replace(UPPER, (letter) => `_${letter.toLowerCase()}`);
+  return FACE_LAYOUT.arkit.indexOf(snake);
+}
+
+// src/interactives/runtime/face-canonical.ts
+var CANONICAL_FACE = Float32Array.of(
+  0,
+  -3.406404,
+  5.979507,
+  0,
+  -1.126865,
+  7.475604,
+  0,
+  -2.089024,
+  6.058267,
+  -0.463928,
+  0.955357,
+  6.633583,
+  0,
+  -0.46317,
+  7.58658,
+  0,
+  0.365669,
+  7.24287,
+  0,
+  2.473255,
+  5.788627,
+  -4.253081,
+  2.577646,
+  3.279702,
+  0,
+  4.019042,
+  5.284764,
+  0,
+  4.885979,
+  5.385258,
+  0,
+  8.261778,
+  4.481535,
+  0,
+  -3.706811,
+  5.864924,
+  0,
+  -3.918301,
+  5.56943,
+  0,
+  -3.994436,
+  5.219482,
+  0,
+  -4.5424,
+  5.404754,
+  0,
+  -4.745577,
+  5.529457,
+  0,
+  -5.019567,
+  5.601448,
+  0,
+  -5.365123,
+  5.535441,
+  0,
+  -6.149624,
+  5.071372,
+  0,
+  -1.501095,
+  7.112196,
+  -0.416106,
+  -1.466449,
+  6.447657,
+  -7.08796,
+  5.434801,
+  0.09962,
+  -2.628639,
+  2.035898,
+  3.848121,
+  -3.198363,
+  1.985815,
+  3.796952,
+  -3.775151,
+  2.039402,
+  3.646194,
+  -4.465819,
+  2.42295,
+  3.155168,
+  -2.164289,
+  2.189867,
+  3.851822,
+  -3.208229,
+  3.223926,
+  4.115822,
+  -2.673803,
+  3.205337,
+  4.092203,
+  -3.745193,
+  3.165286,
+  3.972409,
+  -4.161018,
+  3.059069,
+  3.719554,
+  -5.062006,
+  1.934418,
+  2.776093,
+  -2.266659,
+  -7.425768,
+  4.389812,
+  -4.445859,
+  2.663991,
+  3.173422,
+  -7.21453,
+  2.263009,
+  0.07315,
+  -5.799793,
+  2.349546,
+  2.204059,
+  -2.844939,
+  -0.720868,
+  4.43313,
+  -0.711452,
+  -3.329355,
+  5.877044,
+  -0.606033,
+  -3.924562,
+  5.444923,
+  -1.431615,
+  -3.500953,
+  5.496189,
+  -1.91491,
+  -3.803146,
+  5.02893,
+  -1.131043,
+  -3.973937,
+  5.189648,
+  -1.563548,
+  -4.082763,
+  4.842263,
+  -2.650112,
+  -5.003649,
+  4.188483,
+  -0.427049,
+  -1.094134,
+  7.360529,
+  -0.496396,
+  -0.475659,
+  7.440358,
+  -5.253307,
+  3.881582,
+  3.363159,
+  -1.718698,
+  0.974609,
+  4.558359,
+  -1.608635,
+  -0.942516,
+  5.814193,
+  -1.651267,
+  -0.610868,
+  5.581319,
+  -4.765501,
+  -0.701554,
+  3.534632,
+  -0.478306,
+  0.295766,
+  7.101013,
+  -3.734964,
+  4.50823,
+  4.550454,
+  -4.588603,
+  4.302037,
+  4.048484,
+  -6.279331,
+  6.615427,
+  1.42585,
+  -1.220941,
+  4.142165,
+  5.106035,
+  -2.193489,
+  3.100317,
+  4.000575,
+  -3.102642,
+  -4.352984,
+  4.095905,
+  -6.719682,
+  -4.788645,
+  -1.745401,
+  -1.193824,
+  -1.306795,
+  5.737747,
+  -0.729766,
+  -1.593712,
+  5.833208,
+  -2.456206,
+  -4.342621,
+  4.283884,
+  -2.204823,
+  -4.304508,
+  4.162499,
+  -4.985894,
+  4.802461,
+  3.751977,
+  -1.592294,
+  -1.257709,
+  5.456949,
+  -2.644548,
+  4.524654,
+  4.921559,
+  -2.760292,
+  5.100971,
+  5.01599,
+  -3.523964,
+  8.005976,
+  3.729163,
+  -5.599763,
+  5.71547,
+  2.724259,
+  -3.063932,
+  6.566144,
+  4.529981,
+  -5.720968,
+  4.254584,
+  2.830852,
+  -6.374393,
+  4.78559,
+  1.591691,
+  -0.672728,
+  -3.688016,
+  5.737804,
+  -1.26256,
+  -3.787691,
+  5.417779,
+  -1.732553,
+  -3.952767,
+  5.000579,
+  -1.043625,
+  -1.464973,
+  5.662455,
+  -2.321234,
+  -4.329069,
+  4.258156,
+  -2.056846,
+  -4.477671,
+  4.520883,
+  -2.153084,
+  -4.276322,
+  4.038093,
+  -0.946874,
+  -1.035249,
+  6.512274,
+  -1.469132,
+  -4.036351,
+  4.604908,
+  -1.02434,
+  -3.989851,
+  4.926693,
+  -0.533422,
+  -3.993222,
+  5.138202,
+  -0.76972,
+  -6.095394,
+  4.985883,
+  -0.699606,
+  -5.29185,
+  5.448304,
+  -0.669687,
+  -4.94977,
+  5.509612,
+  -0.630947,
+  -4.695101,
+  5.449371,
+  -0.583218,
+  -4.517982,
+  5.339869,
+  -1.53717,
+  -4.423206,
+  4.74547,
+  -1.6156,
+  -4.475942,
+  4.813632,
+  -1.729053,
+  -4.61868,
+  4.854463,
+  -1.838624,
+  -4.828746,
+  4.823737,
+  -2.36825,
+  -3.106237,
+  4.868096,
+  -7.542244,
+  -1.049282,
+  -2.431321,
+  0,
+  -1.724003,
+  6.60139,
+  -1.826614,
+  -4.399531,
+  4.399021,
+  -1.929558,
+  -4.411831,
+  4.497052,
+  -0.597442,
+  -2.013686,
+  5.866456,
+  -1.405627,
+  -1.714196,
+  5.241087,
+  -0.662449,
+  -1.819321,
+  5.863759,
+  -2.34234,
+  0.572222,
+  4.294303,
+  -3.327324,
+  0.104863,
+  4.11386,
+  -1.726175,
+  -0.919165,
+  5.273355,
+  -5.133204,
+  7.485602,
+  2.660442,
+  -4.538641,
+  6.319907,
+  3.683424,
+  -3.986562,
+  5.109487,
+  4.466315,
+  -2.169681,
+  -5.440433,
+  4.455874,
+  -1.395634,
+  5.011963,
+  5.316032,
+  -1.6195,
+  6.599217,
+  4.921106,
+  -1.891399,
+  8.236377,
+  4.274997,
+  -4.195832,
+  2.235205,
+  3.375099,
+  -5.733342,
+  1.411738,
+  2.431726,
+  -1.859887,
+  2.355757,
+  3.843181,
+  -4.988612,
+  3.074654,
+  3.083858,
+  -1.303263,
+  1.416453,
+  4.831091,
+  -1.305757,
+  -0.672779,
+  6.415959,
+  -6.46517,
+  0.937119,
+  1.689873,
+  -5.258659,
+  0.945811,
+  2.974312,
+  -4.432338,
+  0.722096,
+  3.522615,
+  -3.300681,
+  0.861641,
+  3.872784,
+  -2.430178,
+  1.131492,
+  4.039035,
+  -1.820731,
+  1.467954,
+  4.224124,
+  -0.563221,
+  2.307693,
+  5.566789,
+  -6.338145,
+  -0.529279,
+  1.881175,
+  -5.587698,
+  3.208071,
+  2.687839,
+  -0.242624,
+  -1.462857,
+  7.071491,
+  -1.611251,
+  0.339326,
+  4.895421,
+  -7.743095,
+  2.364999,
+  -2.005167,
+  -1.391142,
+  1.851048,
+  4.448999,
+  -1.785794,
+  -0.978284,
+  4.85047,
+  -4.670959,
+  2.664461,
+  3.084075,
+  -1.33397,
+  -0.283761,
+  6.097047,
+  -7.270895,
+  -2.890917,
+  -2.252455,
+  -1.856432,
+  2.585245,
+  3.757904,
+  -0.923388,
+  0.073076,
+  6.671944,
+  -5.000589,
+  -6.135128,
+  1.892523,
+  -5.085276,
+  -7.17859,
+  0.714711,
+  -7.159291,
+  -0.81182,
+  -0.072044,
+  -5.843051,
+  -5.248023,
+  0.924091,
+  -6.847258,
+  3.662916,
+  0.724695,
+  -2.412942,
+  -8.258853,
+  4.119213,
+  -0.179909,
+  -1.689864,
+  6.573301,
+  -2.103655,
+  -0.163946,
+  4.566119,
+  -6.407571,
+  2.236021,
+  1.560843,
+  -3.670075,
+  2.360153,
+  3.63523,
+  -3.177186,
+  2.294265,
+  3.775704,
+  -2.196121,
+  -4.598322,
+  4.479786,
+  -6.234883,
+  -1.94443,
+  1.663542,
+  -1.292924,
+  -9.29592,
+  4.094063,
+  -3.210651,
+  -8.533278,
+  2.802001,
+  -4.068926,
+  -7.993109,
+  1.925119,
+  0,
+  6.54539,
+  5.027311,
+  0,
+  -9.403378,
+  4.264492,
+  -2.724032,
+  2.315802,
+  3.777151,
+  -2.28846,
+  2.398891,
+  3.697603,
+  -1.998311,
+  2.496547,
+  3.689148,
+  -6.13004,
+  3.399261,
+  2.038516,
+  -2.28846,
+  2.886504,
+  3.775031,
+  -2.724032,
+  2.96181,
+  3.871767,
+  -3.177186,
+  2.964136,
+  3.876973,
+  -3.670075,
+  2.927714,
+  3.724325,
+  -4.018389,
+  2.857357,
+  3.482983,
+  -7.555811,
+  4.106811,
+  -0.991917,
+  -4.018389,
+  2.483695,
+  3.440898,
+  0,
+  -2.521945,
+  5.932265,
+  -1.776217,
+  -2.683946,
+  5.213116,
+  -1.222237,
+  -1.182444,
+  5.952465,
+  -0.731493,
+  -2.536683,
+  5.815343,
+  0,
+  3.271027,
+  5.236015,
+  -4.135272,
+  -6.996638,
+  2.67197,
+  -3.311811,
+  -7.660815,
+  3.382963,
+  -1.313701,
+  -8.639995,
+  4.702456,
+  -5.940524,
+  -6.223629,
+  -0.631468,
+  -1.998311,
+  2.743838,
+  3.74403,
+  -0.901447,
+  1.236992,
+  5.754256,
+  0,
+  -8.765243,
+  4.891441,
+  -2.308977,
+  -8.974196,
+  3.60907,
+  -6.954154,
+  -2.439843,
+  -0.131163,
+  -1.098819,
+  -4.458788,
+  5.120727,
+  -1.181124,
+  -4.579996,
+  5.189564,
+  -1.255818,
+  -4.787901,
+  5.237051,
+  -1.325085,
+  -5.106507,
+  5.20501,
+  -1.546388,
+  -5.819392,
+  4.757893,
+  -1.953754,
+  -4.183892,
+  4.431713,
+  -2.117802,
+  -4.137093,
+  4.555096,
+  -2.285339,
+  -4.051196,
+  4.582438,
+  -2.85016,
+  -3.66572,
+  4.484994,
+  -5.278538,
+  -2.238942,
+  2.861224,
+  -0.946709,
+  1.907628,
+  5.196779,
+  -1.314173,
+  3.104912,
+  4.231404,
+  -1.78,
+  2.86,
+  3.881555,
+  -1.84511,
+  -4.09888,
+  4.247264,
+  -5.436187,
+  -4.030482,
+  2.109852,
+  -0.766444,
+  3.182131,
+  4.861453,
+  -1.938616,
+  -6.61441,
+  4.521085,
+  0,
+  1.059413,
+  6.774605,
+  -0.516573,
+  1.583572,
+  6.148363,
+  0,
+  1.728369,
+  6.31675,
+  -1.246815,
+  0.230297,
+  5.681036,
+  0,
+  -7.942194,
+  5.181173,
+  0,
+  -6.991499,
+  5.153478,
+  -0.997827,
+  -6.930921,
+  4.979576,
+  -3.288807,
+  -5.382514,
+  3.795752,
+  -2.311631,
+  -1.566237,
+  4.590085,
+  -2.68025,
+  -6.111567,
+  4.096152,
+  -3.832928,
+  -1.537326,
+  4.137731,
+  -2.96186,
+  -2.274215,
+  4.440943,
+  -4.386901,
+  -2.683286,
+  3.643886,
+  -1.217295,
+  -7.834465,
+  4.969286,
+  -1.542374,
+  -0.136843,
+  5.201008,
+  -3.878377,
+  -6.041764,
+  3.311079,
+  -3.084037,
+  -6.809842,
+  3.814195,
+  -3.747321,
+  -4.503545,
+  3.726453,
+  -6.094129,
+  -3.205991,
+  1.473482,
+  -4.588995,
+  -4.728726,
+  2.983221,
+  -6.583231,
+  -3.941269,
+  0.070268,
+  -3.49258,
+  -3.19582,
+  4.130198,
+  -1.255543,
+  0.802341,
+  5.307551,
+  -1.126122,
+  -0.933602,
+  6.538785,
+  -1.443109,
+  -1.142774,
+  5.905127,
+  -0.923043,
+  -0.529042,
+  7.003423,
+  -1.755386,
+  3.529117,
+  4.327696,
+  -2.632589,
+  3.713828,
+  4.364629,
+  -3.388062,
+  3.721976,
+  4.309028,
+  -4.075766,
+  3.675413,
+  4.076063,
+  -4.62291,
+  3.474691,
+  3.646321,
+  -5.171755,
+  2.535753,
+  2.670867,
+  -7.297331,
+  0.763172,
+  -0.048769,
+  -4.706828,
+  1.651,
+  3.109532,
+  -4.071712,
+  1.476821,
+  3.476944,
+  -3.269817,
+  1.470659,
+  3.731945,
+  -2.527572,
+  1.617311,
+  3.865444,
+  -1.970894,
+  1.858505,
+  3.961782,
+  -1.579543,
+  2.097941,
+  4.084996,
+  -7.664182,
+  0.673132,
+  -2.435867,
+  -1.397041,
+  -1.340139,
+  5.630378,
+  -0.884838,
+  0.65874,
+  6.233232,
+  -0.767097,
+  -0.968035,
+  7.077932,
+  -0.460213,
+  -1.334106,
+  6.787447,
+  -0.748618,
+  -1.067994,
+  6.798303,
+  -1.236408,
+  -1.585568,
+  5.48049,
+  -0.387306,
+  -1.40999,
+  6.957705,
+  -0.319925,
+  -1.607931,
+  6.508676,
+  -1.639633,
+  2.556298,
+  3.863736,
+  -1.255645,
+  2.467144,
+  4.2038,
+  -1.031362,
+  2.382663,
+  4.615849,
+  -4.253081,
+  2.772296,
+  3.315305,
+  -4.53,
+  2.91,
+  3.339685,
+  0.463928,
+  0.955357,
+  6.633583,
+  4.253081,
+  2.577646,
+  3.279702,
+  0.416106,
+  -1.466449,
+  6.447657,
+  7.08796,
+  5.434801,
+  0.09962,
+  2.628639,
+  2.035898,
+  3.848121,
+  3.198363,
+  1.985815,
+  3.796952,
+  3.775151,
+  2.039402,
+  3.646194,
+  4.465819,
+  2.42295,
+  3.155168,
+  2.164289,
+  2.189867,
+  3.851822,
+  3.208229,
+  3.223926,
+  4.115822,
+  2.673803,
+  3.205337,
+  4.092203,
+  3.745193,
+  3.165286,
+  3.972409,
+  4.161018,
+  3.059069,
+  3.719554,
+  5.062006,
+  1.934418,
+  2.776093,
+  2.266659,
+  -7.425768,
+  4.389812,
+  4.445859,
+  2.663991,
+  3.173422,
+  7.21453,
+  2.263009,
+  0.07315,
+  5.799793,
+  2.349546,
+  2.204059,
+  2.844939,
+  -0.720868,
+  4.43313,
+  0.711452,
+  -3.329355,
+  5.877044,
+  0.606033,
+  -3.924562,
+  5.444923,
+  1.431615,
+  -3.500953,
+  5.496189,
+  1.91491,
+  -3.803146,
+  5.02893,
+  1.131043,
+  -3.973937,
+  5.189648,
+  1.563548,
+  -4.082763,
+  4.842263,
+  2.650112,
+  -5.003649,
+  4.188483,
+  0.427049,
+  -1.094134,
+  7.360529,
+  0.496396,
+  -0.475659,
+  7.440358,
+  5.253307,
+  3.881582,
+  3.363159,
+  1.718698,
+  0.974609,
+  4.558359,
+  1.608635,
+  -0.942516,
+  5.814193,
+  1.651267,
+  -0.610868,
+  5.581319,
+  4.765501,
+  -0.701554,
+  3.534632,
+  0.478306,
+  0.295766,
+  7.101013,
+  3.734964,
+  4.50823,
+  4.550454,
+  4.588603,
+  4.302037,
+  4.048484,
+  6.279331,
+  6.615427,
+  1.42585,
+  1.220941,
+  4.142165,
+  5.106035,
+  2.193489,
+  3.100317,
+  4.000575,
+  3.102642,
+  -4.352984,
+  4.095905,
+  6.719682,
+  -4.788645,
+  -1.745401,
+  1.193824,
+  -1.306795,
+  5.737747,
+  0.729766,
+  -1.593712,
+  5.833208,
+  2.456206,
+  -4.342621,
+  4.283884,
+  2.204823,
+  -4.304508,
+  4.162499,
+  4.985894,
+  4.802461,
+  3.751977,
+  1.592294,
+  -1.257709,
+  5.456949,
+  2.644548,
+  4.524654,
+  4.921559,
+  2.760292,
+  5.100971,
+  5.01599,
+  3.523964,
+  8.005976,
+  3.729163,
+  5.599763,
+  5.71547,
+  2.724259,
+  3.063932,
+  6.566144,
+  4.529981,
+  5.720968,
+  4.254584,
+  2.830852,
+  6.374393,
+  4.78559,
+  1.591691,
+  0.672728,
+  -3.688016,
+  5.737804,
+  1.26256,
+  -3.787691,
+  5.417779,
+  1.732553,
+  -3.952767,
+  5.000579,
+  1.043625,
+  -1.464973,
+  5.662455,
+  2.321234,
+  -4.329069,
+  4.258156,
+  2.056846,
+  -4.477671,
+  4.520883,
+  2.153084,
+  -4.276322,
+  4.038093,
+  0.946874,
+  -1.035249,
+  6.512274,
+  1.469132,
+  -4.036351,
+  4.604908,
+  1.02434,
+  -3.989851,
+  4.926693,
+  0.533422,
+  -3.993222,
+  5.138202,
+  0.76972,
+  -6.095394,
+  4.985883,
+  0.699606,
+  -5.29185,
+  5.448304,
+  0.669687,
+  -4.94977,
+  5.509612,
+  0.630947,
+  -4.695101,
+  5.449371,
+  0.583218,
+  -4.517982,
+  5.339869,
+  1.53717,
+  -4.423206,
+  4.74547,
+  1.6156,
+  -4.475942,
+  4.813632,
+  1.729053,
+  -4.61868,
+  4.854463,
+  1.838624,
+  -4.828746,
+  4.823737,
+  2.36825,
+  -3.106237,
+  4.868096,
+  7.542244,
+  -1.049282,
+  -2.431321,
+  1.826614,
+  -4.399531,
+  4.399021,
+  1.929558,
+  -4.411831,
+  4.497052,
+  0.597442,
+  -2.013686,
+  5.866456,
+  1.405627,
+  -1.714196,
+  5.241087,
+  0.662449,
+  -1.819321,
+  5.863759,
+  2.34234,
+  0.572222,
+  4.294303,
+  3.327324,
+  0.104863,
+  4.11386,
+  1.726175,
+  -0.919165,
+  5.273355,
+  5.133204,
+  7.485602,
+  2.660442,
+  4.538641,
+  6.319907,
+  3.683424,
+  3.986562,
+  5.109487,
+  4.466315,
+  2.169681,
+  -5.440433,
+  4.455874,
+  1.395634,
+  5.011963,
+  5.316032,
+  1.6195,
+  6.599217,
+  4.921106,
+  1.891399,
+  8.236377,
+  4.274997,
+  4.195832,
+  2.235205,
+  3.375099,
+  5.733342,
+  1.411738,
+  2.431726,
+  1.859887,
+  2.355757,
+  3.843181,
+  4.988612,
+  3.074654,
+  3.083858,
+  1.303263,
+  1.416453,
+  4.831091,
+  1.305757,
+  -0.672779,
+  6.415959,
+  6.46517,
+  0.937119,
+  1.689873,
+  5.258659,
+  0.945811,
+  2.974312,
+  4.432338,
+  0.722096,
+  3.522615,
+  3.300681,
+  0.861641,
+  3.872784,
+  2.430178,
+  1.131492,
+  4.039035,
+  1.820731,
+  1.467954,
+  4.224124,
+  0.563221,
+  2.307693,
+  5.566789,
+  6.338145,
+  -0.529279,
+  1.881175,
+  5.587698,
+  3.208071,
+  2.687839,
+  0.242624,
+  -1.462857,
+  7.071491,
+  1.611251,
+  0.339326,
+  4.895421,
+  7.743095,
+  2.364999,
+  -2.005167,
+  1.391142,
+  1.851048,
+  4.448999,
+  1.785794,
+  -0.978284,
+  4.85047,
+  4.670959,
+  2.664461,
+  3.084075,
+  1.33397,
+  -0.283761,
+  6.097047,
+  7.270895,
+  -2.890917,
+  -2.252455,
+  1.856432,
+  2.585245,
+  3.757904,
+  0.923388,
+  0.073076,
+  6.671944,
+  5.000589,
+  -6.135128,
+  1.892523,
+  5.085276,
+  -7.17859,
+  0.714711,
+  7.159291,
+  -0.81182,
+  -0.072044,
+  5.843051,
+  -5.248023,
+  0.924091,
+  6.847258,
+  3.662916,
+  0.724695,
+  2.412942,
+  -8.258853,
+  4.119213,
+  0.179909,
+  -1.689864,
+  6.573301,
+  2.103655,
+  -0.163946,
+  4.566119,
+  6.407571,
+  2.236021,
+  1.560843,
+  3.670075,
+  2.360153,
+  3.63523,
+  3.177186,
+  2.294265,
+  3.775704,
+  2.196121,
+  -4.598322,
+  4.479786,
+  6.234883,
+  -1.94443,
+  1.663542,
+  1.292924,
+  -9.29592,
+  4.094063,
+  3.210651,
+  -8.533278,
+  2.802001,
+  4.068926,
+  -7.993109,
+  1.925119,
+  2.724032,
+  2.315802,
+  3.777151,
+  2.28846,
+  2.398891,
+  3.697603,
+  1.998311,
+  2.496547,
+  3.689148,
+  6.13004,
+  3.399261,
+  2.038516,
+  2.28846,
+  2.886504,
+  3.775031,
+  2.724032,
+  2.96181,
+  3.871767,
+  3.177186,
+  2.964136,
+  3.876973,
+  3.670075,
+  2.927714,
+  3.724325,
+  4.018389,
+  2.857357,
+  3.482983,
+  7.555811,
+  4.106811,
+  -0.991917,
+  4.018389,
+  2.483695,
+  3.440898,
+  1.776217,
+  -2.683946,
+  5.213116,
+  1.222237,
+  -1.182444,
+  5.952465,
+  0.731493,
+  -2.536683,
+  5.815343,
+  4.135272,
+  -6.996638,
+  2.67197,
+  3.311811,
+  -7.660815,
+  3.382963,
+  1.313701,
+  -8.639995,
+  4.702456,
+  5.940524,
+  -6.223629,
+  -0.631468,
+  1.998311,
+  2.743838,
+  3.74403,
+  0.901447,
+  1.236992,
+  5.754256,
+  2.308977,
+  -8.974196,
+  3.60907,
+  6.954154,
+  -2.439843,
+  -0.131163,
+  1.098819,
+  -4.458788,
+  5.120727,
+  1.181124,
+  -4.579996,
+  5.189564,
+  1.255818,
+  -4.787901,
+  5.237051,
+  1.325085,
+  -5.106507,
+  5.20501,
+  1.546388,
+  -5.819392,
+  4.757893,
+  1.953754,
+  -4.183892,
+  4.431713,
+  2.117802,
+  -4.137093,
+  4.555096,
+  2.285339,
+  -4.051196,
+  4.582438,
+  2.85016,
+  -3.66572,
+  4.484994,
+  5.278538,
+  -2.238942,
+  2.861224,
+  0.946709,
+  1.907628,
+  5.196779,
+  1.314173,
+  3.104912,
+  4.231404,
+  1.78,
+  2.86,
+  3.881555,
+  1.84511,
+  -4.09888,
+  4.247264,
+  5.436187,
+  -4.030482,
+  2.109852,
+  0.766444,
+  3.182131,
+  4.861453,
+  1.938616,
+  -6.61441,
+  4.521085,
+  0.516573,
+  1.583572,
+  6.148363,
+  1.246815,
+  0.230297,
+  5.681036,
+  0.997827,
+  -6.930921,
+  4.979576,
+  3.288807,
+  -5.382514,
+  3.795752,
+  2.311631,
+  -1.566237,
+  4.590085,
+  2.68025,
+  -6.111567,
+  4.096152,
+  3.832928,
+  -1.537326,
+  4.137731,
+  2.96186,
+  -2.274215,
+  4.440943,
+  4.386901,
+  -2.683286,
+  3.643886,
+  1.217295,
+  -7.834465,
+  4.969286,
+  1.542374,
+  -0.136843,
+  5.201008,
+  3.878377,
+  -6.041764,
+  3.311079,
+  3.084037,
+  -6.809842,
+  3.814195,
+  3.747321,
+  -4.503545,
+  3.726453,
+  6.094129,
+  -3.205991,
+  1.473482,
+  4.588995,
+  -4.728726,
+  2.983221,
+  6.583231,
+  -3.941269,
+  0.070268,
+  3.49258,
+  -3.19582,
+  4.130198,
+  1.255543,
+  0.802341,
+  5.307551,
+  1.126122,
+  -0.933602,
+  6.538785,
+  1.443109,
+  -1.142774,
+  5.905127,
+  0.923043,
+  -0.529042,
+  7.003423,
+  1.755386,
+  3.529117,
+  4.327696,
+  2.632589,
+  3.713828,
+  4.364629,
+  3.388062,
+  3.721976,
+  4.309028,
+  4.075766,
+  3.675413,
+  4.076063,
+  4.62291,
+  3.474691,
+  3.646321,
+  5.171755,
+  2.535753,
+  2.670867,
+  7.297331,
+  0.763172,
+  -0.048769,
+  4.706828,
+  1.651,
+  3.109532,
+  4.071712,
+  1.476821,
+  3.476944,
+  3.269817,
+  1.470659,
+  3.731945,
+  2.527572,
+  1.617311,
+  3.865444,
+  1.970894,
+  1.858505,
+  3.961782,
+  1.579543,
+  2.097941,
+  4.084996,
+  7.664182,
+  0.673132,
+  -2.435867,
+  1.397041,
+  -1.340139,
+  5.630378,
+  0.884838,
+  0.65874,
+  6.233232,
+  0.767097,
+  -0.968035,
+  7.077932,
+  0.460213,
+  -1.334106,
+  6.787447,
+  0.748618,
+  -1.067994,
+  6.798303,
+  1.236408,
+  -1.585568,
+  5.48049,
+  0.387306,
+  -1.40999,
+  6.957705,
+  0.319925,
+  -1.607931,
+  6.508676,
+  1.639633,
+  2.556298,
+  3.863736,
+  1.255645,
+  2.467144,
+  4.2038,
+  1.031362,
+  2.382663,
+  4.615849,
+  4.253081,
+  2.772296,
+  3.315305,
+  4.53,
+  2.91,
+  3.339685
+);
+
+// src/interactives/runtime/face-solve.ts
+var FACE_REGIONS = {
+  imageLeftEye: [33, 7, 163, 144, 145, 153, 154, 155, 133, 173, 157, 158, 159, 160, 161, 246],
+  imageRightEye: [263, 249, 390, 373, 374, 380, 381, 382, 362, 398, 384, 385, 386, 387, 388, 466],
+  imageLeftBrow: [46, 53, 52, 65, 55, 70, 63, 105, 66, 107],
+  imageRightBrow: [276, 283, 282, 295, 285, 300, 293, 334, 296, 336],
+  outerLips: [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 409, 270, 269, 267, 0, 37, 39, 40, 185],
+  innerLips: [78, 95, 88, 178, 87, 14, 317, 402, 318, 324, 308, 415, 310, 311, 312, 13, 82, 81, 80, 191]
+}, FaceCalibration = {
+  canonicalFaceWidth: 15.33,
+  canonicalEyeSpan: 8.891718,
+  minimumInterPupil: 0.01,
+  eyeOpenAspect: 0.3,
+  mouthRestWidth: 0.8,
+  smileWidth: 1.05,
+  smileLift: 0.25,
+  jawRest: 0.05,
+  jawSpan: 0.45,
+  browRest: 0.5,
+  browSpan: 0.12,
+  puckerSpan: 0.25
+}, STRIDE = FACE_LAYOUT.landmark_stride, POINTS = FACE_LAYOUT.landmark_count, LANDMARK_FLOATS = POINTS * STRIDE, EXPRESSION_AT = LANDMARK_FLOATS, POSE_AT = EXPRESSION_AT + FACE_LAYOUT.expressions.length, SOLVED_FLOATS = POSE_AT + FACE_LAYOUT.head_pose.length, SOLVED_LANDMARK_FLOATS = LANDMARK_FLOATS, SOLVED_POSE_AT = POSE_AT, expressionIndex = (name) => FACE_LAYOUT.expressions.indexOf(name), poseIndex = (name) => FACE_LAYOUT.head_pose.indexOf(name), SMILE = EXPRESSION_AT + expressionIndex("smile"), JAW_OPEN = EXPRESSION_AT + expressionIndex("jaw_open"), BLINK_LEFT = EXPRESSION_AT + expressionIndex("blink_left"), BLINK_RIGHT = EXPRESSION_AT + expressionIndex("blink_right"), BROW_RAISE = EXPRESSION_AT + expressionIndex("brow_raise"), PUCKER = EXPRESSION_AT + expressionIndex("pucker"), YAW = POSE_AT + poseIndex("yaw"), PITCH = POSE_AT + poseIndex("pitch"), ROLL = POSE_AT + poseIndex("roll"), POSE_X = POSE_AT + poseIndex("x"), POSE_Y = POSE_AT + poseIndex("y"), POSE_Z = POSE_AT + poseIndex("z"), AXES = 4, RIDGE = 1e-6, MINIMUM_SCALE = 1e-5, MINIMUM_ASPECT = 1e-6, DETERMINANT_FLOOR = 1e-30, HALF = 0.5, ROOT_HALF = Math.SQRT1_2;
+function clampUnit(value) {
+  return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function invert4(source, out) {
+  let work = new Float64Array((4) * (4) * 2);
+  for (let r = 0; r < (4); r++)
+    for (let c = 0; c < (4); c++)
+      work[r * (4) * 2 + c] = source[r * (4) + c], work[r * (4) * 2 + (4) + c] = r === c ? 1 : 0;
+  let width = (4) * 2;
+  for (let col = 0; col < (4); col++) {
+    let pivot = col;
+    for (let r = col + 1; r < (4); r++) Math.abs(work[r * width + col]) > Math.abs(work[pivot * width + col]) && (pivot = r);
+    let lead = work[pivot * width + col];
+    if (Math.abs(lead) < (1e-30)) return false;
+    if (pivot !== col)
+      for (let c = 0; c < width; c++) {
+        let swap = work[col * width + c];
+        work[col * width + c] = work[pivot * width + c], work[pivot * width + c] = swap;
+      }
+    for (let c = 0; c < width; c++) work[col * width + c] /= lead;
+    for (let r = 0; r < (4); r++) {
+      if (r === col) continue;
+      let factor = work[r * width + col];
+      if (factor !== 0)
+        for (let c = 0; c < width; c++) work[r * width + c] -= factor * work[col * width + c];
+    }
+  }
+  for (let r = 0; r < (4); r++) for (let c = 0; c < (4); c++) out[r * (4) + c] = work[r * width + (4) + c];
+  return true;
+}
+var FaceSolver = class {
+  constructor() {
+    this.inverse = new Float64Array((4) * (4));
+    this.bx = new Float64Array((4));
+    this.by = new Float64Array((4));
+    this.rows = new Float64Array(9);
+    this.units = new Float64Array(POINTS * 2);
+    let normal = new Float64Array((4) * (4)), x = new Float64Array((4));
+    for (let i = 0; i < 468; i++) {
+      x[0] = CANONICAL_FACE[i * 3], x[1] = CANONICAL_FACE[i * 3 + 1], x[2] = CANONICAL_FACE[i * 3 + 2], x[3] = 1;
+      for (let r = 0; r < (4); r++) for (let c = 0; c < (4); c++) normal[r * (4) + c] += x[r] * x[c];
+    }
+    for (let a = 0; a < (4); a++) normal[a * (4) + a] += (1e-6);
+    this.ready = invert4(normal, this.inverse);
+  }
+  solve(points, count, aspect, out) {
+    if (!this.ready || count < POINTS || out.length < SOLVED_FLOATS) return false;
+    let ratio = Math.max(aspect, (1e-6)), units = this.units;
+    for (let i = 0; i < LANDMARK_FLOATS; i++) out[i] = points[i];
+    for (let i = 0; i < POINTS; i++)
+      units[i * 2] = points[i * STRIDE], units[i * 2 + 1] = points[i * STRIDE + 1] * ratio;
+    return this.fit(out, ratio) ? (this.expressions(out), true) : false;
+  }
+  fit(out, ratio) {
+    let bx = this.bx, by = this.by, units = this.units;
+    bx.fill(0), by.fill(0);
+    for (let i = 0; i < POINTS; i++) {
+      let base = i * 3, ux = units[i * 2], uy = units[i * 2 + 1], cx = CANONICAL_FACE[base], cy = CANONICAL_FACE[base + 1], cz = CANONICAL_FACE[base + 2];
+      bx[0] += cx * ux, bx[1] += cy * ux, bx[2] += cz * ux, bx[3] += ux, by[0] += cx * uy, by[1] += cy * uy, by[2] += cz * uy, by[3] += uy;
+    }
+    let inv = this.inverse, m1x = inv[0] * bx[0] + inv[1] * bx[1] + inv[2] * bx[2] + inv[3] * bx[3], m1y = inv[4] * bx[0] + inv[5] * bx[1] + inv[6] * bx[2] + inv[7] * bx[3], m1z = inv[8] * bx[0] + inv[9] * bx[1] + inv[10] * bx[2] + inv[11] * bx[3], m2x = inv[0] * by[0] + inv[1] * by[1] + inv[2] * by[2] + inv[3] * by[3], m2y = inv[4] * by[0] + inv[5] * by[1] + inv[6] * by[2] + inv[7] * by[3], m2z = inv[8] * by[0] + inv[9] * by[1] + inv[10] * by[2] + inv[11] * by[3], n1 = Math.hypot(m1x, m1y, m1z), n2 = Math.hypot(m2x, m2y, m2z);
+    if (n1 <= (1e-5) || n2 <= (1e-5)) return false;
+    let ax = m1x / n1, ay = m1y / n1, az = m1z / n1, bxn = m2x / n2, byn = m2y / n2, bzn = m2z / n2, sx = ax + bxn, sy = ay + byn, sz = az + bzn, sn = Math.hypot(sx, sy, sz), dx = ax - bxn, dy = ay - byn, dz = az - bzn, dn = Math.hypot(dx, dy, dz);
+    if (dn <= (1e-5) || sn <= (1e-5)) return false;
+    sx /= sn, sy /= sn, sz /= sn, dx /= dn, dy /= dn, dz /= dn;
+    let rows = this.rows;
+    rows[0] = (sx + dx) * ROOT_HALF, rows[1] = (sy + dy) * ROOT_HALF, rows[2] = (sz + dz) * ROOT_HALF, rows[3] = (sx - dx) * ROOT_HALF, rows[4] = (sy - dy) * ROOT_HALF, rows[5] = (sz - dz) * ROOT_HALF, rows[6] = rows[1] * rows[5] - rows[2] * rows[4], rows[7] = rows[2] * rows[3] - rows[0] * rows[5], rows[8] = rows[0] * rows[4] - rows[1] * rows[3];
+    let scale = (n1 + n2) * (0.5), tx = 0, ty = 0;
+    for (let i = 0; i < POINTS; i++) {
+      let base = i * 3, cx = CANONICAL_FACE[base], cy = CANONICAL_FACE[base + 1], cz = CANONICAL_FACE[base + 2];
+      tx += units[i * 2] - (rows[0] * cx + rows[1] * cy + rows[2] * cz) * scale, ty += units[i * 2 + 1] - (rows[3] * cx + rows[4] * cy + rows[5] * cz) * scale;
+    }
+    return tx /= POINTS, ty /= POINTS, out[YAW] = Math.atan2(rows[2], -rows[8]), out[PITCH] = -Math.asin(Math.min(Math.max(rows[5], -1), 1)), out[ROLL] = -Math.atan2(-rows[3], -rows[4]), out[POSE_X] = tx, out[POSE_Y] = ty / ratio, out[POSE_Z] = 1 / Math.max(scale * FaceCalibration.canonicalFaceWidth, (1e-5)), true;
+  }
+  expressions(out) {
+    let leftX = this.centroid(FACE_REGIONS.imageLeftEye, 0), leftY = this.centroid(FACE_REGIONS.imageLeftEye, 1), rightX = this.centroid(FACE_REGIONS.imageRightEye, 0), rightY = this.centroid(FACE_REGIONS.imageRightEye, 1), swapped = leftX > rightX, lineX = swapped ? leftX - rightX : rightX - leftX, lineY = swapped ? leftY - rightY : rightY - leftY, ipd = Math.max(Math.hypot(lineX, lineY), FaceCalibration.minimumInterPupil), roll = Math.atan2(lineY, lineX), acrossX = Math.cos(roll), acrossY = Math.sin(roll), upX = acrossY, upY = -acrossX, mouthOpen = this.extent(FACE_REGIONS.innerLips, upX, upY) / ipd, jaw = clampUnit((mouthOpen - FaceCalibration.jawRest) / FaceCalibration.jawSpan);
+    out[SMILE] = this.smile(acrossX, acrossY, upX, upY, ipd), out[JAW_OPEN] = jaw, out[BLINK_LEFT] = this.blink(FACE_REGIONS.imageRightEye, acrossX, acrossY, upX, upY), out[BLINK_RIGHT] = this.blink(FACE_REGIONS.imageLeftEye, acrossX, acrossY, upX, upY);
+    let browLeft = (this.centroid(FACE_REGIONS.imageLeftBrow, 0) - leftX) * upX + (this.centroid(FACE_REGIONS.imageLeftBrow, 1) - leftY) * upY, browRight = (this.centroid(FACE_REGIONS.imageRightBrow, 0) - rightX) * upX + (this.centroid(FACE_REGIONS.imageRightBrow, 1) - rightY) * upY, brows = (browLeft + browRight) * (0.5) / ipd;
+    out[BROW_RAISE] = clampUnit((brows - FaceCalibration.browRest) / FaceCalibration.browSpan);
+    let width = this.extent(FACE_REGIONS.outerLips, acrossX, acrossY) / ipd, narrowing = clampUnit((FaceCalibration.mouthRestWidth - width) / FaceCalibration.puckerSpan);
+    out[PUCKER] = narrowing * (1 - jaw);
+  }
+  centroid(region, axis) {
+    let sum = 0;
+    for (let i = 0; i < region.length; i++) sum += this.units[region[i] * 2 + axis];
+    return sum / region.length;
+  }
+  extent(region, ax, ay) {
+    let low = Number.POSITIVE_INFINITY, high = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < region.length; i++) {
+      let p = region[i] * 2, along = this.units[p] * ax + this.units[p + 1] * ay;
+      along < low && (low = along), along > high && (high = along);
+    }
+    return high - low;
+  }
+  blink(region, acrossX, acrossY, upX, upY) {
+    let width = this.extent(region, acrossX, acrossY);
+    return width <= 0 ? 0 : clampUnit(1 - this.extent(region, upX, upY) / width / FaceCalibration.eyeOpenAspect);
+  }
+  smile(acrossX, acrossY, upX, upY, ipd) {
+    let lips = FACE_REGIONS.outerLips, cx = this.centroid(lips, 0), cy = this.centroid(lips, 1), leftmost = Number.POSITIVE_INFINITY, rightmost = Number.NEGATIVE_INFINITY, leftLift = 0, rightLift = 0;
+    for (let i = 0; i < lips.length; i++) {
+      let p = lips[i] * 2, ox = this.units[p] - cx, oy = this.units[p + 1] - cy, along = ox * acrossX + oy * acrossY, lift = ox * upX + oy * upY;
+      along < leftmost && (leftmost = along, leftLift = lift), along > rightmost && (rightmost = along, rightLift = lift);
+    }
+    let widthShare = ((rightmost - leftmost) / ipd - FaceCalibration.mouthRestWidth) / (FaceCalibration.smileWidth - FaceCalibration.mouthRestWidth), liftShare = (leftLift + rightLift) * (0.5) / ipd / FaceCalibration.smileLift;
+    return clampUnit(widthShare + liftShare);
+  }
+};
+
+// src/interactives/hosts/identity-capture.ts
+var IDENTITY_PURPOSE = CAMERA_LAYOUT.identity_purpose, IdentityCopy = {
+  title: "Make your character from your face",
+  consent: "Use your own face only, never anyone else's. The camera picture stays on this device. The game gets only your character's shape and colours.",
+  decline: "Not now",
+  agree: "This is me, continue",
+  capture: "Capture",
+  close: "Close",
+  ready: "Your character is ready",
+  save: "Also save as my avatar",
+  use: "Use in game",
+  retake: "Try again",
+  preview: "Your camera, shown only here on this device"
+}, IdentityGuidance = {
+  starting: "Starting the camera",
+  find_face: "Look at the camera",
+  face_camera: "Face the camera straight on",
+  move_closer: "Move a little closer",
+  hold_still: "Hold still"
+}, POSE_YAW = SOLVED_POSE_AT + FACE_LAYOUT.head_pose.indexOf("yaw"), POSE_PITCH = SOLVED_POSE_AT + FACE_LAYOUT.head_pose.indexOf("pitch"), POSE_Z2 = SOLVED_POSE_AT + FACE_LAYOUT.head_pose.indexOf("z"), MINIMUM_DEPTH = 1e-6, RED_SHIFT = 16, GREEN_SHIFT = 8, BYTE = 255;
+function faceWidthFromDepth(depth) {
+  return depth > (1e-6) ? FaceCalibration.canonicalEyeSpan / (depth * FaceCalibration.canonicalFaceWidth) : 0;
+}
+function unpack(word) {
+  return word === NO_FACE_COLOUR ? null : [word >> (16) & (255), word >> (8) & (255), word & (255)];
+}
+function capturedColours(colours) {
+  let skin = colours === null ? null : unpack(colours.skin);
+  return colours === null || skin === null ? null : { skin, hair: unpack(colours.hair), eye: unpack(colours.eye) };
+}
+function frameContext(solved, faces, ageRange) {
+  return {
+    ageRange,
+    consented: true,
+    subject: "self",
+    source: "camera",
+    faces,
+    yaw: faces === 1 ? solved[POSE_YAW] : 0,
+    pitch: faces === 1 ? solved[POSE_PITCH] : 0,
+    faceWidth: faces === 1 ? faceWidthFromDepth(solved[POSE_Z2]) : 0
+  };
+}
+var GUIDANCE_FOR = {
+  one_face_only: "find_face",
+  face_turned: "face_camera",
+  face_too_small: "move_closer"
+};
+function guidanceFor(context) {
+  let refusal = identityCapturePolicy(context).refusal;
+  return refusal === null ? "hold_still" : GUIDANCE_FOR[refusal] ?? "find_face";
+}
+function ageAnswer(ageRange) {
+  return ageRange === "under_16" || ageRange === "undeclared" ? "refused" : null;
+}
+function fitIdentity(fitter, landmarks, aspect, colours, context) {
+  let { fit } = identityFromCapture(fitter, { landmarks, aspect, colours }, context, {
+    residual: true
+  });
+  return fit === null ? null : encodeIdentity(fit.params);
+}
+async function identityFitter(options) {
+  let base = await options.base();
+  return base instanceof IdentityFitter ? base : new IdentityFitter(base);
+}
+var IdentityAttempt = class {
+  constructor(grant, handle) {
+    this.grant = grant;
+    this.handle = handle;
+    this.consented = false;
+    this.framing = false;
+    this.wanted = false;
+    this.shown = null;
+    this.identity = null;
+    this.ageRange = "undeclared";
+    this.fitter = null;
+    this.sheet = null;
+    this.queue = [];
+    this.waiting = null;
+    this.aborted = null;
+    this.events = {
+      agree: () => this.push({ kind: "agree" }),
+      decline: () => this.push({ kind: "decline" }),
+      capture: () => this.push({ kind: "capture" }),
+      retake: () => this.push({ kind: "retake" }),
+      use: (save) => this.push({ kind: "use", save }),
+      close: () => this.push({ kind: "close" })
+    };
+  }
+  push(event) {
+    if (this.aborted !== null) return;
+    event.kind === "abort" && (this.aborted = event.code);
+    let waiting = this.waiting;
+    if (waiting === null) {
+      this.queue.push(event);
+      return;
+    }
+    this.waiting = null, waiting(event);
+  }
+  abort(code) {
+    this.push({ kind: "abort", code });
+  }
+  get abortedWith() {
+    return this.aborted;
+  }
+  next() {
+    let queued = this.queue.shift();
+    return queued !== void 0 ? Promise.resolve(queued) : this.aborted !== null ? Promise.resolve({ kind: "abort", code: this.aborted }) : new Promise((resolve) => {
+      this.waiting = resolve;
+    });
+  }
+  guide(guidance) {
+    this.shown !== guidance && (this.shown = guidance, this.sheet?.guide(guidance));
+  }
+}, LAYER_SHEET = 4, SHEET_STYLE = `position:absolute;inset:0;z-index:${(4)};display:flex;flex-direction:column;align-items:center;justify-content:center;gap:16px;padding:24px 16px;box-sizing:border-box;background:rgba(8,10,12,0.94);color:#f4f5f6;font:15px/1.45 system-ui,-apple-system,sans-serif;text-align:center`, PREVIEW_STYLE = "width:min(72vw,280px);aspect-ratio:3/4;border-radius:24px;object-fit:cover;transform:scaleX(-1);background:#000", TEXT_STYLE = "margin:0;max-width:340px", TITLE_STYLE = "margin:0;font-size:19px;font-weight:600", ROW_STYLE = "display:flex;gap:12px;flex-wrap:wrap;justify-content:center", PRIMARY_STYLE = "min-height:44px;padding:0 20px;border:0;border-radius:22px;background:#f4f5f6;color:#0b0d0f;font:inherit;font-weight:600;cursor:pointer", SECONDARY_STYLE = "min-height:44px;padding:0 20px;border:1px solid rgba(255,255,255,0.32);border-radius:22px;background:transparent;color:inherit;font:inherit;cursor:pointer", TOGGLE_STYLE = "display:flex;align-items:center;gap:10px;min-height:44px;cursor:pointer";
+function domIdentitySheet(container) {
+  return (events) => {
+    let doc = container?.ownerDocument ?? document, root = doc.createElement("div");
+    root.setAttribute("role", "dialog"), root.setAttribute("aria-modal", "true"), root.setAttribute("aria-label", IdentityCopy.title), root.setAttribute("style", SHEET_STYLE), root.addEventListener("keydown", (event) => {
+      event.key === "Escape" && events.close();
+    }), container?.appendChild(root);
+    let video = null, guidance = null, captureButton = null, element = (tag, style, text2) => {
+      let node = doc.createElement(tag);
+      return node.setAttribute("style", style), text2 !== void 0 && (node.textContent = text2), node;
+    }, button = (text2, style, action) => {
+      let node = element("button", style, text2);
+      return node.type = "button", node.addEventListener("click", action), node;
+    }, stopPreview = () => {
+      video !== null && (video.pause(), video.srcObject = null, video = null);
+    }, show = (...nodes) => {
+      root.replaceChildren(...nodes);
+    };
+    return {
+      consent() {
+        let agree = button(IdentityCopy.agree, PRIMARY_STYLE, () => events.agree());
+        show(
+          element("h2", TITLE_STYLE, IdentityCopy.title),
+          element("p", TEXT_STYLE, IdentityCopy.consent),
+          rowOf(
+            element("div", ROW_STYLE),
+            button(IdentityCopy.decline, SECONDARY_STYLE, () => events.decline()),
+            agree
+          )
+        ), agree.focus();
+      },
+      framing(stream) {
+        stopPreview();
+        let preview = element("video", PREVIEW_STYLE);
+        preview.muted = true, preview.playsInline = true, preview.autoplay = true, preview.setAttribute("aria-label", IdentityCopy.preview), preview.srcObject = stream, video = preview, guidance = element("p", TEXT_STYLE, IdentityGuidance.starting), guidance.setAttribute("aria-live", "polite"), captureButton = button(IdentityCopy.capture, PRIMARY_STYLE, () => events.capture()), captureButton.disabled = true, show(
+          element("h2", TITLE_STYLE, IdentityCopy.title),
+          preview,
+          guidance,
+          rowOf(
+            element("div", ROW_STYLE),
+            button(IdentityCopy.close, SECONDARY_STYLE, () => events.close()),
+            captureButton
+          )
+        ), preview.play().catch(() => {
+        });
+      },
+      guide(key) {
+        guidance !== null && (guidance.textContent = IdentityGuidance[key]), captureButton !== null && (captureButton.disabled = key !== "hold_still");
+      },
+      result(offerSave) {
+        stopPreview(), guidance = null, captureButton = null;
+        let nodes = [element("h2", TITLE_STYLE, IdentityCopy.ready)], save = null;
+        if (offerSave) {
+          let label = element("label", TOGGLE_STYLE);
+          save = element("input", "width:20px;height:20px"), save.type = "checkbox", save.checked = false, label.append(save, doc.createTextNode(IdentityCopy.save)), nodes.push(label);
+        }
+        let chosen = save, use = button(IdentityCopy.use, PRIMARY_STYLE, () => events.use(chosen?.checked === true));
+        nodes.push(
+          rowOf(
+            element("div", ROW_STYLE),
+            button(IdentityCopy.close, SECONDARY_STYLE, () => events.close()),
+            button(IdentityCopy.retake, SECONDARY_STYLE, () => events.retake()),
+            use
+          )
+        ), show(...nodes), use.focus();
+      },
+      close() {
+        stopPreview(), root.remove();
+      }
+    };
+  };
+}
+function rowOf(row, ...children) {
+  return row.append(...children), row;
+}
+
+// src/interactives/hosts/face-camera.ts
+var CAMERA_ON_COPY = "Your camera is on. It stays on this device.", CAMERA_NEEDLE = new TextEncoder().encode('"camera.'), REQUEST_OPERATION = "camera.request", RELEASE_OPERATION = "camera.release", VIEW_PURPOSE = CAMERA_LAYOUT.view_purpose, TRACK_PURPOSE = CAMERA_LAYOUT.track_purpose, GRANTED = "granted", DENIED = "denied", AGE_UNDECLARED = "age_undeclared", UNDECLARED_RANGE = "undeclared", UNAVAILABLE = "unavailable", CANCELLED = "cancelled", CONSENT = "consent", READY = "hold_still", IDENTITY_CONSUMER = -1, NOT_ALLOWED = "NotAllowedError", MAX_POINTS = 478, POINT_STRIDE = 3, LANDMARK_FLOATS2 = FACE_LAYOUT.landmark_count * FACE_LAYOUT.landmark_stride, EXPRESSION_FLOATS = FACE_FRAME.expression_floats, POSE_FLOATS = FACE_FRAME.pose_floats, MEASURED = 1, DERIVED = 0, LAYER_UNDER = 0, LAYER_INSET = 2, LAYER_OVER = 3, decoder6 = new TextDecoder();
+function mentionsCamera(bytes) {
+  let needle = CAMERA_NEEDLE, last = bytes.length - needle.length;
+  outer: for (let i = 0; i <= last; i++) {
+    for (let j = 0; j < needle.length; j++) if (bytes[i + j] !== needle[j]) continue outer;
+    return true;
+  }
+  return false;
+}
+var CameraGrants = class {
+  constructor(revoked = () => {
+  }) {
+    this.revoked = revoked;
+    this.pending = /* @__PURE__ */ new Map();
+    this.granted = /* @__PURE__ */ new Map();
+  }
+  observeRequest(bytes) {
+    if (!mentionsCamera(bytes)) return;
+    let envelope;
+    try {
+      envelope = readJson(bytes);
+    } catch {
+      return;
+    }
+    let call = envelope.call;
+    call.operation === REQUEST_OPERATION ? this.pending.set(envelope.request_id, { kind: "request" }) : call.operation === RELEASE_OPERATION && this.pending.set(envelope.request_id, {
+      kind: "release",
+      grant: call.arguments?.grant_id ?? null
+    });
+  }
+  observeResponse(bytes) {
+    if (this.pending.size === 0) return null;
+    let envelope;
+    try {
+      envelope = readJson(bytes);
+    } catch {
+      return null;
+    }
+    let operation = this.pending.get(envelope.request_id);
+    if (operation === void 0) return null;
+    this.pending.delete(envelope.request_id);
+    let outcome = envelope.outcome;
+    if (operation.kind === "release")
+      return operation.grant !== null && this.granted.delete(operation.grant) && this.revoked(operation.grant), null;
+    if (outcome.status === "error") {
+      let error = outcome.error;
+      return error.code === DENIED && error.reason === AGE_UNDECLARED ? AGE_UNDECLARED : null;
+    }
+    let consent = outcome.response.result;
+    return consent?.status !== GRANTED || typeof consent.grant_id != "string" || this.granted.set(consent.grant_id, new Set(consent.purposes ?? [])), null;
+  }
+  allows(grant, purpose) {
+    return this.granted.get(grant)?.has(purpose) ?? false;
+  }
+  allowsFaceTracking(grant) {
+    return this.allows(grant, TRACK_PURPOSE);
+  }
+  allowsPreview(grant) {
+    return this.allows(grant, VIEW_PURPOSE);
+  }
+  revokeAll() {
+    let all = [...this.granted.keys()];
+    this.granted.clear(), this.pending.clear();
+    for (let grant of all) this.revoked(grant);
+  }
+}, INSET_STYLE = `position:absolute;top:12px;right:12px;width:88px;height:120px;border-radius:14px;object-fit:cover;transform:scaleX(-1);pointer-events:none;z-index:${(2)};border:1px solid rgba(255,255,255,0.24);background:#000`;
+function cameraViewStyle(rect, origin = { left: 0, top: 0 }) {
+  if (rect === null) return INSET_STYLE;
+  let mirror = rect.mirror ? "transform:scaleX(-1);" : "", layer = rect.over ? (3) : (0);
+  return `position:absolute;left:${origin.left + rect.x}px;top:${origin.top + rect.y}px;width:${rect.width}px;height:${rect.height}px;object-fit:cover;${mirror}pointer-events:none;z-index:${layer};background:#000`;
+}
+function readViewRect(bytes) {
+  if (bytes.length < CAMERA_PLACE_BYTES) return null;
+  let x = readFloat(bytes, CAMERA_PLACE_X_AT), y = readFloat(bytes, CAMERA_PLACE_X_AT + CAMERA_WORD_BYTES), width = readFloat(bytes, CAMERA_PLACE_X_AT + CAMERA_WORD_BYTES * 2), height = readFloat(bytes, CAMERA_PLACE_X_AT + CAMERA_WORD_BYTES * 3);
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0) return null;
+  let flags = bytes[CAMERA_PLACE_FLAGS_AT];
+  return {
+    x,
+    y,
+    width,
+    height,
+    mirror: (flags & CameraViewFlag.mirror) !== 0,
+    over: (flags & CameraViewFlag.over) !== 0
+  };
+}
+var VIDEO_CONSTRAINTS = {
+  audio: false,
+  video: { facingMode: "user", width: { ideal: 1280 }, height: { ideal: 720 } }
+};
+function insetVideo(container, surface = () => ({ left: 0, top: 0 })) {
+  return async (stream) => {
+    let video = (container?.ownerDocument ?? document).createElement("video");
+    return video.muted = true, video.playsInline = true, video.autoplay = true, video.setAttribute("aria-label", CAMERA_ON_COPY), video.setAttribute("title", CAMERA_ON_COPY), video.setAttribute("role", "img"), video.setAttribute("style", INSET_STYLE), video.srcObject = stream, container?.appendChild(video), await video.play(), {
+      video,
+      place: (rect) => video.setAttribute("style", cameraViewStyle(rect, surface())),
+      release: () => {
+        video.pause(), video.srcObject = null, video.remove();
+      }
+    };
+  };
+}
+var FaceCameraRelay = class {
+  constructor(port, options) {
+    this.port = port;
+    this.options = options;
+    this.solver = new FaceSolver();
+    this.solved = new Float32Array(SOLVED_FLOATS);
+    this.staging = new ArrayBuffer(FACE_PAYLOAD_BYTES);
+    this.stagingBytes = new Uint8Array(this.staging);
+    this.stagingWords = new Uint32Array(this.staging, 0, FACE_FRAME.header_words - FACE_FRAME.faces);
+    this.floats = new Float32Array(this.staging, FACE_FLOATS_AT, FACE_FLOATS);
+    this.expressions = this.floats.subarray(0, EXPRESSION_FLOATS);
+    this.arkit = this.floats.subarray(FACE_ARKIT_AT, FACE_POSE_AT);
+    this.pose = this.floats.subarray(FACE_POSE_AT, FACE_POSE_AT + POSE_FLOATS);
+    this.points = new Float32Array((478) * (3));
+    this.paints = [];
+    this.session = null;
+    this.attempt = null;
+    this.runner = null;
+    this.loading = false;
+    this.visible = true;
+    this.frameHandle = 0;
+    this.frameScheduled = false;
+    this.nextHandle = 0;
+    this.placements = 0;
+    this.under = false;
+    this.closed = false;
+    this.step = () => {
+      this.frameScheduled = false;
+      let session = this.session, runner = this.runner;
+      if (session === null || runner === null || !this.wanted(session) || !this.visible || session.view === null) return;
+      let video = session.view.video, faces = 0;
+      try {
+        let count = runner.detect(video, this.now(), this.points);
+        count > 0 && this.solver.solve(this.points, count, video.videoHeight / Math.max(video.videoWidth, 1), this.solved) && (faces = 1);
+      } catch (error) {
+        this.options?.on_error?.(error);
+      }
+      this.tracked(session) && (faces === 1 && this.derive(runner), this.publish(session, faces), faces === 1 && this.paints.length > 0 && this.paint(session));
+      let attempt = this.attempt;
+      attempt !== null && attempt.framing && this.frame(attempt, session, video, faces), this.schedule();
+    };
+    this.grants = new CameraGrants((grant) => this.revoke(grant));
+    let scope = globalThis;
+    this.media = options?.media ?? scope.navigator?.mediaDevices ?? null, this.videoFactory = options?.video ?? insetVideo(options?.container ?? null, options?.surface), this.now = options?.now ?? (() => performance.now());
+  }
+  get live() {
+    return this.session?.media !== null && this.session?.media !== void 0;
+  }
+  observeRequest(bytes) {
+    this.grants.observeRequest(bytes);
+  }
+  observeResponse(bytes) {
+    this.grants.observeResponse(bytes) === AGE_UNDECLARED && this.options?.on_age_needed?.();
+  }
+  observeLifecycle(code) {
+    code === LifecycleCode.hidden || code === LifecycleCode.suspend ? this.setVisible(false) : code === LifecycleCode.visible || code === LifecycleCode.resume ? this.setVisible(true) : code === LifecycleCode.dispose && this.releaseAll();
+  }
+  handle(bytes) {
+    let tag = bytes[0];
+    if ((tag < MessageTag.camera_open || tag > MessageTag.camera_coloured) && tag !== MessageTag.camera_place && tag !== MessageTag.camera_identify) return false;
+    if (bytes.length < CAMERA_HANDLE_BYTES) return true;
+    let id = readWord(bytes, CAMERA_ID_AT);
+    switch (tag) {
+      case MessageTag.camera_open:
+        bytes.length >= CAMERA_OPEN_BYTES && this.open(id, bytes[CAMERA_PURPOSE_AT], decoder6.decode(bytes.subarray(CAMERA_OPEN_BYTES)));
+        break;
+      case MessageTag.camera_close:
+        this.close(id);
+        break;
+      case MessageTag.camera_track:
+        this.track(id);
+        break;
+      case MessageTag.camera_untrack:
+        this.untrack(id);
+        break;
+      case MessageTag.camera_colours:
+        bytes.length >= CAMERA_PAIR_BYTES && this.colours(id, readWord(bytes, CAMERA_SECOND_AT));
+        break;
+      case MessageTag.camera_place:
+        this.place(id, bytes);
+        break;
+      case MessageTag.camera_identify:
+        this.identify(id, decoder6.decode(bytes.subarray(CAMERA_HANDLE_BYTES)));
+        break;
+    }
+    return true;
+  }
+  setVisible(visible) {
+    if (this.visible === visible) return;
+    this.visible = visible, visible || this.attempt?.abort(CANCELLED);
+    let session = this.session;
+    if (session !== null) {
+      if (visible) {
+        this.acquire(session).then((ok) => {
+          ok && this.schedule();
+        });
+        return;
+      }
+      this.stopMedia(session), this.answerPaints(), this.tracked(session) && this.publish(session, 0);
+    }
+  }
+  shutdown() {
+    this.closed || (this.closed = true, this.releaseAll());
+  }
+  releaseAll() {
+    this.attempt?.abort(CANCELLED), this.grants.revokeAll();
+    let session = this.session;
+    session !== null && this.end(session);
+  }
+  async open(request2, purpose, grant) {
+    if (this.closed || this.options === null || this.media === null) return this.opened(request2, NO_CAMERA, CameraRefusal.unavailable);
+    if (purpose === CameraOpenPurpose.track) {
+      if (!this.grants.allowsFaceTracking(grant)) return this.opened(request2, NO_CAMERA, CameraRefusal.noGrant);
+    } else if (purpose === CameraOpenPurpose.view) {
+      if (!this.grants.allowsPreview(grant)) return this.opened(request2, NO_CAMERA, CameraRefusal.noPreview);
+    } else
+      return this.opened(request2, NO_CAMERA, CameraRefusal.unavailable);
+    if (this.session !== null && this.session.grant !== grant) return this.opened(request2, NO_CAMERA, CameraRefusal.busy);
+    let session = this.session ?? {
+      grant,
+      consumers: /* @__PURE__ */ new Map(),
+      media: null,
+      view: null,
+      colours: null,
+      acquiring: null
+    };
+    this.session = session, this.nextHandle = this.nextHandle + 1 >>> 0 || 1;
+    let consumer = {
+      handle: this.nextHandle,
+      purpose,
+      tracking: false,
+      rect: null,
+      shown: false,
+      placed: 0
+    };
+    session.consumers.set(consumer.handle, consumer);
+    let refusal = await this.acquireOrRefuse(session);
+    if (this.session !== session || !session.consumers.has(consumer.handle)) return this.opened(request2, NO_CAMERA, CameraRefusal.notOpen);
+    if (refusal !== null)
+      return session.consumers.delete(consumer.handle), session.consumers.size === 0 && this.end(session), this.opened(request2, NO_CAMERA, refusal);
+    this.opened(request2, consumer.handle, "");
+  }
+  async acquireOrRefuse(session) {
+    try {
+      return await this.acquire(session, !0) ? null : CameraRefusal.notOpen;
+    } catch (error) {
+      return error?.name === NOT_ALLOWED ? CameraRefusal.denied : CameraRefusal.unavailable;
+    }
+  }
+  acquire(session, rethrow = false) {
+    return session.media !== null || !this.visible ? Promise.resolve(true) : (session.acquiring ?? (session.acquiring = this.start(session).finally(() => {
+      session.acquiring = null;
+    })), rethrow ? session.acquiring : session.acquiring.catch(() => false));
+  }
+  async start(session) {
+    let stream = await this.media.getUserMedia(VIDEO_CONSTRAINTS);
+    if (this.session !== session || !this.visible) {
+      for (let track of stream.getTracks()) track.stop();
+      return this.session === session;
+    }
+    let view;
+    try {
+      view = await this.videoFactory(stream);
+    } catch (error) {
+      for (let track of stream.getTracks()) track.stop();
+      throw error;
+    }
+    if (this.session !== session || !this.visible) {
+      view.release();
+      for (let track of stream.getTracks()) track.stop();
+      return this.session === session;
+    }
+    return session.media = stream, session.view = view, session.colours = new WebFaceColours(view.video), this.restyle(session), this.options?.on_live?.(true), true;
+  }
+  stopMedia(session) {
+    this.cancelFrame(session);
+    let media = session.media, view = session.view;
+    if (session.media = null, session.view = null, session.colours = null, view?.release(), this.setUnder(false), media !== null) {
+      for (let track of media.getTracks()) track.stop();
+      this.options?.on_live?.(false);
+    }
+  }
+  end(session) {
+    this.session === session && (this.session = null, session.consumers.clear(), this.stopMedia(session), this.answerPaints());
+  }
+  consumer(handle) {
+    return this.session?.consumers.get(handle) ?? null;
+  }
+  close(handle) {
+    let session = this.session;
+    session === null || session.consumers.get(handle)?.purpose === (-1) || this.drop(session, handle);
+  }
+  drop(session, handle) {
+    if (session.consumers.delete(handle)) {
+      if (session.consumers.size === 0) {
+        this.end(session);
+        return;
+      }
+      this.wanted(session) || this.cancelFrame(session), this.restyle(session);
+    }
+  }
+  revoke(grant) {
+    this.attempt?.grant === grant && this.attempt.abort(CONSENT);
+    let session = this.session;
+    session !== null && session.grant === grant && this.end(session);
+  }
+  wanted(session) {
+    let attempt = this.attempt;
+    return this.tracked(session) || attempt !== null && attempt.framing && attempt.grant === session.grant;
+  }
+  frame(attempt, session, video, faces) {
+    let context = frameContext(this.solved, faces, attempt.ageRange), guidance = guidanceFor(context);
+    if (attempt.guide(guidance), !attempt.wanted || guidance !== READY || attempt.fitter === null) return;
+    attempt.wanted = false;
+    let landmarks = this.solved.subarray(0, SOLVED_LANDMARK_FLOATS), colours = null;
+    try {
+      colours = session.colours === null ? null : session.colours.sample(landmarks);
+    } catch (error) {
+      this.options?.on_error?.(error);
+    }
+    let identity = null;
+    try {
+      identity = fitIdentity(attempt.fitter, landmarks, video.videoWidth / Math.max(video.videoHeight, 1), capturedColours(colours), context);
+    } catch (error) {
+      this.options?.on_error?.(error);
+    }
+    identity !== null && (attempt.framing = false, attempt.push({ kind: "captured", identity }));
+  }
+  async identify(request2, grant) {
+    let identity = this.options?.identity;
+    if (this.closed || this.options === null || identity === void 0 || this.media === null || this.attempt !== null || !this.visible)
+      return this.identified(request2, { code: UNAVAILABLE });
+    if (!this.grants.allows(grant, IDENTITY_PURPOSE)) return this.identified(request2, { code: CONSENT });
+    this.nextHandle = this.nextHandle + 1 >>> 0 || 1;
+    let attempt = new IdentityAttempt(grant, this.nextHandle);
+    this.attempt = attempt;
+    let answer;
+    try {
+      answer = await this.capture(attempt, identity);
+    } catch (error) {
+      this.options.on_error?.(error), answer = { code: attempt.abortedWith ?? UNAVAILABLE };
+    }
+    attempt.framing = false, attempt.sheet?.close(), this.attempt === attempt && (this.attempt = null);
+    let session = this.session;
+    session !== null && session.grant === grant && this.drop(session, attempt.handle), this.identified(request2, answer);
+  }
+  async capture(attempt, options) {
+    let ageRange = await options.age_range(), refused = ageAnswer(ageRange);
+    if (refused !== null)
+      return ageRange === UNDECLARED_RANGE && this.options?.on_age_needed?.(), { code: refused };
+    if (attempt.abortedWith !== null) return { code: attempt.abortedWith };
+    attempt.ageRange = ageRange;
+    let fitter = identityFitter(options);
+    fitter.catch(() => {
+    }), attempt.sheet = (options.sheet ?? domIdentitySheet(this.options?.container ?? null))(attempt.events), attempt.sheet.consent();
+    let answered = await attempt.next();
+    if (answered.kind === "abort") return { code: answered.code };
+    if (answered.kind !== "agree") return { code: CONSENT };
+    attempt.consented = true;
+    let refusal = await this.openFor(attempt);
+    if (refusal !== null) return { code: refusal };
+    let session = this.session;
+    if (await this.loadRunner(), this.runner === null) return { code: UNAVAILABLE };
+    if (attempt.fitter = await fitter, attempt.abortedWith !== null || session.media === null) return { code: attempt.abortedWith ?? UNAVAILABLE };
+    let stream = session.media;
+    for (attempt.sheet.framing(stream), attempt.framing = true, attempt.shown = null, this.schedule(); ; ) {
+      let event = await attempt.next();
+      switch (event.kind) {
+        case "abort":
+          return { code: event.code };
+        case "capture":
+          attempt.wanted = true;
+          break;
+        case "captured":
+          attempt.identity = event.identity, attempt.sheet.result(options.save_avatar !== void 0);
+          break;
+        case "retake":
+          attempt.identity = null, attempt.sheet.framing(stream), attempt.framing = true, attempt.shown = null, this.schedule();
+          break;
+        case "use":
+          if (attempt.identity === null) break;
+          if (event.save && options.save_avatar !== void 0)
+            try {
+              await options.save_avatar(attempt.identity);
+            } catch (error) {
+              this.options?.on_error?.(error);
+            }
+          return { identity: attempt.identity };
+        default:
+          return { code: CANCELLED };
+      }
+    }
+  }
+  async openFor(attempt) {
+    if (this.session !== null && this.session.grant !== attempt.grant) return UNAVAILABLE;
+    let session = this.session ?? {
+      grant: attempt.grant,
+      consumers: /* @__PURE__ */ new Map(),
+      media: null,
+      view: null,
+      colours: null,
+      acquiring: null
+    };
+    this.session = session, session.consumers.set(attempt.handle, {
+      handle: attempt.handle,
+      purpose: (-1),
+      tracking: false,
+      rect: null,
+      shown: false,
+      placed: 0
+    });
+    let refusal = await this.acquireOrRefuse(session);
+    return attempt.abortedWith !== null ? attempt.abortedWith : this.session !== session || !session.consumers.has(attempt.handle) ? UNAVAILABLE : refusal === null ? null : refusal === CameraRefusal.denied ? CONSENT : UNAVAILABLE;
+  }
+  identified(request2, answer) {
+    let identity = "identity" in answer ? answer.identity : null, at = this.port.reserve(CAMERA_IDENTIFIED_BYTES + (identity?.length ?? 0)), out = this.port.out;
+    out[at] = MessageTag.camera_identified, writeWord(out, at + CAMERA_ID_AT, request2), out[at + CAMERA_IDENTITY_CODE_AT] = identity === null ? identityCodeByte(answer.code) : IDENTITY_CAPTURED, identity !== null && out.set(identity, at + CAMERA_IDENTIFIED_BYTES), this.port.commitTask();
+  }
+  tracked(session) {
+    for (let consumer of session.consumers.values()) if (consumer.tracking) return true;
+    return false;
+  }
+  track(handle) {
+    let consumer = this.consumer(handle);
+    consumer === null || consumer.purpose !== CameraOpenPurpose.track || (consumer.tracking = true, this.loadRunner().then(() => this.schedule()));
+  }
+  untrack(handle) {
+    let consumer = this.consumer(handle), session = this.session;
+    consumer === null || session === null || (consumer.tracking = false, this.wanted(session) || this.cancelFrame(session));
+  }
+  place(handle, bytes) {
+    let consumer = this.consumer(handle), session = this.session;
+    if (consumer === null || session === null || consumer.purpose !== CameraOpenPurpose.view) return;
+    let rect = readViewRect(bytes);
+    rect !== null && (consumer.rect = rect, consumer.shown = (bytes[CAMERA_PLACE_FLAGS_AT] & CameraViewFlag.shown) !== 0, consumer.placed = ++this.placements, this.restyle(session));
+  }
+  restyle(session) {
+    let view = session.view;
+    if (view === null) return;
+    let shown = null;
+    for (let consumer of session.consumers.values())
+      consumer.shown && consumer.rect !== null && (shown === null || consumer.placed > shown.placed) && (shown = consumer);
+    view.place(shown?.rect ?? null), this.setUnder(shown !== null && shown.rect !== null && !shown.rect.over);
+  }
+  setUnder(under) {
+    this.under !== under && (this.under = under, this.options?.on_under?.(under));
+  }
+  colours(handle, request2) {
+    let session = this.session, consumer = session?.consumers.get(handle);
+    if (session === null || consumer === void 0 || consumer.purpose === (-1) || session.media === null) {
+      this.coloured(request2, null);
+      return;
+    }
+    this.paints.push(request2);
+  }
+  paint(session) {
+    let requests = this.paints.splice(0, this.paints.length), result = null;
+    try {
+      result = session.colours === null ? null : session.colours.sample(this.solved.subarray(0, LANDMARK_FLOATS2));
+    } catch (error) {
+      this.options?.on_error?.(error);
+    }
+    for (let request2 of requests) this.coloured(request2, result);
+  }
+  answerPaints() {
+    let requests = this.paints.splice(0, this.paints.length);
+    for (let request2 of requests) this.coloured(request2, null);
+  }
+  async loadRunner() {
+    if (!(this.runner !== null || this.loading || this.options === null)) {
+      this.loading = true;
+      try {
+        this.runner = await this.options.runner();
+      } catch (error) {
+        this.options.on_error?.(error);
+      } finally {
+        this.loading = false;
+      }
+    }
+  }
+  schedule() {
+    let session = this.session;
+    if (this.frameScheduled || session === null || !this.wanted(session) || !this.visible || session.view === null || this.runner === null) return;
+    this.frameScheduled = true;
+    let video = session.view.video;
+    typeof video.requestVideoFrameCallback == "function" ? this.frameHandle = video.requestVideoFrameCallback(this.step) : this.frameHandle = requestAnimationFrame(this.step);
+  }
+  cancelFrame(session) {
+    if (!this.frameScheduled) return;
+    this.frameScheduled = false;
+    let video = session.view?.video;
+    video !== void 0 && typeof video.cancelVideoFrameCallback == "function" ? video.cancelVideoFrameCallback(this.frameHandle) : cancelAnimationFrame(this.frameHandle);
+  }
+  derive(runner) {
+    let solved = this.solved;
+    for (let i = 0; i < EXPRESSION_FLOATS; i++) this.expressions[i] = solved[LANDMARK_FLOATS2 + i];
+    for (let i = 0; i < POSE_FLOATS; i++) this.pose[i] = solved[LANDMARK_FLOATS2 + EXPRESSION_FLOATS + i];
+    let measured = runner.weigh?.(this.arkit) ?? false;
+    measured || deriveArkit(this.expressions, this.arkit), this.stagingWords[FACE_FRAME.measured - FACE_FRAME.faces] = measured ? (1) : (0);
+  }
+  publish(session, faces) {
+    this.stagingWords[0] = faces;
+    for (let consumer of session.consumers.values()) {
+      if (!consumer.tracking) continue;
+      let at = this.port.reserve(CAMERA_FACE_BYTES), out = this.port.out;
+      out[at] = MessageTag.camera_face, writeWord(out, at + CAMERA_ID_AT, consumer.handle), out.set(this.stagingBytes, at + CAMERA_HANDLE_BYTES), this.port.commitFrame();
+    }
+  }
+  opened(request2, handle, reason) {
+    let text2 = new TextEncoder().encode(reason), at = this.port.reserve(CAMERA_PAIR_BYTES + text2.length), out = this.port.out;
+    out[at] = MessageTag.camera_opened, writeWord(out, at + CAMERA_ID_AT, request2), writeWord(out, at + CAMERA_SECOND_AT, handle), out.set(text2, at + CAMERA_PAIR_BYTES), this.port.commitTask();
+  }
+  coloured(request2, colours) {
+    let at = this.port.reserve(CAMERA_COLOURED_BYTES), out = this.port.out;
+    out[at] = MessageTag.camera_coloured, writeWord(out, at + CAMERA_ID_AT, request2), writeWord(out, at + CAMERA_SECOND_AT, colours === null ? NO_FACE_COLOUR : colours.skin), writeWord(out, at + CAMERA_SECOND_AT + CAMERA_WORD_BYTES, colours === null ? NO_FACE_COLOUR : colours.hair), writeWord(out, at + CAMERA_SECOND_AT + CAMERA_WORD_BYTES * 2, colours === null ? NO_FACE_COLOUR : colours.eye), this.port.commitTask();
+  }
+};
+
+// src/interactives/hosts/font-relay.ts
+var FontRelay = class {
+  constructor(port, source) {
+    this.port = port;
+    this.source = source;
+  }
+  handle(bytes) {
+    if (bytes[0] !== MessageTag.font_request) return false;
+    if (bytes.length < FONT_REQUEST_BYTES) return true;
+    let request2 = readWord(bytes, FONT_ID_AT), codepoint = readWord(bytes, FONT_CODEPOINT_AT), source = this.source;
+    return source === null ? (this.reply(request2, null), true) : (source(codepoint).then(
+      (face) => this.reply(request2, face),
+      () => this.reply(request2, null)
+    ), true);
+  }
+  reply(request2, face) {
+    let length = face === null ? 0 : face.byteLength, at = this.port.reserve(FONT_REPLY_HEADER_BYTES + length), out = this.port.out;
+    out[at] = MessageTag.font_reply, writeWord(out, at + FONT_ID_AT, request2), face !== null && out.set(face, at + FONT_REPLY_HEADER_BYTES), this.port.commitTask();
+  }
+};
+
+// src/interactives/hosts/canvas.ts
+var CANVAS_SANDBOX = "allow-scripts", CONTENT_SANDBOX = "allow-scripts allow-same-origin", ANY_ORIGIN = "*", CANVAS_PERMISSIONS = "cross-origin-isolated; autoplay; gamepad; fullscreen; accelerometer; gyroscope", RELAY_SCRATCH_SLOTS = 64, ROOM_OPERATIONS = /* @__PURE__ */ new Set(["room.create", "room.join"]), SCRIPT_CLOSE = /<\/script/gi, SCRIPT_CLOSE_ESCAPED = "<\\/script", FRAME_STYLE = "position:relative;z-index:1;border:0;width:100%;height:100%;display:none;background:#000", FRAME_SHOWN = "block", FRAME_BACKDROP = "#000", FRAME_SEE_THROUGH = "transparent", NAVIGATED = "the canvas document navigated away from its package", LITTLE_ENDIAN = true, NO_PING = -1, BEAT_RECHECK_MS = 50, AUDIO_WARM_TIMEOUT_MS = 2e3, PING_SEQUENCE_OFFSET = 1, PONG_HEAP_OFFSET = 5;
+function sharedHeartbeat() {
+  return typeof SharedArrayBuffer == "function" && globalThis.crossOriginIsolated === true ? new SharedArrayBuffer((16)) : null;
+}
+var NETWORK_DIALERS = (transport, url) => transport === Transport.WebTransport ? new WebTransportDialer(url) : new WebSocketDialer(url);
+function fallbackFonts(options) {
+  if (options.fallback_fonts !== void 0) return options.fallback_fonts;
+  let base = options.asset_cdn_base;
+  return base == null ? null : notoFallbackSource(notoFallbackBase(base), (url) => fetch(url));
+}
+function base64(bytes) {
+  return encodeBase64(bytes);
+}
+function canvasPolicy(scriptHash) {
+  return [
+    "default-src 'none'",
+    `script-src 'sha256-${scriptHash}' blob: 'wasm-unsafe-eval'`,
+    "worker-src blob:",
+    "connect-src 'none'",
+    "img-src blob: data:",
+    "media-src blob:",
+    "font-src blob: data:",
+    "style-src 'unsafe-inline'",
+    "base-uri 'none'",
+    "form-action 'none'"
+  ].join("; ");
+}
+function canvasDocument(runtime) {
+  let script = runtime.replace(SCRIPT_CLOSE, SCRIPT_CLOSE_ESCAPED), digest = new Uint8Array(SHA256_BYTES);
+  return sha256Into(new TextEncoder().encode(script), digest), `<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${canvasPolicy(base64(digest))}"><meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no,viewport-fit=cover"><style>html,body{margin:0;width:100%;height:100%;overflow:hidden;background:transparent;touch-action:none;user-select:none}</style><script>${script}</script></head><body></body></html>`;
+}
+var RelayHandler = class {
+  constructor(relay, id) {
+    this.relay = relay;
+    this.id = id;
+  }
+  frame(lane, bytes) {
+    this.relay.inbound(this.id, lane, bytes);
+  }
+  closed() {
+    this.relay.lost(this.id);
+  }
+}, RoomRelay = class {
+  constructor(port, dialers) {
+    this.port = port;
+    this.dialers = dialers;
+    this.links = Array.from({ length: (64) }, () => ({ link: null, dialing: false }));
+    this.handlers = Array.from({ length: (64) }, (_, i) => new RelayHandler(this, i));
+    this.scratch = Array.from({ length: (64) }, () => new SizedViews(new Uint8Array(PACKET_BYTES)));
+    this.allowed = /* @__PURE__ */ new Set();
+    this.pending = /* @__PURE__ */ new Set();
+    this.next = 0;
+  }
+  observeRequest(bytes) {
+    let envelope = readJson(bytes);
+    ROOM_OPERATIONS.has(envelope.call.operation) && this.pending.add(envelope.request_id);
+  }
+  observeResponse(bytes) {
+    if (this.pending.size === 0) return;
+    let envelope = readJson(bytes);
+    if (!this.pending.delete(envelope.request_id) || envelope.outcome.status !== "ok") return;
+    let endpoints = envelope.outcome.response.result.tick?.endpoints;
+    endpoints?.web_transport && this.allowed.add(`${Transport.WebTransport} ${endpoints.web_transport}`), endpoints?.web_socket && this.allowed.add(`${Transport.WebSocket} ${endpoints.web_socket}`);
+  }
+  handle(bytes) {
+    switch (bytes[0]) {
+      case MessageTag.room_dial:
+        return this.dial(bytes), true;
+      case MessageTag.room_send:
+        return this.outbound(bytes), true;
+      case MessageTag.room_close:
+        return this.close(linkOf(bytes)), true;
+    }
+    return false;
+  }
+  dial(bytes) {
+    let id = linkOf(bytes), transport = transportOf(bytes[(3)]), urlBytes = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint16(4, (true)), url = new TextDecoder().decode(bytes.subarray((6), (6) + urlBytes)), request2 = bytes.slice((6) + urlBytes), entry = this.links[id], dialer = transport === null || entry === void 0 || entry.link !== null || entry.dialing || !this.allowed.has(`${transport} ${url}`) ? null : this.dialers(transport, url);
+    if (dialer === null) {
+      this.dialed(id, null);
+      return;
+    }
+    entry.dialing = true, dialer.dial(request2, this.handlers[id]).then(
+      (dialed) => this.settle(id, dialed),
+      () => this.settle(id, null)
+    );
+  }
+  settle(id, dialed) {
+    let entry = this.links[id];
+    if (!entry.dialing) {
+      dialed?.link.close();
+      return;
+    }
+    entry.dialing = false, entry.link = dialed?.link ?? null, this.dialed(id, dialed);
+  }
+  dialed(id, dialed) {
+    let reply = dialed?.reply, length = reply === void 0 ? 0 : reply.length, at = this.port.reserve((3) + 1 + length), out = this.port.out;
+    writeLinkHeader(out, at, MessageTag.room_dialed, id), out[at + (3)] = dialed === null ? 0 : (1), reply !== void 0 && out.set(reply, at + (3) + 1), this.port.commitTask();
+  }
+  outbound(bytes) {
+    let link = this.links[linkOf(bytes)]?.link;
+    if (link == null) return;
+    let payload = bytes.subarray((4));
+    if (payload.length > PACKET_BYTES) return;
+    let slot = this.scratch[this.next];
+    this.next = (this.next + 1) % (64), slot.buffer.set(payload), link.send(bytes[(3)], slot.of(payload.length));
+  }
+  inbound(id, lane, bytes) {
+    this.links[id].link !== null && writeRoomFrame(this.port, MessageTag.room_frames, id, lane, bytes);
+  }
+  lost(id) {
+    let entry = this.links[id];
+    entry.link !== null && (entry.link = null, writeRoomSignal(this.port, MessageTag.room_closed, id));
+  }
+  close(id) {
+    let entry = this.links[id];
+    if (entry === void 0) return;
+    entry.dialing = false;
+    let link = entry.link;
+    entry.link = null, link?.close();
+  }
+  closeAll() {
+    for (let i = 0; i < (64); i++) this.close(i);
+  }
+}, CanvasEngine = class {
+  constructor(options, document2, placement) {
+    this.target = ANY_ORIGIN;
+    this.hosted = false;
+    this.terminated = false;
+    this.channel = new MessageChannel();
+    this.listener = () => {
+    };
+    this.crashed = () => {
+    };
+    this.loads = 0;
+    this.heartbeat = sharedHeartbeat();
+    this.beats = this.heartbeat === null ? null : new Int32Array(this.heartbeat, 0, 1);
+    this.heap = this.heartbeat === null ? null : new Float64Array(this.heartbeat, (8), 1);
+    this.pong = new Uint8Array(PONG_BYTES);
+    this.pongView = new DataView(this.pong.buffer);
+    this.lastBeat = 0;
+    this.beatsShared = false;
+    this.pending = (-1);
+    this.recheck = null;
+    this.checkBeat = () => {
+      this.recheck = null;
+      let beats = this.beats;
+      if (beats === null || this.pending === (-1)) return;
+      let current = Atomics.load(beats, (0));
+      if (current === this.lastBeat) {
+        this.recheck = setTimeout(this.checkBeat, (50));
+        return;
+      }
+      this.lastBeat = current, this.pong[0] = MessageTag.pong, this.pongView.setUint32((1), this.pending, (true)), this.pongView.setFloat64((5), this.heap[0], (true)), this.pending = (-1), this.listener(this.pong);
+    };
+    let frame = options.container.ownerDocument.createElement("iframe");
+    frame.setAttribute("allow", CANVAS_PERMISSIONS), frame.setAttribute("referrerpolicy", "no-referrer"), frame.setAttribute("style", FRAME_STYLE), this.frame = frame, this.placed = placement !== null, this.bridge = new PortBridge(this.channel.port1, options.scheduler ?? animationFrameScheduler()), this.relay = new RoomRelay(this.bridge, options.dialers ?? NETWORK_DIALERS);
+    let camera = options.camera ?? null;
+    this.clips = new ClipRelay(this.bridge), this.camera = new FaceCameraRelay(
+      this.bridge,
+      camera === null ? null : {
+        ...camera,
+        container: camera.container ?? options.container,
+        on_live: (live) => {
+          camera.on_live?.(live), this.clips.cameraLive(live);
+        },
+        surface: camera.surface ?? (() => ({ left: frame.offsetLeft, top: frame.offsetTop })),
+        on_under: (under) => {
+          frame.style.background = under ? FRAME_SEE_THROUGH : FRAME_BACKDROP, camera.on_under?.(under);
+        }
+      }
+    ), this.fonts = new FontRelay(this.bridge, fallbackFonts(options)), this.bridge.on_message((bytes) => this.fromGuest(bytes));
+    let boot = {
+      engine: options.engine ?? "core",
+      heartbeat: null,
+      game_ui_accessibility: options.game_ui_accessibility ?? true,
+      engine_session: options.engine_session ?? null
+    };
+    frame.addEventListener("load", () => {
+      if (++this.loads > 1) {
+        this.crashed(NAVIGATED);
+        return;
+      }
+      let guest = frame.contentWindow;
+      guest?.postMessage(boot, this.target, [this.channel.port2]), this.heartbeat !== null && guest?.postMessage({ heartbeat: this.heartbeat }, this.target);
+    }), placement === null ? this.place(options.container, document2, null) : placement.reachable.then((hosted) => this.place(options.container, document2, hosted ? placement : null));
+  }
+  get fetches_wasm() {
+    return this.hosted;
+  }
+  get may_fetch_wasm() {
+    return this.placed;
+  }
+  place(container, document2, placement) {
+    this.terminated || (placement === null ? (this.frame.setAttribute("sandbox", CANVAS_SANDBOX), this.frame.srcdoc = document2) : (this.frame.setAttribute("sandbox", CONTENT_SANDBOX), this.frame.src = placement.origin + placement.shell, this.target = placement.origin, this.hosted = true), container.appendChild(this.frame));
+  }
+  beating() {
+    return this.beatsShared ? true : (this.beatsShared = this.beats !== null && Atomics.load(this.beats, (0)) !== 0, this.beatsShared);
+  }
+  fromGuest(bytes) {
+    this.relay.handle(bytes) || this.camera.handle(bytes) || this.fonts.handle(bytes) || this.clips.handle(bytes) || (bytes[0] === MessageTag.request && (this.relay.observeRequest(bytes), this.camera.observeRequest(bytes)), this.listener(bytes));
+  }
+  send(bytes, length) {
+    let tag = bytes[0];
+    if (tag === MessageTag.ping && this.beating()) {
+      this.pending = (bytes[1] | bytes[2] << 8 | bytes[3] << 16 | bytes[4] << 24) >>> 0, this.checkBeat();
+      return;
+    }
+    if (tag === MessageTag.start && (this.frame.style.display = FRAME_SHOWN), tag === MessageTag.response) {
+      let response = bytes.subarray(0, length);
+      this.relay.observeResponse(response), this.camera.observeResponse(response);
+    }
+    tag === MessageTag.lifecycle && this.camera.observeLifecycle(bytes[1]), tag === MessageTag.frames ? this.bridge.sendFrame(bytes, length) : this.bridge.send(bytes, length);
+  }
+  on_message(listener) {
+    this.listener = listener;
+  }
+  on_crash(listener) {
+    this.crashed = listener;
+  }
+  terminate() {
+    this.terminated = true, this.recheck !== null && clearTimeout(this.recheck), this.pending = (-1), this.relay.closeAll(), this.camera.shutdown(), this.clips.shutdown(), this.channel.port1.close(), this.frame.remove();
+  }
+};
+function probeShell(origin, shell) {
+  return typeof fetch != "function" ? Promise.resolve(false) : fetch(origin + shell, { method: "HEAD", mode: "cors", credentials: "omit", redirect: "error" }).then(
+    (response) => response.ok,
+    () => false
+  );
+}
+var audioWarmed = false;
+function warmAudioOutput() {
+  if (audioWarmed || typeof AudioContext != "function") return;
+  audioWarmed = true;
+  let warm = () => {
+    try {
+      new AudioContext().close();
+    } catch {
+      audioWarmed = false;
+    }
+  }, idle = globalThis.requestIdleCallback;
+  typeof idle == "function" ? idle(warm, { timeout: (2e3) }) : setTimeout(warm, 0);
+}
+function iframeEngines(options) {
+  warmAudioOutput();
+  let document2 = canvasDocument(options.runtime), content = options.content ?? null, shell = content === null ? "" : shellPath(sha256Hex(new TextEncoder().encode(options.runtime))), reachable = null, placement = (interactive) => {
+    if (content === null || interactive === void 0) return null;
+    let origin = guestOrigin(content, interactive);
+    return reachable ?? (reachable = probeShell(origin, shell)), { origin, shell, reachable };
+  };
+  return { spawn: (interactive) => new CanvasEngine(options, document2, placement(interactive)), isolates_interactives: content !== null };
+}
+
+// src/interactives/hosts/face-landmarker.ts
+var TASKS_VISION = "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@1.0.1/", FACE_MODEL = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task", FACE_LANDMARKER = {
+  runtime: "@mediapipe/tasks-vision",
+  runtime_version: "1.0.1",
+  model: "face_landmarker/float16/1",
+  licence: "Apache-2.0",
+  points: 478,
+  parts: {
+    bundle: {
+      sha256: "d885630c297c0b20b1fe86096cb06291c4c8080876f27852e724f24ac603713f",
+      bytes: 155439,
+      type: "text/javascript",
+      upstream: `${TASKS_VISION}vision_bundle.mjs`
+    },
+    loader: {
+      sha256: "e170ee67dd4e16c1a6fcd8840a206687e5a59b22c20e4a902bc445b095454d73",
+      bytes: 323377,
+      type: "text/javascript",
+      upstream: `${TASKS_VISION}wasm/vision_wasm_internal.js`
+    },
+    wasm: {
+      sha256: "8da277a733926eacd0474b8704b36742d6ec3231c57a860c5b889dff8f1df886",
+      bytes: 11756954,
+      type: "application/wasm",
+      upstream: `${TASKS_VISION}wasm/vision_wasm_internal.wasm`
+    },
+    model: {
+      sha256: "64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff",
+      bytes: 3758596,
+      type: "application/octet-stream",
+      upstream: FACE_MODEL
+    }
+  }
+}, DELEGATES = ["GPU", "CPU"], FACES = 1, STRIDE2 = 3;
+function defaultScope() {
+  return {
+    URL,
+    Blob,
+    import: (url) => import(
+      /* @vite-ignore */
+      url
+    )
+  };
+}
+function partSource(source, store) {
+  return store === null ? async (digest) => (await fetchVerified(source, [digest]))[0] : (digest) => store.fetch(digest, source);
+}
+var UNMAPPED = -2, MAX_CATEGORIES = 64;
+function weighBlendshapes(categories, lookup, out) {
+  if (categories === void 0 || categories.length === 0) return false;
+  out.fill(0, 0, ARKIT_WEIGHTS);
+  for (let i = 0; i < categories.length; i++) {
+    let at;
+    i < lookup.length ? (lookup[i] === (-2) && (lookup[i] = arkitIndex(categories[i].categoryName)), at = lookup[i]) : at = arkitIndex(categories[i].categoryName), at >= 0 && (out[at] = categories[i].score);
+  }
+  return true;
+}
+var MediaPipeRunner = class {
+  constructor(landmarker) {
+    this.landmarker = landmarker;
+    this.last = Number.NEGATIVE_INFINITY;
+    this.categories = void 0;
+    this.lookup = new Int32Array((64)).fill((-2));
+  }
+  weigh(out) {
+    return weighBlendshapes(this.categories, this.lookup, out);
+  }
+  detect(video, timestamp_ms, out) {
+    let at = timestamp_ms > this.last ? timestamp_ms : this.last + 1;
+    this.last = at;
+    let result = this.landmarker.detectForVideo(video, at), faces = result.faceLandmarks;
+    if (this.categories = result.faceBlendshapes?.[0]?.categories, faces.length === 0) return 0;
+    let points = faces[0], count = Math.min(points.length, Math.floor(out.length / (3)));
+    for (let i = 0; i < count; i++) {
+      let point = points[i];
+      out[i * (3)] = point.x, out[i * (3) + 1] = point.y, out[i * (3) + 2] = point.z;
+    }
+    return count;
+  }
+  close() {
+    this.landmarker.close();
+  }
+};
+async function createRunner(fetchPart, scope) {
+  let parts = FACE_LANDMARKER.parts, [bundle, loader, wasm, model] = await Promise.all([parts.bundle, parts.loader, parts.wasm, parts.model].map((part) => fetchPart(part.sha256))), urls = [
+    scope.URL.createObjectURL(new scope.Blob([bundle], { type: parts.bundle.type })),
+    scope.URL.createObjectURL(new scope.Blob([loader], { type: parts.loader.type })),
+    scope.URL.createObjectURL(new scope.Blob([wasm], { type: parts.wasm.type }))
+  ];
+  try {
+    let vision = await scope.import(urls[0]), failure = null;
+    for (let delegate of DELEGATES)
+      try {
+        let landmarker = await vision.FaceLandmarker.createFromOptions(
+          { wasmLoaderPath: urls[1], wasmBinaryPath: urls[2] },
+          {
+            baseOptions: { modelAssetBuffer: model, delegate },
+            runningMode: "VIDEO",
+            numFaces: (1),
+            outputFaceBlendshapes: !0,
+            outputFacialTransformationMatrixes: !1
+          }
+        );
+        return new MediaPipeRunner(landmarker);
+      } catch (error) {
+        failure = error;
+      }
+    throw failure;
+  } finally {
+    for (let url of urls) scope.URL.revokeObjectURL(url);
+  }
+}
+function mediaPipeFaceRunner(source, store = null, scope = defaultScope()) {
+  let loading = null, fetchPart = partSource(source, store);
+  return () => (loading ?? (loading = createRunner(fetchPart, scope).catch((error) => {
+    throw loading = null, error;
+  })), loading);
+}
+
+// src/interactives/content/edge.ts
+var MAX_WASM_TWIN_BYTES = 16 * 1024 * 1024;
+var BROTLI_CODING = "br", ACCEPT_SEPARATOR = ",", PARAMETER_SEPARATOR = ";", QUALITY_PREFIX = "q=", NO_QUALITY = 0;
+function acceptsBrotli(accept) {
+  return accept === null ? false : accept.split(ACCEPT_SEPARATOR).some((entry) => {
+    let [coding, ...parameters] = entry.split(PARAMETER_SEPARATOR).map((part) => part.trim().toLowerCase());
+    if (coding !== BROTLI_CODING) return false;
+    let quality = parameters.find((parameter) => parameter.startsWith(QUALITY_PREFIX));
+    return quality === void 0 || Number(quality.slice(QUALITY_PREFIX.length)) > (0);
+  });
+}
+var CHUNK_MAGIC = 1262701891, CHUNK_FORMAT_VERSION = 1, CHUNK_HEADER_BYTES = 64, CHUNK_KIND_WASM = 6, CHUNK_KIND_DATA = 5, OFFSET_MAGIC = 0, OFFSET_VERSION = 4, OFFSET_KIND = 6, OFFSET_LENGTH = 8, OFFSET_PAYLOAD = 16, TWO_32 = 2 ** 32, STATUS_OK = 200, STATUS_NOT_FOUND = 404, STATUS_NOT_ALLOWED = 405, STATUS_BAD_GATEWAY = 502, IMMUTABLE = "public, max-age=31536000, immutable", NO_STORE = "no-store", SHELL_STYLE = "html,body{margin:0;width:100%;height:100%;overflow:hidden;background:transparent;touch-action:none;user-select:none}", VIEWPORT = "width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no,viewport-fit=cover", READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]), ISOLATION_HEADERS = {
+  "cross-origin-opener-policy": "same-origin",
+  "cross-origin-embedder-policy": "require-corp",
+  "cross-origin-resource-policy": "cross-origin",
+  "origin-agent-cluster": "?1",
+  "x-content-type-options": "nosniff",
+  "referrer-policy": "no-referrer",
+  "access-control-allow-origin": "*"
+}, SHA256 = "SHA-256", HEX_RADIX = 16, HEX_PAIR = 2;
+async function digestHex(bytes) {
+  let subtle = globalThis.crypto?.subtle;
+  if (subtle === void 0) return sha256Hex(bytes);
+  let digest = new Uint8Array(await subtle.digest(SHA256, bytes)), out = "";
+  for (let i = 0; i < digest.length; i++) out += digest[i].toString((16)).padStart((2), "0");
+  return out;
+}
+function shellPolicy(runtimeDigest, policy) {
+  let script = sri(runtimeDigest), ancestors = policy.frame_ancestors.length === 0 ? "'none'" : policy.frame_ancestors.join(" ");
+  return [
+    "default-src 'none'",
+    `script-src '${script}' blob: 'wasm-unsafe-eval'`,
+    "worker-src blob:",
+    "connect-src 'self'",
+    "img-src blob: data:",
+    "media-src blob:",
+    "font-src blob: data:",
+    "style-src 'unsafe-inline'",
+    "base-uri 'none'",
+    "form-action 'none'",
+    `frame-ancestors ${ancestors}`
+  ].join("; ");
+}
+function shellDocument(runtimeDigest) {
+  let integrity = sri(runtimeDigest);
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="${VIEWPORT}"><style>${SHELL_STYLE}</style><script src="${runtimePath(runtimeDigest)}" integrity="${integrity}"></script></head><body></body></html>`;
+}
+function respond(status, body, headers, head) {
+  return new Response(head ? null : body, { status, headers: { ...ISOLATION_HEADERS, ...headers } });
+}
+var VARY_ENCODING = "Accept-Encoding";
+function brotliWasm(twin) {
+  let init = {
+    status: (200),
+    headers: {
+      ...ISOLATION_HEADERS,
+      "content-type": "application/wasm",
+      "content-encoding": BROTLI_CODING,
+      vary: VARY_ENCODING,
+      "cache-control": IMMUTABLE
+    },
+    encodeBody: "manual"
+  };
+  return new Response(twin, init);
+}
+function missing(head) {
+  return respond((404), "not found", { "content-type": "text/plain; charset=utf-8", "cache-control": NO_STORE }, head);
+}
+function wasmPayload(chunk, kind = (6)) {
+  if (chunk.length < (64)) return null;
+  let view = new DataView(chunk.buffer, chunk.byteOffset, (64));
+  if (view.getUint32((0), true) !== (1262701891) || view.getUint16((4), true) !== (1) || view.getUint8((6)) !== kind) return null;
+  let length = view.getUint32((8) + 4, true) * TWO_32 + view.getUint32((8), true), offset = view.getUint32((16), true);
+  return offset < (64) || length > chunk.length - offset ? null : chunk.subarray(offset, offset + length);
+}
+function digestBetween(path, prefix, suffix) {
+  if (!path.startsWith(prefix) || !path.endsWith(suffix)) return null;
+  let digest = path.slice(prefix.length, path.length - suffix.length);
+  return isDigestHex(digest) ? digest : null;
+}
+function joinedParts(url) {
+  let listed = url.searchParams.get(JOINED_PARTS_PARAM);
+  if (listed === null || [...url.searchParams.keys()].length !== 1) return null;
+  let parts = listed.split(JOINED_PART_SEPARATOR);
+  return parts.length < 2 || parts.length > MAX_JOINED_PARTS || !parts.every(isDigestHex) ? null : parts;
+}
+async function joinedWasm(digest, parts, store) {
+  let chunks = await Promise.all(parts.map((part) => store.chunk(part))), payloads = [], total = 0;
+  for (let i = 0; i < parts.length; i++) {
+    let chunk = chunks[i];
+    if (chunk === null) return "missing";
+    if (await digestHex(chunk) !== parts[i]) return "mismatch";
+    let payload = wasmPayload(chunk, (5));
+    if (payload === null) return "missing";
+    payloads.push(payload), total += payload.length;
+  }
+  let joined = new Uint8Array(total), at = 0;
+  for (let payload of payloads)
+    joined.set(payload, at), at += payload.length;
+  return await digestHex(joined) === digest ? joined : "mismatch";
+}
+async function serveContent(request2, store, policy) {
+  if (!READ_METHODS.has(request2.method))
+    return respond((405), "method not allowed", { allow: "GET, HEAD", "cache-control": NO_STORE }, false);
+  let head = request2.method === "HEAD", url = new URL(request2.url), path = url.pathname, joinedDigest = digestBetween(path, JOINED_PREFIX, WASM_SUFFIX);
+  if (joinedDigest !== null) {
+    let parts = joinedParts(url);
+    if (parts === null) return missing(head);
+    let joined = await joinedWasm(joinedDigest, parts, store);
+    return joined === "missing" ? missing(head) : joined === "mismatch" ? respond((502), "joined digest mismatch", { "cache-control": NO_STORE }, head) : respond((200), joined, { "content-type": "application/wasm", "cache-control": IMMUTABLE }, head);
+  }
+  let shell = digestBetween(path, SHELL_PREFIX, "");
+  if (shell !== null) {
+    let runtime = await store.runtime(shell);
+    return runtime === null || await digestHex(runtime) !== shell ? missing(head) : respond(
+      (200),
+      shellDocument(shell),
+      { "content-type": "text/html; charset=utf-8", "cache-control": IMMUTABLE, "content-security-policy": shellPolicy(shell, policy) },
+      head
+    );
+  }
+  let script = digestBetween(path, RUNTIME_PREFIX, RUNTIME_SUFFIX);
+  if (script !== null) {
+    let runtime = await store.runtime(script);
+    return runtime === null ? missing(head) : await digestHex(runtime) !== script ? respond((502), "runtime digest mismatch", { "cache-control": NO_STORE }, head) : respond((200), runtime, { "content-type": "text/javascript; charset=utf-8", "cache-control": IMMUTABLE }, head);
+  }
+  let wasm = digestBetween(path, WASM_PREFIX, WASM_SUFFIX);
+  if (wasm !== null) {
+    if (!head && store.wasmTwin !== void 0 && acceptsBrotli(request2.headers.get("accept-encoding"))) {
+      let twin = await store.wasmTwin(wasm);
+      if (twin !== null && twin.length > 0 && twin.length <= MAX_WASM_TWIN_BYTES) return brotliWasm(twin);
+    }
+    let chunk = await store.chunk(wasm);
+    if (chunk === null) return missing(head);
+    if (await digestHex(chunk) !== wasm) return respond((502), "chunk digest mismatch", { "cache-control": NO_STORE }, head);
+    let payload = wasmPayload(chunk);
+    return payload === null ? missing(head) : respond((200), payload, { "content-type": "application/wasm", "cache-control": IMMUTABLE, vary: VARY_ENCODING }, head);
+  }
+  return missing(head);
+}
+
+// src/interactives/hosts/spindrift.ts
+var REPAIR_SYMBOL_BYTES = 1024, DECODE_SLACK = 2, NOMINAL_RTT_MS = 300, NOMINAL_BYTES_PER_SECOND = 125e3, NOMINAL_CONCURRENCY = 4, RUN_LIMIT_BYTES = 256 * 1024, MS_PER_SECOND = 1e3, PARTIAL_CONTENT = 206, SECURE_PROTOCOL2 = "https:", DECODED = 0, INSUFFICIENT = 1;
+function partSymbols(bytes) {
+  return Math.max(1, Math.ceil(bytes / (1024)));
+}
+function nominalCostMs(requests, bytes) {
+  return Math.ceil(requests / (4)) * (300) + bytes * (1e3) / (125e3);
+}
+async function repairDecoder(wasm) {
+  let module = wasm instanceof WebAssembly.Module ? wasm : await WebAssembly.compile(wasm), exports = (await WebAssembly.instantiate(module, {})).exports;
+  return {
+    decode(block, known, repair) {
+      let symbols = known.length;
+      if (symbols === 0 || block.length !== symbols * (1024) || repair.length % (1024) !== 0) return "shape";
+      let blockAt = exports.cimplify_spindrift_alloc(block.length), knownAt = exports.cimplify_spindrift_alloc(known.length), repairAt = exports.cimplify_spindrift_alloc(repair.length);
+      try {
+        if (blockAt === 0 || knownAt === 0 || repairAt === 0) return "shape";
+        let memory = new Uint8Array(exports.memory.buffer);
+        memory.set(block, blockAt), memory.set(known, knownAt), memory.set(repair, repairAt);
+        let code = exports.cimplify_spindrift_decode(blockAt, symbols, knownAt, repairAt, repair.length / (1024));
+        return code === (0) && block.set(new Uint8Array(exports.memory.buffer, blockAt, block.length)), code === (0) ? "decoded" : code === (1) ? "insufficient" : "shape";
+      } finally {
+        exports.cimplify_spindrift_free(blockAt, block.length), exports.cimplify_spindrift_free(knownAt, known.length), exports.cimplify_spindrift_free(repairAt, repair.length);
+      }
+    }
+  };
+}
+function cdnRepairs(base, fetcher = fetch) {
+  if (new URL(base).protocol !== SECURE_PROTOCOL2) throw new Error(`repair files come only from the CDN over TLS, not ${base}`);
+  return {
+    async fetchRepair(digest, symbols, signal) {
+      let bytes = symbols * (1024), response = await fetcher(new URL(digest, base).href, { signal, headers: { Range: `bytes=0-${bytes - 1}` } });
+      if (!response.ok) throw new Error(`repair file ${digest} answered ${response.status}`);
+      let body = new Uint8Array(await response.arrayBuffer());
+      if (body.length < bytes) throw new Error(`repair file ${digest} answered ${body.length} bytes for ${bytes}`);
+      return response.status === (206) && body.length === bytes ? body : body.slice(0, bytes);
+    }
+  };
+}
+function runsOf(members, missing2) {
+  let runs = 0, bytes = 0, last = -2;
+  for (let index of missing2) {
+    let size = members[index].size;
+    (index !== last + 1 || bytes + size > RUN_LIMIT_BYTES) && (runs++, bytes = 0), bytes += size, last = index;
+  }
+  return runs;
+}
+function planZone(members, held, files) {
+  let plans = [], covered = Array.from({ length: members.length }, () => false);
+  for (let file of files) {
+    let end = file.first + file.parts;
+    if (file.first < 0 || end > members.length || members.slice(file.first, end).reduce((sum, member) => sum + partSymbols(member.size), 0) !== file.symbols) continue;
+    let missing2 = [], missingSymbols = 0, missingBytes = 0;
+    for (let index = file.first; index < end; index++)
+      covered[index] = true, !held[index] && (missing2.push(index), missingSymbols += partSymbols(members[index].size), missingBytes += members[index].size);
+    if (missing2.length === 0) continue;
+    let ask = missingSymbols + (2), runs = runsOf(members, missing2), repairs = ask <= file.repair && nominalCostMs(1, ask * (1024)) < nominalCostMs(runs, missingBytes);
+    plans.push(repairs ? { kind: "repair", file, missing: missing2, ask } : { kind: "runs", missing: missing2, runs });
+  }
+  let rest = [];
+  for (let index = 0; index < members.length; index++) !covered[index] && !held[index] && rest.push(index);
+  return rest.length > 0 && plans.push({ kind: "runs", missing: rest, runs: runsOf(members, rest) }), plans;
+}
+async function decodeBlock(store, members, plan, repair, decoder7) {
+  let { file } = plan, block = new Uint8Array(file.symbols * (1024)), known = new Uint8Array(file.symbols), offsets = [], missing2 = new Set(plan.missing), symbol = 0;
+  for (let index = file.first; index < file.first + file.parts; index++) {
+    offsets.push(symbol);
+    let span = partSymbols(members[index].size);
+    if (!missing2.has(index)) {
+      let body = await store.read(members[index].digest);
+      if (body === null || body.length !== members[index].size) return plan.missing.slice();
+      block.set(body, symbol * (1024)), known.fill(1, symbol, symbol + span);
+    }
+    symbol += span;
+  }
+  if (decoder7.decode(block, known, repair) !== "decoded") return plan.missing.slice();
+  let failed = [];
+  for (let index of plan.missing) {
+    let start = offsets[index - file.first] * (1024), body = block.slice(start, start + members[index].size);
+    await verifyChunk(members[index].digest, body) ? await store.admit(members[index].digest, body) : failed.push(index);
+  }
+  return failed;
+}
+async function completeZone(store, members, files, upstream, repairs, decoder7, signal) {
+  let held = members.map((member) => store.has(member.digest)), repaired = 0, fetched = 0, requests = 0, repairBytes = 0, plain = [];
+  for (let plan of planZone(members, held, files)) {
+    if (plan.kind === "runs") {
+      plain.push(...plan.missing), requests += plan.runs;
+      continue;
+    }
+    requests++;
+    let repair = await repairs.fetchRepair(plan.file.digest, plan.ask, signal).catch(() => null), failed = repair === null ? plan.missing.slice() : await decodeBlock(store, members, plan, repair, decoder7);
+    repair !== null && (repairBytes += repair.length), repaired += plan.missing.length - failed.length, failed.length > 0 && (plain.push(...failed), requests += runsOf(members, failed));
+  }
+  return plain.length > 0 && (plain.sort((a, b) => a - b), fetched = (await store.fetchRun(
+    plain.map((index) => members[index].digest),
+    upstream,
+    signal
+  )).filter((body) => body !== null).length), { repaired, fetched, requests, repair_bytes: repairBytes };
+}
+
+// src/interactives/hosts/shoal.ts
+var SHOAL_MAX_MESSAGE_BYTES = 65536, ID_BYTES = 32, POINTER_BYTES = 4, HOLDINGS_OPEN_BYTES = 6 * (4), OPEN_BYTES = 3 * (4), PART_BYTES = (32) + 4, EVENT_BYTES = 16, SCRATCH_BYTES = 32, OK = 0, EVENT_KINDS = ["reconciled", "unreconciled", "admitted", "rejected", "missing", "closed"], CLOSE_REASONS = ["mismatch", "hostile", "peer", "finished"], HIGH_WATER_BYTES = 1 << 20, LOW_WATER_BYTES = 256 * 1024, ShoalHoldings = class {
+  constructor(exports, handle) {
+    this.sessions = 0;
+    this.exports = exports, this.handle = handle;
+  }
+  setHeld(zone, index, held) {
+    this.handle !== 0 && this.exports.cimplify_shoal_holdings_set_held(this.handle, zone, index, held ? 1 : 0);
+  }
+  /** A session over these holdings, asking for `order`'s zones in turn. Free it before the holdings. */
+  session(order) {
+    if (this.handle === 0) throw new Error("these holdings were freed");
+    let bytes = OPEN_BYTES + order.length * 4, base = this.exports.cimplify_spindrift_alloc(bytes);
+    if (base === 0) throw new Error("the delivery module could not allocate a session");
+    try {
+      let view = new DataView(this.exports.memory.buffer), at = base + OPEN_BYTES;
+      order.forEach((zone, k) => view.setUint32(at + k * 4, zone, !0)), [this.handle, at, order.length].forEach((value, k) => view.setUint32(base + k * (4), value, !0));
+      let session = this.exports.cimplify_shoal_open(base);
+      if (session === 0) throw new Error("the delivery module refused the session");
+      return this.sessions++, new ShoalSession(this.exports, session, this, () => this.sessions--);
+    } finally {
+      this.exports.cimplify_spindrift_free(base, bytes);
+    }
+  }
+  /** Frees the holdings; every session over them must be freed first. */
+  free() {
+    if (this.handle !== 0) {
+      if (this.sessions > 0) throw new Error("free every session over these holdings first");
+      this.exports.cimplify_shoal_holdings_free(this.handle), this.handle = 0;
+    }
+  }
+}, ShoalSession = class {
+  constructor(exports, session, holdings, released) {
+    this.staging = 0;
+    this.stagingBytes = 0;
+    if (this.exports = exports, this.holdings = holdings, this.released = released, this.session = session, this.message = exports.cimplify_spindrift_alloc((65536)), this.scratch = exports.cimplify_spindrift_alloc((32)), this.message === 0 || this.scratch === 0) throw new Error("the delivery module could not allocate a session's buffers");
+  }
+  get bytes() {
+    return new Uint8Array(this.exports.memory.buffer);
+  }
+  get view() {
+    return new DataView(this.exports.memory.buffer);
+  }
+  /** Hands the session one received message and returns the events it raised. */
+  receive(message) {
+    return this.session === 0 ? [] : (message.length > (65536) ? (this.bytes.fill(0, this.message, this.message + 1), this.exports.cimplify_shoal_receive(this.session, this.message, 1)) : (this.bytes.set(message, this.message), this.exports.cimplify_shoal_receive(this.session, this.message, message.length)), this.events());
+  }
+  /** The next message to send, or null when there is nothing to send now. */
+  transmit() {
+    if (this.session === 0) return null;
+    let length = this.exports.cimplify_shoal_transmit(this.session, this.message, (65536));
+    return length === 0 ? null : this.bytes.slice(this.message, this.message + length);
+  }
+  events() {
+    let out = [];
+    for (; this.session !== 0 && this.exports.cimplify_shoal_event(this.session, this.scratch) === 1; ) {
+      let view = this.view, kind = EVENT_KINDS[view.getUint32(this.scratch, true) - 1], zone = view.getUint32(this.scratch + 4, true), index = view.getUint32(this.scratch + 8, true), value = view.getUint32(this.scratch + 12, true);
+      kind === "reconciled" ? out.push({ kind, zone, wanted: value }) : kind === "unreconciled" ? out.push({ kind, zone }) : kind === "admitted" ? out.push({ kind, zone, index, body: this.admitted() }) : kind === "rejected" || kind === "missing" ? out.push({ kind, zone, index }) : kind === "closed" && out.push({ kind, reason: CLOSE_REASONS[value - 1] ?? "hostile" });
+    }
+    return out;
+  }
+  admitted() {
+    let length = this.exports.cimplify_shoal_admitted(this.session, this.scratch + (16)), at = this.view.getUint32(this.scratch + (16), true);
+    return this.bytes.slice(at, at + length);
+  }
+  /** The held part the peer asked for whose bytes the session is waiting on. */
+  need() {
+    return this.session === 0 || this.exports.cimplify_shoal_need(this.session, this.scratch, this.scratch + 4) !== 1 ? null : { zone: this.view.getUint32(this.scratch, true), index: this.view.getUint32(this.scratch + 4, true) };
+  }
+  provide(zone, index, body) {
+    return this.session === 0 || this.stagingBytes < body.length && (this.staging !== 0 && this.exports.cimplify_spindrift_free(this.staging, this.stagingBytes), this.staging = this.exports.cimplify_spindrift_alloc(body.length), this.stagingBytes = this.staging === 0 ? 0 : body.length, this.staging === 0) ? false : (this.bytes.set(body, this.staging), this.exports.cimplify_shoal_provide(this.session, zone, index, this.staging, body.length) === (0));
+  }
+  /** Marks a part held or not in the holdings this session borrows. */
+  setHeld(zone, index, held) {
+    this.holdings.setHeld(zone, index, held);
+  }
+  closed() {
+    if (this.session === 0) return "peer";
+    let code = this.exports.cimplify_shoal_closed(this.session);
+    return code === 0 ? null : CLOSE_REASONS[code - 1] ?? "hostile";
+  }
+  free() {
+    this.session !== 0 && (this.exports.cimplify_shoal_free(this.session), this.exports.cimplify_spindrift_free(this.message, (65536)), this.exports.cimplify_spindrift_free(this.scratch, (32)), this.staging !== 0 && this.exports.cimplify_spindrift_free(this.staging, this.stagingBytes), this.session = 0, this.released());
+  }
+};
+function idBytes(text2, what) {
+  let out = new Uint8Array((32));
+  if (!unhex(text2, out)) throw new Error(`${what} must be ${(32)} bytes of hex`);
+  return out;
+}
+var PEER_SHARING_FEATURE = "peer_sharing";
+function peerSharingEnabled(features) {
+  return features.includes(PEER_SHARING_FEATURE);
+}
+async function openPeerSharing(features, load) {
+  return peerSharingEnabled(features) ? shoalModule(await load()) : null;
+}
+async function shoalModule(wasm) {
+  let module = wasm instanceof WebAssembly.Module ? wasm : await WebAssembly.compile(wasm), exports = (await WebAssembly.instantiate(module, {})).exports;
+  return {
+    holdings(options) {
+      let game = idBytes(options.game, "the game id"), root = idBytes(options.root, "the manifest root"), parts = options.zones.flat(), ids = 2 * (32), countBytes = options.zones.length * 4, partBytes = parts.length * PART_BYTES, total = HOLDINGS_OPEN_BYTES + ids + countBytes + partBytes + parts.length, base = exports.cimplify_spindrift_alloc(total);
+      if (base === 0) throw new Error("the delivery module could not allocate the holdings");
+      try {
+        let memory = new Uint8Array(exports.memory.buffer), view = new DataView(exports.memory.buffer), at = { ids: base + HOLDINGS_OPEN_BYTES, counts: base + HOLDINGS_OPEN_BYTES + ids, parts: 0, held: 0 };
+        at.parts = at.counts + countBytes, at.held = at.parts + partBytes, memory.set(game, at.ids), memory.set(root, at.ids + (32)), options.zones.forEach((zone, k) => view.setUint32(at.counts + k * 4, zone.length, !0)), parts.forEach((part, k) => {
+          let digest = memory.subarray(at.parts + k * PART_BYTES, at.parts + k * PART_BYTES + (32));
+          if (!unhex(part.digest, digest)) throw new Error(`part digest ${part.digest} is not ${(32)} bytes of hex`);
+          view.setUint32(at.parts + k * PART_BYTES + (32), part.size, !0), memory[at.held + k] = options.holds(part.digest) ? 1 : 0;
+        }), [at.ids, at.ids + (32), options.zones.length, at.counts, at.parts, at.held].forEach((value, k) => view.setUint32(base + k * (4), value, !0));
+        let handle = exports.cimplify_shoal_holdings_open(base);
+        if (handle === 0) throw new Error("the delivery module refused the manifest");
+        return new ShoalHoldings(exports, handle);
+      } finally {
+        exports.cimplify_spindrift_free(base, total);
+      }
+    }
+  };
+}
+function runOverChannel(session, channel, store, zones) {
+  let admitted = 0, rejected = 0, reconciled = [], unreconciled = [], staging = false, settled = false;
+  return new Promise((resolve) => {
+    let finish = (reason) => {
+      settled || (settled = true, session.free(), channel.close(), resolve({ reason, admitted, rejected, reconciled, unreconciled }));
+    }, handle = (events) => {
+      for (let event of events)
+        if (event.kind === "admitted") {
+          admitted++;
+          let digest = zones[event.zone]?.[event.index]?.digest;
+          digest !== void 0 && store.admit(digest, event.body);
+        } else event.kind === "rejected" ? rejected++ : event.kind === "reconciled" ? reconciled.push(event.zone) : event.kind === "unreconciled" && unreconciled.push(event.zone);
+    }, pump = () => {
+      for (; !settled && channel.readyState === "open" && channel.bufferedAmount < HIGH_WATER_BYTES; ) {
+        let message = session.transmit();
+        if (message === null) break;
+        channel.send(message);
+      }
+      let closed = session.closed();
+      if (closed !== null)
+        return handle(session.events()), finish(closed);
+      let need = staging ? null : session.need();
+      if (need === null) return;
+      let digest = zones[need.zone]?.[need.index]?.digest;
+      digest !== void 0 && (staging = true, store.read(digest).then((body) => {
+        staging = false, !settled && ((body === null || !session.provide(need.zone, need.index, body)) && session.setHeld(need.zone, need.index, false), pump());
+      }));
+    };
+    channel.binaryType = "arraybuffer", channel.bufferedAmountLowThreshold = LOW_WATER_BYTES, channel.onopen = pump, channel.onbufferedamountlow = pump, channel.onclose = () => finish(session.closed() ?? "peer"), channel.onmessage = (event) => {
+      let data = event.data;
+      data instanceof ArrayBuffer && (handle(session.receive(new Uint8Array(data))), pump());
+    }, channel.readyState === "open" && pump();
+  });
+}
+
+// src/interactives/hosts/chrome/controller.ts
+var HostChromeController = class {
+  constructor() {
+    this.queue = [];
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (listener) => (this.listeners.add(listener), () => this.listeners.delete(listener));
+    this.snapshot = () => this.queue[0]?.sheet ?? null;
+  }
+  ask(sheet, fallback) {
+    return new Promise((resolve) => {
+      this.queue.push({ sheet, settle: resolve, fallback }), this.queue.length === 1 && this.notify();
+    });
+  }
+  notify() {
+    for (let listener of this.listeners) listener();
+  }
+  requestConsent(consent) {
+    return this.ask({ kind: "consent", consent }, false);
+  }
+  confirmSpend(prompt) {
+    return this.ask({ kind: "spend", prompt }, "cancelled");
+  }
+  showAd(creative) {
+    return this.ask({ kind: "ad", creative }, "skipped");
+  }
+  offerClip(media) {
+    return this.ask({ kind: "clip", media }, "done");
+  }
+  open(sheet) {
+    this.ask(sheet, void 0);
+  }
+  resolve(value) {
+    let current = this.queue.shift();
+    current !== void 0 && (current.settle(value), this.notify());
+  }
+  dismiss() {
+    let current = this.queue[0];
+    current !== void 0 && this.resolve(current.fallback);
+  }
+  dismissAll() {
+    for (; this.queue.length > 0; ) this.dismiss();
+  }
+};
+
+// src/interactives/parts/boot-delivery.ts
+var BOOT_FORMAT_VERSION = 1, PARTIAL_CONTENT2 = 206, SECURE_PROTOCOL3 = "https:", LAZY_GROUP_PREFIX = "lazy:", BYTECODE_GROUP_PREFIX = "engine:hermes";
+function bootSection(head) {
+  let boot = head.boot;
+  if (boot == null || boot.version !== (1) || !Array.isArray(boot.parts) || !Number.isSafeInteger(boot.follow) || boot.follow < 0 || boot.follow > boot.parts.length) return null;
+  let offset = 0;
+  for (let k = 0; k < boot.parts.length; k++) {
+    let part = boot.parts[k];
+    if (typeof part?.digest != "string" || !Number.isSafeInteger(part.size) || part.size < 0 || head.asset_groups[part.group] === void 0 || k === boot.follow && offset !== boot.follow_offset) return null;
+    offset += part.size;
+  }
+  return boot.follow === boot.parts.length && offset !== boot.follow_offset ? null : offset === boot.bytes ? boot : null;
+}
+function bootChunks(head, boot) {
+  return boot.parts.map((part, k) => {
+    let group = head.asset_groups[part.group];
+    return {
+      digest: part.digest,
+      size: part.size,
+      asset_group: group.name,
+      before_play: k < boot.follow,
+      lazy: k >= boot.follow || group.name.startsWith(LAZY_GROUP_PREFIX),
+      runtime: null,
+      payload_digest: null
+    };
+  });
+}
+function cdnBootRanges(base, fetcher = fetch) {
+  if (new URL(base).protocol !== SECURE_PROTOCOL3) throw new Error(`boot files come only from the CDN over TLS, not ${base}`);
+  return {
+    async fetchRange(file, start, end, signal) {
+      let response = await fetcher(new URL(file, base).href, { signal, headers: { Range: `bytes=${start}-${end - 1}` } });
+      if (!response.ok) throw new Error(`boot file ${file} answered ${response.status}`);
+      let body = new Uint8Array(await response.arrayBuffer());
+      if (response.status === (206)) {
+        if (body.length !== end - start) throw new Error(`boot file ${file} answered ${body.length} bytes for ${end - start}`);
+        return body;
+      }
+      if (body.length < end) throw new Error(`boot file ${file} answered ${body.length} bytes for ${end}`);
+      return body.subarray(start, end);
+    }
+  };
+}
+function webBootTail(boot, groups) {
+  let last = boot.follow;
+  for (; last > 0 && (groups[boot.parts[last - 1].group]?.name ?? "").startsWith(BYTECODE_GROUP_PREFIX); ) last--;
+  return last;
+}
+async function installBootRange(store, boot, source, range, signal, bootParts = boot.follow) {
+  let kept = Math.max(0, Math.min(bootParts, boot.follow)), bootEnd = boot.parts.slice(0, kept).reduce((sum, part) => sum + part.size, 0), [first, last, start, end] = range === "boot" ? [0, kept, 0, bootEnd] : [boot.follow, boot.parts.length, boot.follow_offset, boot.bytes];
+  if (end <= start) return { parts: 0, bytes: 0, refused: [] };
+  if (!boot.parts.slice(first, last).some((part) => !store.has(part.digest))) return { parts: 0, bytes: 0, refused: [] };
+  let bytes = await source.fetchRange(boot.file, start, end, signal), refused = [], at = 0, parts = 0;
+  for (let part of boot.parts.slice(first, last)) {
+    let body = bytes.subarray(at, at + part.size);
+    if (at += part.size, !store.has(part.digest)) {
+      if (!await verifyChunk(part.digest, body)) {
+        refused.push(part.digest);
+        continue;
+      }
+      await store.admit(part.digest, body.slice()), parts++;
+    }
+  }
+  return { parts, bytes: bytes.length, refused };
+}
+
+// src/interactives/parts/boot-bundle.ts
+var BOOT_BUNDLE_MAGIC = 1145979459, BOOT_BUNDLE_VERSION = 1, BOOT_BUNDLE_HEADER_BYTES = 32, BOOT_BUNDLE_PART_BYTES = 36, BOOT_BUNDLE_MAX_HEAD_BYTES = 16 * 1024 * 1024, BOOT_BUNDLE_MAX_KEY_ID_BYTES = 64, BOOT_BUNDLE_SIGNATURE_BYTES = 64, BOOT_BUNDLE_MAX_PARTS = 4096, BOOT_BUNDLE_KEY_PREFIX = "boot/", BOOT_BUNDLE_HERMES_SUFFIX = ".hermes";
+var MAX_BOOT_BUNDLE_BYTES = 64 * 1024 * 1024, BYTECODE_GROUP_PREFIX2 = "engine:hermes", BYTECODE_GROUP_SEPARATOR = "@", Field = { magic: 0, version: 4, flavour: 6, bytecode: 8, head: 12, keyId: 16, signature: 20, parts: 24, reserved: 28 }, BootBundleFlavour = { source: 0, hermes: 1 }, BootBundleRefusal = {
+  bounds: "bounds",
+  signature: "signature",
+  head: "head",
+  launch: "launch",
+  table: "table"
+}, BootBundleError = class extends Error {
+  constructor(refusal) {
+    super(`the boot bundle is refused: ${refusal}`);
+    this.refusal = refusal;
+    this.name = "BootBundleError";
+  }
+};
+function bootBundleKey(package_digest, bytecode = null) {
+  return `${BOOT_BUNDLE_KEY_PREFIX}${package_digest}${bytecode === null ? "" : `${BOOT_BUNDLE_HERMES_SUFFIX}${bytecode}`}`;
+}
+function bytecodeOf(group) {
+  if (!group.startsWith(BYTECODE_GROUP_PREFIX2)) return null;
+  let at = group.indexOf(BYTECODE_GROUP_SEPARATOR), version = at < 0 ? Number.NaN : Number(group.slice(at + 1));
+  return Number.isSafeInteger(version) ? version : Number.NaN;
+}
+function allowed(boot, head, flavour, bytecode) {
+  let group = (k) => head.asset_groups[boot.parts[k].group]?.name ?? "", out = boot.parts.map((_, k) => k < boot.follow);
+  if (flavour === BootBundleFlavour.source)
+    for (let k = boot.follow - 1; k >= 0 && bytecodeOf(group(k)) !== null; k--) out[k] = false;
+  else
+    for (let k = 0; k < boot.follow; k++) {
+      let version = bytecodeOf(group(k));
+      version !== null && version !== bytecode && (out[k] = false);
+    }
+  return out;
+}
+function u32(view, at) {
+  return view.getUint32(at, true);
+}
+function openBootBundle(bytes, launch, trust) {
+  if (bytes.length < (32)) throw new BootBundleError(BootBundleRefusal.bounds);
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), flavour = view.getUint16(Field.flavour, true), [headBytes, keyBytes, signatureBytes, count] = [u32(view, Field.head), u32(view, Field.keyId), u32(view, Field.signature), u32(view, Field.parts)];
+  if (u32(view, Field.magic) !== (1145979459) || view.getUint16(Field.version, true) !== (1) || flavour !== BootBundleFlavour.source && flavour !== BootBundleFlavour.hermes || u32(view, Field.reserved) !== 0 || headBytes > BOOT_BUNDLE_MAX_HEAD_BYTES || keyBytes > (64) || signatureBytes !== (64) || count > (4096))
+    throw new BootBundleError(BootBundleRefusal.bounds);
+  let bytecode = u32(view, Field.bytecode), keyAt = (32) + headBytes, signatureAt = keyAt + keyBytes, tableAt = signatureAt + signatureBytes, bodiesAt = tableAt + count * (36);
+  if (bodiesAt > bytes.length) throw new BootBundleError(BootBundleRefusal.bounds);
+  let sizes = [], total = bodiesAt;
+  for (let k = 0; k < count; k++) {
+    let size = u32(view, tableAt + k * (36) + SHA256_BYTES);
+    sizes.push(size), total += size;
+  }
+  if (total !== bytes.length) throw new BootBundleError(BootBundleRefusal.bounds);
+  let head = bytes.subarray((32), keyAt), parsed;
+  try {
+    let peek = JSON.parse(new TextDecoder().decode(head));
+    parsed = openWeaveHead(
+      { root: peek.weave, head: encodeBase64(head), signature: encodeBase64(bytes.subarray(signatureAt, tableAt)), key_id: new TextDecoder().decode(bytes.subarray(keyAt, signatureAt)) },
+      trust
+    );
+  } catch {
+    throw new BootBundleError(BootBundleRefusal.signature);
+  }
+  if (parsed.interactive_id !== launch.interactive_id || parsed.revision_id !== launch.revision_id) throw new BootBundleError(BootBundleRefusal.launch);
+  let boot = bootSection(parsed);
+  if (boot === null) throw new BootBundleError(BootBundleRefusal.head);
+  let may = allowed(boot, parsed, flavour, bytecode), parts = [], refused = [], digest = new Uint8Array(SHA256_BYTES), next = 0, at = bodiesAt;
+  for (let k = 0; k < count; k++) {
+    let name = hex(bytes.subarray(tableAt + k * (36), tableAt + k * (36) + SHA256_BYTES));
+    for (; next < boot.parts.length && boot.parts[next].digest !== name; ) next++;
+    if (next === boot.parts.length || !may[next] || boot.parts[next].size !== sizes[k]) throw new BootBundleError(BootBundleRefusal.table);
+    next++;
+    let body = bytes.subarray(at, at + sizes[k]);
+    at += sizes[k], sha256Into(body, digest), hex(digest) === name ? parts.push({ digest: name, body }) : refused.push(name);
+  }
+  return { head: parsed, boot, flavour, bytecode, parts, refused };
+}
+async function fetchBootBundle(fetcher, url) {
+  let twin = await fetchTwin(fetcher, url, MAX_BOOT_BUNDLE_BYTES);
+  if (twin !== null) return twin;
+  let response = await fetcher(url);
+  if (!response.ok) return null;
+  let bytes = new Uint8Array(await response.arrayBuffer());
+  return { bytes, wire: bytes.length };
+}
+
+// src/interactives/hosts/chrome/prefetch.ts
+var PREFETCH_BATCH = 24, MILESTONE_MARK_PREFIX = "cimplify:", FEED_DWELL_MS = 300, FEED_SESSION_BYTES = 96 * 1024 * 1024, LAZY_GROUP_PREFIX2 = "lazy:";
+function abortError() {
+  let error = new Error("the chunk fetch was aborted");
+  return error.name = "AbortError", error;
+}
+var ChunkCache = class {
+  constructor(origin) {
+    this.origin = origin;
+    this.bodies = /* @__PURE__ */ new Map();
+    this.flights = /* @__PURE__ */ new Map();
+    this.abortedCount = 0;
+  }
+  cached(digest) {
+    return this.bodies.has(digest) || this.flights.has(digest);
+  }
+  holders(digest) {
+    return this.flights.get(digest)?.holders ?? 0;
+  }
+  get aborted() {
+    return this.abortedCount;
+  }
+  from(base) {
+    let source = this.origin(base);
+    return {
+      ...source.fetchTwin === void 0 ? {} : { fetchTwin: source.fetchTwin.bind(source) },
+      fetch: (digest, signal) => {
+        let done2 = this.bodies.get(digest);
+        if (done2 !== void 0) return done2;
+        if (signal?.aborted === true) return Promise.reject(abortError());
+        let flight = this.flights.get(digest);
+        return flight === void 0 && (flight = this.start(source, digest)), this.hold(digest, flight, signal);
+      }
+    };
+  }
+  start(source, digest) {
+    let controller = typeof AbortController == "function" ? new AbortController() : null, body = source.fetch(digest, controller?.signal), flight = { body, controller, holders: 0 };
+    return this.flights.set(digest, flight), body.then(
+      () => {
+        this.flights.get(digest) === flight && (this.flights.delete(digest), this.bodies.set(digest, body));
+      },
+      () => {
+        this.flights.get(digest) === flight && this.flights.delete(digest);
+      }
+    ), flight;
+  }
+  hold(digest, flight, signal) {
+    return flight.holders++, signal === void 0 ? flight.body.finally(() => {
+      flight.holders--;
+    }) : new Promise((resolve, reject) => {
+      let settled = false, leave = () => {
+        settled || (settled = true, signal.removeEventListener("abort", aborted), flight.holders--);
+      }, aborted = () => {
+        settled || (leave(), reject(abortError()), flight.holders === 0 && this.flights.get(digest) === flight && (this.flights.delete(digest), flight.controller?.abort(), this.abortedCount++));
+      };
+      signal.addEventListener("abort", aborted), flight.body.then(
+        (bytes) => {
+          settled || (leave(), resolve(bytes));
+        },
+        (error) => {
+          settled || (leave(), reject(error));
+        }
+      );
+    });
+  }
+}, IDLE_SCHEDULER = {
+  defer(run) {
+    let scope = globalThis;
+    typeof scope.requestIdleCallback == "function" ? scope.requestIdleCallback(run) : setTimeout(run, 0);
+  }
+}, DEFAULT_TIMERS = {
+  set: (run, ms) => setTimeout(run, ms),
+  clear: (timer) => clearTimeout(timer)
+}, BOOT_RANGES = ["boot", "follow"];
+function decoratedChunks(head) {
+  let out = [];
+  for (let chunk of head.chunks) {
+    let group = head.asset_groups[chunk.group];
+    group === void 0 || typeof chunk.guest == "string" || out.push({
+      digest: chunk.digest,
+      size: chunk.size,
+      asset_group: group.name,
+      before_play: group.before_play,
+      lazy: group.name.startsWith(LAZY_GROUP_PREFIX2),
+      runtime: chunk.runtime ?? null,
+      payload_digest: chunk.payload_digest ?? null,
+      ...typeof chunk.brotli_bytes == "number" ? { twinned: true } : {}
+    });
+  }
+  return out;
+}
+function feedChunks(chunks, depth, tier, isolated, threads) {
+  if (depth.feed === "none" || depth.feed_bytes <= 0) return [];
+  let hosted = chunksForHost(chunks, null, isolated, tier, threads).filter(
+    (chunk) => chunk.before_play && chunk.lazy !== true && !(chunk.asset_group ?? "").startsWith(LAZY_GROUP_PREFIX2)
+  ), lead = hosted.filter(linksBeforeStart), ordered = depth.feed === "lead" ? lead : [...lead, ...hosted.filter((chunk) => !linksBeforeStart(chunk))], out = [], bytes = 0;
+  for (let chunk of ordered) {
+    let size = chunk.size ?? 0;
+    if (bytes + size > depth.feed_bytes) break;
+    bytes += size, out.push(chunk);
+  }
+  return out;
+}
+var PackagePrefetcher = class {
+  constructor(registry, chunks, channel = "live", scheduler = IDLE_SCHEDULER, options = {}) {
+    this.registry = registry;
+    this.chunks = chunks;
+    this.channel = channel;
+    this.scheduler = scheduler;
+    this.options = options;
+    this.states = /* @__PURE__ */ new Map();
+    this.dwell = /* @__PURE__ */ new Map();
+    this.indexing = [];
+    this.ready = [];
+    this.indexes = /* @__PURE__ */ new Map();
+    this.roots = /* @__PURE__ */ new Map();
+    this.boots = /* @__PURE__ */ new Map();
+    this.tails = /* @__PURE__ */ new Map();
+    this.transfers = /* @__PURE__ */ new Map();
+    this.launches = /* @__PURE__ */ new Map();
+    this.scheduled = false;
+    this.running = 0;
+    this.paused = false;
+    this.fetched = 0;
+    this.flush = () => {
+      for (this.scheduled = false; this.indexing.length > 0; ) this.load(this.indexing.splice(0, (24)));
+    };
+    this.network = options.network ?? webNetworkHint, this.timers = options.timers ?? DEFAULT_TIMERS;
+  }
+  package(interactive_id) {
+    return this.indexes.get(interactive_id) ?? null;
+  }
+  state(interactive_id) {
+    return this.states.get(interactive_id) ?? "idle";
+  }
+  get bytesFetched() {
+    return this.fetched;
+  }
+  get active() {
+    return this.running;
+  }
+  depth() {
+    return prefetchDepth(this.network());
+  }
+  visible(interactive_id, launch = null) {
+    launch !== null && this.launches.set(interactive_id, launch);
+    let state = this.state(interactive_id);
+    if (state !== "idle" && state !== "cancelled" || this.depth().feed === "none") return;
+    let dwell = this.options.dwell_ms ?? (300);
+    if (this.states.set(interactive_id, "dwelling"), dwell <= 0) {
+      this.dwelled(interactive_id);
+      return;
+    }
+    this.dwell.set(
+      interactive_id,
+      this.timers.set(() => this.dwelled(interactive_id), dwell)
+    );
+  }
+  hidden(interactive_id) {
+    let timer = this.dwell.get(interactive_id);
+    timer !== void 0 && (this.timers.clear(timer), this.dwell.delete(interactive_id));
+    let state = this.state(interactive_id);
+    (state === "dwelling" || state === "waiting" || state === "running") && this.states.set(interactive_id, "cancelled"), this.transfers.get(interactive_id)?.abort(), remove(this.indexing, interactive_id), remove(this.ready, interactive_id);
+  }
+  pause() {
+    this.paused = true;
+    for (let controller of this.transfers.values()) controller.abort();
+  }
+  resume() {
+    this.paused = false, this.pump();
+  }
+  dwelled(interactive_id) {
+    if (this.dwell.delete(interactive_id), this.state(interactive_id) === "dwelling") {
+      if (this.states.set(interactive_id, "waiting"), this.indexes.has(interactive_id)) {
+        this.ready.push(interactive_id), this.pump();
+        return;
+      }
+      this.indexing.push(interactive_id), !this.scheduled && (this.scheduled = true, this.scheduler.defer(this.flush));
+    }
+  }
+  async bundle(interactive_id) {
+    let launch = this.launches.get(interactive_id), base = this.options.boot_bundle_base, trust = this.options.weave_trust, store = this.options.part_store;
+    if (launch === void 0 || base === void 0 || trust === void 0 || store === void 0) return null;
+    try {
+      let fetched = await fetchBootBundle(this.options.fetcher ?? fetch, `${base}${bootBundleKey(launch.package_digest)}`);
+      if (fetched === null) return null;
+      let bytes = fetched.bytes, opened = openBootBundle(bytes, { interactive_id, revision_id: launch.revision_id }, trust);
+      for (let part of opened.parts) await store.admit(part.digest, part.body.slice());
+      this.fetched += fetched.wire, this.boots.set(interactive_id, opened.boot), this.tails.set(interactive_id, webBootTail(opened.boot, opened.head.asset_groups));
+      let chunks = [...decoratedChunks(opened.head), ...bootChunks(opened.head, opened.boot)];
+      return { interactive_id, package: { revision_id: launch.revision_id, package_digest: launch.package_digest, chunk_base_url: base, chunks } };
+    } catch {
+      return null;
+    }
+  }
+  async load(ids) {
+    let found;
+    try {
+      let launched = ids.filter((id) => this.launches.has(id)), bundled = launched.length === 0 ? [] : (await Promise.all(launched.map((id) => this.bundle(id)))).filter((entry) => entry !== null), rest = ids.filter((id) => !bundled.some((entry) => entry.interactive_id === id)), listed = [...bundled, ...rest.length === 0 ? [] : await this.registry.packages(rest, this.channel, this.options.form ?? "weave")];
+      found = listed.some((entry) => woven(entry.package)) ? (await Promise.all(listed.map((entry) => this.unweave(entry)))).filter((entry) => entry !== null) : listed;
+    } catch {
+      for (let id of ids) this.state(id) === "waiting" && this.states.set(id, "cancelled");
+      return;
+    }
+    for (let entry of found)
+      this.indexes.set(entry.interactive_id, entry.package), this.state(entry.interactive_id) === "waiting" && this.ready.push(entry.interactive_id);
+    for (let id of ids) this.state(id) === "waiting" && !this.indexes.has(id) && this.states.set(id, "done");
+    this.pump();
+  }
+  async unweave(entry) {
+    let index = entry.package;
+    if (!woven(index) || index.weave === void 0) return entry;
+    let id = entry.interactive_id;
+    try {
+      let head = openWeaveHead(index.weave, this.options.weave_trust ?? null), boot = bootSection(head);
+      if (boot !== null)
+        return this.boots.set(id, boot), this.tails.set(id, webBootTail(boot, head.asset_groups)), { interactive_id: id, package: { ...index, chunks: [...decoratedChunks(head), ...bootChunks(head, boot)] } };
+      let upstream = this.chunks.from(index.chunk_base_url), store = this.options.part_store, nodes = store === void 0 ? chunkWeaveSource(upstream) : storeWeaveSource(store, upstream), { index: unwoven } = await unweaveIndex(index, nodes, this.options.weave_trust ?? null, this.roots.get(id) ?? null);
+      return this.roots.set(id, index.weave.root), { interactive_id: id, package: unwoven };
+    } catch {
+      return (await this.registry.packages([id], this.channel, "full")).find((found) => found.interactive_id === id) ?? null;
+    }
+  }
+  pump() {
+    if (!this.paused)
+      for (; this.ready.length > 0 && this.running < this.depth().feed_concurrency; ) {
+        let id = this.ready.shift();
+        this.state(id) === "waiting" && (this.running++, this.states.set(id, "running"), this.warm(id).finally(() => {
+          this.running--, this.state(id) === "running" && this.paused ? (this.states.set(id, "waiting"), this.ready.unshift(id)) : this.state(id) === "running" && this.states.set(id, "done"), this.pump();
+        }));
+      }
+  }
+  boot(interactive_id) {
+    return this.boots.get(interactive_id) ?? null;
+  }
+  async warmBoot(interactive_id, index, boot, store) {
+    let controller = typeof AbortController == "function" ? new AbortController() : null;
+    controller !== null && this.transfers.set(interactive_id, controller);
+    try {
+      let ranges = cdnBootRanges(index.chunk_base_url, this.options.fetcher ?? fetch);
+      for (let range of BOOT_RANGES) {
+        if (this.state(interactive_id) !== "running" || this.paused || this.depth().feed === "none") return;
+        let done2 = await installBootRange(store, boot, ranges, range, controller?.signal, this.tails.get(interactive_id));
+        this.fetched += done2.bytes;
+      }
+    } catch {
+      return;
+    } finally {
+      this.transfers.get(interactive_id) === controller && this.transfers.delete(interactive_id);
+    }
+  }
+  async warm(interactive_id) {
+    let index = this.indexes.get(interactive_id);
+    if (index === void 0) return;
+    let boot = this.boots.get(interactive_id), store = this.options.part_store;
+    if (boot !== void 0 && store !== void 0) {
+      await this.warmBoot(interactive_id, index, boot, store);
+      return;
+    }
+    let tier = this.options.tier ?? DEFAULT_HOST_TIER, refs = feedChunks(index.chunks, this.depth(), tier, this.options.isolated ?? hostIsolated(), this.options.threads ?? hostThreads()), source = this.chunks.from(index.chunk_base_url), cap = this.options.session_bytes ?? FEED_SESSION_BYTES;
+    for (let ref of refs) {
+      if (this.state(interactive_id) !== "running" || this.paused || this.depth().feed === "none") return;
+      if (this.chunks.cached(ref.digest)) continue;
+      let size = ref.size ?? 0;
+      if (this.fetched + size > cap) return;
+      this.fetched += size;
+      let controller = typeof AbortController == "function" ? new AbortController() : null;
+      controller !== null && this.transfers.set(interactive_id, controller);
+      try {
+        await source.fetch(ref.digest, controller?.signal);
+      } catch {
+        controller?.signal.aborted === true && (this.fetched -= size);
+        return;
+      } finally {
+        this.transfers.get(interactive_id) === controller && this.transfers.delete(interactive_id);
+      }
+    }
+  }
+  transferring(interactive_id) {
+    return this.transfers.has(interactive_id);
+  }
+};
+function remove(list, value) {
+  let at = list.indexOf(value);
+  at >= 0 && list.splice(at, 1);
+}
+function milestoneMarks(prefix = MILESTONE_MARK_PREFIX) {
+  return (milestone) => {
+    globalThis.performance?.mark(prefix + milestone);
+  };
+}
+
+// src/interactives/hosts/chrome/registry.ts
+var RegistryError = class extends Error {
+  constructor(status, route) {
+    super(`${route} answered ${status}`);
+    this.status = status;
+    this.route = route;
+    this.name = "RegistryError";
+  }
+}, JSON_HEADERS = { "content-type": "application/json" };
+function httpRegistry(base, fetcher = fetch) {
+  let url = (path) => new URL(path, base).href, call = async (method, path, body) => {
+    let response = await fetcher(url(path), {
+      method,
+      credentials: "include",
+      headers: body === void 0 ? void 0 : JSON_HEADERS,
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (!response.ok) throw new RegistryError(response.status, path);
+    if (response.status !== 204)
+      return (await response.json()).data;
+  }, segment = encodeURIComponent;
+  return {
+    async fileReport(interactive_id, filing) {
+      await call("POST", `/v1/interactives/${segment(interactive_id)}/reports`, filing);
+    },
+    async blockHandle(handle) {
+      await call("PUT", `/v1/me/blocks/by-handle/${segment(handle)}`);
+    },
+    decideAd: (interactive_id, body) => call("POST", `/v1/interactives/${segment(interactive_id)}/ads/decisions`, body),
+    completeAd: (interactive_id, placement_id, attested) => call("POST", `/v1/interactives/${segment(interactive_id)}/ads/placements/${segment(placement_id)}/complete`, { attested }),
+    packages: (ids, channel, form = "full") => call("GET", `/v1/interactives/packages?ids=${ids.map(segment).join(",")}&channel=${channel}${form === "full" ? "" : `&form=${form}`}`)
+  };
+}
+
+// src/interactives/hosts/local.ts
+var FAMILIES = Object.keys(CTX_CAPABILITIES), LOCAL_REVISION = "rev_local", LOCAL_INSTANCE = "instance_local", LOCAL_COUNTER_PREFIX = "counter_local_";
+function familyOf(operation) {
+  let best = null;
+  for (let family of FAMILIES)
+    operation.startsWith(`${family}.`) && (best === null || family.length > best.length) && (best = family);
+  return best;
+}
+function localProgram(options) {
+  return {
+    capabilities: [],
+    contract_version: 1,
+    data_lineage: null,
+    features: [],
+    instance: LOCAL_INSTANCE,
+    interactive_id: options.interactive_id,
+    kit_version: null,
+    launch: { source: "direct", reference: null, selected: null },
+    location: "client",
+    profile: options.profile,
+    revision: LOCAL_REVISION
+  };
+}
+function localSession(options) {
+  let writer = new MessageWriter(), now = options.now ?? (() => Date.now()), program = localProgram(options), listener = () => {
+  }, closers = [], counters = /* @__PURE__ */ new Map(), respond2 = (request2) => {
+    let call = request2.call, local = localAnswer(call, program, options, counters);
+    if (local !== void 0)
+      return {
+        contract_version: 1,
+        request_id: request2.request_id,
+        outcome: { status: "ok", response: { operation: call.operation, result: local } }
+      };
+    let error = { code: "unavailable", family: familyOf(call.operation) ?? "program", retry_after_ms: null };
+    return { contract_version: 1, request_id: request2.request_id, outcome: { status: "error", error } };
+  }, deliver = (reply) => {
+    let length = writer.json(MessageTag.response, reply);
+    listener(writer.bytes.slice(0, length));
+  }, settle = (request2, answer) => "error" in answer ? { contract_version: 1, request_id: request2.request_id, outcome: { status: "error", error: answer.error } } : {
+    contract_version: 1,
+    request_id: request2.request_id,
+    outcome: { status: "ok", response: { operation: request2.call.operation, result: answer.result } }
+  };
+  return { transport: {
+    send(bytes) {
+      if (bytes[0] !== MessageTag.request) return;
+      let request2 = readJson(bytes), pending = options.answerAsync?.(request2.call);
+      if (pending !== void 0) {
+        let family = familyOf(request2.call.operation) ?? "program";
+        pending.catch(() => ({ error: { code: "unavailable", family, retry_after_ms: null } })).then((answer) => deliver(settle(request2, answer)));
+        return;
+      }
+      let reply = respond2(request2);
+      queueMicrotask(() => deliver(reply));
+    },
+    on_message(next) {
+      listener = next;
+    },
+    on_close(next) {
+      closers.push(next);
+    },
+    close() {
+      for (let closer of closers) closer({ reason: "closed_by_host", detail: null });
+      closers.length = 0;
+    }
+  }, hello: { protocol: 1, program, server_time_ms: now() } };
+}
+function localAnswer(call, program, options, counters) {
+  let custom = options.answer?.(call);
+  if (custom !== void 0) return custom;
+  switch (call.operation) {
+    case "program.describe":
+      return program;
+    case "program.set_status":
+      return { text: call.arguments.text.length === 0 ? null : call.arguments.text, your_turn: call.arguments.your_turn };
+    case "program.complete":
+      return { recorded: false };
+    case "identity.current":
+      return options.persona;
+    case "counter.open": {
+      let counter_id = `${LOCAL_COUNTER_PREFIX}${call.arguments.name}`, slot = counters.get(counter_id) ?? counters.size;
+      return counters.set(counter_id, slot), { counter_id, kind: call.arguments.kind, scope: call.arguments.scope, slot };
+    }
+    default:
+      return;
+  }
+}
+
+export { CAMERA_ON_COPY, CANVAS_PERMISSIONS, CANVAS_SANDBOX, CLIP_MP4_TYPE, CONTENT_BLOCKED_CLOSE, CONTENT_BLOCKED_ERROR, CONTENT_BLOCKED_STATUS, CacheStoragePartBackend, CameraGrants, ChunkCache, ClipRelay, DEFAULT_WARM_BOOT_MS, EncodedRing, FACE_LANDMARKER, FEED_DWELL_MS, FEED_SESSION_BYTES, FaceCameraRelay, HostChromeController, IDLE_SCHEDULER, ISOLATION_HEADERS, IdentityCopy, IdentityGuidance, IndexedDbPartBackend, MILESTONE_MARK_PREFIX, NETWORK_DIALERS, PART_STORE_NAME, PEER_SHARING_FEATURE, PREFETCH_BATCH, PackagePrefetcher, PortBridge, RegistryError, RoomRelay, RuntimePool, SHOAL_MAX_MESSAGE_BYTES, ShoalHoldings, ShoalSession, WEB_DISK_RESERVE_BYTES, animationFrameScheduler, blockedItems, cameraViewStyle, canvasDocument, canvasPolicy, cdnRepairs, completeZone, domIdentitySheet, familyOf, feedChunks, httpRegistry, iframeEngines, insetVideo, localProgram, localSession, manifestCredits, mediaPipeFaceRunner, milestoneMarks, muxMp4, openPeerSharing, openWebPartStore, peerSharingEnabled, planZone, readViewRect, repairDecoder, runOverChannel, runtimeImage, serveContent, shoalModule, webStorageDisk };