@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-3VEH23I5.mjs

@@ -0,0 +1,1380 @@
+import { IdentityCaptureError } from './chunk-5C3C7VDM.mjs';
+import { TreeDiffer, readReplayMessage } from './chunk-UGH37BQW.mjs';
+import { PackageAssembler, decodeChunk, ChunkKind } from './chunk-KDQOR4QQ.mjs';
+import { readinessProbe } from './chunk-LYEZZEEF.mjs';
+import { StudioAssembler, StudioSender, reportMetersTo, openStudioChannel, deliverStudio, requestMeters } from './chunk-HAGEIC2L.mjs';
+import { readNetworkHint, hotAccepted, relinkingDefinitions, applyHot } from './chunk-K46SMZ66.mjs';
+import { createGenerate } from './chunk-OKC2B4O3.mjs';
+import { GameUi } from './chunk-PPF2BYFL.mjs';
+import { TEXT_DICTIONARIES_ASSET } from './chunk-DS2VU4WW.mjs';
+import { sha256Into } from './chunk-5YWN6H5Q.mjs';
+import { peekFrameCode, frameLength, FrameCode, decodePresenceTick, decodeCounterValue, decodeFastValue, decodeRoomInputFrame, decodeChannelFrame, writeChannelHeader, writeRoomInputHeader, writeFastReadHeader, encodeCounterAdd, encodeMoveInput } from './chunk-OQRVEM56.mjs';
+import { FRAME_LIMITS, FRAME_LAYOUT, FRAME_CODES, CTX_CAPABILITIES } from './chunk-SPCRQ6NO.mjs';
+import { TAG_BYTES, BRIDGE_LIMITS, MessageTag, MessageWriter, PONG_BYTES, MILESTONE_BYTES, SESSION_COMPLETE_BYTES, ChunkBatch, CHUNK_REQUEST_ENTRY_BYTES, CHUNK_RELEASE_ENTRY_BYTES, ChunkPriority, Milestone, writeSessionComplete, readJson, INSPECTOR_SHOWN, CHUNK_REQUESTS_VERSION, LIFECYCLE_BY_CODE, DIGEST_BYTES, hex, readChunkFailed } from './chunk-V7ZRH3PY.mjs';
+import { breakDictionaries, registerBreakDictionaries } from './chunk-GYLP6UG4.mjs';
+import { encodeBase64, decodeBase64 } from './chunk-2IC4H6OV.mjs';
+import { requestInspector } from './chunk-MOMOZEUM.mjs';
+import { withdrawWasm, guardedWebAssembly } from './chunk-N4RGGDEL.mjs';
+
+// src/interactives/runtime/lanes.ts
+var PRESENCE_ROUTE = 0, FRAME_CODE_SLOTS = 16;
+function subscribe(route, slot, listener) {
+  return route.set(slot, [...route.get(slot) ?? [], listener]), () => {
+    let remaining = (route.get(slot) ?? []).filter((l) => l !== listener);
+    remaining.length === 0 ? route.delete(slot) : route.set(slot, remaining);
+  };
+}
+function copyInto(source, target, at, length) {
+  for (let i = 0; i < length; i++) target[at + i] = source[i];
+}
+function deliver(route, slot, message, view) {
+  let listeners = route.get(slot);
+  if (listeners !== void 0)
+    for (let i = 0; i < listeners.length; i++) listeners[i](message, view);
+}
+var FrameLane = class {
+  constructor(bridge) {
+    this.bridge = bridge;
+    this.length = TAG_BYTES;
+    this.scheduled = false;
+    this.channel = { flags: 0, slot: 0, sequence: 0, sender: 0, payload_offset: 0, payload_length: 0 };
+    this.roomInput = {
+      flags: 0,
+      action: 0,
+      sequence: 0,
+      client_tick: 0,
+      sender: 0,
+      payload_offset: 0,
+      payload_length: 0
+    };
+    this.fastValue = {
+      status: 0,
+      slot: 0,
+      correlation: 0,
+      stamp_low: 0,
+      stamp_high: 0,
+      value_offset: 0,
+      value_length: 0
+    };
+    this.counterValue = { status: 0, slot: 0, correlation: 0, value: 0 };
+    this.presence = {
+      flags: 0,
+      server_tick: 0,
+      cell_index: 0,
+      acked_input: 0,
+      layer: 0,
+      baseline_age: 0,
+      count: 0,
+      entries_offset: 0
+    };
+    this.channels = /* @__PURE__ */ new Map();
+    this.roomInputs = /* @__PURE__ */ new Map();
+    this.fastValues = /* @__PURE__ */ new Map();
+    this.counterValues = /* @__PURE__ */ new Map();
+    this.presenceTicks = /* @__PURE__ */ new Map();
+    this.faults = new Uint32Array((16));
+    this.flush = () => {
+      this.scheduled = false, this.length !== TAG_BYTES && (this.bridge.send(this.out, this.length), this.length = TAG_BYTES);
+    };
+    this.out = new Uint8Array(BRIDGE_LIMITS.frame_outbox_bytes), this.out[0] = MessageTag.frames, this.view = new DataView(this.out.buffer);
+  }
+  reserve(bytes) {
+    return this.length + bytes > this.out.length && this.flush(), this.scheduled || (this.scheduled = true, queueMicrotask(this.flush)), this.length;
+  }
+  commit(written) {
+    return written > 0 && (this.length += written), written;
+  }
+  receive(bytes) {
+    let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), end = bytes.byteLength, offset = TAG_BYTES;
+    for (; offset < end; ) {
+      let code = peekFrameCode(view, offset, end), total = frameLength(view, offset, end);
+      if (code < 0 || total < 0) {
+        this.faults[0] += 1;
+        return;
+      }
+      switch (code) {
+        case FrameCode.channel:
+          decodeChannelFrame(view, offset, end, this.channel) > 0 && deliver(this.channels, this.channel.slot, this.channel, view);
+          break;
+        case FrameCode.room_input:
+          decodeRoomInputFrame(view, offset, end, this.roomInput) > 0 && deliver(this.roomInputs, this.roomInput.sender, this.roomInput, view);
+          break;
+        case FrameCode.fast_value:
+          decodeFastValue(view, offset, end, this.fastValue) > 0 && deliver(this.fastValues, this.fastValue.slot, this.fastValue, view);
+          break;
+        case FrameCode.counter_value:
+          decodeCounterValue(view, offset, end, this.counterValue) > 0 && deliver(this.counterValues, this.counterValue.slot, this.counterValue, view);
+          break;
+        case FrameCode.presence_tick:
+          decodePresenceTick(view, offset, end, this.presence) > 0 && deliver(this.presenceTicks, (0), this.presence, view);
+          break;
+        default:
+          this.faults[code] += 1;
+      }
+      offset += total;
+    }
+  }
+};
+function onSlot(route, slot, listener) {
+  return subscribe(route, slot, listener);
+}
+function onPresence(lane, listener) {
+  return subscribe(lane.presenceTicks, (0), listener);
+}
+var PayloadPublisher = class {
+  constructor(lane, slot, maxPayload, headerBytes) {
+    this.lane = lane;
+    this.slot = slot;
+    this.headerBytes = headerBytes;
+    this.sequence = 0;
+    this.max_payload_bytes = maxPayload, this.scratch = new Uint8Array(maxPayload), this.scratchView = new DataView(this.scratch.buffer);
+  }
+  payload() {
+    return this.scratchView;
+  }
+  send(length, flags = 0) {
+    if (length < 0 || length > this.max_payload_bytes) return -1;
+    let offset = this.lane.reserve(this.headerBytes + length), written = this.header(offset, length, flags);
+    if (written < 0) return written;
+    copyInto(this.scratch, this.lane.out, offset + this.headerBytes, length), this.lane.commit(written);
+    let sent = this.sequence;
+    return this.sequence = this.sequence + 1 >>> 0, sent;
+  }
+}, ChannelPublisher = class extends PayloadPublisher {
+  constructor(lane, slot, maxPayload) {
+    super(lane, slot, Math.min(maxPayload, FRAME_LIMITS.max_channel_payload_bytes), FRAME_LAYOUT.channel.header_bytes);
+    this.frame = { flags: 0, slot: 0, sequence: 0, sender: 0 };
+    this.frame.slot = slot;
+  }
+  header(offset, length, flags) {
+    return this.frame.flags = flags, this.frame.sequence = this.sequence, writeChannelHeader(this.lane.view, offset, this.frame, length);
+  }
+}, RoomInputPublisher = class extends PayloadPublisher {
+  constructor(lane, slot) {
+    super(lane, slot, FRAME_LIMITS.max_room_input_payload_bytes, FRAME_LAYOUT.room_input.header_bytes);
+    this.frame = { flags: 0, action: 0, sequence: 0, client_tick: 0, sender: 0 };
+    this.frame.sender = slot;
+  }
+  header(offset, length, flags) {
+    return this.frame.flags = flags, this.frame.sequence = this.sequence, writeRoomInputHeader(this.lane.view, offset, this.frame, length);
+  }
+}, LaneFastReader = class {
+  constructor(lane, slot, target) {
+    this.lane = lane;
+    this.slot = slot;
+    this.keyBytes = new Uint8Array(FRAME_LIMITS.max_fast_key_bytes);
+    this.frame = { target: FRAME_CODES.fast_target[target], slot, correlation: 0 };
+  }
+  key() {
+    return this.keyBytes;
+  }
+  read(key_length, correlation) {
+    if (key_length < 0 || key_length > this.keyBytes.length) return -1;
+    let offset = this.lane.reserve(FRAME_LAYOUT.fast_read.header_bytes + key_length);
+    this.frame.correlation = correlation >>> 0;
+    let written = writeFastReadHeader(this.lane.view, offset, this.frame, key_length);
+    return written < 0 ? written : (copyInto(this.keyBytes, this.lane.out, offset + FRAME_LAYOUT.fast_read.header_bytes, key_length), this.lane.commit(written));
+  }
+  on_value(listener) {
+    return subscribe(this.lane.fastValues, this.slot, listener);
+  }
+}, LaneCounter = class {
+  constructor(lane, slot) {
+    this.lane = lane;
+    this.slot = slot;
+    this.frame = { status: 0, slot: 0, correlation: 0, value: 0 };
+    this.frame.slot = slot;
+  }
+  add(delta, correlation) {
+    let offset = this.lane.reserve(FRAME_LAYOUT.counter_add.header_bytes);
+    return this.frame.correlation = correlation >>> 0, this.frame.value = delta, this.lane.commit(encodeCounterAdd(this.lane.view, offset, this.frame));
+  }
+  on_value(listener) {
+    return subscribe(this.lane.counterValues, this.slot, (frame) => listener(frame));
+  }
+};
+function sendMove(lane, input) {
+  let offset = lane.reserve(FRAME_LAYOUT.move_input.header_bytes);
+  return lane.commit(encodeMoveInput(lane.view, offset, input));
+}
+
+// src/interactives/runtime/local-families.ts
+var UINT32 = 4294967296, SEED_WORDS = 4, CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ", SHORT_ALPHABET = "abcdefghijkmnopqrstuvwxyz23456789", HEX = "0123456789abcdef", UUID_BYTES = 16, ULID_TIME_CHARS = 10, ULID_RANDOM_CHARS = 16, UUID_V7 = 112, UUID_VARIANT = 128, RANDOM_POOL_BYTES = 256, RandomPool = class {
+  constructor(services) {
+    this.services = services;
+    this.bytes = new Uint8Array((256));
+    this.words = new Uint32Array(this.bytes.buffer);
+    this.cursor = (256);
+  }
+  u32() {
+    this.cursor + 4 > (256) && (this.services.random_fill(this.bytes), this.cursor = 0);
+    let word = this.words[this.cursor >> 2];
+    return this.cursor += 4, word;
+  }
+  byte() {
+    return this.u32() & 255;
+  }
+}, Xoshiro128 = class {
+  constructor(words) {
+    this.a = words[0] >>> 0, this.b = words[1] >>> 0, this.c = words[2] >>> 0, this.d = words[3] >>> 0 || 1;
+  }
+  next_u32() {
+    let result = Math.imul(rotl(Math.imul(this.b, 5), 7), 9) >>> 0, t = this.b << 9;
+    return this.c ^= this.a, this.d ^= this.b, this.b ^= this.c, this.a ^= this.d, this.c ^= t, this.d = rotl(this.d, 11), result;
+  }
+  next_float() {
+    return this.next_u32() / (4294967296);
+  }
+};
+function rotl(x, k) {
+  return (x << k | x >>> 32 - k) >>> 0;
+}
+function localRandom(services) {
+  let pool = new RandomPool(services);
+  return {
+    cosmetic: () => pool.u32() / (4294967296),
+    async seed(request) {
+      let words = [0, 0, 0, 0];
+      for (let i = 0; i < (4); i++) words[i] = pool.u32();
+      return { label: request.label, recorded: false, scope: request.scope, words };
+    },
+    stream: (grant) => new Xoshiro128(grant.words)
+  };
+}
+function localCrypto(services) {
+  return {
+    sha256: (input, out) => sha256Into(input, out),
+    random_bytes: (out) => services.random_fill(out),
+    verify: (key, message, signature) => services.verify_ed25519(key, message, signature)
+  };
+}
+function localIds(services) {
+  let pool = new RandomPool(services), uuid = new Uint8Array((16));
+  return {
+    uuid_v7() {
+      let ms = services.now_ms(), high = Math.floor(ms / (4294967296)), low = ms >>> 0;
+      uuid[0] = high >>> 8 & 255, uuid[1] = high & 255, uuid[2] = low >>> 24, uuid[3] = low >>> 16 & 255, uuid[4] = low >>> 8 & 255, uuid[5] = low & 255;
+      for (let i = 6; i < (16); i++) uuid[i] = pool.byte();
+      uuid[6] = (112) | uuid[6] & 15, uuid[8] = (128) | uuid[8] & 63;
+      let out = "";
+      for (let i = 0; i < (16); i++)
+        (i === 4 || i === 6 || i === 8 || i === 10) && (out += "-"), out += HEX[uuid[i] >>> 4] + HEX[uuid[i] & 15];
+      return out;
+    },
+    ulid() {
+      let ms = services.now_ms(), time = "";
+      for (let i = 0; i < (10); i++)
+        time = CROCKFORD[ms % 32] + time, ms = Math.floor(ms / 32);
+      let random = "";
+      for (let i = 0; i < (16); i++) random += CROCKFORD[pool.byte() & 31];
+      return time + random;
+    },
+    short(length) {
+      let out = "";
+      for (let i = 0; i < length; i++) out += SHORT_ALPHABET[pool.u32() % SHORT_ALPHABET.length];
+      return out;
+    },
+    fill: (out) => services.random_fill(out)
+  };
+}
+function localClock(services, offsetMs) {
+  let now = () => services.now_ms() + offsetMs;
+  return {
+    now,
+    async sync() {
+      return { now: now(), source: "app_clock", display_offset_ms: offsetMs, room_tick: null };
+    }
+  };
+}
+function localLocale(info) {
+  let numbers = /* @__PURE__ */ new Map(), money = /* @__PURE__ */ new Map(), time = new Intl.DateTimeFormat(info.language, { timeStyle: "short", timeZone: info.time_zone });
+  return {
+    ...info,
+    format_number(value, fraction_digits) {
+      let digits = fraction_digits ?? -1, format = numbers.get(digits);
+      return format === void 0 && (format = new Intl.NumberFormat(
+        info.language,
+        digits < 0 ? {} : { minimumFractionDigits: digits, maximumFractionDigits: digits }
+      ), numbers.set(digits, format)), format.format(value);
+    },
+    format_money(amount, currency) {
+      let code = currency ?? info.currency, format = money.get(code);
+      return format === void 0 && (format = new Intl.NumberFormat(info.language, { style: "currency", currency: code }), money.set(code, format)), format.format(Number(amount));
+    },
+    format_time: (unix_ms) => time.format(unix_ms)
+  };
+}
+
+// src/interactives/runtime/guest-ctx.ts
+var GuestUnavailableError = class extends Error {
+  constructor(member) {
+    super(`ctx.${member} is not available in the native profile`), this.name = "GuestUnavailableError", this.member = member;
+  }
+}, CLIP_FAILURES = /* @__PURE__ */ new Set(["unavailable", "nothing_recorded", "unknown_clip", "camera_consent", "failed"]), ClipError = class extends Error {
+  constructor(code) {
+    super(`the clip was not saved (${code})`);
+    this.code = code;
+    this.name = "ClipError";
+  }
+};
+function mediaRef(value) {
+  if (value === null || typeof value != "object") throw new ClipError("unavailable");
+  let reply = value;
+  if (typeof reply.media_id == "string") return typeof reply.url == "string" ? { media_id: reply.media_id, url: reply.url } : { media_id: reply.media_id };
+  let code = reply.error?.code;
+  throw new ClipError(typeof code == "string" && CLIP_FAILURES.has(code) ? code : "failed");
+}
+function clipMedia(core) {
+  return {
+    open: () => Promise.reject(new GuestUnavailableError("media.open")),
+    async record_clip(_surface, max_duration_ms) {
+      let started = await core.command({ kind: "clip_start", max_ms: max_duration_ms }, true);
+      if (started === null || typeof started != "object" || typeof started.clip != "number") throw new ClipError("unavailable");
+      let clip = started.clip;
+      return {
+        stop: async () => mediaRef(await core.command({ kind: "clip_stop", clip }, true)),
+        cancel: () => {
+          core.command({ kind: "clip_cancel", clip }, false);
+        }
+      };
+    },
+    keep_clip: async (ms) => mediaRef(await core.command({ kind: "clip_keep", ms }, true)),
+    save_replay: async (replay) => mediaRef(await core.command({ kind: "replay_save", replay: encodeBase64(replay) }, true)),
+    on_replay: (listener) => core.on_replay === void 0 ? () => {
+    } : core.on_replay(listener)
+  };
+}
+var EMPTY = {};
+function unavailable(member) {
+  throw new GuestUnavailableError(member);
+}
+function missing(prefix, members) {
+  let out = {};
+  for (let member of members)
+    Object.defineProperty(out, member, { get: () => unavailable(`${prefix}.${member}`), enumerable: true });
+  return out;
+}
+function realtimeOf(handle, profile) {
+  let tick = handle.tick;
+  if (profile === null || tick === null || tick === void 0) return null;
+  let dialers = profile.dialers(tick.endpoints);
+  return { ticket: decodeBase64(tick.ticket), expires_at: tick.expires_at, primary: dialers.primary, fallback: dialers.fallback };
+}
+function createGuestCtx(core, profile = null) {
+  let call = (operation) => (request) => core.call(operation, request), call0 = (operation) => () => core.call(operation, EMPTY), bound = (operation, field, value) => (request) => core.call(operation, { ...request, [field]: value }), fixed = (operation, request) => () => core.call(operation, request), events = (grant) => ({
+    on_event(listener) {
+      return core.subscribe(grant, (event) => listener(event.event));
+    }
+  }), familyEvents = (family) => ({
+    on_event(listener) {
+      return core.family(family, (event) => listener(event.event));
+    }
+  }), program = { ...core.program, set_status: call("program.set_status"), ready: () => core.mark("ready_for_input") }, openStore = async (request) => {
+    let handle = await core.call("store.open", request), store_id = handle.store_id, grant = null;
+    return {
+      handle,
+      get: bound("store.get", "store_id", store_id),
+      list: bound("store.list", "store_id", store_id),
+      commit: bound("store.commit", "store_id", store_id),
+      checkpoint: bound("store.checkpoint", "store_id", store_id),
+      restore: bound("store.restore", "store_id", store_id),
+      migrate: bound("store.migrate", "store_id", store_id),
+      on_event(listener) {
+        grant ?? (grant = core.call("store.subscribe", { store_id }).then((subscription) => subscription.grant));
+        let stop = null, stopped = false;
+        return grant.then((g) => {
+          stopped || (stop = core.subscribe(g, (event) => listener(event.event)));
+        }), () => {
+          stopped = true, stop?.();
+        };
+      }
+    };
+  }, roomApi = (handle) => {
+    let room_id = handle.state.room_id;
+    return {
+      handle,
+      realtime: realtimeOf(handle, profile),
+      inputs: new RoomInputPublisher(core.lane, handle.slot),
+      leave: fixed("room.leave", { room_id }),
+      state: fixed("room.state", { room_id }),
+      move: bound("room.move", "room_id", room_id),
+      view: fixed("room.view", { room_id }),
+      history: bound("room.history", "room_id", room_id),
+      control: bound("room.control", "room_id", room_id),
+      commit_result: bound("room.commit_result", "room_id", room_id),
+      on_input: (listener) => onSlot(core.lane.roomInputs, handle.slot, listener),
+      ...events(handle.grant)
+    };
+  }, channelApi = (handle) => {
+    let publisher = new ChannelPublisher(core.lane, handle.slot, handle.max_payload_bytes);
+    return {
+      handle,
+      slot: handle.slot,
+      max_payload_bytes: publisher.max_payload_bytes,
+      payload: () => publisher.payload(),
+      send: (length, flags) => publisher.send(length, flags),
+      on_message: (listener) => onSlot(core.lane.channels, handle.slot, listener),
+      close: fixed("channel.close", { channel_id: handle.channel_id }),
+      on_event: (listener) => core.family("channel", (event) => listener(event.event))
+    };
+  }, worldAdmin = (world_id) => ({
+    invite: bound("world.invite", "world_id", world_id),
+    set_role: bound("world.set_role", "world_id", world_id),
+    moderate: bound("world.moderate", "world_id", world_id)
+  }), worldSessionApi = (session) => {
+    let world_id = session.world_id;
+    return {
+      session,
+      realtime: realtimeOf(session, profile),
+      ...worldAdmin(world_id),
+      move: (input) => sendMove(core.lane, input),
+      on_presence: (listener) => onPresence(core.lane, listener),
+      emote: bound("world.emote", "world_id", world_id),
+      set_visibility: bound("world.set_visibility", "world_id", world_id),
+      enter_venue: bound("world.enter_venue", "world_id", world_id),
+      exit_venue: call("world.exit_venue"),
+      nearby: bound("world.nearby", "world_id", world_id),
+      leave: fixed("world.leave", { world_id }),
+      ...events(session.grant)
+    };
+  }, gameUi = null, ui = {
+    game: (options) => {
+      if (gameUi !== null) return gameUi;
+      let assets = profile?.assets, packaged = assets?.has?.(TEXT_DICTIONARIES_ASSET) === true, created = new GameUi(
+        { submit: (bytes, length) => core.game_ui(bytes, length) },
+        { ...options, reserve: TAG_BYTES, dictionaries: options?.dictionaries ?? packaged }
+      );
+      return packaged && assets !== void 0 && breakDictionaries() === null && assets.take(TEXT_DICTIONARIES_ASSET).then(
+        (bytes) => {
+          registerBreakDictionaries(bytes.slice().buffer);
+        },
+        () => {
+        }
+      ), core.on_game_ui((bytes) => created.dispatch(bytes, TAG_BYTES)), gameUi = created, created;
+    },
+    render: (tree) => core.render(tree),
+    present: (mode) => core.command({ kind: "present", mode }, true).then(() => {
+    }),
+    open_sheet: (request) => core.command({ kind: "open_sheet", request }, true),
+    open_handoff: (handoff_id) => core.command({ kind: "open_handoff", handoff_id }, true),
+    toast: (text) => {
+      core.command({ kind: "toast", text }, false);
+    },
+    haptic: (haptic) => {
+      core.command({ kind: "haptic", haptic }, false);
+    },
+    announce: (text) => {
+      core.command({ kind: "announce", text }, false);
+    },
+    on_event: (listener) => core.on_ui(listener)
+  }, loop = profile?.loop, camera = profile?.camera, gameBase = missing("game", loop === void 0 ? ["kit_version", "loop", "scenes", "camera", "feel"] : ["kit_version", "scenes", "camera", "feel"]);
+  loop !== void 0 && Object.defineProperty(gameBase, "loop", { value: loop, enumerable: true });
+  let game = Object.assign(gameBase, {
+    create_physics: () => unavailable("game.create_physics"),
+    saves: () => unavailable("game.saves"),
+    turns: () => unavailable("game.turns"),
+    leaderboards: {
+      async submit(request) {
+        let receipt = await core.call("game.leaderboards.submit", request);
+        return receipt.status !== "rejected" && core.complete({ outcome: "finished", score: receipt.score }), receipt;
+      },
+      page: call("game.leaderboards.page")
+    },
+    achievements: { list: call0("game.achievements.list"), progress: call("game.achievements.progress") },
+    economy: {
+      catalogue: call0("game.economy.catalogue"),
+      balances: call("game.economy.balances"),
+      grant: call("game.economy.grant"),
+      spend: call("game.economy.spend"),
+      propose_trade: call("game.economy.trade.propose"),
+      accept_trade: call("game.economy.trade.accept"),
+      cancel_trade: call("game.economy.trade.cancel"),
+      exchange: call("game.economy.exchange")
+    }
+  });
+  return {
+    program,
+    session: {
+      complete(request) {
+        return core.complete({ outcome: request.outcome, score: request.score ?? null }), core.call("program.complete", request);
+      }
+    },
+    clock: localClock(core.services, core.clock_offset_ms),
+    random: localRandom(core.services),
+    locale: localLocale(core.locale),
+    identity: {
+      current: call0("identity.current"),
+      personas: call("identity.personas"),
+      profile: call0("identity.profile")
+    },
+    social: {
+      friends: call("social.friends"),
+      challenge: call("social.challenge"),
+      invite: call("social.invite"),
+      post: call("social.post"),
+      remix_lineage: call0("social.remix_lineage"),
+      avatars: call("social.avatars"),
+      avatar_consent: call("social.avatar_consent")
+    },
+    open_store: openStore,
+    async schedule(request) {
+      let task = await core.call("schedule.create", request), ref = { task_id: task.task_id };
+      return {
+        task,
+        status: fixed("schedule.status", ref),
+        cancel: fixed("schedule.cancel", ref),
+        ...familyEvents("schedule")
+      };
+    },
+    compute: call("compute.invoke"),
+    async create_worker(request) {
+      let handle = await core.call("worker.create", request);
+      return {
+        handle,
+        post: bound("worker.post", "worker_id", handle.worker_id),
+        terminate: fixed("worker.terminate", { worker_id: handle.worker_id }),
+        ...events(handle.grant)
+      };
+    },
+    create_local_worker: () => unavailable("create_local_worker"),
+    create_room: async (request) => roomApi(await core.call("room.create", request)),
+    join_room: async (request) => roomApi(await core.call("room.join", request)),
+    create_channel: async (request) => channelApi(await core.call("channel.open", request)),
+    create_world: async (request) => {
+      let handle = await core.call("world.create", request);
+      return { handle, ...worldAdmin(handle.world_id) };
+    },
+    join_world: async (request) => worldSessionApi(await core.call("world.join", request)),
+    list_worlds: call("world.list"),
+    game,
+    services: {
+      catalogue: { search: call("services.catalogue.search"), product: call("services.catalogue.product") },
+      cart: { get: call("services.cart.get"), add: call("services.cart.add"), update: call("services.cart.update") },
+      delivery: { quote: call("services.delivery.quote") },
+      purchase_intents: {
+        create: call("services.purchase_intents.create"),
+        status: call("services.purchase_intents.status")
+      },
+      orders: { list: call("services.orders.list"), get: call("services.orders.get") },
+      scheduling: {
+        availability: call("services.scheduling.availability"),
+        book: call("services.scheduling.book")
+      },
+      places: {
+        search: call("services.places.search"),
+        get: call("services.places.get"),
+        contribute: call("services.places.contribute")
+      },
+      arcs: {
+        progress: call("services.arcs.progress"),
+        record: call("services.arcs.record"),
+        challenges: call("services.arcs.challenges")
+      }
+    },
+    gifts: { kinds: call("gifts.kinds"), send: call("gifts.send"), prizes: call("gifts.prizes"), ...familyEvents("gifts") },
+    wallet: {
+      offers: call0("wallet.offers"),
+      spend: call("wallet.spend"),
+      entitlements: call0("wallet.entitlements"),
+      allowance: call0("wallet.allowance"),
+      consume: call("wallet.consume")
+    },
+    ads: { placement: call("ads.placement"), sponsored_items: call("ads.sponsored_items") },
+    notify: { status: call0("notify.status"), request_opt_in: call("notify.request_opt_in"), send: call("notify.send") },
+    moderate: { submit: call("moderate.submit"), status: call("moderate.status") },
+    report: { submit: call("report.submit"), block: call("report.block") },
+    actions: { prepare: call("actions.prepare"), execute: call("actions.execute"), receipt: call("actions.receipt") },
+    provider: { call: call("provider.call"), subscribe: call("provider.subscribe"), ...familyEvents("provider") },
+    flow: {
+      status: call("flow.status"),
+      checkpoint: call("flow.checkpoint"),
+      resume: call("flow.resume"),
+      report_result: call("flow.report_result")
+    },
+    agent: {
+      ask: call("agent.ask"),
+      cancel: call("agent.cancel"),
+      request_edit: call("agent.request_edit"),
+      ...familyEvents("agent")
+    },
+    share: call("share.open"),
+    db: { describe: call0("db.describe"), migrate: call("db.migrate"), query: call("db.query") },
+    tx: { begin: call("tx.begin"), stage: call("tx.stage"), commit: call("tx.commit"), abort: call("tx.abort") },
+    async open_kv(request) {
+      let handle = await core.call("kv.open", request), namespace_id = handle.namespace_id;
+      return {
+        handle,
+        fast: new LaneFastReader(core.lane, handle.slot, "kv"),
+        get: bound("kv.get", "namespace_id", namespace_id),
+        set: bound("kv.set", "namespace_id", namespace_id),
+        compare_and_set: bound("kv.compare_and_set", "namespace_id", namespace_id),
+        delete: bound("kv.delete", "namespace_id", namespace_id),
+        list: bound("kv.list", "namespace_id", namespace_id)
+      };
+    },
+    async open_cache(request) {
+      let handle = await core.call("cache.open", request), namespace_id = handle.namespace_id;
+      return {
+        handle,
+        fast: new LaneFastReader(core.lane, handle.slot, "cache"),
+        get: bound("cache.get", "namespace_id", namespace_id),
+        set: bound("cache.set", "namespace_id", namespace_id),
+        delete: bound("cache.delete", "namespace_id", namespace_id)
+      };
+    },
+    async open_counter(request) {
+      let handle = await core.call("counter.open", request), counter_id = handle.counter_id, fast = new LaneCounter(core.lane, handle.slot);
+      return {
+        handle,
+        add_fast: (delta, correlation) => fast.add(delta, correlation),
+        on_value: (listener) => fast.on_value(listener),
+        add: bound("counter.add", "counter_id", counter_id),
+        read: bound("counter.read", "counter_id", counter_id),
+        rate_limit: bound("counter.rate_limit", "counter_id", counter_id),
+        rank: bound("counter.rank", "counter_id", counter_id),
+        rank_range: bound("counter.rank_range", "counter_id", counter_id),
+        rank_of: bound("counter.rank_of", "counter_id", counter_id)
+      };
+    },
+    blob: {
+      put: call("blob.put"),
+      transfer: () => unavailable("blob.transfer"),
+      commit: call("blob.commit"),
+      get: call("blob.get"),
+      read: () => unavailable("blob.read"),
+      list: call("blob.list"),
+      delete: call("blob.delete")
+    },
+    queue: {
+      enqueue: call("queue.enqueue"),
+      status: call("queue.status"),
+      cancel: call("queue.cancel"),
+      stats: call("queue.stats"),
+      ...familyEvents("queue")
+    },
+    search: { index: call("search.index"), query: call("search.query"), remove: call("search.remove") },
+    ai: {
+      generate: call("ai.generate"),
+      converse: call("ai.converse"),
+      speak: call("ai.speak"),
+      transcribe: call("ai.transcribe"),
+      image: call("ai.image"),
+      translate: call("ai.translate"),
+      prefetch: call("ai.prefetch"),
+      cancel: call("ai.cancel"),
+      forget: call("ai.forget"),
+      usage: call0("ai.usage"),
+      content: call("ai.content"),
+      content_prefetch: call("ai.content_prefetch"),
+      watch(run, listener) {
+        return run.grant ? core.subscribe(run.grant, (event) => listener(event.event)) : (run.result && listener({ kind: "completed", result: run.result }), () => {
+        });
+      },
+      ...familyEvents("ai")
+    },
+    generate: createGenerate({ content: call("ai.content"), content_prefetch: call("ai.content_prefetch") }),
+    pubsub: {
+      async subscribe(request) {
+        let subscription = await core.call("pubsub.subscribe", request), publisher = new ChannelPublisher(core.lane, subscription.slot, subscription.max_payload_bytes);
+        return {
+          subscription,
+          slot: subscription.slot,
+          max_payload_bytes: publisher.max_payload_bytes,
+          payload: () => publisher.payload(),
+          send: (length, flags) => publisher.send(length, flags),
+          publish: bound("pubsub.publish", "topic", subscription.topic),
+          on_message: (listener) => onSlot(core.lane.channels, subscription.slot, listener),
+          close: () => core.call("events.cancel", { subscription_id: subscription.grant.subscription_id }).then(() => {
+          })
+        };
+      }
+    },
+    analytics: { track: call("analytics.track"), record: call("analytics.record"), summary: call("analytics.summary") },
+    secrets: { handle: call("secrets.handle"), sign: call("secrets.sign") },
+    ui,
+    graphics: profile?.graphics ?? missing("graphics", ["features", "engine", "acquire_surface", "attach_engine", "on_context_lost", "on_context_restored"]),
+    input: profile?.input ?? missing("input", ["bind", "pointers", "remap"]),
+    audio: profile?.audio ?? missing("audio", ["unlocked", "unlock", "bus", "load", "play", "stop"]),
+    media: clipMedia(core),
+    files: missing("files", ["pick", "save"]),
+    assets: profile?.assets ?? missing("assets", ["take", "module"]),
+    camera: {
+      request: call("camera.request"),
+      release: call("camera.release"),
+      track_face: camera ? (grant) => camera.track_face(grant) : () => unavailable("camera.track_face"),
+      view: camera ? (grant, placement) => camera.view(grant, placement) : () => unavailable("camera.view"),
+      capture_identity: camera ? (grant) => camera.capture_identity(grant) : () => Promise.reject(new IdentityCaptureError("unavailable"))
+    },
+    lifecycle: core.lifecycle,
+    events: {
+      subscribe: (family, listener) => core.family(family, (event) => listener(event.event)),
+      cancel: call("events.cancel"),
+      resume: call("events.resume")
+    },
+    crypto: localCrypto(core.services),
+    id: localIds(core.services),
+    on_dispose: (callback) => core.on_dispose(callback)
+  };
+}
+
+// src/interactives/runtime/guards.ts
+var WASM_GLOBAL = "WebAssembly", GuardError = class extends Error {
+  constructor(member) {
+    super(`${member} is not available to Interactives; reach the platform through ctx`), this.name = "GuardError";
+  }
+}, REMOVED_GLOBALS = [
+  "eval",
+  "Function",
+  "fetch",
+  "XMLHttpRequest",
+  "WebSocket",
+  "WebTransport",
+  "EventSource",
+  "importScripts",
+  "Worker",
+  "SharedWorker",
+  "indexedDB",
+  "caches",
+  "WebAssembly",
+  "postMessage",
+  "onmessage",
+  "onmessageerror",
+  "addEventListener",
+  "removeEventListener",
+  "close",
+  "BroadcastChannel",
+  "navigator",
+  "location",
+  "__cimplify_host"
+], FROZEN_GLOBALS = [
+  "Object",
+  "Array",
+  "Function",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "BigInt",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "WeakRef",
+  "RegExp",
+  "Date",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "ReferenceError",
+  "EvalError",
+  "URIError",
+  "AggregateError",
+  "ArrayBuffer",
+  "DataView",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "JSON",
+  "Math",
+  "Reflect",
+  "Intl",
+  "TextEncoder",
+  "TextDecoder"
+], STRING_TIMERS = ["setTimeout", "setInterval"], OVERRIDABLE = ["constructor", "toString", "valueOf", "toJSON", "name", "message"], CODE_CONSTRUCTOR_SOURCES = [
+  () => Object.getPrototypeOf(async () => {
+  }),
+  () => Object.getPrototypeOf(function* () {
+  }),
+  () => Object.getPrototypeOf(async function* () {
+  })
+];
+function thrower(member) {
+  return () => {
+    throw new GuardError(member);
+  };
+}
+function seal(target, name, value) {
+  let existing = Object.getOwnPropertyDescriptor(target, name);
+  existing !== void 0 && existing.configurable === false || Object.defineProperty(target, name, { value, writable: false, enumerable: false, configurable: false });
+}
+function enableOverride(target, name) {
+  let found = Object.getOwnPropertyDescriptor(target, name);
+  if (found === void 0 || !("value" in found) || found.configurable === false) return;
+  let value = found.value;
+  Object.defineProperty(target, name, {
+    get() {
+      return value;
+    },
+    set(next) {
+      if (this === target) throw new GuardError(`assigning ${name} on a shared prototype`);
+      Object.defineProperty(this, name, { value: next, writable: true, enumerable: true, configurable: true });
+    },
+    enumerable: found.enumerable,
+    configurable: false
+  });
+}
+function freezeDeep(root, seen) {
+  if (typeof root != "object" && typeof root != "function" || root === null || seen.has(root)) return;
+  seen.add(root);
+  let prototype = root.prototype;
+  for (let name of OVERRIDABLE) enableOverride(root, name);
+  if (typeof prototype == "object" && prototype !== null)
+    for (let name of OVERRIDABLE) enableOverride(prototype, name);
+  Object.freeze(root);
+  for (let key of Reflect.ownKeys(root)) {
+    let descriptor = Object.getOwnPropertyDescriptor(root, key);
+    descriptor && "value" in descriptor && freezeDeep(descriptor.value, seen);
+  }
+  freezeDeep(Object.getPrototypeOf(root), seen);
+}
+function hardenGlobals(global, onTask, runtimeWasm = false) {
+  runtimeWasm || withdrawWasm();
+  let functionThrower = thrower("Function");
+  seal(Function.prototype, "constructor", functionThrower);
+  for (let source of CODE_CONSTRUCTOR_SOURCES) seal(source(), "constructor", functionThrower);
+  for (let name of REMOVED_GLOBALS)
+    name !== "Function" && (name in global || Object.getOwnPropertyDescriptor(global, name) !== void 0) && seal(global, name, name === WASM_GLOBAL && runtimeWasm ? guardedWebAssembly() : void 0);
+  seal(global, "eval", thrower("eval"));
+  for (let name of STRING_TIMERS) {
+    let timer = global[name];
+    if (typeof timer != "function") continue;
+    let schedule = timer;
+    seal(global, name, (handler, ...rest) => {
+      if (typeof handler != "function") throw new GuardError(`${name} with a string`);
+      let task = handler;
+      return schedule((...args) => (onTask(), task(...args)), ...rest);
+    });
+  }
+  let seen = /* @__PURE__ */ new Set();
+  for (let name of FROZEN_GLOBALS) freezeDeep(global[name], seen);
+  for (let source of CODE_CONSTRUCTOR_SOURCES) freezeDeep(source(), seen);
+  seal(global, "Function", functionThrower), lockGlobal(global);
+}
+function lockGlobal(global) {
+  try {
+    Object.freeze(global);
+    return;
+  } catch {
+    for (let key of Reflect.ownKeys(global)) {
+      let descriptor = Object.getOwnPropertyDescriptor(global, key);
+      if (descriptor === void 0 || descriptor.configurable === false) continue;
+      let locked = "value" in descriptor ? { value: descriptor.value, writable: false, configurable: false } : { configurable: false };
+      Reflect.defineProperty(global, key, locked);
+    }
+  }
+  Reflect.preventExtensions(global);
+}
+
+// src/interactives/runtime/slice.ts
+var TICK_GLOBAL = "__cimplify_tick", TICKS_PER_CHECK = 1024, DEFAULT_SLICE_MS = 2e3, SliceExceeded = class extends Error {
+  constructor() {
+    super("the Interactive ran past its time slice without returning to the host"), this.name = "SliceExceeded";
+  }
+};
+function clockBudget(now, slice_ms = 2e3) {
+  let deadline = Number.POSITIVE_INFINITY;
+  return {
+    begin() {
+      deadline = now() + slice_ms;
+    },
+    over() {
+      return now() > deadline;
+    }
+  };
+}
+var COUNT = 0, Slice = class {
+  constructor(budget) {
+    this.budget = budget;
+    this.counter = new Int32Array(1);
+    this.exceeded = false;
+    this.tick = () => {
+      let c = this.counter;
+      ++c[(0)] < 1024 || this.check();
+    };
+  }
+  get dead() {
+    return this.exceeded;
+  }
+  begin() {
+    this.exceeded || this.budget.begin();
+  }
+  check() {
+    let c = this.counter;
+    if (c[(0)] = 0, !this.exceeded) {
+      if (!this.budget.over()) return;
+      this.exceeded = true;
+    }
+    throw c[(0)] = 1024, new SliceExceeded();
+  }
+};
+
+// src/interactives/runtime/guest.ts
+var CTX_REQUEST_DEADLINE_MS = 5e3, CTX_CONFIRMED_REQUEST_DEADLINE_MS = 3e5, CTX_LONG_REQUEST_DEADLINES_MS = {
+  ai: 12e4,
+  compute: 6e4,
+  worker: 6e4,
+  agent: 12e4,
+  flow: 3e5,
+  share: 3e5,
+  camera: 3e5
+}, CAPABILITY_FAMILIES = CTX_CAPABILITIES, NEVER_CONFIRMED = "never", SEGMENT = ".";
+function ctxFamilyOf(operation) {
+  let name = operation;
+  for (; !(name in CAPABILITY_FAMILIES); ) {
+    let at = name.lastIndexOf(SEGMENT);
+    if (at < 0) return operation.slice(0, Math.max(0, operation.indexOf(SEGMENT)));
+    name = name.slice(0, at);
+  }
+  return name;
+}
+function ctxRequestDeadlineMs(family) {
+  let long = CTX_LONG_REQUEST_DEADLINES_MS[family];
+  return long !== void 0 ? long : (CAPABILITY_FAMILIES[family]?.confirmation ?? NEVER_CONFIRMED) === NEVER_CONFIRMED ? (5e3) : (3e5);
+}
+function timerStart() {
+  return typeof globalThis.setTimeout == "function" ? globalThis.setTimeout.bind(globalThis) : null;
+}
+function timerStop() {
+  return typeof globalThis.clearTimeout == "function" ? globalThis.clearTimeout.bind(globalThis) : null;
+}
+var SLICE_MESSAGE = new SliceExceeded().message, LIFECYCLE_STATE = {
+  ready: "ready",
+  visible: "visible",
+  hidden: "hidden",
+  suspend: "suspended",
+  resume: "visible",
+  revision_update: null,
+  dispose: "disposed"
+};
+function describe(error, phase) {
+  return error instanceof Error ? error.message : phase === "slice" ? SLICE_MESSAGE : typeof error == "object" && error !== null ? JSON.stringify(error) : String(error);
+}
+function remove(list, item) {
+  let at = list.indexOf(item);
+  at >= 0 && list.splice(at, 1);
+}
+var GuestRuntime = class {
+  constructor(options) {
+    this.options = options;
+    this.writer = new MessageWriter();
+    this.pending = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.families = /* @__PURE__ */ new Map();
+    this.uiListeners = [];
+    this.gameUiListeners = [];
+    this.replies = /* @__PURE__ */ new Map();
+    this.lifecycleListeners = /* @__PURE__ */ new Map();
+    this.disposers = [];
+    this.replayListeners = [];
+    this.heldReplay = null;
+    this.differ = new TreeDiffer();
+    this.pong = new Uint8Array(PONG_BYTES);
+    this.milestoneMessage = new Uint8Array(MILESTONE_BYTES);
+    this.completeMessage = new Uint8Array(SESSION_COMPLETE_BYTES);
+    this.reached = /* @__PURE__ */ new Set();
+    this.pongView = new DataView(this.pong.buffer);
+    this.boot = null;
+    this.state = "loading";
+    this.nextRequest = 0;
+    this.nextCommand = 0;
+    this.sliceReported = false;
+    this.arriving = [];
+    this.wanted = /* @__PURE__ */ new Map();
+    this.requested = new ChunkBatch(MessageTag.chunk_request, CHUNK_REQUEST_ENTRY_BYTES);
+    this.released = new ChunkBatch(MessageTag.chunk_release, CHUNK_RELEASE_ENTRY_BYTES);
+    this.chunkFlushQueued = false;
+    this.studioIn = new StudioAssembler();
+    this.studioOut = new StudioSender(MessageTag.studio_report, (frame) => this.bridge.send(frame, frame.length));
+    this.flushChunks = () => {
+      this.chunkFlushQueued = false, this.released.size > 0 && this.bridge.send(this.released.bytes, this.released.seal()), this.requested.size > 0 && this.bridge.send(this.requested.bytes, this.requested.seal());
+    };
+    this.chunkChannel = {
+      request: (digest, priority) => this.queueChunk(this.requested, digest, priority),
+      release: (digest) => this.queueChunk(this.released, digest, ChunkPriority.now)
+    };
+    this.starting = false;
+    this.startTimer = void 0;
+    this.stopTimer = void 0;
+    this.lifecycle = lifecycleOf(this);
+    this.bridge = options.bridge, this.services = options.services, this.assembler = new PackageAssembler(options.on_runtime_wasm ?? null, options.native_runtimes ?? null, options.assets ?? null), this.lane = new FrameLane(this.bridge), this.bridge.on_message((bytes) => this.receive(bytes)), reportMetersTo((live) => this.send(this.writer.json(MessageTag.meter_report, live)), options.heap_bytes ?? null), this.pong[0] = MessageTag.pong, this.send(this.writer.tag(MessageTag.ready));
+  }
+  get program() {
+    return this.boot.program;
+  }
+  get locale() {
+    return this.boot.locale;
+  }
+  get clock_offset_ms() {
+    return this.boot.clock_offset_ms;
+  }
+  current() {
+    return this.state;
+  }
+  onLifecycle(event, listener) {
+    let list = this.lifecycleListeners.get(event) ?? [];
+    return list.push(listener), this.lifecycleListeners.set(event, list), () => remove(list, listener);
+  }
+  needRuntime(unit, priority = ChunkPriority.now) {
+    let digest = this.assembler.lateRuntime(unit);
+    return digest === null || this.assembler.holdsWasm(digest) ? false : (this.queueChunk(this.requested, digest, priority), true);
+  }
+  mark(name) {
+    let code = Milestone[name];
+    this.reached.has(code) || (this.reached.add(code), this.milestoneMessage[0] = MessageTag.milestone, this.milestoneMessage[1] = code, this.bridge.send(this.milestoneMessage, MILESTONE_BYTES));
+  }
+  send(length) {
+    this.bridge.send(this.writer.bytes, length);
+  }
+  fault(phase, error) {
+    if (this.services.slice.dead) {
+      if (this.sliceReported) return;
+      this.sliceReported = true, phase = "slice";
+    }
+    let fault = {
+      phase,
+      message: describe(error, phase),
+      stack: error instanceof Error && typeof error.stack == "string" ? error.stack : null
+    };
+    this.send(this.writer.json(MessageTag.fault, fault));
+  }
+  call(operation, request) {
+    let boot = this.boot, request_id = `g${this.nextRequest++}`, envelope = {
+      contract_version: 1,
+      request_id,
+      interactive_id: boot.program.interactive_id,
+      revision: boot.program.revision,
+      deadline_ms: boot.deadline_ms,
+      call: { operation, arguments: request }
+    }, family = ctxFamilyOf(operation), deadline = this.options.request_deadline_ms?.(family) ?? ctxRequestDeadlineMs(family);
+    this.startTimer ?? (this.startTimer = timerStart());
+    let startTimer = this.startTimer;
+    return new Promise((resolve, reject) => {
+      let timer = startTimer === null ? null : startTimer(() => this.expire(request_id, family), deadline);
+      this.pending.set(request_id, { resolve, reject, timer }), this.send(this.writer.json(MessageTag.request, envelope));
+    });
+  }
+  expire(request_id, family) {
+    let waiting = this.pending.get(request_id);
+    waiting !== void 0 && (this.pending.delete(request_id), waiting.reject({ code: "unavailable", family, retry_after_ms: null }));
+  }
+  subscribe(grant, listener) {
+    return this.listen(this.subscriptions, grant.subscription_id, listener);
+  }
+  family(family, listener) {
+    return this.listen(this.families, family, listener);
+  }
+  listen(table, key, listener) {
+    return table.set(key, [...table.get(key) ?? [], listener]), () => {
+      let rest = (table.get(key) ?? []).filter((l) => l !== listener);
+      rest.length === 0 ? table.delete(key) : table.set(key, rest);
+    };
+  }
+  render(tree) {
+    if (this.state !== "disposed")
+      try {
+        let patches = this.differ.diff(tree);
+        patches.length > 0 && this.send(this.writer.json(MessageTag.render, patches));
+      } catch (error) {
+        this.fault("render", error);
+      }
+  }
+  command(command, awaited) {
+    let id = awaited ? ++this.nextCommand : 0;
+    return this.send(this.writer.json(MessageTag.ui_command, { id, command })), awaited ? new Promise((resolve) => this.replies.set(id, resolve)) : Promise.resolve(void 0);
+  }
+  on_ui(listener) {
+    return this.uiListeners.push(listener), () => remove(this.uiListeners, listener);
+  }
+  complete(message) {
+    this.state !== "disposed" && this.bridge.send(this.completeMessage, writeSessionComplete(this.completeMessage, message));
+  }
+  game_ui(bytes, length) {
+    this.state !== "disposed" && (bytes[0] = MessageTag.game_ui, this.bridge.send(bytes, length));
+  }
+  on_game_ui(listener) {
+    return this.gameUiListeners.push(listener), () => remove(this.gameUiListeners, listener);
+  }
+  dispatchGameUi(bytes) {
+    for (let i = 0; i < this.gameUiListeners.length; i++)
+      try {
+        this.gameUiListeners[i](bytes);
+      } catch (error) {
+        this.fault("run", error);
+      }
+  }
+  on_dispose(callback) {
+    this.disposers.push(callback);
+  }
+  receive(bytes) {
+    this.services.slice.begin();
+    try {
+      this.handle(bytes);
+    } catch (error) {
+      this.fault("run", error);
+    }
+    this.services.slice.dead && this.fault("slice", null);
+  }
+  notify(listeners, event) {
+    if (listeners !== void 0)
+      for (let i = 0; i < listeners.length; i++)
+        try {
+          listeners[i](event);
+        } catch (error) {
+          this.fault("run", error);
+        }
+  }
+  handle(bytes) {
+    switch (bytes[0]) {
+      case MessageTag.response:
+        this.answer(readJson(bytes));
+        return;
+      case MessageTag.event:
+        this.deliver(readJson(bytes));
+        return;
+      case MessageTag.frames:
+        this.lane.receive(bytes);
+        return;
+      case MessageTag.ui_event:
+        this.dispatchUi(readJson(bytes));
+        return;
+      case MessageTag.ui_reply:
+        this.reply(readJson(bytes));
+        return;
+      case MessageTag.game_ui_event:
+        this.dispatchGameUi(bytes);
+        return;
+      case MessageTag.ping:
+        this.answerPing(bytes);
+        return;
+      case MessageTag.lifecycle:
+        this.transition(LIFECYCLE_BY_CODE[bytes[TAG_BYTES]] ?? null);
+        return;
+      case MessageTag.boot:
+        this.boot = readJson(bytes), this.options.on_boot?.(this.boot), (this.boot.chunk_requests ?? 0) >= CHUNK_REQUESTS_VERSION && this.options.assets?.connect?.(this.chunkChannel), this.boot.network !== void 0 && this.options.assets?.network?.(this.boot.network);
+        return;
+      case MessageTag.network: {
+        let hint = readNetworkHint(bytes);
+        hint !== null && this.options.assets?.network?.(hint);
+        return;
+      }
+      case MessageTag.inspector:
+        requestInspector(bytes[TAG_BYTES] === INSPECTOR_SHOWN);
+        return;
+      case MessageTag.meters:
+        requestMeters(readJson(bytes));
+        return;
+      case MessageTag.studio: {
+        openStudioChannel((message2) => this.studioOut.post(message2));
+        let message = this.studioIn.accept(bytes);
+        message !== null && deliverStudio(message);
+        return;
+      }
+      case MessageTag.chunk_failed:
+        this.chunkFailed(bytes);
+        return;
+      case MessageTag.chunk:
+        this.acceptChunk(bytes);
+        return;
+      case MessageTag.stage:
+        this.stageChunk(bytes);
+        return;
+      case MessageTag.chunk_ref:
+        this.acceptRef(bytes, false);
+        return;
+      case MessageTag.stage_ref:
+        this.acceptRef(bytes, true);
+        return;
+      case MessageTag.warm:
+        this.warm(readJson(bytes));
+        return;
+      case MessageTag.start:
+        this.start();
+        return;
+      case MessageTag.hot:
+        this.hot(readJson(bytes));
+        return;
+      case MessageTag.replay: {
+        let opened = readReplayMessage(bytes);
+        if (opened === null) return;
+        this.replayListeners.length === 0 && (this.heldReplay = opened);
+        for (let i = 0; i < this.replayListeners.length; i++) this.replayListeners[i](opened.replay, opened.mode);
+        return;
+      }
+    }
+  }
+  on_replay(listener) {
+    this.replayListeners.push(listener);
+    let held = this.heldReplay;
+    return this.heldReplay = null, held !== null && listener(held.replay, held.mode), () => remove(this.replayListeners, listener);
+  }
+  async hot(request) {
+    let done = (result) => this.send(this.writer.json(MessageTag.hot_done, result)), linker = this.services.linker;
+    if (!this.starting || this.state === "loading" || this.state === "disposed") return done({ swapped: false, reason: "the Interactive is not running" });
+    if (linker.relink === void 0) return done({ swapped: false, reason: "this host cannot swap code in place" });
+    if (!hotAccepted()) return done({ swapped: false, reason: "the Interactive does not accept code swaps" });
+    await this.arrivals();
+    let changedAssets = this.assembler.swapIndex(request.chunks);
+    if (changedAssets === null) return done({ swapped: false, reason: "more than the code and assets changed" });
+    try {
+      let { entry, modules } = this.assembler.modules(new Set(this.boot?.bytecode_modules ?? [])), linked = await relinkingDefinitions(() => linker.relink.call(linker, modules, entry, this.services.slice.tick)), report = applyHot(linked, changedAssets);
+      done(report === null ? { swapped: !1, reason: "the new code has no hot export" } : { swapped: !0, report });
+    } catch (error) {
+      done({ swapped: false, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  acceptChunk(bytes) {
+    readinessProbe()?.chunk(bytes.length - TAG_BYTES - DIGEST_BYTES);
+    try {
+      this.assembler.accept(bytes.subarray(TAG_BYTES, TAG_BYTES + DIGEST_BYTES), bytes.subarray(TAG_BYTES + DIGEST_BYTES));
+    } catch (error) {
+      this.fault("boot", error);
+    }
+    this.arrived(bytes);
+  }
+  arrived(bytes) {
+    if (this.wanted.size === 0) return;
+    let digest = hex(bytes.subarray(TAG_BYTES, TAG_BYTES + DIGEST_BYTES)), resolve = this.wanted.get(digest);
+    resolve !== void 0 && (this.wanted.delete(digest), resolve());
+  }
+  acceptRef(bytes, staged) {
+    let digest = hex(bytes.subarray(TAG_BYTES, TAG_BYTES + DIGEST_BYTES)), payload = hex(bytes.subarray(TAG_BYTES + DIGEST_BYTES, TAG_BYTES + DIGEST_BYTES + DIGEST_BYTES));
+    this.arriving.push(this.fetchRef(digest, payload, staged));
+  }
+  async fetchRef(digest, payload, staged) {
+    let fetched = this.options.fetch_wasm?.(digest, payload) ?? null, bytes = fetched === null ? null : await fetched.catch(() => null);
+    if (bytes === null) {
+      await this.want(digest);
+      return;
+    }
+    staged ? this.options.on_staged_wasm?.(digest, this.assembler.stage(digest, bytes)) : this.assembler.acceptWasmPayload(digest, bytes);
+  }
+  want(digest) {
+    return new Promise((resolve) => {
+      this.wanted.set(digest, resolve), this.queueChunk(this.requested, digest, ChunkPriority.now);
+    });
+  }
+  queueChunk(batch, digest, priority) {
+    batch.full && this.flushChunks(), batch.add(digest, priority) && (this.chunkFlushQueued || (this.chunkFlushQueued = true, queueMicrotask(this.flushChunks)));
+  }
+  chunkFailed(bytes) {
+    let failed = readChunkFailed(bytes);
+    failed !== null && (this.wanted.has(failed.digest) && (this.wanted.delete(failed.digest), this.fault("boot", new Error(`the host could not deliver chunk ${failed.digest} (${failed.reason})`))), this.options.assets?.fail?.(failed.digest, failed.reason));
+  }
+  async arrivals() {
+    for (; this.arriving.length > 0; ) await Promise.all(this.arriving.splice(0));
+  }
+  async warm(image) {
+    await this.arrivals(), await this.options.on_warm?.(image)?.catch(() => {
+    }), this.send(this.writer.tag(MessageTag.warmed));
+  }
+  stageChunk(bytes) {
+    try {
+      let chunk = decodeChunk(bytes.subarray(TAG_BYTES + DIGEST_BYTES)), digest = hex(bytes.subarray(TAG_BYTES, TAG_BYTES + DIGEST_BYTES));
+      chunk.kind === ChunkKind.data ? this.options.assets?.accept(digest, chunk.payload) : chunk.kind === ChunkKind.wasm ? this.options.on_staged_wasm?.(digest, this.assembler.stage(digest, chunk.payload)) : chunk.kind === ChunkKind.code && this.options.on_staged_code?.(this.assembler.stageCode(digest, chunk.payload));
+    } catch (error) {
+      this.fault("boot", error);
+    }
+    this.arrived(bytes);
+  }
+  answerPing(bytes) {
+    this.pong[1] = bytes[1], this.pong[2] = bytes[2], this.pong[3] = bytes[3], this.pong[4] = bytes[4], this.pongView.setFloat64(5, this.options.heap_bytes?.() ?? 0, true), this.bridge.send(this.pong, PONG_BYTES);
+  }
+  answer(envelope) {
+    let waiting = this.pending.get(envelope.request_id);
+    waiting !== void 0 && (this.pending.delete(envelope.request_id), this.stopTimer ?? (this.stopTimer = timerStop()), waiting.timer !== null && this.stopTimer !== null && this.stopTimer(waiting.timer), envelope.outcome.status === "ok" ? waiting.resolve(envelope.outcome.response.result) : waiting.reject(envelope.outcome.error));
+  }
+  deliver(envelope) {
+    let event = envelope.event;
+    if (event.family === "ui") {
+      this.dispatchUi(event.event);
+      return;
+    }
+    this.notify(this.subscriptions.get(envelope.subscription_id), event), this.notify(this.families.get(event.family), event);
+  }
+  dispatchUi(event) {
+    if (this.state === "disposed") return;
+    let listeners = this.uiListeners.slice();
+    for (let i = 0; i < listeners.length; i++)
+      try {
+        listeners[i](event);
+      } catch (error) {
+        this.fault("run", error);
+      }
+  }
+  reply(reply) {
+    let resolve = this.replies.get(reply.id);
+    resolve !== void 0 && (this.replies.delete(reply.id), resolve(reply.value));
+  }
+  transition(event) {
+    if (event === null || this.state === "disposed") return;
+    let next = LIFECYCLE_STATE[event];
+    next !== null && (this.state = next);
+    let listeners = (this.lifecycleListeners.get(event) ?? []).slice();
+    for (let listener of listeners)
+      try {
+        listener();
+      } catch (error) {
+        this.fault("run", error);
+      }
+    if (event === "dispose") {
+      for (let i = this.disposers.length - 1; i >= 0; i--)
+        try {
+          this.disposers[i]();
+        } catch (error) {
+          this.fault("run", error);
+        }
+      this.disposers.length = 0, this.uiListeners.length = 0, this.lane.flush(), this.send(this.writer.tag(MessageTag.disposed));
+    }
+  }
+  async start() {
+    if (this.boot === null || this.state !== "loading" || this.starting) {
+      this.fault("start", new Error("start arrived before boot or twice"));
+      return;
+    }
+    this.starting = true, await this.arrivals();
+    try {
+      this.services.harden();
+    } catch (error) {
+      this.fault("guard", error);
+      return;
+    }
+    let entry;
+    try {
+      let { entry: path, modules, runtimes } = this.assembler.modules(new Set(this.boot.bytecode_modules ?? [])), linked = await this.services.linker.link(modules, path, this.services.slice.tick, runtimes);
+      if (typeof linked.default != "function") throw new Error(`${path} does not export a default function`);
+      entry = linked.default;
+    } catch (error) {
+      this.fault("link", error);
+      return;
+    }
+    this.mark("linked");
+    try {
+      let ctx = (this.options.ctx ?? createGuestCtx)(this);
+      this.transition("ready"), this.mark("main_entered"), await entry(ctx);
+    } catch (error) {
+      this.fault("start", error);
+      return;
+    }
+    this.current() === "ready" && this.transition("visible"), this.send(this.writer.tag(MessageTag.started));
+  }
+};
+function lifecycleOf(runtime) {
+  return {
+    get state() {
+      return runtime.current();
+    },
+    on: (event, listener) => runtime.onLifecycle(event, listener)
+  };
+}
+
+export { CTX_CONFIRMED_REQUEST_DEADLINE_MS, CTX_LONG_REQUEST_DEADLINES_MS, CTX_REQUEST_DEADLINE_MS, ChannelPublisher, ClipError, DEFAULT_SLICE_MS, FrameLane, GuardError, GuestRuntime, GuestUnavailableError, LaneCounter, LaneFastReader, RoomInputPublisher, Slice, SliceExceeded, TICKS_PER_CHECK, TICK_GLOBAL, clockBudget, createGuestCtx, ctxFamilyOf, ctxRequestDeadlineMs, hardenGlobals };