@smoothbuilder/smoothagent-agent-server 0.0.0-stage → 0.3.0

package/dist/client-CN6PRCWE.js

@@ -0,0 +1,3420 @@
+import {
+  KNOWN_ERROR_CODES,
+  newMessageId,
+  serverEnv,
+  systemClock,
+  untilStored,
+  uuidv7
+} from "./chunk-T5FJM7CV.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// ../core-live/src/auth.ts
+var SmoothAgentAuthError = class extends Error {
+  constructor(reason, message = `unauthorized (${reason})`) {
+    super(message);
+    this.reason = reason;
+    this.name = "SmoothAgentAuthError";
+  }
+  reason;
+};
+function jwtExpiresAt(token) {
+  const part = token.split(".")[1];
+  if (!part) return null;
+  try {
+    const json = JSON.parse(decodeBase64Url(part));
+    return typeof json.exp === "number" ? json.exp * 1e3 : null;
+  } catch {
+    return null;
+  }
+}
+function decodeBase64Url(s) {
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4);
+  if (typeof atob === "function") {
+    const bin = atob(b64);
+    const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+  }
+  return Buffer.from(b64, "base64").toString("utf8");
+}
+var TokenSource = class {
+  constructor(o) {
+    this.o = o;
+    if (!o.token && !o.getToken) throw new Error("SmoothAgent: passe `token` ou `getToken`");
+    this.current = o.token ?? null;
+    this.skewMs = o.skewMs ?? 6e4;
+  }
+  o;
+  current;
+  inflight = null;
+  stale = false;
+  revoked = false;
+  listeners = /* @__PURE__ */ new Set();
+  skewMs;
+  /** Token válido agora (renova se precisar). Rejeita com SmoothAgentAuthError('revoked') depois de revogado. */
+  async get() {
+    if (this.revoked) throw new SmoothAgentAuthError("revoked");
+    if (this.current && !this.stale && !this.nearExpiry(this.current)) return this.current;
+    if (!this.o.getToken) {
+      if (this.current && !this.stale) return this.current;
+      throw new SmoothAgentAuthError("expired");
+    }
+    return this.refresh();
+  }
+  /** O servidor disse `expired`: a próxima `get()` renova. */
+  invalidate() {
+    this.stale = true;
+  }
+  /** O servidor disse `revoked`: nada de renovar. */
+  markRevoked() {
+    this.revoked = true;
+  }
+  get isRevoked() {
+    return this.revoked;
+  }
+  onRenew(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  nearExpiry(token) {
+    const exp = jwtExpiresAt(token);
+    return exp !== null && exp - this.o.clock.now() < this.skewMs;
+  }
+  refresh() {
+    if (this.inflight) return this.inflight;
+    const prev = this.current;
+    this.inflight = this.o.getToken().then((t) => {
+      this.current = t;
+      this.stale = false;
+      if (t !== prev) for (const l of this.listeners) l(t);
+      return t;
+    }).finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+};
+function authedFetch(source, base = fetch) {
+  return async (input, init) => {
+    const call = async (token) => {
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", `Bearer ${token}`);
+      return base(input, { ...init, headers });
+    };
+    let res = await call(await source.get());
+    if (res.status !== 401) return res;
+    const reason = await reasonOf(res);
+    if (reason === "revoked") {
+      source.markRevoked();
+      return res;
+    }
+    if (reason !== "expired") return res;
+    source.invalidate();
+    res = await call(await source.get());
+    if (res.status === 401 && await reasonOf(res) === "revoked") source.markRevoked();
+    return res;
+  };
+}
+async function reasonOf(res) {
+  try {
+    const body = await res.clone().json();
+    return body.error?.details?.reason;
+  } catch {
+    return void 0;
+  }
+}
+
+// ../core-live/src/wasm/live.js
+var live_exports = {};
+__export(live_exports, {
+  LiveFeed: () => LiveFeed,
+  LiveSession: () => LiveSession,
+  LiveWatch: () => LiveWatch,
+  Reducer: () => Reducer,
+  default: () => live_default,
+  error_code: () => error_code,
+  error_codes: () => error_codes,
+  initSync: () => initSync,
+  needs_provider: () => needs_provider,
+  to_ms: () => to_ms
+});
+var wasm;
+var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
+  throw Error("TextDecoder not available");
+} };
+if (typeof TextDecoder !== "undefined") {
+  cachedTextDecoder.decode();
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var heap = new Array(128).fill(void 0);
+heap.push(void 0, null, true, false);
+var heap_next = heap.length;
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  const idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+function to_ms(epoch, now) {
+  const ret = wasm.to_ms(epoch, now);
+  return ret;
+}
+var WASM_VECTOR_LEN = 0;
+var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
+  throw Error("TextEncoder not available");
+} };
+var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+  return cachedTextEncoder.encodeInto(arg, view);
+} : function(arg, view) {
+  const buf = cachedTextEncoder.encode(arg);
+  view.set(buf);
+  return {
+    read: arg.length,
+    written: buf.length
+  };
+};
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = encodeString(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function error_code(c) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm0(c, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.error_code(retptr, ptr0, len0);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    deferred2_0 = r0;
+    deferred2_1 = r1;
+    return getStringFromWasm0(r0, r1);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+  }
+}
+function error_codes() {
+  let deferred1_0;
+  let deferred1_1;
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    wasm.error_codes(retptr);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    deferred1_0 = r0;
+    deferred1_1 = r1;
+    return getStringFromWasm0(r0, r1);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+  }
+}
+function getObject(idx) {
+  return heap[idx];
+}
+function dropObject(idx) {
+  if (idx < 132) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+function needs_provider(timeline_json, queue_json, refusal_json) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm0(timeline_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(queue_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(refusal_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN;
+    wasm.needs_provider(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+    var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+    var ptr4 = r0;
+    var len4 = r1;
+    if (r3) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeObject(r2);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+  }
+}
+var LiveFeedFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_livefeed_free(ptr >>> 0, 1));
+var LiveFeed = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    LiveFeedFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_livefeed_free(ptr, 0);
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @param {string} text
+   * @returns {string}
+   */
+  on_message(now, online, visible, rand, conn, text) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_on_message(retptr, this.__wbg_ptr, now, online, visible, rand, conn, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} _n
+   * @param {boolean} _o
+   * @param {boolean} _v
+   * @param {number} _r
+   * @param {number} _req
+   * @param {boolean} _ok
+   * @param {string} _s
+   * @returns {string}
+   */
+  on_snapshot(_n, _o, _v, _r, _req, _ok, _s) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(_s, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_on_probe(retptr, this.__wbg_ptr, _n, _o, _v, _r, _req, _ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @returns {number}
+   */
+  next_deadline() {
+    const ret = wasm.livefeed_next_deadline(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_open_failed(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livefeed_on_open_failed(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * `config_json`: { url, agentId?, backoff? }
+   * @param {string} config_json
+   */
+  constructor(config_json) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(config_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_new(retptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      this.__wbg_ptr = r0 >>> 0;
+      LiveFeedFinalization.register(this, this.__wbg_ptr, this);
+      return this;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  tick(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livefeed_tick(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} _why
+   * @param {number} _away_ms
+   * @returns {string}
+   */
+  wake(now, online, visible, rand, _why, _away_ms) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(_why, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_wake(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0, _away_ms);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  close(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livefeed_close(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  start(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livefeed_start(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  status() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livefeed_status(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_open(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livefeed_on_open(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @param {number} code
+   * @param {string} reason
+   * @returns {string}
+   */
+  on_close(now, online, visible, rand, conn, code, reason) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(reason, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_on_close(retptr, this.__wbg_ptr, now, online, visible, rand, conn, code, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} _now
+   * @param {boolean} _online
+   * @param {boolean} _visible
+   * @param {number} _rand
+   * @param {number} _conn
+   * @returns {string}
+   */
+  on_error(_now, _online, _visible, _rand, _conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livefeed_on_error(retptr, this.__wbg_ptr, _now, _online, _visible, _rand, _conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} _n
+   * @param {boolean} _o
+   * @param {boolean} _v
+   * @param {number} _r
+   * @param {number} _req
+   * @param {boolean} _ok
+   * @param {string} _a
+   * @returns {string}
+   */
+  on_probe(_n, _o, _v, _r, _req, _ok, _a) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(_a, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_on_probe(retptr, this.__wbg_ptr, _n, _o, _v, _r, _req, _ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} _n
+   * @param {boolean} _o
+   * @param {boolean} _v
+   * @param {number} _r
+   * @param {number} _req
+   * @param {boolean} _ok
+   * @param {string} _e
+   * @param {number} _f
+   * @param {number} _t
+   * @returns {string}
+   */
+  on_range(_n, _o, _v, _r, _req, _ok, _e, _f, _t) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(_e, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_on_range(retptr, this.__wbg_ptr, _n, _o, _v, _r, _req, _ok, ptr0, len0, _f, _t);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} token
+   * @returns {string}
+   */
+  on_token(now, online, visible, rand, req, ok, token) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livefeed_on_token(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+};
+var LiveSessionFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_livesession_free(ptr >>> 0, 1));
+var LiveSession = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    LiveSessionFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_livesession_free(ptr, 0);
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @param {string} text
+   * @returns {string}
+   */
+  on_message(now, online, visible, rand, conn, text) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_on_message(retptr, this.__wbg_ptr, now, online, visible, rand, conn, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} snapshot_json
+   * @returns {string}
+   */
+  on_snapshot(now, online, visible, rand, req, ok, snapshot_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(snapshot_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_on_snapshot(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * JSON da presença da box ou "".
+   * @returns {string}
+   */
+  box_presence() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_box_presence(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Próximo prazo (ms) ou -1.
+   * @returns {number}
+   */
+  next_deadline() {
+    const ret = wasm.livesession_next_deadline(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} token
+   * @returns {string}
+   */
+  token_renewed(now, online, visible, rand, token) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_token_renewed(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_open_failed(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_on_open_failed(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * `config_json`: { chatId, connectorUrl, resumeCursor?, resumeInboxVersion?, includeRaw?, strict?,
+   * pingEveryMs?, pongTimeoutMs?, switchGraceMs?, syncTimeoutMs?, gapTimeoutMs?,
+   * longAwayMs?, backoff?{…}, has:{probeAccess,eventsRange,snapshot} }
+   * @param {string} config_json
+   */
+  constructor(config_json) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(config_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_new(retptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      this.__wbg_ptr = r0 >>> 0;
+      LiveSessionFinalization.register(this, this.__wbg_ptr, this);
+      return this;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * "connector" | "box" | "" (nenhum)
+   * @returns {string}
+   */
+  via() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_via(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  tick(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_tick(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} why
+   * @param {number} away_ms
+   * @returns {string}
+   */
+  wake(now, online, visible, rand, why, away_ms) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(why, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_wake(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0, away_ms);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  close(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_close(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  start(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_start(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {number}
+   */
+  cursor() {
+    const ret = wasm.livesession_cursor(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {string}
+   */
+  status() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_status(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} frame_json
+   * @returns {string}
+   */
+  command(now, online, visible, rand, frame_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(frame_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_command(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_open(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_on_open(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @param {number} code
+   * @param {string} reason
+   * @returns {string}
+   */
+  on_close(now, online, visible, rand, conn, code, reason) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(reason, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_on_close(retptr, this.__wbg_ptr, now, online, visible, rand, conn, code, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_error(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livesession_on_error(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} access
+   * @returns {string}
+   */
+  on_probe(now, online, visible, rand, req, ok, access) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(access, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_on_probe(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * `events_json` = array de envelopes.
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} events_json
+   * @param {number} from
+   * @param {number} to
+   * @returns {string}
+   */
+  on_range(now, online, visible, rand, req, ok, events_json, from, to) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(events_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_on_range(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0, from, to);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * `ok=false` = o getToken falhou.
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} token
+   * @returns {string}
+   */
+  on_token(now, online, visible, rand, req, ok, token) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livesession_on_token(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+};
+var LiveWatchFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_livewatch_free(ptr >>> 0, 1));
+var LiveWatch = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    LiveWatchFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_livewatch_free(ptr, 0);
+  }
+  /**
+   * @returns {string}
+   */
+  load_newer() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_load_newer(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  load_older() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_load_older(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * `page_json` = a página no formato do log ({items: envelopes, hasBefore, hasAfter, anchorIndex?…});
+   * com `ok=false`, `page_json` é a mensagem de erro.
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} page_json
+   * @returns {string}
+   */
+  on_history(req, ok, page_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(page_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_on_history(retptr, this.__wbg_ptr, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @param {string} text
+   * @returns {string}
+   */
+  on_message(now, online, visible, rand, conn, text) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_on_message(retptr, this.__wbg_ptr, now, online, visible, rand, conn, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  jump_to_end() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_jump_to_end(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} snapshot_json
+   * @returns {string}
+   */
+  on_snapshot(now, online, visible, rand, req, ok, snapshot_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(snapshot_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_on_snapshot(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * Troca de agente (§17.4) no mesmo canal ordenado dos comandos; `to_json` = `{agentId?, model?, effort?}` (o
+   * realtime completa e valida; provider/agentName que vierem são ignorados). O `resolve`
+   * sai com o ref `switch:<switch_id>`.
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} switch_id
+   * @param {string} to_json
+   * @returns {string}
+   */
+  switch_agent(now, online, visible, rand, switch_id, to_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(switch_id, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(to_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.livewatch_switch_agent(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0, ptr1, len1);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr3 = r0;
+      var len3 = r1;
+      if (r3) {
+        ptr3 = 0;
+        len3 = 0;
+        throw takeObject(r2);
+      }
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+    }
+  }
+  /**
+   * Só modelo/esforço do mesmo agente (`change_json` = `{model?, effort?}`). Ref `switch:<switch_id>`.
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} switch_id
+   * @param {string} change_json
+   * @returns {string}
+   */
+  switch_model(now, online, visible, rand, switch_id, change_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(switch_id, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(change_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.livewatch_switch_model(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0, ptr1, len1);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr3 = r0;
+      var len3 = r1;
+      if (r3) {
+        ptr3 = 0;
+        len3 = 0;
+        throw takeObject(r2);
+      }
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+    }
+  }
+  /**
+   * Cancela a troca agendada (frame `cancelSwitch`). Ref `switch:<switch_id>`.
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} switch_id
+   * @returns {string}
+   */
+  cancel_switch(now, online, visible, rand, switch_id) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(switch_id, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_cancel_switch(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @returns {number}
+   */
+  next_deadline() {
+    const ret = wasm.livewatch_next_deadline(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} token
+   * @returns {string}
+   */
+  token_renewed(now, online, visible, rand, token) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_token_renewed(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * O ref que o próximo `queue_op` vai usar (a borda espera o `resolve` dele).
+   * @returns {string}
+   */
+  next_queue_ref() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_next_queue_ref(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_open_failed(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_on_open_failed(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * A mesma configuração da `LiveSession` + `pageSize?`, `maxWindow?`, `has.history`.
+   * @param {string} config_json
+   */
+  constructor(config_json) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(config_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_new(retptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      this.__wbg_ptr = r0 >>> 0;
+      LiveWatchFinalization.register(this, this.__wbg_ptr, this);
+      return this;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  via() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_via(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * `content_json` = ContentPart[] (a borda converte texto/anexos); `metadata_json` = `{chave: texto}` ou `""` (sem).
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} message_id
+   * @param {string} content_json
+   * @param {string} mode
+   * @param {string} metadata_json
+   * @returns {string}
+   */
+  send(now, online, visible, rand, message_id, content_json, mode, metadata_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(message_id, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(content_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len1 = WASM_VECTOR_LEN;
+      const ptr2 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len2 = WASM_VECTOR_LEN;
+      const ptr3 = passStringToWasm0(metadata_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len3 = WASM_VECTOR_LEN;
+      wasm.livewatch_send(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr5 = r0;
+      var len5 = r1;
+      if (r3) {
+        ptr5 = 0;
+        len5 = 0;
+        throw takeObject(r2);
+      }
+      deferred6_0 = ptr5;
+      deferred6_1 = len5;
+      return getStringFromWasm0(ptr5, len5);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  tick(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_tick(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} why
+   * @param {number} away_ms
+   * @returns {string}
+   */
+  wake(now, online, visible, rand, why, away_ms) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(why, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_wake(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0, away_ms);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  close(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_close(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @returns {string}
+   */
+  start(now, online, visible, rand) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_start(retptr, this.__wbg_ptr, now, online, visible, rand);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {number}
+   */
+  cursor() {
+    const ret = wasm.livewatch_cursor(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {string}
+   */
+  status() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_status(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Comando cru com `ref` (stop/respond/resend/reset).
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} frame_json
+   * @returns {string}
+   */
+  command(now, online, visible, rand, frame_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(frame_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_command(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * `anchor_json` = {"messageId": "msg_…"} | {"eventId": N}
+   * @param {string} anchor_json
+   * @returns {string}
+   */
+  jump_to(anchor_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(anchor_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_jump_to(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_open(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_on_open(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @param {number} code
+   * @param {string} reason
+   * @returns {string}
+   */
+  on_close(now, online, visible, rand, conn, code, reason) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(reason, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_on_close(retptr, this.__wbg_ptr, now, online, visible, rand, conn, code, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} conn
+   * @returns {string}
+   */
+  on_error(now, online, visible, rand, conn) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.livewatch_on_error(retptr, this.__wbg_ptr, now, online, visible, rand, conn);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} access
+   * @returns {string}
+   */
+  on_probe(now, online, visible, rand, req, ok, access) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(access, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_on_probe(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} events_json
+   * @param {number} from
+   * @param {number} to
+   * @returns {string}
+   */
+  on_range(now, online, visible, rand, req, ok, events_json, from, to) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(events_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_on_range(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0, from, to);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {number} req
+   * @param {boolean} ok
+   * @param {string} token
+   * @returns {string}
+   */
+  on_token(now, online, visible, rand, req, ok, token) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_on_token(retptr, this.__wbg_ptr, now, online, visible, rand, req, ok, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred2_0 = r0;
+      deferred2_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {number} now
+   * @param {boolean} online
+   * @param {boolean} visible
+   * @param {number} rand
+   * @param {string} op_json
+   * @returns {string}
+   */
+  queue_op(now, online, visible, rand, op_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(op_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.livewatch_queue_op(retptr, this.__wbg_ptr, now, online, visible, rand, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+    }
+  }
+};
+var ReducerFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_reducer_free(ptr >>> 0, 1));
+var Reducer = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    ReducerFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_reducer_free(ptr, 0);
+  }
+  /**
+   * Parte de um estado (o snapshot) em vez do vazio.
+   * @param {string} state_json
+   */
+  load_state(state_json) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(state_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.reducer_load_state(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      if (r1) {
+        throw takeObject(r0);
+      }
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  state_json() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.reducer_state_json(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+  }
+  constructor() {
+    const ret = wasm.reducer_new();
+    this.__wbg_ptr = ret >>> 0;
+    ReducerFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {string} event_json
+   */
+  apply(event_json) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(event_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.reducer_apply(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      if (r1) {
+        throw takeObject(r0);
+      }
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+};
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        if (module.headers.get("Content-Type") != "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  return imports;
+}
+function __wbg_init_memory(imports, memory) {
+}
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  return wasm;
+}
+function initSync(module) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module !== "undefined") {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  __wbg_init_memory(imports);
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  __wbg_init_memory(imports);
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+var live_default = __wbg_init;
+
+// ../core-live/src/native.ts
+var ready = false;
+var loading = null;
+function decode(b64) {
+  if (typeof atob === "function") {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  return Uint8Array.from(Buffer.from(b64, "base64"));
+}
+function loadCore() {
+  if (ready) return Promise.resolve(live_exports);
+  loading ??= import("./bytes-3XCX7CRA.js").then(({ WASM_BASE64 }) => {
+    if (!ready) {
+      initSync({ module: decode(WASM_BASE64) });
+      ready = true;
+    }
+    return live_exports;
+  });
+  return loading;
+}
+function coreIfReady() {
+  return ready ? live_exports : null;
+}
+function core() {
+  if (!ready) throw new Error("SmoothAgent: o n\xFAcleo ainda est\xE1 carregando \u2014 aguarde `loadCore()`");
+  return live_exports;
+}
+
+// ../core-live/src/edge.ts
+var Edge = class {
+  constructor(make, d, chatId, random, handle) {
+    this.d = d;
+    this.chatId = chatId;
+    this.random = random;
+    this.handle = handle;
+    if (coreIfReady()) this.core = make();
+    else
+      void loadCore().then(() => {
+        if (this.stopped && !this.pending.length) return;
+        const c = this.core = make();
+        const queued = this.pending;
+        this.pending = [];
+        for (const p of queued) p(c);
+      });
+  }
+  d;
+  chatId;
+  random;
+  handle;
+  sockets = /* @__PURE__ */ new Map();
+  timer = null;
+  stopped = false;
+  /** O núcleo desta casca; `null` até o wasm carregar (as entradas esperam em `pending`, em ordem). */
+  core = null;
+  pending = [];
+  /** Roda `fn` com o núcleo: na hora se já carregou, senão na ordem em que foi pedido, quando carregar. */
+  when(fn) {
+    if (this.core) fn(this.core);
+    else this.pending.push(fn);
+  }
+  env() {
+    return [this.d.clock.now(), this.d.env.online(), this.d.env.visible(), this.random()];
+  }
+  /** Uma entrada pro núcleo; executa os efeitos devolvidos, em ordem; re-arma o timer. */
+  run(input) {
+    if (this.stopped) return;
+    this.when((c) => this.exec(JSON.parse(input(c, this.env()))));
+  }
+  /** Executa uma lista de efeitos já devolvida (quando quem chamou precisou do JSON antes). */
+  exec(fx) {
+    for (const f of fx) this.one(f);
+    this.arm();
+  }
+  /** Para tudo (depois do close do núcleo): sem timer, sem novas entradas. */
+  stop() {
+    this.stopped = true;
+    this.disarm();
+    if (!this.core) this.pending = [];
+  }
+  arm() {
+    this.disarm();
+    if (this.stopped || !this.core) return;
+    const at = this.core.next_deadline();
+    if (at < 0) return;
+    this.timer = this.d.clock.setTimeout(() => {
+      this.timer = null;
+      this.run((c, e) => c.tick(...e));
+    }, Math.max(0, at - this.d.clock.now()));
+  }
+  disarm() {
+    if (this.timer !== null) {
+      this.d.clock.clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  one(f) {
+    const d = this.d;
+    const chatId = this.chatId;
+    switch (f.k) {
+      case "token": {
+        const req = f.req;
+        d.token().then(
+          (t) => this.run((c, e) => c.on_token(...e, req, true, t)),
+          // o motivo decide: `revoked`/`missing`/`invalid` param de vez; o resto (rede, 500) entra no backoff
+          (err) => this.run((c, e) => c.on_token(...e, req, false, err instanceof SmoothAgentAuthError ? err.reason : "error"))
+        );
+        return;
+      }
+      case "invalidateToken":
+        d.invalidateToken?.();
+        return;
+      case "probe": {
+        const req = f.req;
+        d.probeAccess(chatId).then(
+          (a) => this.run((c, e) => c.on_probe(...e, req, true, a)),
+          () => this.run((c, e) => c.on_probe(...e, req, false, ""))
+        );
+        return;
+      }
+      case "range": {
+        const { req, from, to } = f;
+        d.eventsRange(chatId, from, to).then(
+          (r) => this.run((c, e) => c.on_range(...e, req, true, JSON.stringify(r.events), r.range.from, r.range.to)),
+          () => this.run((c, e) => c.on_range(...e, req, false, "[]", 0, 0))
+        );
+        return;
+      }
+      case "snapshot": {
+        const req = f.req;
+        d.snapshot(chatId).then(
+          (s) => this.run((c, e) => c.on_snapshot(...e, req, true, JSON.stringify(s))),
+          () => this.run((c, e) => c.on_snapshot(...e, req, false, ""))
+        );
+        return;
+      }
+      case "open": {
+        const { conn, url, protocols } = f;
+        return this.open(conn, url, protocols);
+      }
+      case "send": {
+        const { conn, text } = f;
+        const sock = this.sockets.get(conn);
+        if (sock && sock.readyState === 1) sock.send(text);
+        return;
+      }
+      case "close": {
+        const { conn, code, reason } = f;
+        const sock = this.sockets.get(conn);
+        this.sockets.delete(conn);
+        if (!sock) return;
+        sock.onopen = sock.onmessage = sock.onclose = sock.onerror = null;
+        try {
+          sock.close(code, reason);
+        } catch {
+        }
+        return;
+      }
+      default:
+        this.handle(f);
+    }
+  }
+  open(conn, url, protocols) {
+    let sock;
+    try {
+      sock = this.d.openSocket(url, protocols);
+    } catch {
+      this.run((c, e) => c.on_open_failed(...e, conn));
+      return;
+    }
+    this.sockets.set(conn, sock);
+    sock.onopen = () => this.run((c, e) => c.on_open(...e, conn));
+    sock.onmessage = (ev) => this.run((c, e) => c.on_message(...e, conn, String(ev.data)));
+    sock.onerror = () => this.run((c, e) => c.on_error(...e, conn));
+    sock.onclose = (ev) => {
+      this.sockets.delete(conn);
+      this.run((c, e) => c.on_close(...e, conn, ev.code, ev.reason ?? ""));
+    };
+  }
+};
+
+// ../core-live/src/wasm/empty.ts
+var EMPTY_STATE_JSON = '{"seq":0,"chat":{"state":"idle"},"items":{},"order":[],"history":[],"tasks":{},"pending":{},"limits":{},"usage":{"chat":{}},"runs":[],"switches":[]}';
+
+// ../core-live/src/backoff.ts
+var DEFAULT_BACKOFF = {
+  baseMs: 250,
+  factor: 2,
+  capVisibleMs: 3e4,
+  capHiddenMs: 3e5,
+  stableMs: 1e4
+};
+
+// ../core-live/src/stream.ts
+var newRef = () => `r_${uuidv7()}`;
+var ChatStream = class {
+  constructor(d, opts, l) {
+    this.d = d;
+    this.opts = opts;
+    this.l = l;
+    const cfg = JSON.stringify(sessionConfig(d, opts));
+    this.edge = new Edge(() => new (core()).LiveSession(cfg), d, opts.chatId, opts.random ?? Math.random, (f) => this.handle(f));
+    this.unWake = d.env.onWake((why, awayMs) => this.edge.run((c, e) => c.wake(...e, why, awayMs ?? 0)));
+    this.edge.run((c, e) => c.start(...e));
+  }
+  d;
+  opts;
+  l;
+  edge;
+  waiting = /* @__PURE__ */ new Map();
+  closed = false;
+  unWake;
+  // ------------------------------------------------------------------ API (a mesma de antes)
+  get status() {
+    return this.edge.core?.status() ?? (this.closed ? "closed" : "connecting");
+  }
+  get cursor() {
+    return this.edge.core?.cursor() ?? this.opts.resumeFrom?.cursor ?? 0;
+  }
+  get via() {
+    return this.edge.core?.via() || null;
+  }
+  get box() {
+    const b = this.edge.core?.box_presence();
+    return b ? JSON.parse(b) : null;
+  }
+  /**
+   * Manda um comando (send/queue/stop/respond/resend/reset). Resolve com o `ack` — que só vem depois de
+   * gravado no log. Cai o socket antes do ack: o núcleo reenvia o MESMO frame no próximo transporte; o
+   * servidor devolve `duplicate`. Nunca rejeita por transporte; só por close()/revogação.
+   */
+  command(frame) {
+    if (this.closed) return Promise.reject(new Error("stream closed"));
+    return new Promise((resolve, reject) => {
+      this.waiting.set(frame.ref, { resolve, reject });
+      this.edge.run((c, e) => c.command(...e, JSON.stringify(frame)));
+    });
+  }
+  /** Token do usuário renovado: vai pelo socket do conector sem derrubar. */
+  tokenRenewed(token) {
+    this.edge.run((c, e) => c.token_renewed(...e, token));
+  }
+  retry() {
+    this.edge.run((c, e) => c.wake(...e, "manual", 0));
+  }
+  close() {
+    if (this.closed) return;
+    this.edge.run((c, e) => c.close(...e));
+    this.closed = true;
+    this.unWake();
+    this.edge.stop();
+  }
+  handle(f) {
+    const v = f.v;
+    switch (f.k) {
+      case "onSnapshot":
+        return this.l.snapshot?.(v);
+      case "onEvents":
+        return this.l.events?.(v);
+      case "onInbox":
+        return this.l.inbox?.(v);
+      case "onQueue":
+        return this.l.queue?.(v);
+      case "onBox":
+        return this.l.box?.(v, f.via);
+      case "onStatus":
+        return this.l.status?.(v);
+      case "onDebug":
+        return this.l.debug?.(v);
+      case "onViolation":
+        return this.l.violation?.(v);
+      case "onOther":
+        return this.l.other?.(v);
+      case "resolve": {
+        const w = this.waiting.get(f.ref);
+        this.waiting.delete(f.ref);
+        return w?.resolve(v);
+      }
+      case "reject": {
+        const w = this.waiting.get(f.ref);
+        this.waiting.delete(f.ref);
+        return w?.reject(new Error(String(f.v)));
+      }
+    }
+  }
+};
+function sessionConfig(d, opts) {
+  const b = opts.backoff ?? DEFAULT_BACKOFF;
+  return {
+    chatId: opts.chatId,
+    connectorUrl: d.connectorUrl(opts.chatId),
+    ...opts.resumeFrom ? { resumeCursor: opts.resumeFrom.cursor, resumeInboxVersion: opts.resumeFrom.inboxVersion } : {},
+    includeRaw: opts.includeRaw ?? false,
+    strict: opts.strict ?? false,
+    pingEveryMs: opts.pingEveryMs,
+    pongTimeoutMs: opts.pongTimeoutMs,
+    switchGraceMs: opts.switchGraceMs,
+    syncTimeoutMs: opts.syncTimeoutMs,
+    gapTimeoutMs: opts.gapTimeoutMs,
+    longAwayMs: opts.longAwayMs,
+    ackTimeoutMs: opts.ackTimeoutMs,
+    queueCheckEveryMs: opts.queueCheckEveryMs,
+    queueCheckMinMs: opts.queueCheckMinMs,
+    backoff: { baseMs: b.baseMs, factor: b.factor, capVisibleMs: b.capVisibleMs, capHiddenMs: b.capHiddenMs, stableMs: b.stableMs },
+    has: { probeAccess: !!d.probeAccess, eventsRange: !!d.eventsRange, snapshot: !!d.snapshot }
+  };
+}
+
+// ../core-live/src/types.ts
+function toContentParts(content, attachments = []) {
+  const parts = typeof content === "string" ? [{ type: "text", text: content }] : [...content];
+  for (const fileId of attachments) parts.push({ type: "file", fileId });
+  return parts;
+}
+
+// ../core-live/src/watch.ts
+var SendNotConfirmedError = class extends Error {
+  constructor(reason, messageId, content, mode, cause) {
+    super(reason === "closed" ? "stream closed" : reason === "timeout" ? "send: sem confirma\xE7\xE3o no prazo" : "send: n\xE3o confirmado");
+    this.reason = reason;
+    this.messageId = messageId;
+    this.content = content;
+    this.mode = mode;
+    this.cause = cause;
+  }
+  reason;
+  messageId;
+  content;
+  mode;
+  cause;
+  name = "SendNotConfirmedError";
+};
+var CommandAbortedError = class extends Error {
+  constructor(ref) {
+    super("stream closed");
+    this.ref = ref;
+  }
+  ref;
+  name = "CommandAbortedError";
+};
+var SEND_FALLBACK_MS = 2e3;
+var REST_RETRY_MS = 5e3;
+var REST_RETRY_MAX_MS = 6e4;
+function safeCause(e) {
+  const x = e ?? {};
+  const out = new Error(typeof x.message === "string" ? x.message : String(e));
+  if (typeof x.name === "string") out.name = x.name;
+  if (typeof x.status === "number") out.status = x.status;
+  if (typeof x.code === "string") out.code = x.code;
+  return out;
+}
+var EMPTY_INBOX = { version: -1, pending: [], queue: [], notDelivered: [], responses: [] };
+var EMPTY_QUEUE = { version: -1, owner: "cold", turn: "idle", items: [], notDelivered: [] };
+var LiveChat = class {
+  constructor(d, o) {
+    this.d = d;
+    this.o = o;
+    this.state = {
+      version: 0,
+      // a timeline vazia do núcleo (forma completa: order, items, runs…) antes do wasm e do 1º snapshot
+      timeline: JSON.parse(EMPTY_STATE_JSON),
+      queue: EMPTY_QUEUE,
+      inbox: EMPTY_INBOX,
+      needsProvider: null,
+      box: null,
+      local: { sending: [] },
+      history: { anchor: "end", items: [], hasBefore: false, hasAfter: false, loadingBefore: false, loadingAfter: false, newWhileDetached: 0 },
+      sync: { status: "connecting", cursor: 0, via: null, violations: [] }
+    };
+    const cfg = sessionConfig(d, o);
+    cfg.has.history = !!d.history;
+    const wcfg = JSON.stringify({ ...cfg, pageSize: o.pageSize, maxWindow: o.maxWindow, refNonce: uuidv7(d.clock.now()).replace(/-/g, "") });
+    this.edge = new Edge(() => new (core()).LiveWatch(wcfg), d, o.chatId, o.random ?? Math.random, (f) => this.handle(f));
+    this.unWake = d.env.onWake((why, awayMs) => this.edge.run((c, e) => c.wake(...e, why, awayMs ?? 0)));
+    this.edge.run((c, e) => c.start(...e));
+  }
+  d;
+  o;
+  edge;
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  eventTaps = /* @__PURE__ */ new Set();
+  waiting = /* @__PURE__ */ new Map();
+  historyWaiting = /* @__PURE__ */ new Map();
+  /** os `send` esperando, NA ORDEM em que foram mandados (o Map guarda a ordem de inserção) */
+  sends = /* @__PURE__ */ new Map();
+  /** a corrente do REST: um pedido por vez, em ordem (B nunca passa na frente de A) */
+  restBusy = false;
+  restRetry = null;
+  /** falhas de vez seguidas da corrente (a espera cresce; zera quando uma grava) */
+  restFails = 0;
+  /** gravados pelo REST e ainda em `local.sending` do núcleo (que não viu o ack): a tela mostra `pending` */
+  restStored = /* @__PURE__ */ new Map();
+  /** o `local.sending` como o núcleo mandou (antes da sobreposição do REST) */
+  coreLocal = [];
+  /** itens que vieram de páginas do histórico (não estão na timeline viva) */
+  pageItems = /* @__PURE__ */ new Map();
+  historyIds = [];
+  closed = false;
+  unWake;
+  // ------------------------------------------------------------------ leitura
+  getState = () => this.state;
+  /** Compatível com `useSyncExternalStore(live.subscribe, live.getState)`. */
+  subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  };
+  /** Só chama quando o pedaço escolhido muda (a fila não re-renderiza a cada delta de texto — T3). */
+  select(fn, cb, eq = Object.is) {
+    let prev = fn(this.state);
+    cb(prev);
+    return this.subscribe((s) => {
+      const next = fn(s);
+      if (!eq(prev, next)) {
+        prev = next;
+        cb(next);
+      }
+    });
+  }
+  /** Eventos aplicados, em ordem (o `prompt()` e o `events()` usam). */
+  tap(cb) {
+    this.eventTaps.add(cb);
+    return () => this.eventTaps.delete(cb);
+  }
+  get chatId() {
+    return this.o.chatId;
+  }
+  // ------------------------------------------------------------------ comandos
+  /**
+   * Manda uma mensagem. Aparece na hora em `local.sending`; sai quando a inbox do log a mostra. Resolve quando
+   * gravada: pelo socket ou, se ele não confirmar em `sendFallbackMs`, pelo REST com o mesmo messageId (o servidor
+   * deduplica). `timeoutMs`: rejeita com `SendNotConfirmedError` ('timeout') se nada confirmou no prazo.
+   *
+   * O `timeoutMs` só desiste de ESPERAR: não cancela o envio pelo socket (o núcleo segue reenviando aquele frame
+   * até o ack ou o `close()`), então a mensagem ainda pode chegar à fila depois do timeout — e, chegando, a ordem
+   * relativa dela com os `send` seguintes não é garantida (o caminho do REST também não espera mais por ela).
+   * Reenviar com o mesmo `messageId` é seguro (o servidor deduplica) — com o MESMO `metadata`: outro = `conflict`.
+   *
+   * `metadata`: chave → texto do app (até 16 chaves `^[A-Za-z0-9_.:-]{1,64}$`, sem o prefixo `sa.`; valores de até
+   * 512 caracteres). Volta como `metadata` no item `user_message` e nos itens da fila; o agente/LLM NUNCA vê.
+   * Fora dos limites = `rejected` `invalid_request`. `{}` = sem metadata.
+   */
+  async send(content, opts = {}) {
+    const messageId = opts.messageId ?? newMessageId(this.d.clock.now());
+    const parts = toContentParts(content, opts.attachments);
+    const mode = opts.mode ?? "auto";
+    const metadata = opts.metadata && Object.keys(opts.metadata).length ? { ...opts.metadata } : void 0;
+    if (this.closed) throw new SendNotConfirmedError("closed", messageId, parts, mode);
+    const r = await new Promise((resolve, reject) => {
+      const prev = this.sends.get(messageId);
+      if (prev && !prev.done) {
+        prev.done = true;
+        for (const t of prev.timers) this.d.clock.clearTimeout(t);
+      }
+      const ps = {
+        messageId,
+        content: parts,
+        mode,
+        ...metadata ? { metadata } : {},
+        timers: [],
+        rest: false,
+        done: false,
+        resolve: prev ? (x) => (prev.resolve(x), resolve(x)) : resolve,
+        reject: prev ? (e) => (prev.reject(e), reject(e)) : reject
+      };
+      this.sends.set(messageId, ps);
+      const fallback = this.o.sendFallbackMs ?? SEND_FALLBACK_MS;
+      if (this.d.postMessage && Number.isFinite(fallback)) ps.timers.push(this.d.clock.setTimeout(() => this.viaRest(ps), Math.max(0, fallback)));
+      if (opts.timeoutMs !== void 0 && Number.isFinite(opts.timeoutMs))
+        ps.timers.push(this.d.clock.setTimeout(() => this.settleSend(ps, new SendNotConfirmedError("timeout", messageId, parts, mode)), Math.max(0, opts.timeoutMs)));
+      this.waiting.set(`send:${messageId}`, {
+        resolve: (x) => this.settleSend(ps, x),
+        // o núcleo desistiu (fechou): vale o REST, se houver
+        reject: (e) => this.coreGaveUp(ps, e)
+      });
+      this.edge.run((c, e) => c.send(...e, messageId, JSON.stringify(parts), mode, metadata ? JSON.stringify(metadata) : ""));
+    });
+    return { ...r, messageId };
+  }
+  /** Pede o caminho durável pra este send (e, pela ordem, pra todos os anteriores ainda esperando). */
+  viaRest(ps) {
+    if (ps.done || !this.d.postMessage) return;
+    ps.rest = true;
+    this.pumpRest();
+  }
+  /**
+   * A corrente do REST, por chat: grava UM por vez, na ordem dos `send`. A cabeça é o send mais antigo ainda
+   * esperando; se algum depois dela pediu o REST, ela vai antes (a fila no servidor fica na ordem em que o usuário
+   * mandou). A cabeça confirmada (por qualquer caminho) libera a próxima. Falhou de vez: com o chat aberto a corrente
+   * para e tenta de novo com espera crescente, 5 s até 60 s (o socket também segue tentando); fechado, a cabeça e TODAS as de trás
+   * rejeitam — nenhuma pula a que não foi gravada.
+   */
+  pumpRest() {
+    if (this.restBusy || !this.d.postMessage) return;
+    const order = [...this.sends.values()].filter((x) => !x.done);
+    const head = order[0];
+    if (!head || !order.some((x) => x.rest)) return;
+    if (this.restRetry !== null) {
+      this.d.clock.clearTimeout(this.restRetry);
+      this.restRetry = null;
+    }
+    this.restBusy = true;
+    this.d.postMessage(this.o.chatId, { clientMessageId: head.messageId, content: head.content, mode: head.mode, ...head.metadata ? { metadata: head.metadata } : {} }).then(
+      (r) => {
+        this.restBusy = false;
+        this.restFails = 0;
+        if (r.status === "accepted" || r.status === "duplicate") this.markStored(head.messageId, r.version ?? r.inboxVersion);
+        this.settleSend(head, r);
+        this.pumpRest();
+      },
+      (e) => {
+        this.restBusy = false;
+        if (head.done) return this.pumpRest();
+        if (this.closed) {
+          const cause = safeCause(e);
+          this.restBusy = true;
+          for (const x of [...this.sends.values()].filter((y) => !y.done)) this.settleSend(x, new SendNotConfirmedError("failed", x.messageId, x.content, x.mode, cause));
+          this.restBusy = false;
+          return;
+        }
+        const wait = Math.min(REST_RETRY_MAX_MS, REST_RETRY_MS * 2 ** this.restFails++);
+        this.restRetry = this.d.clock.setTimeout(() => {
+          this.restRetry = null;
+          this.pumpRest();
+        }, wait);
+      }
+    );
+  }
+  coreGaveUp(ps, e) {
+    if (ps.done) return;
+    if (this.d.postMessage) this.viaRest(ps);
+    else this.settleSend(ps, new SendNotConfirmedError("closed", ps.messageId, ps.content, ps.mode, e));
+  }
+  settleSend(ps, r) {
+    if (ps.done) return;
+    ps.done = true;
+    for (const t of ps.timers) this.d.clock.clearTimeout(t);
+    if (this.sends.get(ps.messageId) === ps) this.sends.delete(ps.messageId);
+    if (r instanceof Error) ps.reject(r);
+    else ps.resolve(r);
+    if (!this.restBusy) this.pumpRest();
+  }
+  /** Gravado pelo REST: no `local.sending` passa de `sending` a `pending` (o núcleo não viu o ack). */
+  markStored(messageId, version) {
+    if (this.closed || !this.coreLocal.some((l) => l.messageId === messageId)) return;
+    this.restStored.set(messageId, version);
+    this.state = { ...this.state, local: { sending: this.overlayLocal() } };
+    for (const l of this.listeners) l(this.state);
+  }
+  overlayLocal() {
+    for (const id of [...this.restStored.keys()]) if (!this.coreLocal.some((l) => l.messageId === id)) this.restStored.delete(id);
+    if (!this.restStored.size) return this.coreLocal;
+    return this.coreLocal.map((l) => {
+      if (l.status !== "sending" || !this.restStored.has(l.messageId)) return l;
+      const v = this.restStored.get(l.messageId);
+      return { ...l, status: "pending", ...v !== void 0 ? { ackVersion: v } : {} };
+    });
+  }
+  stop() {
+    const stopId = uuidv7(this.d.clock.now());
+    return this.command({ t: "stop", ref: `stop:${stopId}`, chatId: this.o.chatId, stopId });
+  }
+  respond(requestId, answer) {
+    return this.command({ t: "respond", ref: `respond:${requestId}:${uuidv7(this.d.clock.now())}`, chatId: this.o.chatId, requestId, answer });
+  }
+  /** Sessão nova do provedor (era o recycle); `clearHistory` também esconde o histórico até aqui. */
+  reset(opts = {}) {
+    const resetId = uuidv7(this.d.clock.now());
+    return this.command({ t: "reset", ref: `reset:${resetId}`, chatId: this.o.chatId, resetId, ...opts.clearHistory ? { clearHistory: true } : {} });
+  }
+  /**
+   * Troca de agente (§17.4): um comando da fila no MESMO canal ordenado do `send` — "troquei e mandei" chega
+   * na ordem, sem esperar nada. O dono aplica antes do próximo run; uma troca nova substitui a pendente
+   * (`queue.pendingSwitch`). A forma é a do REST (`agentId`, `model?`, `effort?`): o servidor completa o resto e
+   * valida o acesso; `provider`/`agentName` não vão (o servidor ignoraria).
+   */
+  switchAgent(to) {
+    const switchId = uuidv7(this.d.clock.now());
+    return this.wait(`switch:${switchId}`, (c, e) => c.switch_agent(...e, switchId, JSON.stringify(to)));
+  }
+  /**
+   * Troca SÓ modelo/esforço do agente de agora (o que não vier fica o de agora): o mesmo comando `switch`, sem
+   * `agentId` — o servidor completa com o agente atual (a box aplica ao vivo, sem sessão nova). `null` = voltar
+   * ao padrão do agente (vai no frame como `reset`).
+   */
+  switchModel(change) {
+    const switchId = uuidv7(this.d.clock.now());
+    return this.wait(`switch:${switchId}`, (c, e) => c.switch_model(...e, switchId, JSON.stringify(change)));
+  }
+  /** Cancela a troca agendada (`queue.pendingSwitch`): o comando `cancelSwitch`, no mesmo canal ordenado. */
+  cancelSwitch() {
+    const switchId = uuidv7(this.d.clock.now());
+    return this.wait(`switch:${switchId}`, (c, e) => c.cancel_switch(...e, switchId));
+  }
+  resend(messageId) {
+    return this.command({ t: "resend", ref: newRef(), chatId: this.o.chatId, messageId });
+  }
+  /** Fila: sempre em cima da versão que a tela está vendo; `conflict` traz (e aplica) o estado novo. */
+  queue = {
+    reorder: (order) => this.queueOp({ kind: "reorder", order }),
+    edit: (messageId, content) => this.queueOp({ kind: "edit", messageId, content: toContentParts(content) }),
+    remove: (messageId) => this.queueOp({ kind: "remove", messageId }),
+    sendNow: (messageId) => this.queueOp({ kind: "sendNow", messageId })
+  };
+  queueOp(op) {
+    if (this.closed) return Promise.reject(new Error("stream closed"));
+    return new Promise(
+      (resolve, reject) => this.edge.when((c) => this.wait(c.next_queue_ref(), (w, e) => w.queue_op(...e, JSON.stringify(op))).then(resolve, reject))
+    );
+  }
+  command(frame) {
+    return this.wait(frame.ref, (c, e) => c.command(...e, JSON.stringify(frame)));
+  }
+  wait(ref, input) {
+    if (this.closed) return Promise.reject(new Error("stream closed"));
+    return new Promise((resolve, reject) => {
+      this.waiting.set(ref, { resolve, reject });
+      this.edge.run(input);
+    });
+  }
+  retry() {
+    this.edge.run((c, e) => c.wake(...e, "manual", 0));
+  }
+  tokenRenewed(token) {
+    this.edge.run((c, e) => c.token_renewed(...e, token));
+  }
+  /**
+   * Fecha. Nenhuma espera fica pendurada: o `send` não confirmado vai pelo REST (mesmo messageId) e resolve quando
+   * gravado; sem REST, rejeita com `SendNotConfirmedError` ('closed', com a mensagem). Os demais comandos
+   * rejeitam com `CommandAbortedError`.
+   */
+  close() {
+    if (this.closed) return;
+    this.edge.run((c, e) => c.close(...e));
+    this.closed = true;
+    this.unWake();
+    this.edge.stop();
+    this.listeners.clear();
+    this.eventTaps.clear();
+    const left = [...this.waiting];
+    this.waiting.clear();
+    for (const [ref, w] of left) w.reject(new CommandAbortedError(ref));
+    for (const ps of [...this.sends.values()]) this.coreGaveUp(ps, new Error("stream closed"));
+    this.pumpRest();
+  }
+  // ------------------------------------------------------------------ histórico (§4.9)
+  history = {
+    /** Rola pra cima: página de itens fechados antes do primeiro da janela. */
+    loadOlder: () => this.page((c) => c.load_older()),
+    /** Só na janela parada: página depois do último item; encontrando o ao vivo, recola no fim. */
+    loadNewer: () => this.page((c) => c.load_newer()),
+    /** Abre "em volta" de uma mensagem ou evento. O ao vivo continua aplicando por baixo. */
+    jumpTo: (anchor) => this.page((c) => c.jump_to(JSON.stringify(anchor))),
+    /** Volta pro fim (cola no ao vivo). */
+    jumpToEnd: () => this.page((c) => c.jump_to_end())
+  };
+  /** Roda um pedido de histórico; resolve quando a página chegou e foi aplicada (ou na hora, se não pediu). */
+  page(input) {
+    if (this.closed) return Promise.resolve();
+    return new Promise(
+      (resolve) => this.edge.when((c) => {
+        const fx = JSON.parse(input(c));
+        const req = fx.find((f) => f.k === "history")?.req;
+        if (req === void 0) resolve();
+        else this.historyWaiting.set(req, resolve);
+        this.edge.exec(fx);
+      })
+    );
+  }
+  // ------------------------------------------------------------------ efeitos do núcleo
+  handle(f) {
+    switch (f.k) {
+      case "patch":
+        return this.applyPatch(f.v);
+      case "tap": {
+        const evs = f.v;
+        for (const t of this.eventTaps) t(evs);
+        return;
+      }
+      case "history": {
+        const req = f.req;
+        const finish = (input) => {
+          if (!this.closed && this.edge.core) this.edge.exec(JSON.parse(input(this.edge.core)));
+          const w = this.historyWaiting.get(req);
+          this.historyWaiting.delete(req);
+          w?.();
+        };
+        this.d.history(this.o.chatId, f.q).then(
+          (page) => finish((c) => c.on_history(req, true, JSON.stringify(page))),
+          (e) => finish((c) => c.on_history(req, false, e instanceof Error ? e.message : String(e)))
+        );
+        return;
+      }
+      case "onStatus":
+        if (f.v === "auth_failed") this.o.onAuthFailed?.();
+        return;
+      case "onDebug":
+        return this.o.onDebug?.(f.v);
+      case "onViolation":
+        return this.o.onViolation?.(f.v);
+      case "resolve": {
+        const w = this.waiting.get(f.ref);
+        this.waiting.delete(f.ref);
+        return w?.resolve(f.v);
+      }
+      case "reject": {
+        const w = this.waiting.get(f.ref);
+        this.waiting.delete(f.ref);
+        return w?.reject(String(f.v) === "stream closed" ? new CommandAbortedError(f.ref) : new Error(String(f.v)));
+      }
+    }
+  }
+  applyPatch(p) {
+    const prev = this.state;
+    let timeline = prev.timeline;
+    if (p.timeline && "replace" in p.timeline) {
+      timeline = p.timeline.replace;
+    } else if (p.timeline) {
+      const t = p.timeline;
+      timeline = { ...timeline, ...t.set };
+      for (const k of t.del) delete timeline[k];
+      if (Object.keys(t.items).length) timeline.items = { ...timeline.items, ...t.items };
+    }
+    let history = prev.history;
+    if (p.history) {
+      const { ids, items, ...flags } = p.history;
+      for (const [id, it] of Object.entries(items ?? {})) this.pageItems.set(id, it);
+      this.historyIds = ids;
+      history = { ...flags, items: [] };
+    }
+    if (p.history || p.timeline) {
+      const live = timeline.items ?? {};
+      history = { ...history, items: this.historyIds.map((id) => live[id] ?? this.pageItems.get(id)).filter((x) => x !== void 0) };
+    }
+    this.state = {
+      version: p.version,
+      timeline,
+      queue: p.queue ?? prev.queue,
+      inbox: p.inbox ?? prev.inbox,
+      needsProvider: p.needsProvider !== void 0 ? p.needsProvider : prev.needsProvider,
+      box: p.box !== void 0 ? p.box : prev.box,
+      local: p.local ? { sending: (this.coreLocal = p.local, this.overlayLocal()) } : prev.local,
+      history,
+      sync: p.sync ?? prev.sync
+    };
+    for (const l of this.listeners) l(this.state);
+  }
+};
+
+// ../core-live/src/prompt.ts
+var PromptRejectedError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PromptRejectedError";
+  }
+  code;
+};
+var RunHandle = class {
+  constructor(live, content, opts = {}, onSettled) {
+    this.live = live;
+    this.onSettled = onSettled;
+    this.result = new Promise((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+    this.result.catch(() => {
+    });
+    this.untap = live.tap((evs) => evs.forEach((e) => this.onEvent(e)));
+    live.send(content, opts).then((r) => {
+      this.messageId = r.messageId;
+      if (r.status === "rejected") return this.fail(new PromptRejectedError(r.code, r.message));
+      if (r.status === "conflict") return this.fail(new PromptRejectedError("conflict", "conflict"));
+      this.watchQueue();
+    }).catch((e) => this.fail(e));
+    if (opts.messageId) this.messageId = opts.messageId;
+  }
+  live;
+  onSettled;
+  result;
+  state = "sending";
+  messageId = "";
+  runId;
+  resolve;
+  reject;
+  handlers = {};
+  buffer = [];
+  wakeIterators = [];
+  text = "";
+  items = [];
+  untap;
+  unselect = null;
+  on(type, cb) {
+    ;
+    (this.handlers[type] ??= []).push(cb);
+    return this;
+  }
+  /** STOP do chat (o run é dele). O `result` resolve com `stopped` quando o run fechar. */
+  stop() {
+    return this.live.stop();
+  }
+  /** Para de ouvir; o agente segue. O `result` resolve com `cancelled`. */
+  cancel() {
+    this.settle("cancelled");
+  }
+  [Symbol.asyncIterator]() {
+    let i = 0;
+    return {
+      next: () => new Promise((resolve) => {
+        const pull = () => {
+          if (i < this.buffer.length) return resolve({ value: this.buffer[i++], done: false });
+          if (this.state === "done") return resolve({ value: void 0, done: true });
+          this.wakeIterators.push(pull);
+        };
+        pull();
+      })
+    };
+  }
+  // ------------------------------------------------------------------
+  watchQueue() {
+    const mine = (q) => q.messageId === this.messageId;
+    this.unselect = this.live.select(
+      (s) => {
+        const nd = s.queue?.notDelivered?.find(mine) ?? s.inbox.notDelivered?.find(mine);
+        if (nd) return `not_delivered:${nd.notDeliveredReason ?? ""}`;
+        const q = s.queue?.items?.find(mine);
+        return q && q.mode === "queue" || s.inbox.queue.some(mine) ? "queued" : "";
+      },
+      (where) => {
+        if (where.startsWith("not_delivered:") && !this.runId) {
+          const reason = where.slice("not_delivered:".length);
+          return this.settle("not_delivered", void 0, void 0, reason || void 0);
+        }
+        if (where === "queued" && this.state === "sending") {
+          this.state = "queued";
+          this.emit({ type: "queued" });
+        }
+      }
+    );
+  }
+  onEvent(e) {
+    if (this.state === "done") return;
+    const d = e.data ?? {};
+    if (!this.runId) {
+      const item = d.item;
+      const trigger = d.trigger;
+      const read = (e.type === "item.started" || e.type === "item.completed") && item?.kind === "user_message" && item.messageId === this.messageId;
+      if (this.messageId !== "" && (e.type === "run.started" && trigger?.messageIds?.includes(this.messageId) || read)) {
+        this.runId = e.runId ?? d.runId ?? item?.runId;
+        if (this.runId) {
+          this.state = "running";
+          this.emit({ type: "started", runId: this.runId });
+        }
+      }
+      if (!this.runId) return;
+    }
+    const runOf = e.runId ?? d.runId;
+    if (runOf !== this.runId) return;
+    this.emit({ type: "event", event: e });
+    if (e.type === "item.delta") {
+      const delta = d.delta;
+      const piece = delta ? delta.path === "text" ? delta.append : void 0 : d.text;
+      if (piece) {
+        this.text += piece;
+        this.emit({ type: "text", delta: piece, text: this.text });
+      }
+    } else if (e.type === "item.completed") {
+      const item = d.item ?? d;
+      this.items.push(item);
+      this.emit({ type: "item", item });
+    } else if (e.type === "run.completed") {
+      const status = d.status ?? "completed";
+      this.settle(status, d.usage, d.error);
+    }
+  }
+  /**
+   * O texto do run = os itens `text` fechados. Um steer no Codex CORTA a resposta em andamento
+   * (`steerBoundary: 'model_call'`): o parcial fecha `interrupted` e outra resposta começa já com o
+   * steer — a resposta final é a que completou; o parcial cortado só entra se não houver outra.
+   */
+  finalText() {
+    const texts = this.items.filter(
+      (i) => typeof i === "object" && i !== null && i.kind === "text"
+    );
+    if (!texts.length) return this.text;
+    const done = texts.filter((i) => i.status !== "interrupted");
+    return (done.length ? done : texts).map((i) => i.text).join("");
+  }
+  settle(status, usage, error, notDeliveredReason) {
+    if (this.state === "done") return;
+    const result = {
+      status,
+      messageId: this.messageId,
+      text: this.finalText(),
+      items: this.items,
+      ...this.runId ? { runId: this.runId } : {},
+      ...usage !== void 0 ? { usage } : {},
+      ...error !== void 0 ? { error } : {},
+      ...notDeliveredReason ? { notDeliveredReason } : {}
+    };
+    this.emit({ type: "done", result });
+    this.state = "done";
+    this.cleanup();
+    this.resolve(result);
+  }
+  fail(e) {
+    if (this.state === "done") return;
+    this.state = "done";
+    this.cleanup();
+    this.reject(e);
+  }
+  cleanup() {
+    this.untap();
+    this.unselect?.();
+    const wake = this.wakeIterators;
+    this.wakeIterators = [];
+    wake.forEach((w) => w());
+    this.onSettled?.();
+  }
+  emit(ev) {
+    this.buffer.push(ev);
+    for (const h of this.handlers[ev.type] ?? []) {
+      try {
+        h(ev);
+      } catch {
+      }
+    }
+    const wake = this.wakeIterators;
+    this.wakeIterators = [];
+    wake.forEach((w) => w());
+  }
+};
+
+// ../core-live/src/feed.ts
+var ChatListLive = class {
+  constructor(d, filter = {}) {
+    this.d = d;
+    const fcfg = JSON.stringify({ url: d.url, ...filter.agentId ? { agentId: filter.agentId } : {} });
+    const deps = { connectorUrl: () => d.url, openSocket: d.openSocket, token: d.token, invalidateToken: d.invalidateToken, clock: d.clock, env: d.env };
+    this.edge = new Edge(() => new (core()).LiveFeed(fcfg), deps, "", Math.random, (fx) => {
+      if (fx.k !== "feedState") return;
+      this.state = fx.v;
+      for (const l of this.listeners) l(this.state);
+    });
+    this.unWake = d.env.onWake((why, awayMs) => this.edge.run((c, e) => c.wake(...e, why, awayMs ?? 0)));
+    this.edge.run((c, e) => c.start(...e));
+  }
+  d;
+  edge;
+  state = { version: -1, rows: [], status: "connecting" };
+  listeners = /* @__PURE__ */ new Set();
+  unWake;
+  closed = false;
+  getState = () => this.state;
+  subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  };
+  close() {
+    if (this.closed) return;
+    this.edge.run((c, e) => c.close(...e));
+    this.closed = true;
+    this.unWake();
+    this.edge.stop();
+  }
+};
+
+// ../core-live/src/client.ts
+function restTransient(e) {
+  const st = e?.status;
+  return st === void 0 || st === 408 || st === 429 || st >= 500;
+}
+var LiveClient = class {
+  constructor(o) {
+    this.o = o;
+    this.clock = o.clock ?? systemClock;
+    this.tokens = new TokenSource({ token: o.token, getToken: o.getToken, clock: this.clock });
+    this.fetch = authedFetch(this.tokens, o.fetch ?? globalThis.fetch.bind(globalThis));
+    this.api = `${o.baseUrl.replace(/\/$/, "")}/v3`;
+    void loadCore().catch(() => {
+    });
+    this.tokens.onRenew((t) => {
+      for (const e of this.entries.values()) e.live.tokenRenewed(t);
+    });
+  }
+  o;
+  tokens;
+  /** `fetch` com o token e a regra do 401 (a SDK gerada usa o mesmo). */
+  fetch;
+  clock;
+  entries = /* @__PURE__ */ new Map();
+  lists = /* @__PURE__ */ new Set();
+  api;
+  /** O estado ao vivo do chat. Chame `close()` no handle quando a tela desmontar. */
+  watch(chatId) {
+    let e = this.entries.get(chatId);
+    if (e) {
+      e.refs++;
+      if (e.closeTimer !== null) {
+        this.clock.clearTimeout(e.closeTimer);
+        e.closeTimer = null;
+      }
+    } else {
+      e = { live: new LiveChat(this.deps(), this.watchOptions(chatId)), refs: 1, closeTimer: null };
+      this.entries.set(chatId, e);
+    }
+    const entry = e;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      this.release(chatId, entry);
+    };
+    return new Proxy(entry.live, {
+      get(target, key) {
+        if (key === "release") return release;
+        if (key === "close") return release;
+        const v = Reflect.get(target, key, target);
+        return typeof v === "function" ? v.bind(target) : v;
+      }
+    });
+  }
+  /**
+   * Eventos crus, já sem duplicado/buraco e com a troca de transporte. Termina no `return()`/break.
+   * - `after`: começa DEPOIS deste seq (retomar de onde parou: todo evento de `after+1` em diante, sem snapshot);
+   *   sem `after`, começa no estado atual (o snapshot do servidor; `onSnapshot(seq)` diz até onde ele cobre).
+   * - `onSnapshot(seq)`: o servidor mandou um snapshot em vez dos eventos — os anteriores a `seq` NÃO vêm
+   *   (início sem `after`, ou resync depois de um buraco que não fechou). Nunca pula em silêncio (M46).
+   * - `includeRaw`: os eventos trazem o `raw` do provedor.
+   * Um socket próprio (não o do `watch()`), pra o cursor ser só dele.
+   */
+  async *events(chatId, o = {}) {
+    const queue = [];
+    let wake = null;
+    const stream = new ChatStream(
+      this.deps(),
+      {
+        ...this.o.stream,
+        chatId,
+        ...o.includeRaw ? { includeRaw: true } : {},
+        ...o.after !== void 0 ? { resumeFrom: { cursor: o.after, inboxVersion: -1 } } : {},
+        ...this.o.strict ? { strict: true } : {}
+      },
+      {
+        events: (evs) => {
+          queue.push(...evs);
+          wake?.();
+        },
+        snapshot: (s) => o.onSnapshot?.(s.seq),
+        status: (st) => {
+          if (st === "auth_failed") {
+            this.tokens.markRevoked();
+            this.o.onAuthRevoked?.();
+          }
+        },
+        debug: (e) => this.o.onDebug?.(chatId, e),
+        violation: (v) => this.o.onViolation?.(chatId, v)
+      }
+    );
+    const unRenew = this.tokens.onRenew((t) => stream.tokenRenewed(t));
+    try {
+      for (; ; ) {
+        while (queue.length) yield queue.shift();
+        await new Promise((r) => wake = r);
+        wake = null;
+      }
+    } finally {
+      unRenew?.();
+      stream.close();
+    }
+  }
+  /** Manda e acompanha só esse run. `result` nunca rejeita por transporte. */
+  prompt(chatId, content, opts = {}) {
+    const h = this.watch(chatId);
+    return new RunHandle(h, content, opts, () => h.release());
+  }
+  /** A lista lateral ao vivo (UserFeed): título, estado, esperando o quê, não lidas. Filtro por agente aqui. */
+  watchList(filter = {}) {
+    const d = this.deps();
+    const list = new ChatListLive(
+      { url: `${this.api.replace(/^http/, "ws")}/me/feed`, openSocket: d.openSocket, token: d.token, invalidateToken: d.invalidateToken, clock: d.clock, env: d.env },
+      filter
+    );
+    this.lists.add(list);
+    return list;
+  }
+  /** Marca como lido até `seq` (vale pra todos os dispositivos do usuário; o feed atualiza o unreadCount). */
+  async markRead(chatId, seq) {
+    await this.json(`/chats/${encodeURIComponent(chatId)}/read`, { method: "POST", body: JSON.stringify({ seq }), headers: { "Content-Type": "application/json" } });
+  }
+  /** Fecha tudo agora. */
+  close() {
+    for (const e of this.entries.values()) {
+      if (e.closeTimer !== null) this.clock.clearTimeout(e.closeTimer);
+      e.live.close();
+    }
+    this.entries.clear();
+    for (const l of this.lists) l.close();
+    this.lists.clear();
+  }
+  release(chatId, e) {
+    if (--e.refs > 0) return;
+    e.closeTimer = this.clock.setTimeout(() => {
+      if (e.refs > 0 || this.entries.get(chatId) !== e) return;
+      e.live.close();
+      this.entries.delete(chatId);
+    }, this.o.keepAliveMs ?? 3e5);
+  }
+  watchOptions(chatId) {
+    return {
+      ...this.o.stream,
+      chatId,
+      onDebug: (e) => this.o.onDebug?.(chatId, e),
+      ...this.o.strict ? { strict: true } : {},
+      onViolation: (v) => this.o.onViolation?.(chatId, v),
+      onAuthFailed: () => {
+        this.tokens.markRevoked();
+        this.o.onAuthRevoked?.();
+      }
+    };
+  }
+  deps() {
+    const wsBase = this.api.replace(/^http/, "ws");
+    const WS = this.o.WebSocket ?? globalThis.WebSocket;
+    if (!WS) throw new Error("SmoothAgent: sem WebSocket neste ambiente \u2014 passe `WebSocket` nas op\xE7\xF5es");
+    const openSocket = (url, protocols) => new WS(url, protocols);
+    return {
+      connectorUrl: (id) => `${wsBase}/chats/${encodeURIComponent(id)}/live`,
+      openSocket,
+      token: () => this.tokens.get(),
+      invalidateToken: () => this.tokens.invalidate(),
+      clock: this.clock,
+      env: this.o.env ?? browserEnv() ?? serverEnv,
+      eventsRange: (id, from, to) => this.json(`/chats/${encodeURIComponent(id)}/events/range?after=${from - 1}&until=${to}`),
+      snapshot: (id) => this.json(`/chats/${encodeURIComponent(id)}/snapshot`),
+      probeAccess: async (id) => {
+        const res = await this.fetch(`${this.api}/chats/${encodeURIComponent(id)}`, { headers: { Accept: "application/json" } });
+        if (res.status === 401) return "unauthorized";
+        if (res.status === 403 || res.status === 404) return "forbidden";
+        return "ok";
+      },
+      history: async (id, q) => fromControlPage(id, await this.json(`/chats/${encodeURIComponent(id)}/history?${historyQs(q)}`)),
+      postMessage: (id, m) => this.postMessage(id, m)
+    };
+  }
+  /**
+   * O caminho durável do `send` (REST `SendMessage`): a mesma fila fria do ChatLog, deduplicada pelo
+   * `clientMessageId` (= o messageId do socket) e pela Idempotency-Key (a mesma). Falha passageira: repete com
+   * espera (`untilStored`) e, esgotado, rejeita; recusa do servidor = `rejected` com o código do §6.
+   */
+  async postMessage(id, m) {
+    const call = () => this.json(`/chats/${encodeURIComponent(id)}/messages`, {
+      method: "POST",
+      body: JSON.stringify(m),
+      headers: { "Content-Type": "application/json", "Idempotency-Key": m.clientMessageId }
+    });
+    try {
+      const r = await untilStored(call, { clock: this.clock, isTransient: (e) => restTransient(e) });
+      const v = r.inboxVersion ?? 0;
+      return r.status === "duplicate" ? { status: "duplicate", messageId: m.clientMessageId, inboxVersion: v } : { status: "accepted", messageId: m.clientMessageId, inboxVersion: v };
+    } catch (e) {
+      if (restTransient(e)) throw e;
+      const err = e;
+      const code = KNOWN_ERROR_CODES.includes(err.code ?? "") ? err.code : "internal";
+      return { status: "rejected", code, message: err.message ?? code };
+    }
+  }
+  async json(path, init) {
+    const res = await this.fetch(`${this.api}${path}`, { ...init, headers: { Accept: "application/json", ...init?.headers ?? {} } });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw Object.assign(new Error(body.error?.message ?? `HTTP ${res.status}`), { code: body.error?.code, status: res.status });
+    }
+    return await res.json();
+  }
+};
+function fromControlPage(_chatId, p) {
+  const num = (v) => v === null || v === void 0 ? null : Number(v);
+  return {
+    items: p.data.map((entry) => ({ ...entry.event, seq: entry.seq })),
+    firstEventId: num(p.firstEventId),
+    lastEventId: num(p.lastEventId),
+    hasBefore: p.hasBefore,
+    hasAfter: p.hasAfter,
+    ...p.anchorIndex !== void 0 ? { anchorIndex: p.anchorIndex } : {},
+    headEventId: num(p.headEventId) ?? 0,
+    ...p.liveFromEventId !== void 0 && p.liveFromEventId !== null ? { liveFromEventId: Number(p.liveFromEventId) } : {}
+  };
+}
+function historyQs(q) {
+  const p = new URLSearchParams();
+  if (q.limit) p.set("limit", String(q.limit));
+  if ("before" in q) p.set("before", String(q.before));
+  else if ("after" in q) p.set("after", String(q.after));
+  else if ("around" in q) p.set("around", "messageId" in q.around ? q.around.messageId : String(q.around.eventId));
+  else p.set("anchor", "end");
+  return p.toString();
+}
+function browserEnv() {
+  const g = globalThis;
+  if (!g.document || !g.addEventListener) return null;
+  const doc = g.document;
+  return {
+    online: () => g.navigator?.onLine !== false,
+    visible: () => doc.visibilityState !== "hidden",
+    onWake: (cb) => {
+      let hiddenAt = null;
+      const onOnline = () => cb("online");
+      const onFocus = () => cb("focus");
+      const onVis = () => {
+        if (doc.visibilityState === "hidden") hiddenAt = Date.now();
+        else {
+          cb("visible", hiddenAt === null ? 0 : Date.now() - hiddenAt);
+          hiddenAt = null;
+        }
+      };
+      g.addEventListener("online", onOnline);
+      g.addEventListener("focus", onFocus);
+      doc.addEventListener("visibilitychange", onVis);
+      return () => {
+        g.removeEventListener("online", onOnline);
+        g.removeEventListener("focus", onFocus);
+        doc.removeEventListener("visibilitychange", onVis);
+      };
+    }
+  };
+}
+export {
+  LiveClient,
+  fromControlPage
+};
+//# sourceMappingURL=client-CN6PRCWE.js.map