@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-4ZDR72SG.js

@@ -0,0 +1,329 @@
+'use strict';
+
+// src/interactives/runtime/protocol.ts
+var SESSION_PROTOCOL_VERSION = 1, BRIDGE_PROTOCOL_VERSION = 1, ENGINE_CORE_UNIT = "@cimplify/engine-core", ENGINE_CORE_THREADS_UNIT = "@cimplify/engine-core-threads", RUNTIME_WASM_SUFFIX = "/wasm", MessageTag = {
+  hello: 1,
+  close: 2,
+  consent: 3,
+  confirm: 4,
+  ai_local: 5,
+  ai_local_result: 6,
+  request: 16,
+  response: 17,
+  event: 18,
+  frames: 19,
+  boot: 32,
+  chunk: 33,
+  start: 34,
+  lifecycle: 35,
+  ui_event: 36,
+  ui_reply: 37,
+  ping: 38,
+  room_dialed: 39,
+  room_frames: 40,
+  room_closed: 41,
+  stage: 42,
+  warm: 43,
+  chunk_ref: 44,
+  stage_ref: 45,
+  room_batch: 46,
+  room_backpressure: 47,
+  ready: 48,
+  render: 49,
+  ui_command: 50,
+  pong: 51,
+  fault: 52,
+  started: 53,
+  disposed: 54,
+  room_dial: 55,
+  room_send: 56,
+  room_close: 57,
+  milestone: 58,
+  warmed: 59,
+  chunk_request: 60,
+  game_ui: 61,
+  game_ui_event: 62,
+  session_complete: 63,
+  chunk_release: 64,
+  chunk_failed: 65,
+  network: 66,
+  camera_open: 67,
+  camera_opened: 68,
+  camera_close: 69,
+  camera_track: 70,
+  camera_untrack: 71,
+  camera_face: 72,
+  camera_colours: 73,
+  camera_coloured: 74,
+  inspector: 75,
+  frame_mark: 76,
+  frame_step: 77,
+  font_request: 78,
+  font_reply: 79,
+  hot: 80,
+  hot_done: 81,
+  meters: 82,
+  meter_report: 83,
+  studio: 84,
+  studio_report: 85,
+  clip_arm: 86,
+  clip_pause: 87,
+  clip_save: 88,
+  clip_saved: 89,
+  replay: 90,
+  camera_place: 91,
+  camera_identify: 92,
+  camera_identified: 93
+}, FrameTouchKind = { take: 0, progressive: 1, prefetch: 2, pipeline: 3, chunk: 4 }, CHUNK_TOUCH_PREFIX = "chunk:", PIPELINE_TOUCH_PREFIX = "pipeline:", FRAME_MARK_HEADER_BYTES = 13, HEAP_OFFSET = 9, MAX_HEAP_BYTES = 4294967295, FRAME_TOUCH_HEADER_BYTES = 4, FRAME_OFFSET = 1, OUTSTANDING_OFFSET = 5, TOUCH_COUNT_OFFSET = 7, MAX_FRAME_TOUCHES = 65535, markEncoder = new TextEncoder(), markDecoder = new TextDecoder();
+function encodeFrameMark(mark) {
+  let paths = mark.touches.slice(0, (65535)).map((touch) => markEncoder.encode(touch.path)), size = (13) + paths.reduce((sum, path) => sum + (4) + path.length, 0), bytes = new Uint8Array(size), view = new DataView(bytes.buffer);
+  bytes[0] = MessageTag.frame_mark, view.setUint32((1), mark.frame, true), view.setUint16((5), Math.min(mark.outstanding, (65535)), true), view.setUint16((7), paths.length, true), view.setUint32((9), Math.min(Math.max(mark.heap ?? 0, 0), (4294967295)), true);
+  let at = (13);
+  return paths.forEach((path, k) => {
+    let touch = mark.touches[k];
+    bytes[at] = touch.kind, bytes[at + 1] = touch.priority, view.setUint16(at + 2, path.length, true), bytes.set(path, at + (4)), at += (4) + path.length;
+  }), bytes;
+}
+function readFrameMark(bytes) {
+  if (bytes.length < (13) || bytes[0] !== MessageTag.frame_mark) return null;
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), count = view.getUint16((7), true), touches = [], at = (13);
+  for (let k = 0; k < count; k++) {
+    if (at + (4) > bytes.length) return null;
+    let length = view.getUint16(at + 2, true);
+    if (at + (4) + length > bytes.length) return null;
+    touches.push({
+      kind: bytes[at],
+      priority: bytes[at + 1],
+      path: markDecoder.decode(bytes.subarray(at + (4), at + (4) + length))
+    }), at += (4) + length;
+  }
+  return { frame: view.getUint32((1), true), outstanding: view.getUint16((5), true), touches, heap: view.getUint32((9), true) };
+}
+var LifecycleCode = {
+  visible: 1,
+  hidden: 2,
+  suspend: 3,
+  resume: 4,
+  revision_update: 5,
+  dispose: 6
+}, LIFECYCLE_BY_CODE = [
+  null,
+  "visible",
+  "hidden",
+  "suspend",
+  "resume",
+  "revision_update",
+  "dispose"
+], Milestone = {
+  linked: 1,
+  main_entered: 2,
+  attach_requested: 3,
+  attach_resolved: 4,
+  first_frame_scheduled: 5,
+  ready_for_input: 6
+}, MILESTONE_BY_CODE = [
+  null,
+  "linked",
+  "main_entered",
+  "attach_requested",
+  "attach_resolved",
+  "first_frame_scheduled",
+  "ready_for_input"
+], MILESTONE_BYTES = 2, SessionOutcomeCode = {
+  won: 1,
+  lost: 2,
+  draw: 3,
+  finished: 4
+}, SESSION_OUTCOME_BY_CODE = [null, "won", "lost", "draw", "finished"], SESSION_COMPLETE_BYTES = 11, SESSION_OUTCOME_OFFSET = 1, SESSION_SCORE_FLAG_OFFSET = 2, SESSION_SCORE_OFFSET = 3, SCORE_PRESENT = 1, SCORE_ABSENT = 0, UINT32_SPAN = 4294967296, WORD_BYTES = 4;
+function writeSessionComplete(out, message) {
+  let view = new DataView(out.buffer, out.byteOffset, (11));
+  out[0] = MessageTag.session_complete, out[(1)] = SessionOutcomeCode[message.outcome], out[(2)] = message.score === null ? (0) : (1);
+  let score = message.score === null ? 0 : Math.trunc(message.score), high = Math.floor(score / (4294967296));
+  return view.setUint32((3), score - high * (4294967296), true), view.setInt32((3) + (4), high, true), (11);
+}
+function readSessionComplete(bytes) {
+  if (bytes.length < (11) || bytes[0] !== MessageTag.session_complete) return null;
+  let outcome = SESSION_OUTCOME_BY_CODE[bytes[(1)]] ?? null;
+  if (outcome === null) return null;
+  let view = new DataView(bytes.buffer, bytes.byteOffset, (11)), score = bytes[(2)] === (1) ? view.getInt32((3) + (4), true) * (4294967296) + view.getUint32((3), true) : null;
+  return { outcome, score };
+}
+var DIGEST_BYTES = 32, PING_BYTES = 5, PONG_BYTES = 13, LIFECYCLE_BYTES = 2, INSPECTOR_BYTES = 2, INSPECTOR_SHOWN = 1, INSPECTOR_HIDDEN = 0, TAG_BYTES = 1, UTF8_BYTES_PER_UNIT = 3, BRIDGE_LIMITS = {
+  max_message_bytes: 4 * 1024 * 1024,
+  max_render_bytes: 512 * 1024,
+  max_tree_nodes: 2048,
+  max_tree_depth: 64,
+  frame_outbox_bytes: 16 * 1024
+}, encoder = new TextEncoder(), decoder = new TextDecoder(), MessageWriter = class {
+  constructor(initialBytes = 4096) {
+    this.buffer = new Uint8Array(initialBytes);
+  }
+  get bytes() {
+    return this.buffer;
+  }
+  json(tag, value) {
+    return this.text(tag, JSON.stringify(value));
+  }
+  text(tag, text) {
+    for (; ; ) {
+      let encoded = encoder.encodeInto(text, this.buffer.subarray((1)));
+      if (encoded.read === text.length)
+        return this.buffer[0] = tag, (1) + encoded.written;
+      this.buffer = new Uint8Array(Math.max(this.buffer.length * 2, (1) + text.length * (3)));
+    }
+  }
+  tag(tag) {
+    return this.buffer[0] = tag, (1);
+  }
+};
+function tagOf(bytes) {
+  return bytes.length === 0 ? -1 : bytes[0];
+}
+function readJson(bytes) {
+  return JSON.parse(decoder.decode(bytes.subarray((1))));
+}
+function readText(bytes, offset) {
+  return decoder.decode(bytes.subarray(offset));
+}
+function utf8(text) {
+  return encoder.encode(text);
+}
+function hex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += (bytes[i] < 16 ? "0" : "") + bytes[i].toString(16);
+  return out;
+}
+var HEX_DIGIT_ZERO = 48, HEX_DIGIT_NINE = 57, HEX_LOWER_A = 97, HEX_LOWER_F = 102, HEX_UPPER_A = 65, HEX_UPPER_F = 70, HEX_LETTER_BASE = 10, NIBBLE_BITS = 4;
+function nibble(code) {
+  return code >= (48) && code <= (57) ? code - (48) : code >= (97) && code <= (102) ? code - (97) + (10) : code >= (65) && code <= (70) ? code - (65) + (10) : -1;
+}
+function unhexAt(text, out, offset, bytes) {
+  if (text.length !== bytes * 2 || offset + bytes > out.length) return false;
+  for (let i = 0; i < bytes; i++) {
+    let high = nibble(text.charCodeAt(i * 2)), low = nibble(text.charCodeAt(i * 2 + 1));
+    if (high < 0 || low < 0) return false;
+    out[offset + i] = high << (4) | low;
+  }
+  return true;
+}
+function hexAt(bytes, offset, length) {
+  let out = "";
+  for (let i = offset; i < offset + length; i++) out += (bytes[i] < 16 ? "0" : "") + bytes[i].toString(16);
+  return out;
+}
+var CHUNK_REQUESTS_VERSION = 1, ChunkPriority = { now: 0, soon: 1, prefetch: 2 }, PREFETCH_BUDGET_SHARE = 0.75, PREFETCH_SLOT_SHARE = 0.25;
+function prefetchSlots(concurrency) {
+  return Math.max(1, Math.floor(concurrency * (0.25)));
+}
+var ChunkFailure = { unknown: 0, budget: 1, network: 2, verify: 3 }, CHUNK_FAILURE_BY_CODE = ["unknown", "budget", "network", "verify"], CHUNK_COUNT_BYTES = 2, CHUNK_REQUEST_ENTRY_BYTES = (32) + 1, CHUNK_RELEASE_ENTRY_BYTES = (32), CHUNK_FAILED_BYTES = (1) + (32) + 1, MAX_CHUNK_BATCH = 256, COUNT_HIGH_SHIFT = 8, BYTE_MASK = 255, ChunkBatch = class {
+  constructor(tag, entryBytes, capacity = (256)) {
+    this.tag = tag;
+    this.entryBytes = entryBytes;
+    this.capacity = capacity;
+    this.count = 0;
+    this.bytes = new Uint8Array((1) + (2) + capacity * entryBytes);
+  }
+  get size() {
+    return this.count;
+  }
+  get full() {
+    return this.count >= this.capacity;
+  }
+  add(digest, priority = ChunkPriority.now) {
+    if (this.full) return false;
+    let at = (1) + (2) + this.count * this.entryBytes;
+    return unhexAt(digest, this.bytes, at, (32)) ? (this.entryBytes > (32) && (this.bytes[at + (32)] = priority), this.count++, true) : false;
+  }
+  seal() {
+    let count = this.count;
+    return this.bytes[0] = this.tag, this.bytes[(1)] = count & (255), this.bytes[(1) + 1] = count >> (8), this.count = 0, (1) + (2) + count * this.entryBytes;
+  }
+};
+function chunkEntryCount(bytes, entryBytes) {
+  if (bytes.length < (1) + (2)) return 0;
+  let count = bytes[(1)] | bytes[(1) + 1] << (8);
+  return Math.min(count, Math.floor((bytes.length - (1) - (2)) / entryBytes));
+}
+function chunkEntryOffset(index, entryBytes) {
+  return (1) + (2) + index * entryBytes;
+}
+function forEachChunkEntry(bytes, entryBytes, visit) {
+  let count = chunkEntryCount(bytes, entryBytes);
+  for (let i = 0; i < count; i++) {
+    let at = chunkEntryOffset(i, entryBytes);
+    visit(hexAt(bytes, at, (32)), entryBytes > (32) ? bytes[at + (32)] : ChunkPriority.now);
+  }
+}
+function writeChunkFailed(out, digest, reason) {
+  return out[0] = MessageTag.chunk_failed, unhexAt(digest, out, (1), (32)), out[(1) + (32)] = ChunkFailure[reason], CHUNK_FAILED_BYTES;
+}
+function readChunkFailed(bytes) {
+  return bytes.length < CHUNK_FAILED_BYTES || bytes[0] !== MessageTag.chunk_failed ? null : { digest: hexAt(bytes, (1), (32)), reason: CHUNK_FAILURE_BY_CODE[bytes[(1) + (32)]] ?? "unknown" };
+}
+function unhex(text, out) {
+  if (text.length !== out.length * 2) return false;
+  for (let i = 0; i < out.length; i++) {
+    let byte = Number.parseInt(text.slice(i * 2, i * 2 + 2), 16);
+    if (Number.isNaN(byte)) return false;
+    out[i] = byte;
+  }
+  return true;
+}
+
+exports.BRIDGE_LIMITS = BRIDGE_LIMITS;
+exports.BRIDGE_PROTOCOL_VERSION = (1);
+exports.CHUNK_COUNT_BYTES = (2);
+exports.CHUNK_FAILED_BYTES = CHUNK_FAILED_BYTES;
+exports.CHUNK_FAILURE_BY_CODE = CHUNK_FAILURE_BY_CODE;
+exports.CHUNK_RELEASE_ENTRY_BYTES = CHUNK_RELEASE_ENTRY_BYTES;
+exports.CHUNK_REQUESTS_VERSION = (1);
+exports.CHUNK_REQUEST_ENTRY_BYTES = CHUNK_REQUEST_ENTRY_BYTES;
+exports.CHUNK_TOUCH_PREFIX = CHUNK_TOUCH_PREFIX;
+exports.ChunkBatch = ChunkBatch;
+exports.ChunkFailure = ChunkFailure;
+exports.ChunkPriority = ChunkPriority;
+exports.DIGEST_BYTES = (32);
+exports.ENGINE_CORE_THREADS_UNIT = ENGINE_CORE_THREADS_UNIT;
+exports.ENGINE_CORE_UNIT = ENGINE_CORE_UNIT;
+exports.FrameTouchKind = FrameTouchKind;
+exports.INSPECTOR_BYTES = (2);
+exports.INSPECTOR_HIDDEN = (0);
+exports.INSPECTOR_SHOWN = (1);
+exports.LIFECYCLE_BYTES = (2);
+exports.LIFECYCLE_BY_CODE = LIFECYCLE_BY_CODE;
+exports.LifecycleCode = LifecycleCode;
+exports.MAX_CHUNK_BATCH = (256);
+exports.MILESTONE_BYTES = (2);
+exports.MILESTONE_BY_CODE = MILESTONE_BY_CODE;
+exports.MessageTag = MessageTag;
+exports.MessageWriter = MessageWriter;
+exports.Milestone = Milestone;
+exports.PING_BYTES = (5);
+exports.PIPELINE_TOUCH_PREFIX = PIPELINE_TOUCH_PREFIX;
+exports.PONG_BYTES = (13);
+exports.PREFETCH_BUDGET_SHARE = (0.75);
+exports.PREFETCH_SLOT_SHARE = (0.25);
+exports.RUNTIME_WASM_SUFFIX = RUNTIME_WASM_SUFFIX;
+exports.SESSION_COMPLETE_BYTES = (11);
+exports.SESSION_OUTCOME_BY_CODE = SESSION_OUTCOME_BY_CODE;
+exports.SESSION_PROTOCOL_VERSION = (1);
+exports.SessionOutcomeCode = SessionOutcomeCode;
+exports.TAG_BYTES = (1);
+exports.chunkEntryCount = chunkEntryCount;
+exports.chunkEntryOffset = chunkEntryOffset;
+exports.encodeFrameMark = encodeFrameMark;
+exports.forEachChunkEntry = forEachChunkEntry;
+exports.hex = hex;
+exports.hexAt = hexAt;
+exports.prefetchSlots = prefetchSlots;
+exports.readChunkFailed = readChunkFailed;
+exports.readFrameMark = readFrameMark;
+exports.readJson = readJson;
+exports.readSessionComplete = readSessionComplete;
+exports.readText = readText;
+exports.tagOf = tagOf;
+exports.unhex = unhex;
+exports.unhexAt = unhexAt;
+exports.utf8 = utf8;
+exports.writeChunkFailed = writeChunkFailed;
+exports.writeSessionComplete = writeSessionComplete;