@vinaverse/client 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/agent/index.cjs

@@ -0,0 +1,3321 @@
+'use strict';
+
+// src/events.ts
+var CARD_KINDS = {
+  professional: true,
+  workspace: true,
+  service: true,
+  time_slots: true,
+  booking: true,
+  quote: true,
+  policy: true,
+  handoff: true,
+  metric_chart: true,
+  metric_table: true,
+  gap_list: true,
+  cluster: true,
+  claim: true,
+  document: true,
+  question: true,
+  proposal: true,
+  next_step: true,
+  links: true
+};
+function isKnownCard(card) {
+  return Object.hasOwn(CARD_KINDS, card.kind);
+}
+
+// src/agent/cards.ts
+var LISTING = /* @__PURE__ */ new Set(["professional", "workspace"]);
+var PURPOSES = /* @__PURE__ */ new Set(["help", "support", "policy", "contact", "feedback"]);
+var GROUP_ID = /^[A-Za-z0-9_-]{1,64}$/;
+var CURRENCY = /^[A-Z]{3}$/;
+var isFields = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var text = (v) => typeof v === "string" ? v : null;
+var whole = (v) => typeof v === "number" && Number.isInteger(v) ? v : null;
+var list = (v) => Array.isArray(v) ? v : [];
+var https = (v) => {
+  const url = text(v);
+  return url !== null && /^https:\/\//i.test(url) ? url : null;
+};
+var instant = (v) => {
+  const at = text(v);
+  return at !== null && !Number.isNaN(Date.parse(at)) ? at : null;
+};
+function money(v) {
+  if (!isFields(v)) return null;
+  const amount = whole(v.amount);
+  const currency = text(v.currency);
+  return amount !== null && amount >= 0 && currency !== null && CURRENCY.test(currency) ? { amount, currency } : null;
+}
+function hero(card) {
+  for (const image of list(card.images)) {
+    if (!isFields(image)) continue;
+    const url = https(image.url);
+    if (url === null) continue;
+    const width = whole(image.width);
+    const height = whole(image.height);
+    return {
+      url,
+      ratio: width && height && width > 0 && height > 0 ? width / height : null
+    };
+  }
+  const legacy = https(card.image_url);
+  return legacy === null ? null : { url: legacy, ratio: null };
+}
+function readCard(value) {
+  if (!isFields(value)) return null;
+  const id = text(value.id);
+  const kind = text(value.kind);
+  const title = text(value.title);
+  if (id === null || kind === null || title === null) return null;
+  if (!isKnownCard({ kind })) return null;
+  const rating = isFields(value.rating) ? value.rating : null;
+  const ppm = whole(rating?.value_ppm);
+  const count = whole(rating?.count);
+  const group = isFields(value.group) ? value.group : null;
+  const groupId = text(group?.id);
+  const ref = isFields(value.ref) ? value.ref : null;
+  const refType = text(ref?.type);
+  const refId = text(ref?.id);
+  const proposal = isFields(value.proposal) ? value.proposal : null;
+  return {
+    id,
+    kind,
+    listing: LISTING.has(kind),
+    title,
+    subtitle: text(value.subtitle),
+    body: text(value.body),
+    badges: list(value.badges).filter(
+      (b) => typeof b === "string"
+    ),
+    actions: list(value.actions).flatMap((a) => {
+      if (!isFields(a)) return [];
+      const action = text(a.action);
+      const label = text(a.label);
+      return action === null || label === null ? [] : [{ action, label, deepLink: text(a.deep_link) }];
+    }),
+    target: refType !== null && refId !== null ? { type: refType, id: refId } : null,
+    hero: hero(value),
+    rating: ppm !== null && count !== null && ppm >= 0 && ppm <= 5e6 && count >= 0 ? { stars: ppm / 1e6, count } : null,
+    priceFrom: money(value.price_from),
+    price: money(value.price),
+    nextAvailable: instant(value.next_available),
+    startsAt: instant(value.starts_at),
+    group: groupId !== null && GROUP_ID.test(groupId) ? {
+      id: groupId,
+      layout: group?.layout === "carousel" ? "carousel" : "list"
+    } : null,
+    links: list(value.links).flatMap((l) => {
+      if (!isFields(l)) return [];
+      const label = text(l.label);
+      const url = text(l.url)?.trim() ?? "";
+      const purpose = text(l.purpose);
+      return label && [...label].length <= 40 && url && purpose && PURPOSES.has(purpose) ? [{ label, url, purpose }] : [];
+    }),
+    proposalId: kind === "proposal" ? text(proposal?.id) : null
+  };
+}
+
+// src/engine.ts
+var UNLOCKS_KEEP_LOCKED = /* @__PURE__ */ new Set([
+  "card_superseded",
+  "client_event_id_reused"
+]);
+var RESEND = /* @__PURE__ */ new Set(["turn_in_progress", "screen_unavailable"]);
+var FLOW_RESULTS = /* @__PURE__ */ new Set(["ok", "refused", "failed"]);
+var OUTCOMES = /* @__PURE__ */ new Set(["confirmed", "declined", "failed", "expired"]);
+var RECONNECTABLE = /* @__PURE__ */ new Set(["server_restart"]);
+var NEW_SESSION = /* @__PURE__ */ new Set(["idle", "expired", "limit_reached"]);
+var str = (v) => typeof v === "string" ? v : void 0;
+var ConversationEngine = class {
+  sessionId = null;
+  conversationId = null;
+  connection = null;
+  reconnect = "allowed";
+  messages = [];
+  cards = /* @__PURE__ */ new Map();
+  unacknowledged = /* @__PURE__ */ new Map();
+  resend = [];
+  held = [];
+  refused = {};
+  flow = null;
+  turn = null;
+  tools = [];
+  handoffs = [];
+  errors = [];
+  expiring = null;
+  streaming = null;
+  takeover = null;
+  rejections = {};
+  disclosure = null;
+  turnsLeft = null;
+  /** The next arrival number for a message or a card. */
+  seq = 0;
+  /** The cards drawn before a resumed flow's transcript replaced them: proposal outcomes carry over. */
+  replaced = null;
+  /** client_event_id → the first event the app sent under it, until it is settled. */
+  inputs = /* @__PURE__ */ new Map();
+  // ------------------------------------------------------------ what happens around the frames
+  /** The tenant's backend created a session (and named its conversation). */
+  sessionCreated(sessionId, conversationId) {
+    this.sessionId = sessionId;
+    this.conversationId = conversationId ?? null;
+  }
+  /** A connection opened: the user's own action, or an allowed reconnect, so it lifts a hold on reconnecting. */
+  connected(name) {
+    this.connection = { name, state: "open" };
+    this.reconnect = "allowed";
+  }
+  /** A connection closed with its code. `4403` (revoked) and `4409` (replaced) hold reconnecting for a user action. */
+  closed(name, code) {
+    if (this.connection?.name !== name) return;
+    this.connection.state = "closed";
+    this.connection.code = code;
+    if (this.connection.reason === void 0) {
+      if (code === 4403 || code === 4409) this.reconnect = "user_action_only";
+      else if (code === 4408) this.reconnect = "new_session_on_next_action";
+    }
+    this.cutOff("interrupted");
+    this.turn = null;
+  }
+  /** The app was killed: what it drew is gone; what it sent and never saw acknowledged it kept, to resend. */
+  killed() {
+    this.messages = [];
+    this.cards = /* @__PURE__ */ new Map();
+    this.turn = null;
+    this.streaming = null;
+    this.takeover = null;
+  }
+  // ------------------------------------------------------------ what the app sends
+  sent(event) {
+    const id = str(event.client_event_id);
+    switch (event.type) {
+      case "ui.answer": {
+        if (id === void 0) return;
+        if (!this.inputs.has(id)) this.inputs.set(id, event);
+        this.unqueue(id);
+        this.unacknowledged.set(id, event);
+        const card = this.cards.get(str(event.card_id) ?? "");
+        const questionId = str(event.question_id);
+        if (card && questionId) lock(card, questionId);
+        return;
+      }
+      case "input.text": {
+        if (id === void 0) return;
+        if (!this.inputs.has(id)) this.inputs.set(id, event);
+        this.unqueue(id);
+        delete this.refused[id];
+        this.unacknowledged.set(id, event);
+        return;
+      }
+      case "ui.action": {
+        if (id !== void 0) {
+          if (!this.inputs.has(id)) this.inputs.set(id, event);
+          this.unqueue(id);
+          this.unacknowledged.set(id, event);
+        }
+        const card = this.cards.get(str(event.card_id) ?? "");
+        const action = str(event.action);
+        if (card?.kind === "proposal" && action && OUTCOMES.has(action) && card.outcome === null) {
+          card.outcome = action;
+          if (id !== void 0) card.outcomeBy = id;
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  // ------------------------------------------------------------ what the server sends
+  received(event) {
+    switch (event.type) {
+      case "session.ready":
+        this.ready(event);
+        return;
+      case "turn.started": {
+        this.turn = str(event.turn_id) ?? null;
+        const id = str(event.client_event_id);
+        if (id !== void 0) {
+          const sent = this.inputs.get(id);
+          this.settle(id);
+          if (sent?.type === "input.text") {
+            this.say("person", str(sent.text) ?? "", id);
+          }
+        }
+        return;
+      }
+      case "message.delta": {
+        const turnId = str(event.turn_id) ?? "";
+        const text2 = str(event.text) ?? "";
+        if (this.streaming?.turnId === turnId)
+          this.streaming = {
+            ...this.streaming,
+            text: this.streaming.text + text2
+          };
+        else {
+          this.cutOff("interrupted");
+          this.streaming = { turnId, text: text2, seq: this.seq++ };
+        }
+        return;
+      }
+      case "message.completed": {
+        const turnId = str(event.turn_id) ?? "";
+        const streaming = this.streaming?.turnId === turnId ? this.streaming : null;
+        if (streaming) this.streaming = null;
+        this.say(
+          "assistant",
+          str(event.text) ?? "",
+          `a:${turnId}`,
+          {},
+          streaming?.seq
+        );
+        return;
+      }
+      case "ui.cards":
+        for (const card of asArray(event.cards))
+          this.hold(card, str(event.turn_id));
+        return;
+      case "tool.status": {
+        const line = {
+          turn_id: str(event.turn_id) ?? "",
+          label: str(event.label) ?? "",
+          state: str(event.state) ?? ""
+        };
+        const at = this.tools.findIndex(
+          (t) => t.turn_id === line.turn_id && t.label === line.label
+        );
+        if (at === -1) this.tools = [...this.tools, line].slice(-100);
+        else this.tools[at] = line;
+        return;
+      }
+      case "handoff.created":
+        this.handoffs.push(event.ticket);
+        return;
+      case "turn.completed":
+        this.turn = null;
+        return;
+      case "turn.failed": {
+        const code = str(event.code) ?? "";
+        if (this.streaming?.turnId === str(event.turn_id))
+          this.cutOff(
+            code === "output_blocked" ? "blocked" : code === "cancelled" ? "interrupted" : "failed"
+          );
+        this.turn = null;
+        this.error(code);
+        return;
+      }
+      case "takeover.started":
+        this.takeover = {
+          by: str(event.by) ?? null,
+          at: str(event.at) ?? ""
+        };
+        return;
+      case "takeover.ended":
+        this.takeover = null;
+        return;
+      case "message.staff": {
+        const id = str(event.message_id);
+        if (id !== void 0)
+          this.say("staff", str(event.text) ?? "", `s:${id}`);
+        return;
+      }
+      case "input.received": {
+        const id = str(event.client_event_id);
+        if (id === void 0) return;
+        const sent = this.inputs.get(id);
+        this.settle(id);
+        if (sent?.type === "input.text")
+          this.say("person", str(sent.text) ?? "", id, { received: true });
+        return;
+      }
+      case "ui.answer.recorded":
+        this.recorded(event);
+        return;
+      case "ui.answer.rejected":
+        this.rejected(event);
+        return;
+      case "input.rejected":
+        this.inputRejected(event);
+        return;
+      case "flow.completed": {
+        const result = str(event.result) ?? "";
+        this.flow = {
+          flow: event.flow,
+          result: FLOW_RESULTS.has(result) ? result : "failed"
+        };
+        return;
+      }
+      case "session.closed": {
+        const reason = str(event.reason);
+        if (reason === void 0) return;
+        if (NEW_SESSION.has(reason))
+          this.reconnect = "new_session_on_next_action";
+        else if (!RECONNECTABLE.has(reason))
+          this.reconnect = "user_action_only";
+        if (this.connection) this.connection.reason = reason;
+        return;
+      }
+      case "session.expiring":
+        this.expiring = typeof event.seconds_left === "number" ? event.seconds_left : null;
+        return;
+      case "error": {
+        this.error(str(event.code) ?? "");
+        const id = str(event.client_event_id);
+        if (id !== void 0 && event.code === "screen_unavailable") {
+          this.inputRejected(event);
+        } else if (id !== void 0) {
+          this.settle(id);
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  ready(event) {
+    const session = event.session;
+    this.sessionId = str(session?.id) ?? this.sessionId;
+    this.turn = null;
+    this.expiring = null;
+    this.disclosure = str(event.disclosure) ?? this.disclosure;
+    const limits = event.limits;
+    this.turnsLeft = typeof limits?.turns_left === "number" ? limits.turns_left : null;
+    this.takeover = null;
+    this.cutOff("interrupted");
+    if (event.resumed !== true) return;
+    if (event.transcript !== void 0 && transcriptHasIds(event.transcript)) {
+      this.mergeTranscript(asArray(event.transcript));
+    } else if (event.transcript !== void 0) {
+      this.messages = [];
+      this.replaced = this.cards;
+      this.cards = /* @__PURE__ */ new Map();
+      for (const item of asArray(event.transcript)) {
+        if (item.role === "card")
+          this.hold(item.card);
+        else {
+          const role = str(item.role) ?? "";
+          this.say(
+            role,
+            str(item.text) ?? "",
+            transcriptKey(role, str(item.id), str(item.at)),
+            item.interrupted === true ? { partial: "interrupted" } : {}
+          );
+        }
+      }
+    }
+    for (const card of asArray(event.pending_cards))
+      this.hold(card, str(card.turn_id));
+    this.replaced = null;
+  }
+  /**
+   * A transcript merged by key: an item the app holds keeps its place, with the text the server recorded; one it does
+   * not hold goes just after the nearest earlier item it does (just before the first later one when none came before,
+   * at the end when it holds none of them). Nothing the app holds is dropped.
+   */
+  mergeTranscript(items) {
+    const seqOf = (key) => key === void 0 ? void 0 : (this.messages.find((m) => m.key === key) ?? this.cards.get(key))?.seq;
+    const keys = items.map(
+      (item) => item.role === "card" ? str(item.card?.id) : transcriptKey(str(item.role) ?? "", str(item.id), str(item.at))
+    );
+    let prev;
+    items.forEach((item, i) => {
+      const key = keys[i];
+      if (key === void 0) return;
+      const known = seqOf(key);
+      let at;
+      if (known === void 0) {
+        const near = prev ?? keys.slice(i + 1).map(seqOf).find((q) => q !== void 0);
+        if (near !== void 0) {
+          const seqs = [...this.messages, ...this.cards.values()].map(
+            (h) => h.seq
+          );
+          const bound = prev === void 0 ? Math.max(near - 1, ...seqs.filter((q) => q < near)) : Math.min(...seqs.filter((q) => q > near));
+          if (Number.isFinite(bound)) at = (near + bound) / 2;
+        }
+      }
+      if (item.role === "card") this.hold(item.card, void 0, at);
+      else {
+        const text2 = str(item.text) ?? "";
+        const partial = item.interrupted === true ? "interrupted" : void 0;
+        if (known === void 0)
+          this.say(
+            str(item.role) ?? "",
+            text2,
+            key,
+            partial ? { partial } : {},
+            at
+          );
+        else
+          this.messages = this.messages.map((m) => {
+            if (m.key !== key) return m;
+            const { partial: local, ...rest } = m;
+            const kept = partial ?? (local === "interrupted" ? void 0 : local);
+            return {
+              ...rest,
+              text: text2 || m.text,
+              ...kept ? { partial: kept } : {}
+            };
+          });
+      }
+      prev = seqOf(key);
+    });
+    this.messages.sort((a, b) => a.seq - b.seq);
+  }
+  hold(raw, turnId, at) {
+    if (!raw) return;
+    const id = str(raw.id);
+    if (id === void 0) return;
+    const kind = str(raw.kind) ?? "";
+    const question = raw.question;
+    const card = {
+      id,
+      kind,
+      card: raw,
+      ...question ? { question: structuredCopy(question) } : {},
+      locked: lockedFrom(question),
+      ...turnId !== void 0 ? { turnId } : {},
+      // A card still held keeps its place when it is drawn again (a reconnect's pending cards, a repeated ui.cards).
+      seq: this.cards.get(id)?.seq ?? at ?? this.seq++
+    };
+    for (const held of this.held) {
+      const sent = this.inputs.get(held);
+      if (sent?.type === "ui.answer" && sent.card_id === id) {
+        const questionId = str(sent.question_id);
+        if (questionId !== void 0) lock(card, questionId);
+      }
+    }
+    if (kind === "proposal") {
+      const held = this.cards.get(id) ?? this.replaced?.get(id);
+      card.outcome = held?.outcome ?? null;
+      if (held?.outcomeBy !== void 0) card.outcomeBy = held.outcomeBy;
+    }
+    this.cards.delete(id);
+    this.cards.set(id, card);
+  }
+  recorded(event) {
+    const id = str(event.client_event_id) ?? "";
+    const card = this.cards.get(str(event.card_id) ?? "");
+    const sent = this.inputs.get(id);
+    this.settle(id);
+    if (!card?.question || !sent) return;
+    const q = card.question;
+    const questionId = str(event.question_id) ?? "";
+    lock(card, questionId);
+    if (q.kind === "rate_each") {
+      const rows = (q.row_answers ?? []).filter(
+        (r) => r.question_id !== questionId
+      );
+      q.row_answers = [
+        ...rows,
+        { question_id: questionId, answer: sent.answer }
+      ];
+      const answered = q.row_answers;
+      if ((q.rows ?? []).every(
+        (r) => answered.some((a) => a.question_id === r.question_id)
+      )) {
+        q.state = "answered";
+        lock(card, q.question_id);
+      }
+    } else {
+      q.answer = sent.answer;
+      q.state = "answered";
+    }
+  }
+  rejected(event) {
+    this.settle(str(event.client_event_id) ?? "");
+    const card = this.cards.get(str(event.card_id) ?? "");
+    const questionId = str(event.question_id);
+    if (!card || questionId === void 0) return;
+    if (UNLOCKS_KEEP_LOCKED.has(str(event.code) ?? "")) lock(card, questionId);
+    else unlock(card, questionId);
+  }
+  inputRejected(event) {
+    const id = str(event.client_event_id);
+    if (id === void 0) return;
+    this.unacknowledged.delete(id);
+    const code = str(event.code) ?? "";
+    this.rejections[id] = { code, message: str(event.message) ?? "" };
+    if (RESEND.has(code)) {
+      if (!this.resend.includes(id)) this.resend.push(id);
+      return;
+    }
+    if (code === "limit_reached") {
+      this.unqueue(id);
+      const kind = this.inputs.get(id)?.type;
+      if (kind === "input.text" || kind === "ui.answer") {
+        if (!this.held.includes(id)) this.held.push(id);
+      } else this.inputs.delete(id);
+      this.reconnect = "new_session_on_next_action";
+      return;
+    }
+    if (code !== "duplicate") this.refused[id] = code;
+    const sent = this.inputs.get(id);
+    if (code === "guardrail" && sent?.type === "input.text") {
+      this.say("person", str(sent.text) ?? "", id);
+      this.say("assistant", str(event.message) ?? "", `r:${id}`, {
+        refusal: true
+      });
+    }
+    this.inputs.delete(id);
+  }
+  /** No longer to resend, nor held for the next session (sent again, or settled). */
+  unqueue(id) {
+    this.resend = this.resend.filter((r) => r !== id);
+    this.held = this.held.filter((r) => r !== id);
+  }
+  /** An input acknowledged or refused for good: nothing more is resent under its id. */
+  settle(id) {
+    delete this.rejections[id];
+    this.unacknowledged.delete(id);
+    this.inputs.delete(id);
+    this.unqueue(id);
+  }
+  /** Adds a message once: a key already held (a frame seen twice) changes nothing. */
+  say(role, text2, key, extra = {}, seq) {
+    if (this.messages.some((m) => m.key === key)) return;
+    this.messages.push({ role, text: text2, key, seq: seq ?? this.seq++, ...extra });
+  }
+  /** The turn's streamed text, kept as the agent's message when the turn ends without its `message.completed`. */
+  cutOff(partial) {
+    const streaming = this.streaming;
+    this.streaming = null;
+    const text2 = streaming?.text.trim();
+    if (streaming && text2)
+      this.say(
+        "assistant",
+        text2,
+        `a:${streaming.turnId}`,
+        { partial },
+        streaming.seq
+      );
+  }
+  error(code) {
+    this.errors = [...this.errors, code].slice(-100);
+  }
+  /**
+   * An input that could not be delivered, or whose retries are spent (`screen_unavailable` after the last try): it is
+   * no longer resent. A typed message is shown as not sent, with `code`; an answer's question unlocks so the person
+   * can answer again; a proposal outcome it reported is taken back, so it can be reported again.
+   */
+  giveUp(clientEventId, code) {
+    const sent = this.inputs.get(clientEventId);
+    if (!sent) return;
+    const rejection = this.rejections[clientEventId];
+    this.resend = this.resend.filter((r) => r !== clientEventId);
+    this.settle(clientEventId);
+    const card = this.cards.get(str(sent.card_id) ?? "");
+    if (sent.type === "input.text") {
+      this.refused[clientEventId] = code;
+      if (rejection) this.rejections[clientEventId] = rejection;
+    } else if (sent.type === "ui.answer") {
+      const questionId = str(sent.question_id);
+      if (card && questionId !== void 0) unlock(card, questionId);
+    } else if (card?.outcomeBy === clientEventId) {
+      card.outcome = null;
+      delete card.outcomeBy;
+    }
+  }
+  /** A turn the app stopped where no event will say so (an SSE turn cancelled): none is in progress. */
+  turnEnded() {
+    this.turn = null;
+  }
+  // ------------------------------------------------------------ reading it
+  /** The event first sent under a `client_event_id`, to resend it unchanged. */
+  input(clientEventId) {
+    return this.inputs.get(clientEventId);
+  }
+  state() {
+    const cards = [...this.cards.values()].map(freeze);
+    const open = cards.filter(
+      (c) => c.kind === "question" && c.question?.state === "open"
+    );
+    return {
+      sessionId: this.sessionId,
+      conversationId: this.conversationId,
+      connection: this.connection ? { ...this.connection } : null,
+      reconnect: this.reconnect,
+      messages: [...this.messages],
+      cards,
+      openQuestion: open.length ? open[open.length - 1].id : null,
+      unacknowledged: [...this.unacknowledged.values()],
+      resend: [...this.resend],
+      held: [...this.held],
+      refused: { ...this.refused },
+      flow: this.flow,
+      turn: this.turn,
+      tools: [...this.tools],
+      handoffs: [...this.handoffs],
+      errors: [...this.errors],
+      streaming: this.streaming,
+      takeover: this.takeover,
+      rejections: { ...this.rejections },
+      disclosure: this.disclosure,
+      turnsLeft: this.turnsLeft,
+      heldForNextSession: this.reconnect === "new_session_on_next_action" ? [
+        .../* @__PURE__ */ new Set([
+          ...this.unacknowledged.keys(),
+          ...this.resend,
+          ...this.held
+        ])
+      ] : [],
+      expiring: this.expiring
+    };
+  }
+};
+function transcriptKey(role, id, at) {
+  if (id === void 0) return `t:${at ?? ""}:${role}`;
+  if (role === "assistant") return `a:${id}`;
+  if (role === "staff") return `s:${id}`;
+  return id;
+}
+function transcriptHasIds(transcript) {
+  return asArray(transcript).every(
+    (item) => item.role === "card" ? str(item.card?.id) !== void 0 : str(item.id) !== void 0
+  );
+}
+function lockedFrom(question) {
+  if (!question) return [];
+  if (question.state !== "open") {
+    return [
+      question.question_id,
+      ...(question.rows ?? []).map((r) => r.question_id)
+    ];
+  }
+  return (question.row_answers ?? []).map((r) => r.question_id);
+}
+function lock(card, id) {
+  if (!card.locked.includes(id)) card.locked.push(id);
+}
+function unlock(card, id) {
+  card.locked = card.locked.filter((q) => q !== id);
+}
+function freeze(card) {
+  return {
+    id: card.id,
+    kind: card.kind,
+    card: card.card,
+    ...card.question ? { question: { ...card.question } } : {},
+    locked: [...card.locked],
+    ...card.turnId !== void 0 ? { turnId: card.turnId } : {},
+    ...card.outcome !== void 0 ? { outcome: card.outcome } : {},
+    seq: card.seq
+  };
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function structuredCopy(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/errors.ts
+var VinaverseClientError = class extends Error {
+  name = "VinaverseClientError";
+  code;
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+  }
+};
+
+// src/secret.ts
+var CLIENT_SECRET = /^vv_cs_[A-Za-z0-9_-]{16,}$/;
+function clientSecret(value) {
+  const secret = typeof value === "object" && value !== null ? value.value : value;
+  if (typeof secret === "string" && secret.startsWith("vv_sk_")) {
+    throw new VinaverseClientError(
+      "service_key",
+      "A Vinaverse service key belongs on your backend only. Pass the session client secret (vv_cs_\u2026) to the app."
+    );
+  }
+  if (typeof secret !== "string" || !CLIENT_SECRET.test(secret)) {
+    throw new VinaverseClientError(
+      "invalid_secret",
+      "Expected a session client secret (vv_cs_\u2026)."
+    );
+  }
+  return secret;
+}
+
+// src/sse.ts
+var MAX_EVENT_CHARS = 1024 * 1024;
+function turnSse(target, input) {
+  return post(target, target.turnsUrl, input);
+}
+function cardActionSse(target, turnId, input) {
+  return post(
+    target,
+    `${target.turnsUrl.replace(/\/+$/, "")}/${encodeURIComponent(turnId)}/actions`,
+    input
+  );
+}
+async function* post(target, url, body) {
+  const doFetch = target.fetch ?? globalThis.fetch;
+  const response = await doFetch(url, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${target.secret}`,
+      "content-type": "application/json",
+      accept: "text/event-stream"
+    },
+    body: JSON.stringify(body),
+    ...target.signal ? { signal: target.signal } : {}
+  });
+  if (!response.ok) {
+    throw new VinaverseClientError(
+      "http_error",
+      `The turn request failed with HTTP ${response.status}.`,
+      response.status
+    );
+  }
+  const chunks = response.body ? decode(response.body) : once(await response.text());
+  yield* sseFrames(chunks);
+}
+async function* sseFrames(chunks) {
+  let buffer = "";
+  for await (const chunk of chunks) {
+    buffer += chunk;
+    if (buffer.length > MAX_EVENT_CHARS && boundary(buffer) === null) {
+      throw new VinaverseClientError(
+        "http_error",
+        "An SSE event is larger than 1 MiB."
+      );
+    }
+    let end = boundary(buffer);
+    while (end !== null) {
+      const frame = parseEvent(buffer.slice(0, end.at));
+      buffer = buffer.slice(end.at + end.length);
+      if (frame) yield frame;
+      end = boundary(buffer);
+    }
+  }
+  const last = parseEvent(buffer);
+  if (last) yield last;
+}
+function boundary(buffer) {
+  const match = /\r?\n\r?\n|\r\r/.exec(buffer);
+  return match ? { at: match.index, length: match[0].length } : null;
+}
+function parseEvent(block) {
+  let type;
+  const data = [];
+  for (const line of block.split(/\r?\n|\r/)) {
+    if (line === "" || line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field2 = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field2 === "event") type = value;
+    else if (field2 === "data") data.push(value);
+  }
+  if (data.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(data.join("\n"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  const frame = parsed;
+  const kind = typeof frame.type === "string" ? frame.type : type;
+  return kind === void 0 ? null : { ...frame, type: kind };
+}
+async function* decode(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      yield decoder.decode(value, { stream: true });
+    }
+    const rest = decoder.decode();
+    if (rest) yield rest;
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* once(text2) {
+  yield text2;
+}
+
+// src/session.ts
+var OPEN = 1;
+var SUBPROTOCOL = "vinaverse.v1";
+var DEFAULT_RECONNECT = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+var DEFAULT_SCREEN_RETRY = [2e3, 4e3, 8e3];
+var NO_RECONNECT = /* @__PURE__ */ new Set([4403, 4409]);
+var FALLBACK_AFTER = 2;
+var STABLE_MS = 3e4;
+var VinaverseSession = class {
+  engine;
+  info;
+  secret;
+  options;
+  socket = null;
+  /** The engine's name for the connection in `socket`, once it opened. */
+  opened = null;
+  connection = 0;
+  ready = false;
+  current = "idle";
+  everOpened = false;
+  firstFailures = 0;
+  attempts = 0;
+  /** The reason of the `session.closed` that preceded the close, on the current connection. */
+  closeReason = null;
+  stableTimer;
+  /** SSE requests in flight. */
+  streams = /* @__PURE__ */ new Map();
+  reconnectTimer;
+  pingTimer;
+  foreground = true;
+  refreshed = false;
+  /** client_event_id → why it waits: after the turn, or after a backoff. */
+  waiting = /* @__PURE__ */ new Map();
+  /** client_event_id → the session that refused it for its turn limit: resent only on another session. */
+  heldForSession = /* @__PURE__ */ new Map();
+  screenTries = /* @__PURE__ */ new Map();
+  screenTimers = /* @__PURE__ */ new Map();
+  listeners = {
+    event: /* @__PURE__ */ new Set(),
+    state: /* @__PURE__ */ new Set(),
+    status: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set()
+  };
+  constructor(options) {
+    this.options = options;
+    this.info = options.session;
+    this.secret = clientSecret(options.session.client_secret);
+    this.engine = options.engine ?? new ConversationEngine();
+    this.named(options.session);
+  }
+  /** The engine names the session, and keeps the conversation it already knew when this one does not say. */
+  named(session) {
+    this.engine.sessionCreated(
+      session.id,
+      session.conversation_id ?? this.engine.state().conversationId
+    );
+  }
+  get status() {
+    return this.current;
+  }
+  get state() {
+    return this.engine.state();
+  }
+  on(name, listener) {
+    this.listeners[name].add(listener);
+    return () => this.listeners[name].delete(listener);
+  }
+  // ------------------------------------------------------------ connecting
+  /**
+   * Connect, or reconnect: the user's own action, so it also resumes after the conversation continued elsewhere
+   * or the secret was refused.
+   */
+  connect() {
+    if (this.current === "closed") throw ended();
+    if (this.engine.state().reconnect === "new_session_on_next_action") {
+      throw new VinaverseClientError(
+        "needs_new_session",
+        "This session has ended; create a new session for the conversation and call resume() with it."
+      );
+    }
+    this.start();
+  }
+  start() {
+    this.cancelReconnect();
+    this.attempts = 0;
+    this.refreshed = false;
+    this.open();
+  }
+  /**
+   * Continue the conversation on a new session the tenant's backend created for it (by `conversation_key` or
+   * `conversation_id`): its `session.ready` brings the transcript and pending cards, and what was never
+   * acknowledged is resent there. A user action, like `connect()`.
+   */
+  resume(session) {
+    const secret = clientSecret(session.client_secret);
+    if (this.current === "closed") throw ended();
+    this.info = session;
+    this.secret = secret;
+    this.named(session);
+    this.drop(1e3);
+    this.start();
+  }
+  /** Close for good: the connection, any SSE turn still streaming, and every timer. */
+  close() {
+    this.cancelReconnect();
+    this.drop(1e3);
+    this.stopSse("close");
+    for (const timer of this.screenTimers.values()) clearTimeout(timer);
+    this.screenTimers.clear();
+    this.setStatus("closed");
+  }
+  /** Ping only while the app is in the foreground (every 25 s); in the background the connection may idle out. */
+  setForeground(foreground) {
+    this.foreground = foreground;
+    if (foreground && this.ready) this.startPing();
+    else this.stopPing();
+  }
+  open() {
+    this.drop(1e3);
+    const factory = this.options.webSocket ?? defaultWebSocket();
+    if (!factory) {
+      this.fallBack();
+      return;
+    }
+    const auth = this.options.auth ?? "subprotocol";
+    const protocols = auth === "subprotocol" ? [SUBPROTOCOL, `bearer.${this.secret}`] : [SUBPROTOCOL];
+    const headers = auth === "header" ? { authorization: `Bearer ${this.secret}` } : void 0;
+    const name = `c${++this.connection}`;
+    this.closeReason = null;
+    let socket;
+    try {
+      socket = factory(this.info.realtime_url, protocols, headers);
+    } catch {
+      this.fallBack();
+      return;
+    }
+    this.socket = socket;
+    this.ready = false;
+    this.setStatus(this.attempts > 0 ? "reconnecting" : "connecting");
+    socket.onopen = () => {
+      if (this.socket !== socket) return;
+      this.opened = name;
+      this.everOpened = true;
+      this.engine.connected(name);
+      this.emitState();
+      if (auth === "first_frame")
+        socket.send(
+          JSON.stringify({ type: "session.auth", client_secret: this.secret })
+        );
+    };
+    socket.onmessage = (event) => {
+      if (this.socket === socket) this.frame(event.data);
+    };
+    socket.onerror = () => {
+    };
+    socket.onclose = (event) => {
+      if (this.socket !== socket) return;
+      const opened = this.opened !== null;
+      this.forget(event.code);
+      this.afterClose(event.code, opened);
+    };
+  }
+  afterClose(code, opened) {
+    if (this.current === "closed") return;
+    if (this.engine.state().reconnect !== "allowed" || NO_RECONNECT.has(code)) {
+      this.setStatus("ended");
+      return;
+    }
+    if (code === 4401) {
+      this.refresh();
+      return;
+    }
+    if (!opened && !this.everOpened) {
+      this.firstFailures++;
+      if (this.firstFailures >= FALLBACK_AFTER && this.options.sseFallback !== false) {
+        this.fallBack();
+        return;
+      }
+      this.scheduleReconnect();
+      return;
+    }
+    if (this.closeReason === "server_restart") {
+      this.scheduleReconnect();
+      return;
+    }
+    if (code === 1e3) {
+      this.setStatus("idle");
+      return;
+    }
+    this.scheduleReconnect();
+  }
+  /** After a 4401: one fresh secret for the session in use, unless it moved on or was closed meanwhile. */
+  refresh() {
+    const refreshSecret = this.options.refreshSecret;
+    if (!refreshSecret || this.refreshed) {
+      this.setStatus("unauthorized");
+      return;
+    }
+    this.refreshed = true;
+    const sessionId = this.info.id;
+    const current = () => this.current !== "closed" && this.info.id === sessionId;
+    refreshSecret(sessionId).then((fresh) => {
+      if (!current()) return;
+      this.secret = clientSecret(fresh);
+      this.open();
+    }).catch((error) => {
+      if (!current()) return;
+      this.setStatus("unauthorized");
+      this.emit("error", asClientError(error, "invalid_secret"));
+    });
+  }
+  scheduleReconnect() {
+    const max = this.options.maxReconnects ?? 8;
+    if (this.attempts >= max) {
+      this.setStatus("idle");
+      return;
+    }
+    const delays = this.options.reconnectDelays ?? DEFAULT_RECONNECT;
+    const delay = delays[Math.min(this.attempts, delays.length - 1)] ?? 0;
+    this.attempts++;
+    this.setStatus("reconnecting");
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      this.open();
+    }, delay);
+  }
+  cancelReconnect() {
+    if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = void 0;
+  }
+  fallBack() {
+    this.socket = null;
+    if (this.options.sseFallback === false) {
+      this.setStatus("idle");
+      return;
+    }
+    this.setStatus("sse");
+    for (const event of this.engine.state().unacknowledged) this.overSse(event);
+    if (this.streams.size === 0) this.resendWaiting("turn");
+  }
+  /** Close the current connection, if any, without reacting to its close event. */
+  drop(code) {
+    const socket = this.socket;
+    this.forget(code);
+    if (socket && socket.readyState <= OPEN) {
+      try {
+        socket.close(code);
+      } catch {
+      }
+    }
+  }
+  forget(code) {
+    this.socket = null;
+    this.ready = false;
+    this.stopPing();
+    if (this.stableTimer !== void 0) clearTimeout(this.stableTimer);
+    this.stableTimer = void 0;
+    if (this.opened !== null) {
+      this.engine.closed(this.opened, code);
+      this.opened = null;
+      this.emitState();
+    }
+  }
+  // ------------------------------------------------------------ receiving
+  frame(data) {
+    if (typeof data !== "string") return;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.type !== "string")
+      return;
+    this.receive(parsed);
+  }
+  receive(event) {
+    if (this.current === "closed") return;
+    this.engine.received(event);
+    this.emit("event", event);
+    const id = typeof event.client_event_id === "string" ? event.client_event_id : void 0;
+    switch (event.type) {
+      case "session.ready":
+        this.ready = true;
+        this.refreshed = false;
+        this.firstFailures = 0;
+        this.stableTimer = setTimeout(() => {
+          this.stableTimer = void 0;
+          this.attempts = 0;
+        }, STABLE_MS);
+        this.setStatus("ready");
+        if (this.foreground) this.startPing();
+        this.resendUnacknowledged();
+        this.resendWaiting("turn");
+        this.resendHeldForSession();
+        break;
+      case "turn.completed":
+      case "turn.failed":
+      // A tap or an answer refused with turn_in_progress during a takeover waits for no turn: the hand-back frees it.
+      case "takeover.ended":
+        this.resendWaiting("turn");
+        break;
+      case "turn.started":
+      case "ui.answer.recorded":
+      case "ui.answer.rejected":
+        if (id !== void 0) this.screenTries.delete(id);
+        break;
+      case "input.rejected":
+      case "error":
+        this.refusedForNow(event);
+        break;
+      case "session.closed":
+        this.closeReason = typeof event.reason === "string" ? event.reason : "";
+        if (this.engine.state().reconnect !== "allowed")
+          this.setStatus("ended");
+        break;
+    }
+    this.emitState();
+  }
+  refusedForNow(event) {
+    const id = typeof event.client_event_id === "string" ? event.client_event_id : void 0;
+    if (id === void 0) return;
+    if (event.code === "limit_reached") {
+      this.heldForSession.set(id, this.info.id);
+      this.setStatus("ended");
+      return;
+    }
+    if (!this.engine.state().resend.includes(id)) return;
+    if (event.code === "turn_in_progress") {
+      this.waiting.set(id, "turn");
+      return;
+    }
+    const tries = this.screenTries.get(id) ?? 0;
+    const delays = this.options.screenRetryDelays ?? DEFAULT_SCREEN_RETRY;
+    if (tries >= delays.length) {
+      this.screenTries.delete(id);
+      this.waiting.delete(id);
+      this.engine.giveUp(id, "screen_unavailable");
+      return;
+    }
+    this.screenTries.set(id, tries + 1);
+    this.waiting.set(id, "screen");
+    this.screenTimers.set(
+      id,
+      setTimeout(() => {
+        this.screenTimers.delete(id);
+        if (this.waiting.get(id) === "screen") this.resend(id);
+      }, delays[tries])
+    );
+  }
+  resendUnacknowledged() {
+    for (const event of this.engine.state().unacknowledged)
+      this.transmit(event);
+  }
+  /** What a turn limit held, on a session other than the one that refused it. */
+  resendHeldForSession() {
+    for (const [id, refusedIn] of [...this.heldForSession]) {
+      if (refusedIn === this.info.id) continue;
+      this.heldForSession.delete(id);
+      this.resend(id);
+    }
+  }
+  resendWaiting(reason) {
+    for (const [id, why] of [...this.waiting])
+      if (why === reason) this.resend(id);
+  }
+  resend(id) {
+    this.waiting.delete(id);
+    const event = this.engine.input(id);
+    if (!event) return;
+    if (this.live() || this.awaitingNewSession()) this.deliver(event);
+    else this.hold(event);
+  }
+  /** Keep an input for a later session: unacknowledged, so the next `session.ready` (after resume()) sends it. */
+  hold(event) {
+    if (this.current === "closed") return;
+    this.engine.sent(event);
+    this.emitState();
+  }
+  /** The session ended: retries waiting on a timer would go nowhere, so their inputs are held for the next session. */
+  holdRetries() {
+    for (const [id, timer] of [...this.screenTimers]) {
+      clearTimeout(timer);
+      this.screenTimers.delete(id);
+      this.waiting.delete(id);
+      const event = this.engine.input(id);
+      if (event) this.hold(event);
+    }
+  }
+  // ------------------------------------------------------------ sending
+  /** Send a typed message; returns its `client_event_id`. Over SSE it runs the turn there. */
+  sendText(text2) {
+    const id = this.newId();
+    this.deliver({ type: "input.text", text: text2, client_event_id: id });
+    return id;
+  }
+  /** Answer a question card (or a `rate_each` row, by the row's `question_id`); returns the `client_event_id`. */
+  answer(cardId, questionId, answer) {
+    if (this.current === "sse") {
+      throw new VinaverseClientError(
+        "needs_websocket",
+        "Question cards are answered over the WebSocket."
+      );
+    }
+    const id = this.newId();
+    this.deliver({
+      type: "ui.answer",
+      client_event_id: id,
+      card_id: cardId,
+      question_id: questionId,
+      answer
+    });
+    return id;
+  }
+  /**
+   * Report a proposal's outcome after the tenant's backend answered (§6): `confirmed`, `declined`, `failed` or
+   * `expired`. The first outcome per card is final. Returns the `client_event_id`.
+   */
+  reportOutcome(cardId, outcome) {
+    return this.action(cardId, outcome);
+  }
+  /** A card action (`ui.action`), named by the card's `id`; the card's turn is taken from the state. */
+  action(cardId, action) {
+    const turnId = this.engine.state().cards.find((c) => c.id === cardId)?.turnId;
+    if (turnId === void 0)
+      throw new RangeError(`No turn is known for card ${cardId}.`);
+    const id = this.newId();
+    this.deliver({
+      type: "ui.action",
+      client_event_id: id,
+      turn_id: turnId,
+      card_id: cardId,
+      action
+    });
+    return id;
+  }
+  /** Stop the turn in progress: `input.cancel` on the WebSocket; over SSE, the turn's request is stopped. */
+  cancel(turnId) {
+    if (this.current === "sse") {
+      this.stopSse("cancel");
+      this.engine.turnEnded();
+      this.emitState();
+      return;
+    }
+    this.transmit({ type: "input.cancel", turn_id: turnId });
+  }
+  /** Ended idle: inputs are held for the new session that `resume()` brings. */
+  awaitingNewSession() {
+    return this.current === "ended" && this.engine.state().reconnect === "new_session_on_next_action";
+  }
+  live() {
+    return this.current !== "closed" && this.current !== "ended" && this.current !== "unauthorized";
+  }
+  /**
+   * Every input goes through here: recorded as sent (unacknowledged until the server answers it), then over SSE,
+   * or on the WebSocket when the session is ready, or held and resent once `session.ready` arrives.
+   */
+  deliver(event) {
+    if (!this.live() && !this.awaitingNewSession()) throw ended();
+    this.engine.sent(event);
+    this.emitState();
+    if (this.current === "sse") this.overSse(event);
+    else if (this.ready) this.transmit(event);
+    else if (this.current === "idle") this.connect();
+  }
+  transmit(event) {
+    const socket = this.socket;
+    if (!socket || socket.readyState !== OPEN) return;
+    socket.send(JSON.stringify(event));
+  }
+  /** One input over SSE: a typed message or a card action; an answer cannot go, and is shown as not sent. */
+  overSse(event) {
+    const id = typeof event.client_event_id === "string" ? event.client_event_id : void 0;
+    const notSent = (error) => {
+      if (id !== void 0) this.engine.giveUp(id, error.code);
+      this.emitState();
+      this.emit("error", error);
+    };
+    if (id !== void 0 && this.inFlight(id)) return;
+    const controller = new AbortController();
+    const target = { ...this.sseTarget(), signal: controller.signal };
+    let frames;
+    if (event.type === "input.text") {
+      frames = turnSse(target, {
+        text: String(event.text),
+        ...id !== void 0 ? { client_event_id: id } : {}
+      });
+    } else if (event.type === "ui.action") {
+      frames = cardActionSse(target, String(event.turn_id), {
+        card_id: String(event.card_id),
+        action: String(event.action),
+        ...id !== void 0 ? { client_event_id: id } : {}
+      });
+    } else {
+      notSent(
+        new VinaverseClientError(
+          "needs_websocket",
+          "Question cards are answered over the WebSocket."
+        )
+      );
+      return;
+    }
+    const stream = { id };
+    this.streams.set(controller, stream);
+    void (async () => {
+      try {
+        for await (const frame of frames) {
+          if (controller.signal.aborted) break;
+          this.receive(frame);
+        }
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          notSent(asClientError(error, "http_error"));
+          return;
+        }
+      } finally {
+        this.streams.delete(controller);
+      }
+      if (controller.signal.aborted) {
+        if (stream.stop === "cancel" && id !== void 0) {
+          this.engine.giveUp(id, "cancelled");
+          this.emitState();
+        }
+        return;
+      }
+      if (id !== void 0 && this.isUnacknowledged(id)) {
+        notSent(
+          new VinaverseClientError(
+            "http_error",
+            "The turn ended without taking the input."
+          )
+        );
+      }
+    })();
+  }
+  isUnacknowledged(id) {
+    return this.engine.state().unacknowledged.some((e) => e.client_event_id === id);
+  }
+  inFlight(id) {
+    for (const stream of this.streams.values())
+      if (stream.id === id) return true;
+    return false;
+  }
+  stopSse(why) {
+    for (const [controller, stream] of [...this.streams]) {
+      stream.stop = why;
+      controller.abort();
+    }
+  }
+  sseTarget() {
+    return {
+      turnsUrl: this.info.turns_url,
+      secret: this.secret,
+      ...this.options.fetch ? { fetch: this.options.fetch } : {}
+    };
+  }
+  newId() {
+    return (this.options.createId ?? randomId)();
+  }
+  // ------------------------------------------------------------ pings and listeners
+  startPing() {
+    this.stopPing();
+    this.pingTimer = setInterval(
+      () => this.transmit({ type: "ping" }),
+      this.options.pingInterval ?? 25e3
+    );
+  }
+  stopPing() {
+    if (this.pingTimer !== void 0) clearInterval(this.pingTimer);
+    this.pingTimer = void 0;
+  }
+  setStatus(status) {
+    if (this.current === status) return;
+    this.current = status;
+    if (status === "ended") this.holdRetries();
+    this.emit("status", status);
+  }
+  emitState() {
+    if (this.listeners.state.size) this.emit("state", this.engine.state());
+  }
+  emit(name, value) {
+    for (const listener of this.listeners[name]) listener(value);
+  }
+};
+function ended() {
+  return new VinaverseClientError(
+    "session_ended",
+    "The session has ended; resume it on a new session."
+  );
+}
+function asClientError(error, code) {
+  if (error instanceof VinaverseClientError) return error;
+  return new VinaverseClientError(
+    code,
+    error instanceof Error ? error.message : String(error)
+  );
+}
+function defaultWebSocket() {
+  const Ctor = globalThis.WebSocket;
+  if (!Ctor) return null;
+  const scope = globalThis;
+  const node = typeof scope.process?.versions?.node === "string" && scope.document === void 0;
+  return (url, protocols, headers) => {
+    if (!headers) return new Ctor(url, protocols);
+    return node ? new Ctor(url, { protocols, headers }) : new Ctor(url, protocols, { headers });
+  };
+}
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function randomId() {
+  const bytes = new Uint8Array(22);
+  const crypto = globalThis.crypto;
+  if (crypto?.getRandomValues) crypto.getRandomValues(bytes);
+  else
+    for (let i = 0; i < bytes.length; i++)
+      bytes[i] = Math.floor(Math.random() * 256);
+  let id = "ce_";
+  for (const byte of bytes) id += ALPHABET[byte % ALPHABET.length];
+  return id;
+}
+
+// src/conversation/links.ts
+var PREFIX = /^[a-z][a-z0-9+.-]*:(\/\/\.*[A-Za-z0-9_~-][A-Za-z0-9._~-]*(:(6553[0-5]|655[0-2][0-9]|65[0-4][0-9]{2}|6[0-4][0-9]{3}|[1-5][0-9]{4}|[1-9][0-9]{0,3}))?\/|\.*[A-Za-z0-9_~-][A-Za-z0-9._~-]*\/)(\.*[A-Za-z0-9_~-][A-Za-z0-9._~-]*\/)*$/;
+var PREFIX_HTTPS = /^https?:\/\/[a-z0-9-]+(\.[a-z0-9-]+)*(:(6553[0-5]|655[0-2][0-9]|65[0-4][0-9]{2}|6[0-4][0-9]{3}|[1-5][0-9]{4}|[1-9][0-9]{0,3}))?\/\.*[A-Za-z0-9_~-][A-Za-z0-9._~-]*\//;
+var REFUSED_SCHEMES = /^(javascript|vbscript|data|blob|file|filesystem|about|view-source|intent|android-app|content|jar|mhtml|itms-services|ftp|ws|wss):/;
+var CONTROLS = /[\x00-\x1f\x7f]/;
+var REMAINDER = /^(\.*[A-Za-z0-9_~-][A-Za-z0-9._~-]*(\/\.*[A-Za-z0-9_~-][A-Za-z0-9._~-]*)*\/?)?(\?([A-Za-z0-9._~=&-]|%(2[0-46-9A-Ea-e]|3[0-9B-Fb-f]|[46][0-9A-Fa-f]|5[0-9ABD-Fabd-f]|7[0-9A-Ea-e]))*)?$/;
+function isValidLinkPrefix(prefix) {
+  if (CONTROLS.test(prefix) || REFUSED_SCHEMES.test(prefix)) return false;
+  if (/^https?:/.test(prefix) && !PREFIX_HTTPS.test(prefix)) return false;
+  return PREFIX.test(prefix);
+}
+function isAllowedLink(link, prefixes) {
+  return prefixes.some(
+    (prefix) => isValidLinkPrefix(prefix) && link.startsWith(prefix) && REMAINDER.test(link.slice(prefix.length))
+  );
+}
+
+// src/conversation/timeline.ts
+function lastOrder(state) {
+  let last = -1;
+  for (const m of state.messages) last = Math.max(last, m.seq);
+  for (const c of state.cards) last = Math.max(last, c.seq);
+  if (state.streaming) last = Math.max(last, state.streaming.seq);
+  return last;
+}
+function pendingState(id, input) {
+  const { state } = input;
+  if (input.retried.has(id)) return null;
+  if (input.early.has(id)) return "sending";
+  if (state.messages.some((m) => m.key === id)) return null;
+  const refused = state.refused[id];
+  if (refused !== void 0) return refused === "guardrail" ? null : "not_sent";
+  if (state.heldForNextSession.includes(id)) return "held";
+  if (state.resend.includes(id) || state.held.includes(id) || state.unacknowledged.some((f) => f.client_event_id === id))
+    return "sending";
+  return null;
+}
+function buildTimeline(input, previous) {
+  const before = new Map(previous.map((item) => [item.key, item]));
+  const live = [];
+  const { state } = input;
+  for (const m of state.messages)
+    live.push({ item: messageItem(m), order: m.seq });
+  if (state.streaming) {
+    live.push({
+      item: {
+        type: "message",
+        key: `a:${state.streaming.turnId}`,
+        role: "agent",
+        text: "",
+        state: "streaming"
+      },
+      order: state.streaming.seq
+    });
+  }
+  for (const card of state.cards) {
+    if (!isKnownCard(card.card)) continue;
+    live.push({
+      item: {
+        type: "card",
+        key: card.id,
+        card,
+        busy: !input.inert?.has(card.id) && input.busy.has(card.id),
+        ...input.inert?.has(card.id) ? { restored: true } : {},
+        ...input.decisionErrors?.has(card.id) ? { decisionError: true } : {}
+      },
+      order: input.cardOrder?.get(card.id) ?? card.seq
+    });
+  }
+  for (const { item, order } of input.system) live.push({ item, order });
+  const held = new Set(state.cards.map((c) => c.id));
+  for (const { item, order } of input.kept ?? [])
+    if (!held.has(item.key)) live.push({ item, order });
+  for (const [id, sent] of input.sent) {
+    const pending = pendingState(id, input);
+    if (pending === null) continue;
+    const rejection = state.rejections[id];
+    live.push({
+      item: {
+        type: "message",
+        key: id,
+        role: "person",
+        text: sent.text,
+        state: pending,
+        ...pending === "not_sent" ? {
+          rejection: rejection ?? {
+            code: state.refused[id] ?? "",
+            message: ""
+          }
+        } : {}
+      },
+      order: sent.order
+    });
+  }
+  live.sort((a, b) => a.order - b.order);
+  const items = mergeByKey(
+    input.transcriptSeen === true ? [] : input.history,
+    live.map((l) => l.item)
+  );
+  let same = items.length === previous.length;
+  const shared = items.map((item, i) => {
+    const prev = before.get(item.key);
+    const kept = prev !== void 0 && equal(prev, item) ? prev : item;
+    if (kept !== previous[i]) same = false;
+    return kept;
+  });
+  return same ? previous : shared;
+}
+function mergeByKey(history, live) {
+  if (!history.length) return [...live];
+  const items = [...history];
+  const at = (key) => items.findIndex((item) => item.key === key);
+  let last = -1;
+  live.forEach((item, i) => {
+    const found = at(item.key);
+    if (found >= 0) {
+      items[found] = item;
+      last = found;
+      return;
+    }
+    const next = live.slice(i + 1).map((l) => at(l.key)).find((p) => p >= 0);
+    last = next === void 0 ? items.length : last >= 0 ? last + 1 : next;
+    items.splice(last, 0, item);
+  });
+  return items;
+}
+function messageItem(m) {
+  const role = m.role === "assistant" ? "agent" : m.role;
+  return {
+    type: "message",
+    key: m.key,
+    role,
+    text: m.text,
+    state: m.received ? "delivered" : "sent",
+    ...m.partial ? { partial: m.partial } : {},
+    ...m.refusal ? { refusal: true } : {}
+  };
+}
+function equal(a, b) {
+  if (a.type !== b.type || a.key !== b.key) return false;
+  if (a.type === "message" && b.type === "message")
+    return a.role === b.role && a.text === b.text && a.state === b.state && a.partial === b.partial && a.refusal === b.refusal && a.rejection?.code === b.rejection?.code && a.rejection?.message === b.rejection?.message;
+  if (a.type === "card" && b.type === "card")
+    return a.busy === b.busy && a.restored === b.restored && a.decisionError === b.decisionError && sameCard(a.card, b.card);
+  return a === b;
+}
+function sameCard(a, b) {
+  return a.card === b.card && a.seq === b.seq && a.turnId === b.turnId && a.outcome === b.outcome && a.locked.length === b.locked.length && a.locked.every((q, i) => q === b.locked[i]) && a.question?.state === b.question?.state && JSON.stringify(a.question?.answer) === JSON.stringify(b.question?.answer) && JSON.stringify(a.question?.row_answers) === JSON.stringify(b.question?.row_answers);
+}
+function persistable(item) {
+  if (item.type === "message")
+    return item.state === "sent" || item.state === "delivered";
+  return item.type === "card";
+}
+
+// src/conversation/store.ts
+var MAX_TEXT = 2e3;
+var TURN_INPUTS = 50;
+var PERSIST_DELAY = 500;
+var PERSIST_VERSION = 1;
+var NO_ITEMS = [];
+var OUTCOMES2 = /* @__PURE__ */ new Set([
+  "confirmed",
+  "declined",
+  "failed",
+  "expired"
+]);
+var ConversationStore = class {
+  options;
+  engine = new ConversationEngine();
+  session = null;
+  info = null;
+  getting = null;
+  failed = false;
+  disposed = false;
+  online = null;
+  foreground = true;
+  lastStatus = "idle";
+  offlineAfterRetries = false;
+  /** The id the next send gets, so a text typed before the session keeps its key. */
+  nextId = null;
+  sent = /* @__PURE__ */ new Map();
+  early = /* @__PURE__ */ new Map();
+  retried = /* @__PURE__ */ new Set();
+  busy = /* @__PURE__ */ new Set();
+  /** Proposals whose tenant decision threw: shown as recoverable, the person may decide again. */
+  decisionErrors = /* @__PURE__ */ new Set();
+  system = [];
+  /** The person's text that started each recent turn, by `turn_id` (`turn.started` echoes its `client_event_id`). */
+  turnInputs = /* @__PURE__ */ new Map();
+  /** Numbers system rows that carry no id of their own. */
+  systemSeq = 0;
+  history = NO_ITEMS;
+  historyState = "none";
+  /** A resumed session.ready carried a transcript: the server's history replaced what the device kept. */
+  transcriptSeen = false;
+  /** The session of the last session.ready: a card of another one takes no tap (§6). */
+  readySession = null;
+  cardOrder = /* @__PURE__ */ new Map();
+  kept = [];
+  /** Cards an earlier session drew, kept by a merged transcript: drawn as restored, taking no tap. */
+  inert = /* @__PURE__ */ new Set();
+  locale;
+  /** The request for a session in flight, to abort when it is no longer wanted. */
+  fetching = null;
+  view;
+  listeners = /* @__PURE__ */ new Set();
+  streaming = null;
+  streamListeners = /* @__PURE__ */ new Set();
+  /** The frame that will notify, and what it will notify about. */
+  frame = void 0;
+  framePending = false;
+  viewDirty = false;
+  streamDirty = false;
+  persistTimer;
+  unsubscribe = [];
+  constructor(options) {
+    this.options = options;
+    this.locale = options.locale;
+    this.view = this.compute(null);
+    this.restore();
+  }
+  // ------------------------------------------------------------ reading
+  getSnapshot = () => this.view;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getStreaming = () => this.streaming;
+  subscribeStreaming = (listener) => {
+    this.streamListeners.add(listener);
+    return () => this.streamListeners.delete(listener);
+  };
+  /** Whether a card's link may be opened (the deep-link rule, against `deepLinkPrefixes`). */
+  checkLink(link) {
+    return isAllowedLink(link, this.options.deepLinkPrefixes ?? []);
+  }
+  // ------------------------------------------------------------ the conversation's life
+  /** Ask for a session and connect, early: a client secret must open its first connection within two minutes. */
+  start() {
+    this.live();
+    if (this.session) {
+      if (this.session.status === "idle") this.session.connect();
+      else if (this.session.status === "unauthorized")
+        void this.resumeWith("resume");
+      return;
+    }
+    void this.ensureSession("open");
+  }
+  /** Close for good. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.fetching?.abort();
+    this.fetching = null;
+    this.session?.close();
+    for (const off of this.unsubscribe) off();
+    this.unsubscribe = [];
+    clearTimeout(this.persistTimer);
+    this.update();
+    this.flush();
+  }
+  /** Close for good and forget the conversation kept on the device (sign-out). Never throws for the storage. */
+  clear() {
+    this.dispose();
+    this.history = NO_ITEMS;
+    try {
+      const removed = this.options.persistence?.removeItem(this.key());
+      if (removed) removed.catch(() => void 0);
+    } catch {
+    }
+    this.update();
+    this.flush();
+  }
+  /**
+   * The person switched the app's language: the UI's words change at once (the kit's own locale); the next session
+   * asks for this locale (`subject.locale`). The open session keeps its language: the agent answers in the new one
+   * from the next session, and the store never starts a session for it.
+   */
+  setLocale(locale) {
+    this.locale = locale;
+  }
+  /** The app came to the foreground or went to the background (AppState, `visibilitychange`). */
+  setForeground(foreground) {
+    this.foreground = foreground;
+    if (this.options.closeInBackground && !this.disposed) {
+      if (!foreground) {
+        this.suspend();
+        return;
+      }
+      if (this.suspended) {
+        void this.wake();
+        return;
+      }
+    }
+    this.session?.setForeground(foreground);
+    if (foreground) this.reconnectIfDown();
+  }
+  /** In the background (`closeInBackground`): the connection is closed; the engine keeps what was sent, to resend. */
+  suspended = false;
+  suspend() {
+    const session = this.session;
+    if (!session || this.suspended || session.status === "ended") return;
+    this.suspended = true;
+    for (const off of this.unsubscribe) off();
+    this.unsubscribe = [];
+    session.close();
+    this.update();
+  }
+  /**
+   * Back in the foreground, or the person acted while away: a new connection to the same session, with a fresh secret
+   * when the backend gives one. A session that passed its end meanwhile is never reopened (a fresh secret cannot bring
+   * back an expired tool token): the person's action continues the conversation in a new session from `getSession`,
+   * and until then nothing connects.
+   */
+  async wake(byPerson = false) {
+    const info = this.info;
+    if (info && this.sessionOver()) {
+      if (byPerson) await this.resumeWith("resume");
+      else this.update();
+      return;
+    }
+    this.suspended = false;
+    if (!info) return;
+    let next = info;
+    if (this.options.refreshSecret) {
+      try {
+        next = {
+          ...info,
+          client_secret: await this.options.refreshSecret(info.id)
+        };
+      } catch (error) {
+        this.options.onError?.(error);
+      }
+    }
+    if (this.disposed || this.suspended) return;
+    this.open(next);
+  }
+  /** The network as the app sees it; null when unknown. Back online reconnects a connection that gave up. */
+  setOnline(online) {
+    this.online = online;
+    if (online) this.reconnectIfDown();
+    this.update();
+  }
+  // ------------------------------------------------------------ the person's actions
+  /** Send a typed message; returns its `client_event_id`. Typed before a session exists, it is sent once one does. */
+  send(text2) {
+    this.live();
+    if (!text2.trim()) throw new RangeError("A message needs some text.");
+    if ([...text2].length > MAX_TEXT)
+      throw new RangeError(`A message is at most ${MAX_TEXT} characters.`);
+    const id = (this.options.createId ?? randomId)();
+    this.sent.set(id, { text: text2, order: lastOrder(this.engine.state()) + 0.5 });
+    this.tellActivity({ type: "message_sent", id });
+    if (!this.session) {
+      this.early.set(id, text2);
+      void this.ensureSession("open");
+      this.update();
+      return id;
+    }
+    if (this.suspended) {
+      this.early.set(id, text2);
+      void this.wake(true);
+      this.update();
+      return id;
+    }
+    if (this.nextFrom(this.engine.state()) === "continue_here") {
+      this.early.set(id, text2);
+      void this.resumeWith("continue_here");
+      this.update();
+      return id;
+    }
+    if (this.sessionOver()) {
+      this.early.set(id, text2);
+      void this.resumeWith("resume");
+      this.update();
+      return id;
+    }
+    this.nextId = id;
+    this.session.sendText(text2);
+    this.nextId = null;
+    this.continueIfEnded();
+    return id;
+  }
+  /** Answer a question card (a `rate_each` row by its `question_id`); returns the `client_event_id`. */
+  answer(cardId, questionId, answer) {
+    const session = this.required();
+    const id = session.answer(cardId, questionId, answer);
+    this.continueIfEnded();
+    return id;
+  }
+  /** A card action (`ui.action`) other than a proposal's outcome. */
+  cardAction(cardId, action) {
+    return this.required().action(cardId, action);
+  }
+  /**
+   * Decide a proposal: `decide` is the tenant's own call (its backend, the person's token), which confirms or
+   * declines it and says the outcome; the store then reports it. One decision per card; the card is busy meanwhile.
+   * Resolves to the outcome reported, or null when the card was busy or already decided.
+   *
+   * Only an outcome `decide` resolves with is reported (§6: the first is final). When `decide` throws, or resolves
+   * with anything but `confirmed`, `declined`, `failed` or `expired`, nothing is reported: the backend may have
+   * applied the change, so the outcome stays unknown; the card shows `decisionError` and the person may decide
+   * again. When the conversation is disposed meanwhile (sign-out), the outcome is not reported either: the tenant's
+   * backend holds it, and the session takes it as unknown.
+   */
+  async decideProposal(cardId, decide) {
+    this.live();
+    const card = this.engine.state().cards.find((c) => c.id === cardId);
+    if (card?.kind !== "proposal") return null;
+    if (this.busy.has(cardId) || (card.outcome ?? null) !== null) return null;
+    this.busy.add(cardId);
+    this.decisionErrors.delete(cardId);
+    this.update();
+    try {
+      const outcome = await decide();
+      if (typeof outcome !== "string" || !OUTCOMES2.has(outcome))
+        throw new TypeError(
+          `decide() resolved with ${JSON.stringify(outcome)}, not confirmed, declined, failed or expired`
+        );
+      if (this.disposed) return outcome;
+      if (this.view.next === "continue") await this.resumeWith("resume");
+      this.required().reportOutcome(cardId, outcome);
+      return outcome;
+    } catch (error) {
+      this.decisionErrors.add(cardId);
+      throw error;
+    } finally {
+      this.busy.delete(cardId);
+      this.update();
+    }
+  }
+  /** Send a "not sent" message again, as a new message (the person's action). Returns the new id. */
+  retry(key) {
+    const sent = this.sent.get(key);
+    if (!sent || this.engine.state().refused[key] === void 0) return null;
+    this.retried.add(key);
+    this.sent.delete(key);
+    return this.send(sent.text);
+  }
+  /**
+   * Send again the person's text whose turn failed before any reply (a `turn_failed` row with `data.retry`), as a new
+   * message (the person's action). Once per row: its `retry` turns false. Returns the new id, or null when the row
+   * allows no retry.
+   */
+  retryTurn(key) {
+    const at = this.system.findIndex(
+      (s) => s.item.key === key && s.item.event === "turn_failed"
+    );
+    const entry = this.system[at];
+    if (entry?.item.data.retry !== true) return null;
+    const text2 = this.turnText(String(entry.item.data.turn ?? ""));
+    if (text2 === void 0) return null;
+    this.system = this.system.map(
+      (s, i) => i === at ? { ...s, item: { ...s.item, data: { ...s.item.data, retry: false } } } : s
+    );
+    return this.send(text2);
+  }
+  /** After the conversation continued on another device: continue it here (the person's choice). */
+  continueHere() {
+    return this.resumeWith("continue_here");
+  }
+  /** Stop the turn in progress. */
+  cancel() {
+    const turn = this.engine.state().turn;
+    if (this.session && turn) this.session.cancel(turn);
+  }
+  // ------------------------------------------------------------ sessions
+  async ensureSession(reason) {
+    if (this.session) return this.session;
+    if (this.getting) return this.getting;
+    this.getting = this.fetchSession(reason).then((info) => {
+      this.getting = null;
+      if (!info || this.disposed) return null;
+      this.open(info);
+      return this.session;
+    });
+    this.update();
+    return this.getting;
+  }
+  async fetchSession(reason) {
+    this.failed = false;
+    this.fetching?.abort();
+    const Controller = globalThis.AbortController;
+    const controller = Controller ? new Controller() : null;
+    const mine = { abort: () => controller?.abort() };
+    this.fetching = mine;
+    let aborted = false;
+    const signal = controller?.signal;
+    signal?.addEventListener("abort", () => {
+      aborted = true;
+    });
+    try {
+      const info = await this.options.getSession({
+        reason,
+        conversationId: this.engine.state().conversationId,
+        ...this.locale !== void 0 ? { locale: this.locale } : {},
+        ...this.options.timeZone !== void 0 ? { timeZone: this.options.timeZone } : {},
+        ...signal ? { signal } : {}
+      });
+      return aborted || this.fetching !== mine ? null : info;
+    } catch (error) {
+      if (aborted || this.fetching !== mine) return null;
+      this.failed = true;
+      this.getting = null;
+      this.options.onError?.(error);
+      this.update();
+      return null;
+    } finally {
+      if (this.fetching === mine) this.fetching = null;
+    }
+  }
+  open(info) {
+    this.info = info;
+    this.suspended = false;
+    const refreshSecret = this.options.refreshSecret;
+    const session = new VinaverseSession({
+      ...this.options.transport,
+      session: info,
+      engine: this.engine,
+      ...refreshSecret ? {
+        // Past the session's end a fresh secret cannot help: refused here, and the store rolls over instead.
+        refreshSecret: (id) => this.sessionOver() ? Promise.reject(
+          new VinaverseClientError(
+            "needs_new_session",
+            "This session has ended."
+          )
+        ) : refreshSecret(id)
+      } : {},
+      createId: () => this.nextId ?? (this.options.createId ?? randomId)()
+    });
+    this.session = session;
+    this.unsubscribe.push(
+      session.on("state", () => this.update()),
+      session.on("status", (status) => this.statusChanged(status)),
+      session.on("event", (event) => this.event(event)),
+      session.on("error", (error) => {
+        if (!this.sessionOver()) this.options.onError?.(error);
+      })
+    );
+    session.setForeground(this.foreground);
+    session.connect();
+    this.flushEarly();
+  }
+  /** What was typed before there was a session to take it. */
+  flushEarly() {
+    const session = this.session;
+    if (!session) return;
+    for (const [id, text2] of this.early) {
+      this.nextId = id;
+      session.sendText(text2);
+    }
+    this.nextId = null;
+    this.early.clear();
+    this.update();
+  }
+  /** A new session for the conversation, then `resume()`: once per person action, never in a loop. */
+  resuming = null;
+  resumeWith(reason) {
+    this.live();
+    if (this.resuming) return this.resuming;
+    if (!this.session) return this.ensureSession(reason).then(() => void 0);
+    this.resuming = this.fetchSession(reason).then((info) => {
+      this.resuming = null;
+      if (!info || this.disposed || !this.session) return;
+      if (this.session.status === "closed") {
+        this.open(info);
+        return;
+      }
+      this.info = info;
+      this.session.resume(info);
+      this.flushEarly();
+    });
+    return this.resuming;
+  }
+  /** The person acted after the session ended idle, expired or at its limit: the next session takes what they sent. */
+  continueIfEnded() {
+    if (this.nextFrom(this.engine.state()) === "continue")
+      void this.resumeWith("resume");
+    this.update();
+  }
+  reconnectIfDown() {
+    const session = this.session;
+    if (session && session.status === "idle" && !this.sessionOver() && // past its end: the person's next action gets a new session
+    this.nextFrom(this.engine.state()) === null)
+      session.connect();
+  }
+  /** A refusal already led to a new session, and none has been ready since: another refusal is no cue. */
+  rolled = false;
+  statusChanged(status) {
+    if (status === "ready") this.rolled = false;
+    if (status === "unauthorized" && !this.rolled) {
+      this.rolled = true;
+      void this.resumeWith("resume");
+    }
+    if (status === "idle")
+      this.offlineAfterRetries = this.lastStatus === "reconnecting";
+    else if (status !== "reconnecting") this.offlineAfterRetries = false;
+    this.lastStatus = status;
+    this.update();
+  }
+  /** The app's analytics hears of a step; what it throws is reported (`onError`), never in the way of a send or a frame. */
+  tellActivity(activity) {
+    try {
+      this.options.onActivity?.(activity);
+    } catch (error) {
+      this.options.onError?.(error);
+    }
+  }
+  /** The live frames analytics hears of: a reply finished, cards drawn. */
+  activity(frame) {
+    if (!this.options.onActivity) return;
+    const on = (a) => this.tellActivity(a);
+    if (frame.type === "message.completed" && typeof frame.turn_id === "string")
+      on({ type: "reply_completed", turnId: frame.turn_id });
+    if (frame.type === "ui.cards" && Array.isArray(frame.cards)) {
+      for (const card of frame.cards)
+        if (typeof card.id === "string" && typeof card.kind === "string")
+          on({ type: "card_shown", cardId: card.id, kind: card.kind });
+    }
+  }
+  event(event) {
+    const frame = event;
+    const str2 = (v) => typeof v === "string" ? v : null;
+    this.activity(frame);
+    const add = (key, kind, data) => {
+      if (this.system.some((s) => s.item.key === key)) return;
+      this.system = [
+        ...this.system,
+        {
+          item: { type: "system", key, event: kind, data },
+          order: lastOrder(this.engine.state()) + 0.75
+        }
+      ];
+    };
+    switch (frame.type) {
+      case "session.ready": {
+        const session = frame.session?.id;
+        const moved = typeof session === "string" && session !== this.readySession;
+        if (typeof session === "string") this.readySession = session;
+        if (frame.resumed === true && Array.isArray(frame.transcript) && !transcriptHasIds(frame.transcript)) {
+          this.transcriptSeen = true;
+          this.anchorCards(moved);
+        } else if (moved && frame.resumed === true) {
+          const pending = new Set(
+            (Array.isArray(frame.pending_cards) ? frame.pending_cards : []).map(
+              (c) => str2(c.id)
+            )
+          );
+          for (const card of this.engine.state().cards)
+            if (pending.has(card.id)) this.inert.delete(card.id);
+            else this.inert.add(card.id);
+        }
+        return;
+      }
+      // `at` is required (v1-draft.15); the same takeover announced again after a reconnect has the same `at`, so it
+      // draws one row. A frame without one still gets a row of its own.
+      case "takeover.started":
+        add(
+          `takeover:${str2(frame.at) ?? `#${++this.systemSeq}`}`,
+          "takeover_started",
+          { by: str2(frame.by) }
+        );
+        return;
+      case "takeover.ended":
+        add(
+          `takeover-ended:${str2(frame.at) ?? `#${++this.systemSeq}`}`,
+          "takeover_ended",
+          {}
+        );
+        return;
+      case "handoff.created": {
+        const ticket = frame.ticket;
+        add(`handoff:${str2(ticket?.id) ?? ""}`, "handoff_created", {
+          expected_response: str2(ticket?.expected_response)
+        });
+        return;
+      }
+      case "flow.completed":
+        add(`flow:#${++this.systemSeq}`, "flow_completed", {
+          result: str2(frame.result),
+          code: str2(frame.code)
+        });
+        return;
+      case "turn.started": {
+        const turn = str2(frame.turn_id);
+        const input = str2(frame.client_event_id);
+        if (turn === null || input === null) return;
+        this.turnInputs.set(turn, input);
+        if (this.turnInputs.size > TURN_INPUTS) {
+          const oldest = this.turnInputs.keys().next().value;
+          if (oldest !== void 0) this.turnInputs.delete(oldest);
+        }
+        return;
+      }
+      case "turn.failed": {
+        const turn = str2(frame.turn_id) ?? "";
+        if (this.engine.state().messages.some((m) => m.key === `a:${turn}`))
+          return;
+        if (frame.code === "cancelled") return;
+        add(`failed:${turn}`, "turn_failed", {
+          code: str2(frame.code),
+          message: str2(frame.message),
+          retryable: frame.retryable === true,
+          retry: frame.retryable === true && this.turnText(turn) !== void 0,
+          turn
+        });
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /** The person's text that started a turn, while its message is on screen. */
+  turnText(turn) {
+    const input = this.turnInputs.get(turn);
+    if (input === void 0) return void 0;
+    const message = this.engine.state().messages.find((m) => m.key === input && m.role === "person");
+    return message?.text || void 0;
+  }
+  /**
+   * A resumed session's transcript replaced the messages, and a chat transcript carries text only: the engine drops
+   * the cards it drew, and draws the pending ones again at the end. Each card on screen is anchored just after the
+   * message it followed (by key; the transcript keeps the live keys), so a pending proposal stays where it was, and a
+   * card the transcript dropped stays drawn there; taking no tap when it belongs to an earlier session.
+   */
+  anchorCards(sessionChanged) {
+    const state = this.engine.state();
+    const seqOf = new Map(state.messages.map((m) => [m.key, m.seq]));
+    const first = Math.min(...state.messages.map((m) => m.seq), 0);
+    const held = new Set(state.cards.map((c) => c.id));
+    const order = /* @__PURE__ */ new Map();
+    const kept = [];
+    let anchor = first - 1;
+    let step = 0;
+    for (const item of this.view.items) {
+      if (item.type === "message" && seqOf.has(item.key)) {
+        anchor = seqOf.get(item.key);
+        step = 0;
+      } else if (item.type === "card") {
+        const at = anchor + 0.5 + ++step / 1e3;
+        order.set(item.key, at);
+        if (!held.has(item.key))
+          kept.push({
+            item: sessionChanged ? { ...item, busy: false, restored: true } : item,
+            order: at
+          });
+      }
+    }
+    this.cardOrder = order;
+    this.kept = kept;
+  }
+  // ------------------------------------------------------------ the view
+  /**
+   * Recomputes now (getSnapshot and getStreaming are always current) and notifies from the scheduler, at most once
+   * per frame, both channels in the same flush: a streamed reply that completes becomes its message in one frame.
+   */
+  update() {
+    const state = this.engine.state();
+    this.stream(state);
+    const view = this.compute(state);
+    if (view !== this.view) {
+      this.view = view;
+      this.viewDirty = true;
+      this.schedulePersist();
+    }
+    if (this.viewDirty || this.streamDirty) this.scheduleNotify();
+  }
+  scheduleNotify() {
+    if (this.framePending || this.disposed) return;
+    if (this.listeners.size === 0 && this.streamListeners.size === 0) return;
+    this.framePending = true;
+    this.frame = this.scheduler().request(() => {
+      this.frame = void 0;
+      this.framePending = false;
+      this.flush();
+    });
+  }
+  /** Calls the listeners of what changed since the last flush. */
+  flush() {
+    if (this.frame !== void 0) {
+      this.scheduler().cancel(this.frame);
+      this.frame = void 0;
+      this.framePending = false;
+    }
+    const view = this.viewDirty;
+    const stream = this.streamDirty;
+    this.viewDirty = false;
+    this.streamDirty = false;
+    if (stream) for (const l of [...this.streamListeners]) l();
+    if (view) for (const l of [...this.listeners]) l();
+  }
+  compute(state) {
+    const s = state ?? this.engine.state();
+    const prev = this.view;
+    for (const id of [...this.sent.keys()])
+      if (!this.early.has(id) && s.messages.some((m) => m.key === id))
+        this.sent.delete(id);
+    const items = buildTimeline(
+      {
+        state: s,
+        history: this.history,
+        sent: this.sent,
+        early: new Set(this.early.keys()),
+        retried: this.retried,
+        busy: this.busy,
+        decisionErrors: this.decisionErrors,
+        transcriptSeen: this.transcriptSeen,
+        cardOrder: this.cardOrder,
+        kept: this.kept,
+        inert: this.inert,
+        system: this.system
+      },
+      prev?.items ?? NO_ITEMS
+    );
+    const status = this.status();
+    const next = this.nextFrom(s);
+    const activity = s.turn === null ? [] : s.tools.filter((t) => t.turn_id === s.turn);
+    const name = this.info?.agent?.display_name ?? null;
+    const avatarUrl = this.info?.agent?.avatar_url ?? null;
+    const view = {
+      status,
+      conversationId: s.conversationId,
+      banner: banner(status, next),
+      next,
+      agent: sameAgent(prev?.agent, name, avatarUrl) ? prev.agent : { name, avatarUrl },
+      disclosure: s.disclosure ?? this.info?.disclosure ?? null,
+      welcome: this.info?.welcome ?? null,
+      takeover: s.takeover,
+      items,
+      activity: prev && sameTools(prev.activity, activity) ? prev.activity : activity,
+      responding: s.turn !== null || s.streaming !== null,
+      openQuestion: s.openQuestion,
+      answersNeedWebSocket: status === "sse",
+      turnsLeft: s.turnsLeft,
+      history: this.historyState
+    };
+    if (prev && shallowEqual(prev, view)) return prev;
+    return view;
+  }
+  status() {
+    if (this.disposed) return "closed";
+    if (this.suspended) return "idle";
+    const session = this.session;
+    if (!session) {
+      if (this.failed) return "unavailable";
+      return this.getting || this.early.size ? "starting" : "idle";
+    }
+    const status = session.status;
+    if (this.failed && status === "ended") return "unavailable";
+    if (status === "idle")
+      return this.offlineAfterRetries || this.online === false ? "offline" : "idle";
+    if (status === "reconnecting" && this.online === false) return "offline";
+    return status;
+  }
+  nextFrom(state) {
+    if (this.session?.status !== "ended" && state.reconnect === "allowed")
+      return null;
+    if (state.reconnect === "new_session_on_next_action") return "continue";
+    if (state.reconnect === "user_action_only") return "continue_here";
+    return null;
+  }
+  /** The streamed text, current at once; its listeners hear of it with the next flush. */
+  stream(state) {
+    const s = state.streaming;
+    if (!s) {
+      if (this.streaming !== null) {
+        this.streaming = null;
+        this.streamDirty = true;
+      }
+      return;
+    }
+    if (this.streaming?.turnId === s.turnId && this.streaming.text === s.text)
+      return;
+    this.streaming = { key: `a:${s.turnId}`, turnId: s.turnId, text: s.text };
+    this.streamDirty = true;
+  }
+  scheduler() {
+    return this.options.scheduler ?? defaultScheduler;
+  }
+  // ------------------------------------------------------------ persistence
+  key() {
+    return this.options.persistenceKey ?? "vinaverse.conversation";
+  }
+  restore() {
+    const store = this.options.persistence;
+    if (!store) return;
+    const done = () => {
+      this.historyState = "restored";
+      this.update();
+    };
+    const apply = (raw) => {
+      if (this.disposed) return;
+      if (raw === null) return done();
+      try {
+        const saved = JSON.parse(raw);
+        if (saved.v === PERSIST_VERSION && Array.isArray(saved.items))
+          this.history = saved.items.map(
+            (item) => item.type === "card" ? { ...item, busy: false, restored: true } : item
+          );
+      } catch {
+      }
+      done();
+    };
+    try {
+      const raw = store.getItem(this.key());
+      if (typeof raw === "string" || raw === null) apply(raw);
+      else {
+        this.historyState = "restoring";
+        this.view = this.compute(null);
+        raw.then(apply, () => {
+          if (!this.disposed) done();
+        });
+      }
+    } catch {
+      done();
+    }
+  }
+  schedulePersist() {
+    const store = this.options.persistence;
+    if (!store || this.disposed || this.persistTimer !== void 0) return;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = void 0;
+      const items = this.view.items.filter(persistable).slice(-100);
+      try {
+        void store.setItem(
+          this.key(),
+          JSON.stringify({ v: PERSIST_VERSION, items })
+        );
+      } catch {
+      }
+    }, PERSIST_DELAY);
+  }
+  // ------------------------------------------------------------ guards
+  /** Past the session's end (`expires_at`), when the backend passed it on. */
+  sessionOver() {
+    const end = this.info?.expires_at;
+    return end !== void 0 && (this.options.clock?.now() ?? Date.now()) >= Date.parse(end);
+  }
+  live() {
+    if (this.disposed)
+      throw new VinaverseClientError(
+        "session_ended",
+        "This conversation was closed."
+      );
+  }
+  required() {
+    this.live();
+    if (!this.session)
+      throw new VinaverseClientError(
+        "session_ended",
+        "The conversation has no session yet: start() it first."
+      );
+    return this.session;
+  }
+};
+function createConversation(options) {
+  return new ConversationStore(options);
+}
+var defaultScheduler = {
+  request(callback) {
+    const raf = globalThis.requestAnimationFrame;
+    return raf ? { raf: raf(callback) } : { timer: setTimeout(callback, 16) };
+  },
+  cancel(handle) {
+    const h = handle;
+    const caf = globalThis.cancelAnimationFrame;
+    if (h.raf !== void 0) caf?.(h.raf);
+    if (h.timer !== void 0) clearTimeout(h.timer);
+  }
+};
+function banner(status, next) {
+  if (status === "connecting" || status === "starting") return "connecting";
+  if (status === "reconnecting") return "reconnecting";
+  if (status === "offline") return "offline";
+  if (status === "unavailable" || status === "unauthorized")
+    return "unavailable";
+  if (next === "continue_here") return "continued_elsewhere";
+  return null;
+}
+function sameAgent(agent, name, avatarUrl) {
+  return agent?.name === name && agent?.avatarUrl === avatarUrl;
+}
+function sameTools(a, b) {
+  return a.length === b.length && a.every(
+    (t, i) => t.turn_id === b[i]?.turn_id && t.label === b[i]?.label && t.state === b[i]?.state
+  );
+}
+function shallowEqual(a, b) {
+  return a.status === b.status && a.banner === b.banner && a.next === b.next && a.agent.name === b.agent.name && a.agent.avatarUrl === b.agent.avatarUrl && a.disclosure === b.disclosure && a.takeover?.by === b.takeover?.by && a.takeover?.at === b.takeover?.at && a.takeover === null === (b.takeover === null) && a.items === b.items && a.activity === b.activity && a.responding === b.responding && a.openQuestion === b.openQuestion && a.answersNeedWebSocket === b.answersNeedWebSocket && a.turnsLeft === b.turnsLeft && a.history === b.history;
+}
+
+// src/agent/runtime.ts
+var AgentRefusal = class extends Error {
+  constructor(kind, options = {}) {
+    super(
+      options.message ?? (kind === "ended" ? "The conversation is over." : "No agent now.")
+    );
+    this.kind = kind;
+    this.name = "AgentRefusal";
+    this.reason = options.reason ?? (kind === "ended" ? "ended" : "unknown");
+    this.code = options.code ?? null;
+  }
+  kind;
+  reason;
+  code;
+};
+var GREETED = "vinaverse.greeted";
+var GREETED_BEFORE = "vinaverse.agent.greeted";
+function greetedKey(subject, mode) {
+  return `${GREETED}.${JSON.stringify([subject, mode])}`;
+}
+function tupleOf(key, prefix) {
+  if (!key.startsWith(`${prefix}.[`)) return null;
+  try {
+    const t = JSON.parse(key.slice(prefix.length + 1));
+    return Array.isArray(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+function legacyTranscripts(keys, prefix) {
+  const out = [];
+  for (const key of keys) {
+    const t = tupleOf(key, prefix);
+    if (t)
+      out.push(
+        `${prefix}.${t[1] ?? "guest"}|${t[2]}|${t[3] ?? "-"}|${t[4] ?? "chat"}`
+      );
+  }
+  return out;
+}
+function legacyGreetings(pairs) {
+  const out = [];
+  for (const [subject, mode] of pairs)
+    out.push(`${GREETED_BEFORE}.${subject ?? "guest"}:${mode}`);
+  return out;
+}
+var NOT_KEPT = /* @__PURE__ */ new Set(["starting", "unavailable", "unauthorized", "closed"]);
+var CLEARED = { screen: "other" };
+function hashKey(key, salt) {
+  return `k${sha256(`${salt}\0${key}`).slice(0, 32)}`;
+}
+var K;
+var H;
+function sha256(text2) {
+  if (!K || !H) {
+    K = [];
+    H = [];
+    for (let n = 2; K.length < 64; n++) {
+      let prime = true;
+      for (let d = 2; d * d <= n; d++) if (n % d === 0) prime = false;
+      if (!prime) continue;
+      if (H.length < 8) H.push(Math.sqrt(n) % 1 * 2 ** 32 | 0);
+      K.push(Math.cbrt(n) % 1 * 2 ** 32 | 0);
+    }
+  }
+  const bytes = [];
+  const s = encodeURIComponent(text2);
+  for (let i = 0; i < s.length; i++)
+    if (s[i] === "%") {
+      bytes.push(Number.parseInt(s.slice(i + 1, i + 3), 16));
+      i += 2;
+    } else bytes.push(s.charCodeAt(i));
+  const bits = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) bytes.push(0);
+  for (const word of [Math.floor(bits / 2 ** 32), bits >>> 0])
+    bytes.push(
+      word >>> 24,
+      word >>> 16 & 255,
+      word >>> 8 & 255,
+      word & 255
+    );
+  const h = [...H];
+  const w = new Array(64);
+  const ror = (x, n) => x >>> n | x << 32 - n;
+  for (let at = 0; at < bytes.length; at += 64) {
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        const b2 = at + i * 4;
+        w[i] = bytes[b2] << 24 | bytes[b2 + 1] << 16 | bytes[b2 + 2] << 8 | bytes[b2 + 3];
+      } else {
+        const x = w[i - 15];
+        const y = w[i - 2];
+        w[i] = w[i - 16] + (ror(x, 7) ^ ror(x, 18) ^ x >>> 3) + w[i - 7] + (ror(y, 17) ^ ror(y, 19) ^ y >>> 10) | 0;
+      }
+    }
+    let [a, b, c, d, e, f, g, k] = h;
+    for (let i = 0; i < 64; i++) {
+      const t1 = k + (ror(e, 6) ^ ror(e, 11) ^ ror(e, 25)) + (e & f ^ ~e & g) + K[i] + w[i] | 0;
+      const t2 = (ror(a, 2) ^ ror(a, 13) ^ ror(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      k = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    [a, b, c, d, e, f, g, k].forEach((v, i) => {
+      h[i] = h[i] + v | 0;
+    });
+  }
+  return h.map((v) => (v >>> 0).toString(16).padStart(8, "0")).join("");
+}
+var NO_FEATURES = {
+  history: false,
+  memory: false,
+  businessAgent: false,
+  businessSetup: false
+};
+var SYSTEM_CLOCK = { now: () => Date.now() };
+function agentKey(key, agent = null) {
+  return JSON.stringify([
+    agent,
+    key.subject,
+    key.mode,
+    key.scope ?? null,
+    key.thread ?? "chat"
+  ]);
+}
+var samePlace = (a, b) => a?.screen === b?.screen && (a?.entity?.type ?? null) === (b?.entity?.type ?? null) && (a?.entity?.id ?? null) === (b?.entity?.id ?? null) && JSON.stringify(a?.filters ?? null) === JSON.stringify(b?.filters ?? null);
+function usable(session, insecure) {
+  return typeof session.id === "string" && session.id !== "" && (insecure.realtime === true || /^wss:\/\//i.test(session.realtime_url ?? "")) && (insecure.turns === true || /^https:\/\//i.test(session.turns_url ?? "")) && Boolean(session.client_secret);
+}
+function warnInsecure(insecure, warn) {
+  if (!(insecure.realtime || insecure.turns)) return;
+  if (globalThis.__DEV__ === true) return;
+  warn(
+    "@vinaverse/client/agent: insecureAddresses lets sessions use plaintext ws:// or http:// addresses. For mocks and local development only.",
+    { code: "insecure_addresses" }
+  );
+}
+var OPEN_KEPT_MS = 24 * 36e5;
+var MAX_WAITING = 100;
+function createAgentRuntime(options) {
+  const { backend } = options;
+  const policy = {
+    delays: options.retry?.delays ?? [500, 1500, 3500],
+    isRetryable: options.retry?.isRetryable ?? retryable
+  };
+  const clock = options.clock ?? SYSTEM_CLOCK;
+  const keepAlive = options.keepAlive ?? "session";
+  const staleMs = options.statusStaleMs ?? 5 * 6e4;
+  const insecure = options.insecureAddresses ?? {};
+  warnInsecure(insecure, options.onWarning ?? ((m) => console.warn(m)));
+  const live = /* @__PURE__ */ new Map();
+  const current = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let status = null;
+  let reading = null;
+  const NO_STATUS = {
+    status: null,
+    reading: false,
+    failed: false
+  };
+  let statusState = NO_STATUS;
+  const setStatusState = (next) => {
+    statusState = { status: status?.value ?? null, ...next };
+    changed();
+  };
+  let sessionName = null;
+  let generation = 0;
+  const keyOf = (key) => agentKey(key, options.agent ?? null);
+  const prefix = options.conversation?.persistenceKey ?? "vinaverse.agent";
+  const storage = guardedStorage(
+    options.conversation?.persistence,
+    prefix,
+    () => generation
+  );
+  const greetings = guardedStorage(
+    options.greetingStorage,
+    GREETED,
+    () => generation
+  );
+  const warn = options.onWarning ?? ((m) => console.warn(m));
+  const isolated = (what, call) => {
+    try {
+      call();
+    } catch (error) {
+      warn(
+        `@vinaverse/client/agent: the app's ${what} threw (${error instanceof Error ? error.message : String(error)}); the conversation went on.`,
+        { code: "callback_threw", callback: what }
+      );
+    }
+  };
+  const saltStore = options.conversation?.persistence ?? options.greetingStorage;
+  const saltKey = `${prefix}:salt`;
+  let salt = null;
+  const waiting = [];
+  const loadSalt = () => {
+    if (!options.onEvent) return;
+    const settle = (kept2) => {
+      if (salt !== null) return;
+      if (kept2) salt = kept2;
+      else {
+        salt = randomId().slice(3);
+        void Promise.resolve(saltStore?.setItem(saltKey, salt)).catch(
+          () => void 0
+        );
+      }
+      for (const event of waiting.splice(0)) deliver(event);
+    };
+    try {
+      const got = saltStore?.getItem(saltKey);
+      if (typeof got === "string" || got == null) settle(got);
+      else got.then(settle, () => settle(null));
+    } catch {
+      settle(null);
+    }
+  };
+  const deliver = (event) => isolated(
+    "onEvent",
+    () => options.onEvent?.(
+      event.key ? { ...event, key: hashKey(event.key, salt ?? "") } : event
+    )
+  );
+  let dropping = false;
+  const emit = (event) => {
+    if (!options.onEvent) return;
+    if (salt !== null) return deliver(event);
+    if (waiting.push(event) > MAX_WAITING) {
+      waiting.shift();
+      if (!dropping)
+        warn(
+          "@vinaverse/client/agent: the analytics salt is still being read from storage; the oldest events are dropped.",
+          { code: "events_dropped" }
+        );
+      dropping = true;
+    }
+  };
+  loadSalt();
+  const changed = () => {
+    for (const l of [...listeners]) l();
+  };
+  const update = (entry, next) => {
+    entry.state = { ...entry.state, ...next };
+    for (const l of [...entry.listeners]) l();
+  };
+  const end = (k) => {
+    const entry = live.get(k);
+    if (!entry) return;
+    live.delete(k);
+    clearTimeout(entry.timer);
+    entry.store.dispose();
+    emit({ type: "conversation_ended", key: k });
+    changed();
+  };
+  const patiently = (run, signal, key) => retrying(
+    run,
+    policy,
+    signal,
+    (attempt) => emit({ type: "session_retried", key, attempt })
+  );
+  async function open(entry, key, request) {
+    if (live.get(entry.key) !== entry) throw new AgentRefusal("unavailable");
+    const held = entry.failedOpen && clock.now() - entry.failedOpen.at < OPEN_KEPT_MS ? entry.failedOpen : void 0;
+    entry.failedOpen = void 0;
+    const asked = held ? {
+      ...held.request,
+      ...request.signal ? { signal: request.signal } : {}
+    } : {
+      ...request,
+      conversationId: request.conversationId ?? current.get(entry.key) ?? null,
+      key,
+      openId: `op_${randomId().slice(3)}`,
+      agent: options.agent ?? null,
+      place: entry.place,
+      placeRevision: ++entry.revision,
+      entryPoint: entry.entryPoint
+    };
+    const { conversationId, openId, place: told } = asked;
+    let session;
+    try {
+      session = await patiently(
+        () => backend.openSession(asked),
+        request.signal,
+        entry.key
+      );
+      if (!usable(session, insecure))
+        throw new AgentRefusal("unavailable", {
+          reason: "invalid_session",
+          message: "Unusable session: an id, a secret, wss:// and https:// addresses."
+        });
+    } catch (error) {
+      if (live.get(entry.key) === entry) {
+        const failure = isRefusal(error) ? error.kind === "ended" && conversationId !== null ? "ended" : "unavailable" : policy.isRetryable(error) ? "unreachable" : "unavailable";
+        const reason = reasonOf(error, failure);
+        const code = isRefusal(error) ? error.code : codeOf(error);
+        if (failure === "unreachable") {
+          const { signal, ...again } = asked;
+          entry.failedOpen = { request: again, at: held?.at ?? clock.now() };
+        }
+        const unsettled = reason === "unknown_open" ? String(field(error, "openId") ?? openId) : null;
+        update(entry, { failure, reason, code, openId: unsettled });
+        emit({ type: "session_failed", key: entry.key, failure, reason });
+      }
+      throw error;
+    }
+    if (live.get(entry.key) !== entry) throw new AgentRefusal("unavailable");
+    entry.told = told;
+    entry.expiresAt = session.expires_at ? Date.parse(session.expires_at) : null;
+    if (session.conversation_id)
+      current.set(entry.key, session.conversation_id);
+    const name = session.agent?.display_name?.trim();
+    if (name && name !== sessionName) {
+      sessionName = name;
+      changed();
+    }
+    update(entry, {
+      failure: null,
+      reason: null,
+      code: null,
+      openId: null,
+      sessionId: session.id,
+      conversationId: session.conversation_id ?? conversationId,
+      moved: !samePlace(told, entry.place)
+    });
+    emit({
+      type: conversationId === null ? "session_opened" : "session_resumed",
+      key: entry.key,
+      sessionId: session.id,
+      ...entry.entryPoint ? { from: entry.entryPoint } : {}
+    });
+    return session;
+  }
+  const kept = (k) => `${prefix}.${k}`;
+  const signOut = async (erasing) => {
+    generation++;
+    if (erasing) salt = null;
+    for (const entry of live.values()) {
+      clearTimeout(entry.timer);
+      entry.store.clear();
+    }
+    const known = /* @__PURE__ */ new Set([...live.keys(), ...current.keys()]);
+    live.clear();
+    current.clear();
+    sessionName = null;
+    status = null;
+    reading = null;
+    statusState = NO_STATUS;
+    changed();
+    const pairs = [];
+    await Promise.all([
+      backend.endSessions?.().catch(() => void 0),
+      storage?.purge(
+        [`${prefix}.`],
+        (keys) => {
+          const all = /* @__PURE__ */ new Set([...keys, ...[...known].map(kept)]);
+          for (const key of all) {
+            const t = tupleOf(key, prefix);
+            if (t) pairs.push([t[1], t[2]]);
+          }
+          return [
+            ...all,
+            ...legacyTranscripts(all, prefix),
+            ...options.legacyKeys ?? []
+          ];
+        },
+        `${GREETED}.`
+      )
+    ]);
+    if (!erasing) return;
+    await Promise.all([
+      Promise.resolve(saltStore?.removeItem(saltKey)).catch(() => void 0),
+      greetings?.purge([`${GREETED}.`, `${GREETED_BEFORE}.`], (keys) => {
+        for (const key of keys) {
+          const t = tupleOf(key, GREETED);
+          if (t) pairs.push([t[0], t[1]]);
+        }
+        return [...legacyGreetings(pairs), ...options.legacyKeys ?? []];
+      })
+    ]);
+    loadSalt();
+  };
+  const forget = (k) => {
+    current.delete(k);
+    const entry = live.get(k);
+    if (entry) {
+      entry.store.clear();
+      end(k);
+    } else void storage?.removeItem(kept(k));
+  };
+  const activity = (entry, a) => {
+    const sessionId = entry.state.sessionId;
+    if (a.type === "reply_completed" && sessionId) {
+      entry.turns.set(a.turnId, sessionId);
+      update(entry, {});
+    }
+    emit({
+      type: a.type,
+      key: entry.key,
+      ...sessionId ? { sessionId } : {},
+      ...a.type === "reply_completed" ? { turnId: a.turnId } : {},
+      ...a.type === "card_shown" ? { cardId: a.cardId, kind: a.kind } : {}
+    });
+  };
+  function make(key) {
+    const k = keyOf(key);
+    const own = options.conversation ?? {};
+    const refresh = backend.refreshSecret?.bind(backend);
+    const entry = {
+      key: k,
+      store: createConversation({
+        ...own,
+        ...storage ? {
+          persistence: storage,
+          persistenceKey: kept(k)
+        } : {},
+        onActivity: (a) => {
+          activity(entry, a);
+          isolated("onActivity", () => own.onActivity?.(a));
+        },
+        getSession: (request) => open(entry, key, request),
+        ...refresh ? {
+          // A refusal (`session_closed`) is the store's cue to go on in a new session, never a fault.
+          refreshSecret: (id) => patiently(() => refresh(id), void 0, k).catch((error) => {
+            throw isRefusal(error) ? new VinaverseClientError(
+              "needs_new_session",
+              error.message
+            ) : error;
+          })
+        } : {},
+        clock,
+        onError: (error) => {
+          if (!isRefusal(error) && codeOf(error) !== "needs_new_session")
+            own.onError?.(error);
+        }
+      }),
+      listeners: /* @__PURE__ */ new Set(),
+      state: {
+        failure: null,
+        reason: null,
+        code: null,
+        moved: false,
+        ratings: /* @__PURE__ */ new Map(),
+        sessionId: null,
+        conversationId: current.get(k) ?? null,
+        openId: null
+      },
+      place: null,
+      told: null,
+      revision: 0,
+      entryPoint: null,
+      expiresAt: null,
+      shown: 0,
+      started: false,
+      suspended: false,
+      sentOnce: /* @__PURE__ */ new Set(),
+      timer: void 0,
+      turns: /* @__PURE__ */ new Map(),
+      failedOpen: void 0
+    };
+    return entry;
+  }
+  const over = (entry) => entry.expiresAt !== null && entry.expiresAt <= clock.now();
+  const expireLater = (entry) => {
+    clearTimeout(entry.timer);
+    if (entry.expiresAt === null) return;
+    entry.timer = setTimeout(
+      () => {
+        entry.timer = void 0;
+        if (live.get(entry.key) !== entry || entry.shown > 0) return;
+        if (over(entry)) end(entry.key);
+        else expireLater(entry);
+      },
+      Math.max(0, entry.expiresAt - clock.now())
+    );
+  };
+  const tell = (entry, at) => {
+    if (at.place !== void 0) entry.place = at.place;
+    if (at.entryPoint !== void 0) entry.entryPoint = at.entryPoint;
+    const sessionId = entry.state.sessionId;
+    const moved = sessionId !== null && !samePlace(entry.told, entry.place);
+    update(entry, { moved });
+    const updateContext = backend.updateContext?.bind(backend);
+    if (!moved || !updateContext || sessionId === null) return;
+    const asked = generation;
+    const current2 = () => asked === generation && live.get(entry.key) === entry && entry.state.sessionId === sessionId;
+    const send = (again) => {
+      const place = entry.place;
+      const revision = ++entry.revision;
+      updateContext(sessionId, place ?? CLEARED, revision).then(
+        () => {
+          if (!current2() || entry.revision !== revision) return;
+          entry.told = place;
+          update(entry, { moved: !samePlace(entry.told, entry.place) });
+          emit({ type: "context_updated", key: entry.key, sessionId });
+        },
+        (error) => {
+          const theirs = field(error, "currentRevision");
+          const conflict = field(error, "outcome") === "context_conflict" || field(error, "reason") === "conflict";
+          if (!conflict || again || !current2() || entry.revision !== revision)
+            return;
+          if (typeof theirs === "number" && theirs >= entry.revision)
+            entry.revision = theirs;
+          send(true);
+        }
+      );
+    };
+    send(false);
+  };
+  function handle(entry) {
+    return {
+      key: entry.key,
+      store: entry.store,
+      show(at = {}) {
+        if (live.get(entry.key) !== entry) return () => void 0;
+        if (entry.shown === 0 && over(entry)) {
+          end(entry.key);
+          return () => void 0;
+        }
+        entry.shown++;
+        clearTimeout(entry.timer);
+        entry.timer = void 0;
+        if (entry.suspended) {
+          entry.suspended = false;
+          entry.store.setForeground(true);
+        }
+        tell(entry, at);
+        if (!entry.started) {
+          entry.started = true;
+          entry.store.start();
+        }
+        let released = false;
+        return () => {
+          if (released) return;
+          released = true;
+          entry.shown--;
+          if (entry.shown > 0 || live.get(entry.key) !== entry) return;
+          if (keepAlive === "view" || NOT_KEPT.has(entry.store.getSnapshot().status) || entry.expiresAt === null || over(entry)) {
+            end(entry.key);
+            return;
+          }
+          entry.suspended = true;
+          entry.store.setForeground(false);
+          expireLater(entry);
+        };
+      },
+      tell: (at) => tell(entry, at),
+      getState: () => entry.state,
+      subscribe(listener) {
+        entry.listeners.add(listener);
+        return () => entry.listeners.delete(listener);
+      },
+      retry() {
+        update(entry, {
+          failure: null,
+          reason: null,
+          code: null,
+          openId: null
+        });
+        entry.store.start();
+      },
+      canRate: (turnId) => entry.turns.has(turnId),
+      rate(turnId, rating) {
+        const sessionId = entry.turns.get(turnId);
+        if (!sessionId || entry.state.ratings.get(turnId) === rating) return;
+        update(entry, {
+          ratings: new Map(entry.state.ratings).set(turnId, rating)
+        });
+        emit({ type: "rated", key: entry.key, sessionId, turnId, rating });
+        void backend.sendFeedback?.({ sessionId, turnId, rating }).catch(() => void 0);
+      },
+      sendOnce(text2) {
+        if (entry.sentOnce.has(text2)) return;
+        entry.sentOnce.add(text2);
+        entry.store.send(text2);
+      }
+    };
+  }
+  const handles = /* @__PURE__ */ new WeakMap();
+  const lookup = (key) => {
+    const k = keyOf(key);
+    let entry = live.get(k);
+    if (!entry) {
+      entry = make(key);
+      live.set(k, entry);
+    }
+    let h = handles.get(entry);
+    if (!h) {
+      h = handle(entry);
+      handles.set(entry, h);
+    }
+    return h;
+  };
+  return {
+    conversation(key) {
+      const k = keyOf(key);
+      const entry = live.get(k);
+      if (entry && entry.shown === 0 && over(entry)) end(k);
+      return lookup(key);
+    },
+    peek: lookup,
+    startNew(key) {
+      const k = keyOf(key);
+      current.delete(k);
+      end(k);
+    },
+    dispose(key) {
+      end(keyOf(key));
+    },
+    forget(key) {
+      forget(keyOf(key));
+    },
+    sweep() {
+      for (const entry of [...live.values()])
+        if (entry.shown === 0 && over(entry)) end(entry.key);
+    },
+    continue(key, conversationId) {
+      const k = keyOf(key);
+      if (current.get(k) !== conversationId) {
+        forget(k);
+        current.set(k, conversationId);
+      }
+      return lookup(key);
+    },
+    async signOut() {
+      await signOut(false);
+    },
+    async erase() {
+      await signOut(true);
+    },
+    async deleteConversation(key, conversationId) {
+      if (!backend.deleteConversation)
+        throw new Error(
+          "@vinaverse/client/agent: deleteConversation needs AgentBackend.deleteConversation."
+        );
+      await backend.deleteConversation(conversationId);
+      const k = keyOf(key);
+      const continued = current.get(k) ?? live.get(k)?.store.getSnapshot().conversationId ?? null;
+      if (continued === conversationId) forget(k);
+    },
+    greetings: greetings ?? null,
+    status() {
+      if (status && clock.now() - status.at < staleMs)
+        return Promise.resolve(status.value);
+      if (reading) return reading;
+      const asked = generation;
+      const read = readStatus(backend).then(
+        (value) => {
+          if (asked !== generation) return value;
+          reading = null;
+          status = { value, at: clock.now() };
+          setStatusState({ reading: false, failed: false });
+          return value;
+        },
+        (error) => {
+          if (asked === generation) {
+            reading = null;
+            setStatusState({ reading: false, failed: true });
+          }
+          throw error;
+        }
+      );
+      reading = read;
+      setStatusState({ reading: true, failed: statusState.failed });
+      return read;
+    },
+    getStatus: () => status?.value ?? null,
+    getStatusState: () => statusState,
+    backend,
+    epoch: () => generation,
+    getName: () => sessionName ?? status?.value.displayName ?? null,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit
+  };
+}
+function guardedStorage(raw, prefix, generation) {
+  if (!raw) return void 0;
+  const indexKey = `${prefix}:index`;
+  const chains = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const queued = (key, op) => {
+    pending.set(key, (pending.get(key) ?? 0) + 1);
+    const run = (chains.get(key) ?? Promise.resolve()).then(op);
+    const settled = run.then(
+      () => void 0,
+      () => void 0
+    );
+    chains.set(key, settled);
+    void settled.then(() => {
+      const left = (pending.get(key) ?? 1) - 1;
+      if (left > 0) pending.set(key, left);
+      else {
+        pending.delete(key);
+        if (chains.get(key) === settled) chains.delete(key);
+      }
+    });
+    return run;
+  };
+  const safe = (p) => p.catch(() => void 0);
+  const readIndex = async () => {
+    try {
+      const value = await raw.getItem(indexKey);
+      const list3 = value ? JSON.parse(value) : [];
+      return new Set(
+        Array.isArray(list3) ? list3.filter((k) => typeof k === "string") : []
+      );
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  };
+  const listed = /* @__PURE__ */ new Set();
+  const list2 = (key) => {
+    if (listed.has(key)) return;
+    listed.add(key);
+    void safe(
+      queued(indexKey, async () => {
+        const all = await readIndex();
+        if (all.has(key)) return;
+        all.add(key);
+        await raw.setItem(indexKey, JSON.stringify([...all]));
+      })
+    );
+  };
+  return {
+    getItem(key) {
+      const asked = generation();
+      const read = pending.has(key) ? queued(key, () => raw.getItem(key)) : raw.getItem(key);
+      if (typeof read === "string" || read === null) return read;
+      return Promise.resolve(read).then(
+        (v) => asked === generation() ? v ?? null : null,
+        () => null
+      );
+    },
+    setItem(key, value) {
+      const asked = generation();
+      return safe(
+        queued(key, () => {
+          if (asked !== generation()) return;
+          list2(key);
+          return raw.setItem(key, value);
+        })
+      );
+    },
+    removeItem: (key) => safe(queued(key, () => raw.removeItem(key))),
+    /**
+     * Everything kept: the index, what the app's storage finds under `under` (`removePrefix`, else `keys`), and `extra`
+     * (older key shapes). Nothing under `keep` goes, so `removePrefix` is used only for a prefix that cannot reach it.
+     */
+    async purge(under, extra = () => [], keep) {
+      const all = /* @__PURE__ */ new Set([...listed, ...await readIndex()]);
+      listed.clear();
+      for (const p of under)
+        try {
+          if (raw.removePrefix && !keep?.startsWith(p))
+            await raw.removePrefix(p);
+          else if (raw.keys) {
+            for (const key of await raw.keys(p))
+              if (!keep || !key.startsWith(keep)) all.add(key);
+          }
+        } catch {
+        }
+      for (const key of extra(all)) all.add(key);
+      await Promise.all(
+        [...all].map((key) => safe(queued(key, () => raw.removeItem(key))))
+      );
+      await safe(queued(indexKey, () => raw.removeItem(indexKey)));
+    }
+  };
+}
+async function readStatus(backend) {
+  const read = backend.status ? await backend.status() : { available: true };
+  const available = read.available === true;
+  const features = read.features ?? NO_FEATURES;
+  return {
+    available,
+    launcher: available && read.launcher === true,
+    displayName: read.displayName?.trim() || null,
+    avatarUrl: read.avatarUrl?.startsWith("https://") ? read.avatarUrl : null,
+    features: {
+      history: available && features.history === true,
+      memory: available && features.memory === true,
+      businessAgent: available && features.businessAgent === true,
+      businessSetup: available && features.businessSetup === true
+    }
+  };
+}
+function isRefusal(error) {
+  return error instanceof AgentRefusal || field(error, "name") === "AgentRefusal" && (field(error, "kind") === "ended" || field(error, "kind") === "unavailable");
+}
+var field = (error, name) => typeof error === "object" && error !== null ? error[name] : void 0;
+var retryable = (error) => field(error, "retryable") === true;
+var REASONS = /* @__PURE__ */ new Set([
+  "ended",
+  "not_found",
+  "expired",
+  "mismatch",
+  "completed",
+  "forbidden",
+  "conflict",
+  "unknown_open",
+  "auth",
+  "off",
+  "rate_limited",
+  "network",
+  "server",
+  "invalid_session",
+  "unknown"
+]);
+function reasonOf(error, failure) {
+  if (isRefusal(error)) return error.reason;
+  const given = field(error, "reason");
+  if (typeof given === "string" && REASONS.has(given))
+    return given;
+  const status = field(error, "status");
+  if (status === 401 || status === 403) return "auth";
+  if (status === 429) return "rate_limited";
+  if (typeof status === "number" && status >= 500) return "server";
+  return failure === "unreachable" ? "network" : "unknown";
+}
+function codeOf(error) {
+  const code = field(error, "code") ?? field(error, "outcome");
+  return typeof code === "string" ? code : null;
+}
+async function retrying(run, policy, signal, onRetry) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await run();
+    } catch (error) {
+      const delay = policy.delays[attempt];
+      if (delay === void 0 || !policy.isRetryable(error) || signal?.aborted)
+        throw error;
+      const asked = field(error, "retryAfterMs");
+      const wait = typeof asked === "number" && asked > delay ? Math.min(asked, 6e4) : delay;
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          signal?.removeEventListener("abort", stop);
+          resolve();
+        }, wait);
+        function stop() {
+          clearTimeout(timer);
+          reject(error);
+        }
+        signal?.addEventListener("abort", stop, { once: true });
+      });
+      onRetry(attempt + 1);
+    }
+  }
+}
+
+exports.AgentRefusal = AgentRefusal;
+exports.agentKey = agentKey;
+exports.createAgentRuntime = createAgentRuntime;
+exports.greetedKey = greetedKey;
+exports.hashKey = hashKey;
+exports.isRefusal = isRefusal;
+exports.readCard = readCard;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map