@athenaintel/react 0.43.0 → 0.50.0

package/dist/keryx-http/src/unconfirmed-update-attributions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unconfirmed-update-attributions.js","sources":["../../../../keryx-http/src/unconfirmed-update-attributions.ts"],"sourcesContent":["/**\n * The attributed writes a room has not seen Keryx acknowledge, kept so that a write made while the\n * room's socket is closed still reaches Keryx with its attributions.\n *\n * A write made inside `runWithDocUpdateAttributions` leaves as its own sync update followed by the\n * attributions trailer (`attributingWebSocket`), but only if the room's socket is open as it is\n * made. One made while it is closed (offline, reconnecting, before the first connection) reaches\n * Keryx inside the reconnect's sync step 2: the client's answer to Keryx's sync step 1, everything\n * it holds that Keryx lacks. Keryx reads no trailer after a sync step 2, so it would count the\n * write as the person's edit.\n *\n * So the room keeps the content ids of every write made in a scope, with the scope's attributions,\n * until Keryx sends those ids back: the echo of the update that carried them, or the whole document\n * Keryx sends when a socket opens (`received`; `@y/websocket` confirms its own unconfirmed updates\n * the same way). When the socket sends a sync step 2, each kept write's part of it goes out first,\n * oldest first, as its own sync update with its trailer, and the sync step 2 follows without those\n * ids (`framesFor`). The parts are cut from the sync step 2 itself, which already holds only what\n * Keryx lacks past its state vector. One socket keeps the order, so Keryx appends each marked update\n * before the person's sync step 2.\n *\n * That answer waits for Keryx's document (`connect`). Keryx sends its sync step 1 and, in the same\n * cork, its whole document, but `@y/websocket` answers the sync step 1 as it arrives. A kept write\n * Keryx already appended (its echo lost with the socket) is still kept then, and the sync step 2\n * holds the client's whole delete set, so its deletes would go out again as a marked update, which\n * Keryx appends: it drops what it holds from the first sync step 2 only. Held until the next frame,\n * the answer is split once Keryx's document has dropped what it holds.\n *\n * What Keryx records (`patches/@y%2Fhub@0.10.1.patch`):\n * - An update's content map attributes every id it carries, inserts and deletes, read from its\n *   bytes: an update that cannot integrate yet (an item next to one the person typed offline, the\n *   next clocks of the person's own client) is attributed like any other. Peers hold it until the\n *   sync step 2 behind it brings what it needs.\n * - An id is attributed by the first stream entry that carries it (`getDoc`'s `excludeContentMap`),\n *   so a later copy changes no merged history. The live change notices read each entry's own\n *   content map, though (keryx/src/doc-watcher.ts), and the first sync step 2's strip of what Keryx\n *   holds reads the known ids when the frame arrives, possibly before the update ahead of it is in\n *   the stream (one whose content map the compute pool builds). A copy inside the sync step 2\n *   would then be announced as the person's: the sync step 2 never carries a kept write's ids.\n *\n * Bounded: consecutive writes of one scope merge into one run, and past\n * {@link MAX_ATTRIBUTED_RUNS} runs the oldest is let go (its content then reaches Keryx in a sync\n * step 2, as the person's). A room's local copy keeps them across sessions\n * ({@link unconfirmedAttributedWritesOf}, {@link restoreUnconfirmedAttributedWrites}); without one,\n * a write the room kept is forgotten with the page.\n */\nimport {\n  type ContentIds,\n  createContentIdsFromUpdate,\n  type Doc,\n  excludeContentIds,\n  intersectContentIds,\n  intersectUpdateWithContentIds,\n  mergeContentIds,\n} from '@y/y';\nimport {\n  type AttributedWritesSocket,\n  readVarUint,\n  type UnconfirmedAttributedWrites,\n  type UpdateAttribution,\n  withUpdateAttributionsTrailer,\n  writeVarUint,\n} from './update-attributions.js';\n\n/** y-protocols: a sync message, and the sub-types that carry content. */\nconst MESSAGE_SYNC = 0;\nconst SYNC_STEP_2 = 1;\nconst SYNC_UPDATE = 2;\n\n/** Writes made in one attribution scope, by the content ids they wrote (inserts and deletes). */\nexport interface AttributedWrites {\n  ids: ContentIds;\n  attributions: readonly UpdateAttribution[];\n}\n\n/**\n * The most runs a room keeps; a run is one scope's writes since a write of another scope. Housekeeping\n * all shares one scope, so runs pile up only as Quick Edit steps interleave with it.\n */\nexport const MAX_ATTRIBUTED_RUNS = 64;\n\nfunction noIds(ids: ContentIds): boolean {\n  return ids.inserts.isEmpty() && ids.deletes.isEmpty();\n}\n\nfunction sameAttributions(\n  a: readonly UpdateAttribution[],\n  b: readonly UpdateAttribution[]\n): boolean {\n  return (\n    a.length === b.length &&\n    a.every((pair, index) => pair.k === b[index]?.k && pair.v === b[index]?.v)\n  );\n}\n\n/** The sync message `frame` is, when it is exactly one (nothing after its payload). */\nfunction readSyncFrame(frame: Uint8Array): { syncType: number; payload: Uint8Array } | null {\n  const type = readVarUint({ bytes: frame, start: 0 });\n  if (type?.value !== MESSAGE_SYNC) return null;\n  const syncType = readVarUint({ bytes: frame, start: type.next });\n  if (syncType === null) return null;\n  const length = readVarUint({ bytes: frame, start: syncType.next });\n  if (length === null || length.next + length.value !== frame.length) return null;\n  return { syncType: syncType.value, payload: frame.subarray(length.next) };\n}\n\n/** A sync message of `syncType` carrying `payload`, as y-protocols writes one. */\nfunction syncFrame({ syncType, payload }: { syncType: number; payload: Uint8Array }): Uint8Array {\n  const head: number[] = [];\n  writeVarUint({ out: head, value: MESSAGE_SYNC });\n  writeVarUint({ out: head, value: syncType });\n  writeVarUint({ out: head, value: payload.length });\n  const frame = new Uint8Array(head.length + payload.length);\n  frame.set(head, 0);\n  frame.set(payload, head.length);\n  return frame;\n}\n\n/** The content ids an update carries, or `null` for bytes that are not one. */\nfunction idsOf(update: Uint8Array): ContentIds | null {\n  try {\n    return createContentIdsFromUpdate(update);\n  } catch {\n    return null;\n  }\n}\n\nfunction copyOf({ ids, attributions }: AttributedWrites): AttributedWrites {\n  return { ids, attributions: attributions.map(({ k, v }) => ({ k, v })) };\n}\n\n/** `runs` without the oldest past {@link MAX_ATTRIBUTED_RUNS}. */\nfunction bounded(runs: AttributedWrites[]): AttributedWrites[] {\n  return runs.length > MAX_ATTRIBUTED_RUNS ? runs.slice(runs.length - MAX_ATTRIBUTED_RUNS) : runs;\n}\n\n/** What a page reads of a room's tracker, whichever copy of this module made it. */\ninterface KeptWrites {\n  readonly pending: readonly AttributedWrites[];\n  restore(writes: readonly AttributedWrites[]): void;\n}\n\n/**\n * Each document's tracker in the page, and what a destroyed one still kept for the next tracker made\n * for the same document (a transport rebuilt over a retained document; a local copy read into a\n * document before its room's transport exists). On `globalThis`, not in module scope, for the reason\n * the scopes are (`update-attributions.ts`): the SDK's dist inlines its own copy of this module, and\n * a local copy reading a room through another copy must find the same tracker. Weak: each entry goes\n * with its document.\n */\nconst ROOMS = Symbol.for('@athenaintel/keryx-http/unconfirmed-update-attributions');\n\ninterface Rooms {\n  live: WeakMap<object, KeptWrites>;\n  left: WeakMap<object, AttributedWrites[]>;\n}\n\ntype RoomsHost = typeof globalThis & {\n  [ROOMS]?: Rooms;\n};\n\n// process-local: browser-only, each entry keyed by the document whose writes it holds\nfunction rooms(): Rooms {\n  const host = globalThis as RoomsHost;\n  return (host[ROOMS] ??= { live: new WeakMap(), left: new WeakMap() });\n}\n\n/**\n * The attributed writes Keryx has not acknowledged for `doc`, oldest first: its room's, or what a\n * destroyed room left for the next. What a room's local copy keeps of them.\n */\nexport function unconfirmedAttributedWritesOf(doc: object): readonly AttributedWrites[] {\n  const { live, left } = rooms();\n  return live.get(doc)?.pending ?? left.get(doc)?.map(copyOf) ?? [];\n}\n\n/**\n * Hands `doc`'s room attributed writes an earlier session kept (the room's local copy), or keeps\n * them for the next tracker made for it. They are older than anything written since, so they go\n * out first.\n */\nexport function restoreUnconfirmedAttributedWrites({\n  doc,\n  writes,\n}: {\n  doc: object;\n  writes: readonly AttributedWrites[];\n}): void {\n  if (writes.length === 0) return;\n  const { live, left } = rooms();\n  const room = live.get(doc);\n  if (room) {\n    room.restore(writes);\n    return;\n  }\n  left.set(doc, bounded([...writes.map(copyOf), ...(left.get(doc) ?? [])]));\n}\n\n/**\n * The two above, as a page hands them to its local copies (`@athenaintel/local-copy`'s\n * `openLocalCopyStore({ attributedWrites })`, `createLocalCopiesPage({ attributedWrites })`): the\n * copy records a room's kept writes with its edits and restores an ended session's to its room.\n */\nexport const roomAttributedWrites = {\n  of: unconfirmedAttributedWritesOf,\n  restore: restoreUnconfirmedAttributedWrites,\n};\n\n/**\n * One room's attributed writes Keryx has not acknowledged (see the module comment). Made once per\n * room by its transport, which hands it to every socket it opens (`attributingWebSocket`'s\n * `unconfirmed`) and destroys it with the room; a tracker made for the same document later takes\n * over what it still kept, and what its local copy kept from an earlier session\n * ({@link restoreUnconfirmedAttributedWrites}). Not for a room that only listens: its socket sends\n * nothing to split.\n */\nexport class UnconfirmedUpdateAttributions implements UnconfirmedAttributedWrites, KeptWrites {\n  private runs: AttributedWrites[];\n  private readonly doc: Doc;\n  private readonly attributionsFor: () => readonly UpdateAttribution[] | undefined;\n  private readonly isRemoteOrigin: (origin: unknown) => boolean;\n\n  constructor({\n    doc,\n    attributionsFor,\n    isRemoteOrigin,\n  }: {\n    doc: Doc;\n    /** The attributions of the update being written now: what the socket's trailer reads. */\n    attributionsFor: () => readonly UpdateAttribution[] | undefined;\n    /** True for a transaction the transport applied (Keryx's state, a peer's edit). */\n    isRemoteOrigin: (origin: unknown) => boolean;\n  }) {\n    this.doc = doc;\n    this.attributionsFor = attributionsFor;\n    this.isRemoteOrigin = isRemoteOrigin;\n    const { live, left } = rooms();\n    this.runs = left.get(doc) ?? [];\n    left.delete(doc);\n    live.set(doc, this);\n    doc.on('update', this.handleUpdate);\n  }\n\n  private readonly handleUpdate = (update: Uint8Array, origin: unknown): void => {\n    if (this.isRemoteOrigin(origin)) return;\n    const attributions = this.attributionsFor();\n    if (!attributions || attributions.length === 0) return;\n    const ids = idsOf(update);\n    if (!ids || noIds(ids)) return;\n    const last = this.runs.at(-1);\n    if (last && sameAttributions(last.attributions, attributions)) {\n      last.ids = mergeContentIds([last.ids, ids]);\n      return;\n    }\n    this.runs = bounded([...this.runs, copyOf({ ids, attributions })]);\n  };\n\n  /** The attributed writes Keryx has not acknowledged, oldest first. */\n  get pending(): readonly AttributedWrites[] {\n    return this.runs.map(copyOf);\n  }\n\n  /** Writes an earlier session kept, older than any written here: they go out first. */\n  restore(writes: readonly AttributedWrites[]): void {\n    this.runs = bounded([...writes.map(copyOf), ...this.runs]);\n  }\n\n  /**\n   * One socket of the room. While the room keeps writes, the socket's sync step 2 (its answer to\n   * Keryx's sync step 1) waits for the next frame Keryx sends, its whole document, which drops what\n   * Keryx already holds before the answer is split (see the module comment); every frame sent\n   * meanwhile waits behind it, in order. Nothing kept, or a socket that cannot hear Keryx: every\n   * frame goes out as it is sent.\n   */\n  connect({\n    send,\n    hears,\n  }: {\n    send: (frame: Uint8Array) => void;\n    hears: boolean;\n  }): AttributedWritesSocket {\n    let held: Uint8Array[] | null = null;\n    const sendNow = (frame: Uint8Array) => {\n      for (const out of this.framesFor(frame)) send(out);\n    };\n    return {\n      received: (frame) => {\n        this.received(frame);\n        if (held === null) return;\n        const waiting = held;\n        held = null;\n        for (const next of waiting) sendNow(next);\n      },\n      send: (frame) => {\n        if (held !== null) {\n          held.push(frame);\n          return;\n        }\n        if (hears && this.runs.length > 0 && readSyncFrame(frame)?.syncType === SYNC_STEP_2) {\n          held = [frame];\n          return;\n        }\n        sendNow(frame);\n      },\n    };\n  }\n\n  /** Keryx sent `frame`: the ids it carries are Keryx's, kept no longer. */\n  received(frame: Uint8Array): void {\n    if (this.runs.length === 0) return;\n    const message = readSyncFrame(frame);\n    if (message === null) return;\n    if (message.syncType !== SYNC_STEP_2 && message.syncType !== SYNC_UPDATE) return;\n    const held = idsOf(message.payload);\n    if (!held) return;\n    this.runs = this.runs\n      .map(({ ids, attributions }) => ({ ids: excludeContentIds(ids, held), attributions }))\n      .filter((run) => !noIds(run.ids));\n  }\n\n  /**\n   * What goes out in place of `frame`: `[frame]` itself, except a sync step 2 carrying kept writes,\n   * which goes out behind each of them as its own marked sync update.\n   */\n  framesFor(frame: Uint8Array): readonly Uint8Array[] {\n    if (this.runs.length === 0) return [frame];\n    const message = readSyncFrame(frame);\n    if (message === null || message.syncType !== SYNC_STEP_2) return [frame];\n    const answer = message.payload;\n    const all = idsOf(answer);\n    if (!all) return [frame];\n    const frames: Uint8Array[] = [];\n    const marked: ContentIds[] = [];\n    for (const run of this.runs) {\n      const part = intersectContentIds(run.ids, all);\n      if (noIds(part)) continue;\n      frames.push(\n        withUpdateAttributionsTrailer({\n          message: syncFrame({\n            syncType: SYNC_UPDATE,\n            payload: intersectUpdateWithContentIds(answer, part),\n          }),\n          attributions: run.attributions,\n        })\n      );\n      marked.push(part);\n    }\n    if (marked.length === 0) return [frame];\n    const rest = excludeContentIds(all, mergeContentIds(marked));\n    frames.push(\n      syncFrame({ syncType: SYNC_STEP_2, payload: intersectUpdateWithContentIds(answer, rest) })\n    );\n    return frames;\n  }\n\n  /** Stops keeping; what is still kept waits for the next tracker made for the document. */\n  destroy(): void {\n    this.doc.off('update', this.handleUpdate);\n    const { live, left } = rooms();\n    if (live.get(this.doc) === this) live.delete(this.doc);\n    if (this.runs.length > 0) left.set(this.doc, this.runs);\n    this.runs = [];\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/keryx-http/src/update-attributions.cjs

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BACKGROUND_UPDATE_ATTRIBUTIONS = [
+  { k: "origin", v: "background" }
+];
+const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;
+const MESSAGE_SYNC = 0;
+const MESSAGE_SYNC_UPDATE = 2;
+const DOC_SCOPES = Symbol.for("@athenaintel/keryx-http/update-attribution-scopes");
+function docScopes() {
+  const host = globalThis;
+  return host[DOC_SCOPES] ?? (host[DOC_SCOPES] = /* @__PURE__ */ new WeakMap());
+}
+function runWithDocUpdateAttributions({
+  doc,
+  attributions,
+  run
+}) {
+  const scopes = docScopes();
+  const outer = scopes.get(doc);
+  scopes.set(doc, attributions);
+  try {
+    return run();
+  } finally {
+    if (outer === void 0) scopes.delete(doc);
+    else scopes.set(doc, outer);
+  }
+}
+function docUpdateAttributions(doc) {
+  return docScopes().get(doc);
+}
+function readVarUint({
+  bytes,
+  start
+}) {
+  let value = 0;
+  let multiplier = 1;
+  for (let pos = start; pos < bytes.length; pos += 1) {
+    const byte = bytes[pos];
+    if (byte === void 0) return null;
+    value += (byte & 127) * multiplier;
+    if (byte < 128) return { value, next: pos + 1 };
+    multiplier *= 128;
+    if (multiplier > Number.MAX_SAFE_INTEGER) return null;
+  }
+  return null;
+}
+function writeVarUint({ out, value }) {
+  let rest = value;
+  while (rest > 127) {
+    out.push(128 | rest % 128);
+    rest = Math.floor(rest / 128);
+  }
+  out.push(rest);
+}
+function isBareSyncUpdate(message) {
+  const type = readVarUint({ bytes: message, start: 0 });
+  if ((type == null ? void 0 : type.value) !== MESSAGE_SYNC) return false;
+  const syncType = readVarUint({ bytes: message, start: type.next });
+  if ((syncType == null ? void 0 : syncType.value) !== MESSAGE_SYNC_UPDATE) return false;
+  const length = readVarUint({ bytes: message, start: syncType.next });
+  return length !== null && length.next + length.value === message.length;
+}
+function withUpdateAttributionsTrailer({
+  message,
+  attributions
+}) {
+  if (attributions.length === 0 || !isBareSyncUpdate(message)) return message;
+  const trailer = [];
+  writeVarUint({ out: trailer, value: UPDATE_ATTRIBUTIONS_TRAILER_V1 });
+  writeVarUint({ out: trailer, value: attributions.length });
+  const utf8 = new TextEncoder();
+  for (const { k, v } of attributions) {
+    for (const text of [k, v]) {
+      const bytes = utf8.encode(text);
+      writeVarUint({ out: trailer, value: bytes.length });
+      for (const byte of bytes) trailer.push(byte);
+    }
+  }
+  const out = new Uint8Array(message.length + trailer.length);
+  out.set(message, 0);
+  out.set(trailer, message.length);
+  return out;
+}
+function receivedBytes(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data))
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return null;
+}
+function listenToFrames({
+  socket,
+  onFrame
+}) {
+  if (!("addEventListener" in socket) || typeof socket.addEventListener !== "function") {
+    return false;
+  }
+  socket.addEventListener("message", (event) => {
+    const frame = receivedBytes(event.data);
+    if (frame) onFrame(frame);
+  });
+  return true;
+}
+function attributingWebSocket({
+  Base,
+  attributionsFor,
+  unconfirmed
+}) {
+  if (typeof Base !== "function") return Base;
+  return new Proxy(Base, {
+    construct(target, args) {
+      const socket = Reflect.construct(target, args);
+      const send = socket.send.bind(socket);
+      let connection = null;
+      if (unconfirmed) {
+        const hears = listenToFrames({ socket, onFrame: (frame) => connection == null ? void 0 : connection.received(frame) });
+        connection = unconfirmed.connect({ send, hears });
+      }
+      socket.send = (data) => {
+        if (!(data instanceof Uint8Array)) {
+          send(data);
+          return;
+        }
+        const attributions = attributionsFor();
+        const message = attributions ? withUpdateAttributionsTrailer({ message: data, attributions }) : data;
+        if (connection) connection.send(message);
+        else send(message);
+      };
+      return socket;
+    }
+  });
+}
+exports.BACKGROUND_UPDATE_ATTRIBUTIONS = BACKGROUND_UPDATE_ATTRIBUTIONS;
+exports.UPDATE_ATTRIBUTIONS_TRAILER_V1 = UPDATE_ATTRIBUTIONS_TRAILER_V1;
+exports.attributingWebSocket = attributingWebSocket;
+exports.docUpdateAttributions = docUpdateAttributions;
+exports.readVarUint = readVarUint;
+exports.runWithDocUpdateAttributions = runWithDocUpdateAttributions;
+exports.withUpdateAttributionsTrailer = withUpdateAttributionsTrailer;
+exports.writeVarUint = writeVarUint;
+//# sourceMappingURL=update-attributions.cjs.map

package/dist/keryx-http/src/update-attributions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-attributions.cjs","sources":["../../../../keryx-http/src/update-attributions.ts"],"sourcesContent":["/**\n * Attributions one Keryx socket update carries of its own.\n *\n * A Keryx connection's attributions are fixed when its socket opens, so every update a client\n * sends is attributed to the person whose client it is. A write the client makes on its own (the\n * sheet leader re-issuing `=AOP` formulas or re-pushing `=IMPORTRANGE` values, a restored result,\n * an editor binding re-keying what an older binding stored) read as that person's edit and woke\n * \"people only\" subscriptions. Keryx reads a trailer after the update in a sync update message\n * (`readUpdateAttributions` in `patches/@y%2Fhub@0.10.1.patch`): `varUint(1)`, `varUint(n)`, then\n * `n` pairs of `varString` key and value. It accepts only `origin: background`, which it counts as\n * system work (`actorOf` in `keryx/src/compaction-activity.ts`), and the pairs that name a Quick\n * Edit step (`@athenaintel/keryx-http/quick-edit`: `session_id`/`run_kind` on the apply,\n * `quick_edit_undo`/`quick_edit_redo` with `quick_edit_op` on an undo or redo), each value in\n * exactly its shape. A Keryx without that hunk reads the update and ignores the bytes after it, so\n * a trailer never costs an update; a pair it does not allow is dropped and the rest kept.\n *\n * A writer marks its writes by making them inside {@link runWithDocUpdateAttributions} for the\n * doc; the transport's socket ({@link attributingWebSocket}) appends the trailer to each sync\n * update it sends while that scope is open. Both Keryx transports wrap their sockets with it:\n * Olympus's rooms (`KeryxYjsProviderV14`) and `@athenaintel/react/collab`'s `connectGenericDoc`\n * (Midas, the phone's editor page). y-websocket sends a local update from inside the doc's\n * `update` event, which fires inside the write itself, so the trailer always rides on the update\n * the scope wrote. A write made while the socket is closed is not sent then: it reaches Keryx in\n * the reconnect's sync step 2, which can carry no trailer. A transport that hands its socket the\n * room's {@link UnconfirmedAttributedWrites} (`@athenaintel/keryx-http/unconfirmed-update-attributions`)\n * sends each such write ahead of that sync step 2 as its own marked update; without one it stays\n * the person's.\n */\n\n/** One custom attribution, as Keryx stores it on the items an update wrote. */\nexport interface UpdateAttribution {\n  k: string;\n  v: string;\n}\n\n/** The pair a housekeeping write carries; Agora and Keryx spell it the same way. */\nexport const BACKGROUND_UPDATE_ATTRIBUTIONS: readonly UpdateAttribution[] = [\n  { k: 'origin', v: 'background' },\n];\n\n/** The trailer format Keryx reads (`updateAttributionsTrailerV1`). */\nexport const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;\n\n/** y-protocols: a sync message, and its update sub-type. */\nconst MESSAGE_SYNC = 0;\nconst MESSAGE_SYNC_UPDATE = 2;\n\n/**\n * The open scopes live on `globalThis`, not in module scope, because two copies of this module can\n * run in one page: `@athenaintel/react` bundles it into its dist (this package is private, so the\n * published SDK must inline it) while a host may import it from this package. A scope a writer\n * opens through one copy must be the one the transport's socket reads through the other.\n */\nconst DOC_SCOPES = Symbol.for('@athenaintel/keryx-http/update-attribution-scopes');\n\ntype DocScopesHost = typeof globalThis & {\n  [DOC_SCOPES]?: WeakMap<object, readonly UpdateAttribution[]>;\n};\n\n// process-local: browser-only scopes, each keyed by the doc it guards and cleared in the same synchronous call that set it\nfunction docScopes(): WeakMap<object, readonly UpdateAttribution[]> {\n  const host = globalThis as DocScopesHost;\n  return (host[DOC_SCOPES] ??= new WeakMap());\n}\n\n/**\n * Run `run` with every update it writes into `doc` marked with `attributions`. Synchronous only:\n * the scope ends when `run` returns. Nested scopes restore the outer one.\n */\nexport function runWithDocUpdateAttributions<T>({\n  doc,\n  attributions,\n  run,\n}: {\n  doc: object;\n  attributions: readonly UpdateAttribution[];\n  run: () => T;\n}): T {\n  const scopes = docScopes();\n  const outer = scopes.get(doc);\n  scopes.set(doc, attributions);\n  try {\n    return run();\n  } finally {\n    if (outer === undefined) scopes.delete(doc);\n    else scopes.set(doc, outer);\n  }\n}\n\n/** The attributions the update being written into `doc` right now carries, if any. */\nexport function docUpdateAttributions(doc: object): readonly UpdateAttribution[] | undefined {\n  return docScopes().get(doc);\n}\n\n/** The lib0 varUint at `start` in `bytes` and where the next field begins; `null` past the end. */\nexport function readVarUint({\n  bytes,\n  start,\n}: {\n  bytes: Uint8Array;\n  start: number;\n}): { value: number; next: number } | null {\n  let value = 0;\n  let multiplier = 1;\n  for (let pos = start; pos < bytes.length; pos += 1) {\n    const byte = bytes[pos];\n    if (byte === undefined) return null;\n    value += (byte & 0x7f) * multiplier;\n    if (byte < 0x80) return { value, next: pos + 1 };\n    multiplier *= 0x80;\n    if (multiplier > Number.MAX_SAFE_INTEGER) return null;\n  }\n  return null;\n}\n\n/** Append `value` to `out` as a lib0 varUint. */\nexport function writeVarUint({ out, value }: { out: number[]; value: number }): void {\n  let rest = value;\n  while (rest > 0x7f) {\n    out.push(0x80 | (rest % 0x80));\n    rest = Math.floor(rest / 0x80);\n  }\n  out.push(rest);\n}\n\n/** Exactly one sync update message, with nothing after the update. */\nfunction isBareSyncUpdate(message: Uint8Array): boolean {\n  const type = readVarUint({ bytes: message, start: 0 });\n  if (type?.value !== MESSAGE_SYNC) return false;\n  const syncType = readVarUint({ bytes: message, start: type.next });\n  if (syncType?.value !== MESSAGE_SYNC_UPDATE) return false;\n  const length = readVarUint({ bytes: message, start: syncType.next });\n  return length !== null && length.next + length.value === message.length;\n}\n\n/**\n * `message` with the trailer for `attributions` appended, when it is a bare sync update message;\n * any other message (sync step 1 or 2, awareness, one that already ends in a trailer) is returned\n * as it is.\n */\nexport function withUpdateAttributionsTrailer({\n  message,\n  attributions,\n}: {\n  message: Uint8Array;\n  attributions: readonly UpdateAttribution[];\n}): Uint8Array {\n  if (attributions.length === 0 || !isBareSyncUpdate(message)) return message;\n  const trailer: number[] = [];\n  writeVarUint({ out: trailer, value: UPDATE_ATTRIBUTIONS_TRAILER_V1 });\n  writeVarUint({ out: trailer, value: attributions.length });\n  const utf8 = new TextEncoder();\n  for (const { k, v } of attributions) {\n    for (const text of [k, v]) {\n      const bytes = utf8.encode(text);\n      writeVarUint({ out: trailer, value: bytes.length });\n      for (const byte of bytes) trailer.push(byte);\n    }\n  }\n  const out = new Uint8Array(message.length + trailer.length);\n  out.set(message, 0);\n  out.set(trailer, message.length);\n  return out;\n}\n\n/** What {@link attributingWebSocket} needs of a socket: the `send` y-websocket writes frames with. */\nexport interface SendingSocket {\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;\n}\n\n/** One socket of a room, as the room's attributed writes Keryx has not acknowledged see it. */\nexport interface AttributedWritesSocket {\n  /** Keryx sent `frame` on the socket: what it carries, Keryx holds. */\n  received(frame: Uint8Array): void;\n  /** The socket sends `frame` (now, or once Keryx has sent what it holds; see the implementation). */\n  send(frame: Uint8Array): void;\n}\n\n/**\n * The room's attributed writes Keryx has not acknowledged yet, as its sockets see them\n * (`UnconfirmedUpdateAttributions` in `@athenaintel/keryx-http/unconfirmed-update-attributions`).\n */\nexport interface UnconfirmedAttributedWrites {\n  /**\n   * A socket opened, sending through `send`. `hears`: the socket hands it every frame Keryx sends\n   * (`received`), ahead of the transport.\n   */\n  connect(params: { send: (frame: Uint8Array) => void; hears: boolean }): AttributedWritesSocket;\n}\n\n/** The bytes of a binary frame a socket received, or `null` for one that is not (a string, a `Blob`). */\nfunction receivedBytes(data: unknown): Uint8Array | null {\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  if (ArrayBuffer.isView(data))\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  return null;\n}\n\n/**\n * Hands `onFrame` every binary frame `socket` receives; whether it can. A listener added before\n * y-websocket sets `onmessage` runs ahead of it. A socket without `addEventListener` hands nothing.\n */\nfunction listenToFrames({\n  socket,\n  onFrame,\n}: {\n  socket: SendingSocket;\n  onFrame: (frame: Uint8Array) => void;\n}): boolean {\n  if (!('addEventListener' in socket) || typeof socket.addEventListener !== 'function') {\n    return false;\n  }\n  socket.addEventListener('message', (event: { data?: unknown }) => {\n    const frame = receivedBytes(event.data);\n    if (frame) onFrame(frame);\n  });\n  return true;\n}\n\n/**\n * `Base` with `send` appending the trailer of `attributionsFor()` to each sync update it sends.\n * With the room's `unconfirmed` attributed writes, each socket also tells them every frame Keryx\n * sends and sends its frames through them, so a sync step 2 goes out behind the kept writes it\n * carries. A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's\n * `WebSocketPolyfill`.\n */\nexport function attributingWebSocket<TBase extends new (...args: never[]) => SendingSocket>({\n  Base,\n  attributionsFor,\n  unconfirmed,\n}: {\n  Base: TBase;\n  attributionsFor: () => readonly UpdateAttribution[] | undefined;\n  unconfirmed?: UnconfirmedAttributedWrites;\n}): TBase {\n  // No WebSocket where the provider is built (server render, a test without one): nothing to wrap,\n  // and the transport fails at connect as it always did.\n  if (typeof Base !== 'function') return Base;\n  return new Proxy(Base, {\n    construct(target, args) {\n      const socket: SendingSocket = Reflect.construct(target, args);\n      const send = socket.send.bind(socket);\n      let connection: AttributedWritesSocket | null = null;\n      if (unconfirmed) {\n        const hears = listenToFrames({ socket, onFrame: (frame) => connection?.received(frame) });\n        connection = unconfirmed.connect({ send, hears });\n      }\n      socket.send = (data) => {\n        if (!(data instanceof Uint8Array)) {\n          send(data);\n          return;\n        }\n        const attributions = attributionsFor();\n        const message = attributions\n          ? withUpdateAttributionsTrailer({ message: data, attributions })\n          : data;\n        if (connection) connection.send(message);\n        else send(message);\n      };\n      return socket;\n    },\n  });\n}\n"],"names":[],"mappings":"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"}

package/dist/keryx-http/src/update-attributions.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Attributions one Keryx socket update carries of its own.
+ *
+ * A Keryx connection's attributions are fixed when its socket opens, so every update a client
+ * sends is attributed to the person whose client it is. A write the client makes on its own (the
+ * sheet leader re-issuing `=AOP` formulas or re-pushing `=IMPORTRANGE` values, a restored result,
+ * an editor binding re-keying what an older binding stored) read as that person's edit and woke
+ * "people only" subscriptions. Keryx reads a trailer after the update in a sync update message
+ * (`readUpdateAttributions` in `patches/@y%2Fhub@0.10.1.patch`): `varUint(1)`, `varUint(n)`, then
+ * `n` pairs of `varString` key and value. It accepts only `origin: background`, which it counts as
+ * system work (`actorOf` in `keryx/src/compaction-activity.ts`), and the pairs that name a Quick
+ * Edit step (`@athenaintel/keryx-http/quick-edit`: `session_id`/`run_kind` on the apply,
+ * `quick_edit_undo`/`quick_edit_redo` with `quick_edit_op` on an undo or redo), each value in
+ * exactly its shape. A Keryx without that hunk reads the update and ignores the bytes after it, so
+ * a trailer never costs an update; a pair it does not allow is dropped and the rest kept.
+ *
+ * A writer marks its writes by making them inside {@link runWithDocUpdateAttributions} for the
+ * doc; the transport's socket ({@link attributingWebSocket}) appends the trailer to each sync
+ * update it sends while that scope is open. Both Keryx transports wrap their sockets with it:
+ * Olympus's rooms (`KeryxYjsProviderV14`) and `@athenaintel/react/collab`'s `connectGenericDoc`
+ * (Midas, the phone's editor page). y-websocket sends a local update from inside the doc's
+ * `update` event, which fires inside the write itself, so the trailer always rides on the update
+ * the scope wrote. A write made while the socket is closed is not sent then: it reaches Keryx in
+ * the reconnect's sync step 2, which can carry no trailer. A transport that hands its socket the
+ * room's {@link UnconfirmedAttributedWrites} (`@athenaintel/keryx-http/unconfirmed-update-attributions`)
+ * sends each such write ahead of that sync step 2 as its own marked update; without one it stays
+ * the person's.
+ */
+/** One custom attribution, as Keryx stores it on the items an update wrote. */
+export interface UpdateAttribution {
+    k: string;
+    v: string;
+}
+/** The pair a housekeeping write carries; Agora and Keryx spell it the same way. */
+export declare const BACKGROUND_UPDATE_ATTRIBUTIONS: readonly UpdateAttribution[];
+/** The trailer format Keryx reads (`updateAttributionsTrailerV1`). */
+export declare const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;
+/**
+ * Run `run` with every update it writes into `doc` marked with `attributions`. Synchronous only:
+ * the scope ends when `run` returns. Nested scopes restore the outer one.
+ */
+export declare function runWithDocUpdateAttributions<T>({ doc, attributions, run, }: {
+    doc: object;
+    attributions: readonly UpdateAttribution[];
+    run: () => T;
+}): T;
+/** The attributions the update being written into `doc` right now carries, if any. */
+export declare function docUpdateAttributions(doc: object): readonly UpdateAttribution[] | undefined;
+/** The lib0 varUint at `start` in `bytes` and where the next field begins; `null` past the end. */
+export declare function readVarUint({ bytes, start, }: {
+    bytes: Uint8Array;
+    start: number;
+}): {
+    value: number;
+    next: number;
+} | null;
+/** Append `value` to `out` as a lib0 varUint. */
+export declare function writeVarUint({ out, value }: {
+    out: number[];
+    value: number;
+}): void;
+/**
+ * `message` with the trailer for `attributions` appended, when it is a bare sync update message;
+ * any other message (sync step 1 or 2, awareness, one that already ends in a trailer) is returned
+ * as it is.
+ */
+export declare function withUpdateAttributionsTrailer({ message, attributions, }: {
+    message: Uint8Array;
+    attributions: readonly UpdateAttribution[];
+}): Uint8Array;
+/** What {@link attributingWebSocket} needs of a socket: the `send` y-websocket writes frames with. */
+export interface SendingSocket {
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+}
+/** One socket of a room, as the room's attributed writes Keryx has not acknowledged see it. */
+export interface AttributedWritesSocket {
+    /** Keryx sent `frame` on the socket: what it carries, Keryx holds. */
+    received(frame: Uint8Array): void;
+    /** The socket sends `frame` (now, or once Keryx has sent what it holds; see the implementation). */
+    send(frame: Uint8Array): void;
+}
+/**
+ * The room's attributed writes Keryx has not acknowledged yet, as its sockets see them
+ * (`UnconfirmedUpdateAttributions` in `@athenaintel/keryx-http/unconfirmed-update-attributions`).
+ */
+export interface UnconfirmedAttributedWrites {
+    /**
+     * A socket opened, sending through `send`. `hears`: the socket hands it every frame Keryx sends
+     * (`received`), ahead of the transport.
+     */
+    connect(params: {
+        send: (frame: Uint8Array) => void;
+        hears: boolean;
+    }): AttributedWritesSocket;
+}
+/**
+ * `Base` with `send` appending the trailer of `attributionsFor()` to each sync update it sends.
+ * With the room's `unconfirmed` attributed writes, each socket also tells them every frame Keryx
+ * sends and sends its frames through them, so a sync step 2 goes out behind the kept writes it
+ * carries. A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's
+ * `WebSocketPolyfill`.
+ */
+export declare function attributingWebSocket<TBase extends new (...args: never[]) => SendingSocket>({ Base, attributionsFor, unconfirmed, }: {
+    Base: TBase;
+    attributionsFor: () => readonly UpdateAttribution[] | undefined;
+    unconfirmed?: UnconfirmedAttributedWrites;
+}): TBase;

package/dist/keryx-http/src/update-attributions.js

@@ -0,0 +1,141 @@
+const BACKGROUND_UPDATE_ATTRIBUTIONS = [
+  { k: "origin", v: "background" }
+];
+const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;
+const MESSAGE_SYNC = 0;
+const MESSAGE_SYNC_UPDATE = 2;
+const DOC_SCOPES = Symbol.for("@athenaintel/keryx-http/update-attribution-scopes");
+function docScopes() {
+  const host = globalThis;
+  return host[DOC_SCOPES] ?? (host[DOC_SCOPES] = /* @__PURE__ */ new WeakMap());
+}
+function runWithDocUpdateAttributions({
+  doc,
+  attributions,
+  run
+}) {
+  const scopes = docScopes();
+  const outer = scopes.get(doc);
+  scopes.set(doc, attributions);
+  try {
+    return run();
+  } finally {
+    if (outer === void 0) scopes.delete(doc);
+    else scopes.set(doc, outer);
+  }
+}
+function docUpdateAttributions(doc) {
+  return docScopes().get(doc);
+}
+function readVarUint({
+  bytes,
+  start
+}) {
+  let value = 0;
+  let multiplier = 1;
+  for (let pos = start; pos < bytes.length; pos += 1) {
+    const byte = bytes[pos];
+    if (byte === void 0) return null;
+    value += (byte & 127) * multiplier;
+    if (byte < 128) return { value, next: pos + 1 };
+    multiplier *= 128;
+    if (multiplier > Number.MAX_SAFE_INTEGER) return null;
+  }
+  return null;
+}
+function writeVarUint({ out, value }) {
+  let rest = value;
+  while (rest > 127) {
+    out.push(128 | rest % 128);
+    rest = Math.floor(rest / 128);
+  }
+  out.push(rest);
+}
+function isBareSyncUpdate(message) {
+  const type = readVarUint({ bytes: message, start: 0 });
+  if ((type == null ? void 0 : type.value) !== MESSAGE_SYNC) return false;
+  const syncType = readVarUint({ bytes: message, start: type.next });
+  if ((syncType == null ? void 0 : syncType.value) !== MESSAGE_SYNC_UPDATE) return false;
+  const length = readVarUint({ bytes: message, start: syncType.next });
+  return length !== null && length.next + length.value === message.length;
+}
+function withUpdateAttributionsTrailer({
+  message,
+  attributions
+}) {
+  if (attributions.length === 0 || !isBareSyncUpdate(message)) return message;
+  const trailer = [];
+  writeVarUint({ out: trailer, value: UPDATE_ATTRIBUTIONS_TRAILER_V1 });
+  writeVarUint({ out: trailer, value: attributions.length });
+  const utf8 = new TextEncoder();
+  for (const { k, v } of attributions) {
+    for (const text of [k, v]) {
+      const bytes = utf8.encode(text);
+      writeVarUint({ out: trailer, value: bytes.length });
+      for (const byte of bytes) trailer.push(byte);
+    }
+  }
+  const out = new Uint8Array(message.length + trailer.length);
+  out.set(message, 0);
+  out.set(trailer, message.length);
+  return out;
+}
+function receivedBytes(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data))
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return null;
+}
+function listenToFrames({
+  socket,
+  onFrame
+}) {
+  if (!("addEventListener" in socket) || typeof socket.addEventListener !== "function") {
+    return false;
+  }
+  socket.addEventListener("message", (event) => {
+    const frame = receivedBytes(event.data);
+    if (frame) onFrame(frame);
+  });
+  return true;
+}
+function attributingWebSocket({
+  Base,
+  attributionsFor,
+  unconfirmed
+}) {
+  if (typeof Base !== "function") return Base;
+  return new Proxy(Base, {
+    construct(target, args) {
+      const socket = Reflect.construct(target, args);
+      const send = socket.send.bind(socket);
+      let connection = null;
+      if (unconfirmed) {
+        const hears = listenToFrames({ socket, onFrame: (frame) => connection == null ? void 0 : connection.received(frame) });
+        connection = unconfirmed.connect({ send, hears });
+      }
+      socket.send = (data) => {
+        if (!(data instanceof Uint8Array)) {
+          send(data);
+          return;
+        }
+        const attributions = attributionsFor();
+        const message = attributions ? withUpdateAttributionsTrailer({ message: data, attributions }) : data;
+        if (connection) connection.send(message);
+        else send(message);
+      };
+      return socket;
+    }
+  });
+}
+export {
+  BACKGROUND_UPDATE_ATTRIBUTIONS,
+  UPDATE_ATTRIBUTIONS_TRAILER_V1,
+  attributingWebSocket,
+  docUpdateAttributions,
+  readVarUint,
+  runWithDocUpdateAttributions,
+  withUpdateAttributionsTrailer,
+  writeVarUint
+};
+//# sourceMappingURL=update-attributions.js.map

package/dist/keryx-http/src/update-attributions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-attributions.js","sources":["../../../../keryx-http/src/update-attributions.ts"],"sourcesContent":["/**\n * Attributions one Keryx socket update carries of its own.\n *\n * A Keryx connection's attributions are fixed when its socket opens, so every update a client\n * sends is attributed to the person whose client it is. A write the client makes on its own (the\n * sheet leader re-issuing `=AOP` formulas or re-pushing `=IMPORTRANGE` values, a restored result,\n * an editor binding re-keying what an older binding stored) read as that person's edit and woke\n * \"people only\" subscriptions. Keryx reads a trailer after the update in a sync update message\n * (`readUpdateAttributions` in `patches/@y%2Fhub@0.10.1.patch`): `varUint(1)`, `varUint(n)`, then\n * `n` pairs of `varString` key and value. It accepts only `origin: background`, which it counts as\n * system work (`actorOf` in `keryx/src/compaction-activity.ts`), and the pairs that name a Quick\n * Edit step (`@athenaintel/keryx-http/quick-edit`: `session_id`/`run_kind` on the apply,\n * `quick_edit_undo`/`quick_edit_redo` with `quick_edit_op` on an undo or redo), each value in\n * exactly its shape. A Keryx without that hunk reads the update and ignores the bytes after it, so\n * a trailer never costs an update; a pair it does not allow is dropped and the rest kept.\n *\n * A writer marks its writes by making them inside {@link runWithDocUpdateAttributions} for the\n * doc; the transport's socket ({@link attributingWebSocket}) appends the trailer to each sync\n * update it sends while that scope is open. Both Keryx transports wrap their sockets with it:\n * Olympus's rooms (`KeryxYjsProviderV14`) and `@athenaintel/react/collab`'s `connectGenericDoc`\n * (Midas, the phone's editor page). y-websocket sends a local update from inside the doc's\n * `update` event, which fires inside the write itself, so the trailer always rides on the update\n * the scope wrote. A write made while the socket is closed is not sent then: it reaches Keryx in\n * the reconnect's sync step 2, which can carry no trailer. A transport that hands its socket the\n * room's {@link UnconfirmedAttributedWrites} (`@athenaintel/keryx-http/unconfirmed-update-attributions`)\n * sends each such write ahead of that sync step 2 as its own marked update; without one it stays\n * the person's.\n */\n\n/** One custom attribution, as Keryx stores it on the items an update wrote. */\nexport interface UpdateAttribution {\n  k: string;\n  v: string;\n}\n\n/** The pair a housekeeping write carries; Agora and Keryx spell it the same way. */\nexport const BACKGROUND_UPDATE_ATTRIBUTIONS: readonly UpdateAttribution[] = [\n  { k: 'origin', v: 'background' },\n];\n\n/** The trailer format Keryx reads (`updateAttributionsTrailerV1`). */\nexport const UPDATE_ATTRIBUTIONS_TRAILER_V1 = 1;\n\n/** y-protocols: a sync message, and its update sub-type. */\nconst MESSAGE_SYNC = 0;\nconst MESSAGE_SYNC_UPDATE = 2;\n\n/**\n * The open scopes live on `globalThis`, not in module scope, because two copies of this module can\n * run in one page: `@athenaintel/react` bundles it into its dist (this package is private, so the\n * published SDK must inline it) while a host may import it from this package. A scope a writer\n * opens through one copy must be the one the transport's socket reads through the other.\n */\nconst DOC_SCOPES = Symbol.for('@athenaintel/keryx-http/update-attribution-scopes');\n\ntype DocScopesHost = typeof globalThis & {\n  [DOC_SCOPES]?: WeakMap<object, readonly UpdateAttribution[]>;\n};\n\n// process-local: browser-only scopes, each keyed by the doc it guards and cleared in the same synchronous call that set it\nfunction docScopes(): WeakMap<object, readonly UpdateAttribution[]> {\n  const host = globalThis as DocScopesHost;\n  return (host[DOC_SCOPES] ??= new WeakMap());\n}\n\n/**\n * Run `run` with every update it writes into `doc` marked with `attributions`. Synchronous only:\n * the scope ends when `run` returns. Nested scopes restore the outer one.\n */\nexport function runWithDocUpdateAttributions<T>({\n  doc,\n  attributions,\n  run,\n}: {\n  doc: object;\n  attributions: readonly UpdateAttribution[];\n  run: () => T;\n}): T {\n  const scopes = docScopes();\n  const outer = scopes.get(doc);\n  scopes.set(doc, attributions);\n  try {\n    return run();\n  } finally {\n    if (outer === undefined) scopes.delete(doc);\n    else scopes.set(doc, outer);\n  }\n}\n\n/** The attributions the update being written into `doc` right now carries, if any. */\nexport function docUpdateAttributions(doc: object): readonly UpdateAttribution[] | undefined {\n  return docScopes().get(doc);\n}\n\n/** The lib0 varUint at `start` in `bytes` and where the next field begins; `null` past the end. */\nexport function readVarUint({\n  bytes,\n  start,\n}: {\n  bytes: Uint8Array;\n  start: number;\n}): { value: number; next: number } | null {\n  let value = 0;\n  let multiplier = 1;\n  for (let pos = start; pos < bytes.length; pos += 1) {\n    const byte = bytes[pos];\n    if (byte === undefined) return null;\n    value += (byte & 0x7f) * multiplier;\n    if (byte < 0x80) return { value, next: pos + 1 };\n    multiplier *= 0x80;\n    if (multiplier > Number.MAX_SAFE_INTEGER) return null;\n  }\n  return null;\n}\n\n/** Append `value` to `out` as a lib0 varUint. */\nexport function writeVarUint({ out, value }: { out: number[]; value: number }): void {\n  let rest = value;\n  while (rest > 0x7f) {\n    out.push(0x80 | (rest % 0x80));\n    rest = Math.floor(rest / 0x80);\n  }\n  out.push(rest);\n}\n\n/** Exactly one sync update message, with nothing after the update. */\nfunction isBareSyncUpdate(message: Uint8Array): boolean {\n  const type = readVarUint({ bytes: message, start: 0 });\n  if (type?.value !== MESSAGE_SYNC) return false;\n  const syncType = readVarUint({ bytes: message, start: type.next });\n  if (syncType?.value !== MESSAGE_SYNC_UPDATE) return false;\n  const length = readVarUint({ bytes: message, start: syncType.next });\n  return length !== null && length.next + length.value === message.length;\n}\n\n/**\n * `message` with the trailer for `attributions` appended, when it is a bare sync update message;\n * any other message (sync step 1 or 2, awareness, one that already ends in a trailer) is returned\n * as it is.\n */\nexport function withUpdateAttributionsTrailer({\n  message,\n  attributions,\n}: {\n  message: Uint8Array;\n  attributions: readonly UpdateAttribution[];\n}): Uint8Array {\n  if (attributions.length === 0 || !isBareSyncUpdate(message)) return message;\n  const trailer: number[] = [];\n  writeVarUint({ out: trailer, value: UPDATE_ATTRIBUTIONS_TRAILER_V1 });\n  writeVarUint({ out: trailer, value: attributions.length });\n  const utf8 = new TextEncoder();\n  for (const { k, v } of attributions) {\n    for (const text of [k, v]) {\n      const bytes = utf8.encode(text);\n      writeVarUint({ out: trailer, value: bytes.length });\n      for (const byte of bytes) trailer.push(byte);\n    }\n  }\n  const out = new Uint8Array(message.length + trailer.length);\n  out.set(message, 0);\n  out.set(trailer, message.length);\n  return out;\n}\n\n/** What {@link attributingWebSocket} needs of a socket: the `send` y-websocket writes frames with. */\nexport interface SendingSocket {\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;\n}\n\n/** One socket of a room, as the room's attributed writes Keryx has not acknowledged see it. */\nexport interface AttributedWritesSocket {\n  /** Keryx sent `frame` on the socket: what it carries, Keryx holds. */\n  received(frame: Uint8Array): void;\n  /** The socket sends `frame` (now, or once Keryx has sent what it holds; see the implementation). */\n  send(frame: Uint8Array): void;\n}\n\n/**\n * The room's attributed writes Keryx has not acknowledged yet, as its sockets see them\n * (`UnconfirmedUpdateAttributions` in `@athenaintel/keryx-http/unconfirmed-update-attributions`).\n */\nexport interface UnconfirmedAttributedWrites {\n  /**\n   * A socket opened, sending through `send`. `hears`: the socket hands it every frame Keryx sends\n   * (`received`), ahead of the transport.\n   */\n  connect(params: { send: (frame: Uint8Array) => void; hears: boolean }): AttributedWritesSocket;\n}\n\n/** The bytes of a binary frame a socket received, or `null` for one that is not (a string, a `Blob`). */\nfunction receivedBytes(data: unknown): Uint8Array | null {\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  if (ArrayBuffer.isView(data))\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  return null;\n}\n\n/**\n * Hands `onFrame` every binary frame `socket` receives; whether it can. A listener added before\n * y-websocket sets `onmessage` runs ahead of it. A socket without `addEventListener` hands nothing.\n */\nfunction listenToFrames({\n  socket,\n  onFrame,\n}: {\n  socket: SendingSocket;\n  onFrame: (frame: Uint8Array) => void;\n}): boolean {\n  if (!('addEventListener' in socket) || typeof socket.addEventListener !== 'function') {\n    return false;\n  }\n  socket.addEventListener('message', (event: { data?: unknown }) => {\n    const frame = receivedBytes(event.data);\n    if (frame) onFrame(frame);\n  });\n  return true;\n}\n\n/**\n * `Base` with `send` appending the trailer of `attributionsFor()` to each sync update it sends.\n * With the room's `unconfirmed` attributed writes, each socket also tells them every frame Keryx\n * sends and sends its frames through them, so a sync step 2 goes out behind the kept writes it\n * carries. A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's\n * `WebSocketPolyfill`.\n */\nexport function attributingWebSocket<TBase extends new (...args: never[]) => SendingSocket>({\n  Base,\n  attributionsFor,\n  unconfirmed,\n}: {\n  Base: TBase;\n  attributionsFor: () => readonly UpdateAttribution[] | undefined;\n  unconfirmed?: UnconfirmedAttributedWrites;\n}): TBase {\n  // No WebSocket where the provider is built (server render, a test without one): nothing to wrap,\n  // and the transport fails at connect as it always did.\n  if (typeof Base !== 'function') return Base;\n  return new Proxy(Base, {\n    construct(target, args) {\n      const socket: SendingSocket = Reflect.construct(target, args);\n      const send = socket.send.bind(socket);\n      let connection: AttributedWritesSocket | null = null;\n      if (unconfirmed) {\n        const hears = listenToFrames({ socket, onFrame: (frame) => connection?.received(frame) });\n        connection = unconfirmed.connect({ send, hears });\n      }\n      socket.send = (data) => {\n        if (!(data instanceof Uint8Array)) {\n          send(data);\n          return;\n        }\n        const attributions = attributionsFor();\n        const message = attributions\n          ? withUpdateAttributionsTrailer({ message: data, attributions })\n          : data;\n        if (connection) connection.send(message);\n        else send(message);\n      };\n      return socket;\n    },\n  });\n}\n"],"names":[],"mappings":"AAoCO,MAAM,iCAA+D;AAAA,EAC1E,EAAE,GAAG,UAAU,GAAG,aAAA;AACpB;AAGO,MAAM,iCAAiC;AAG9C,MAAM,eAAe;AACrB,MAAM,sBAAsB;AAQ5B,MAAM,aAAa,OAAO,IAAI,mDAAmD;AAOjF,SAAS,YAA2D;AAClE,QAAM,OAAO;AACb,SAAQ,wCAAqB,oBAAI,QAAA;AACnC;AAMO,SAAS,6BAAgC;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AACF,GAIM;AACJ,QAAM,SAAS,UAAA;AACf,QAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,SAAO,IAAI,KAAK,YAAY;AAC5B,MAAI;AACF,WAAO,IAAA;AAAA,EACT,UAAA;AACE,QAAI,UAAU,OAAW,QAAO,OAAO,GAAG;AAAA,QACrC,QAAO,IAAI,KAAK,KAAK;AAAA,EAC5B;AACF;AAGO,SAAS,sBAAsB,KAAuD;AAC3F,SAAO,UAAA,EAAY,IAAI,GAAG;AAC5B;AAGO,SAAS,YAAY;AAAA,EAC1B;AAAA,EACA;AACF,GAG2C;AACzC,MAAI,QAAQ;AACZ,MAAI,aAAa;AACjB,WAAS,MAAM,OAAO,MAAM,MAAM,QAAQ,OAAO,GAAG;AAClD,UAAM,OAAO,MAAM,GAAG;AACtB,QAAI,SAAS,OAAW,QAAO;AAC/B,cAAU,OAAO,OAAQ;AACzB,QAAI,OAAO,IAAM,QAAO,EAAE,OAAO,MAAM,MAAM,EAAA;AAC7C,kBAAc;AACd,QAAI,aAAa,OAAO,iBAAkB,QAAO;AAAA,EACnD;AACA,SAAO;AACT;AAGO,SAAS,aAAa,EAAE,KAAK,SAAiD;AACnF,MAAI,OAAO;AACX,SAAO,OAAO,KAAM;AAClB,QAAI,KAAK,MAAQ,OAAO,GAAK;AAC7B,WAAO,KAAK,MAAM,OAAO,GAAI;AAAA,EAC/B;AACA,MAAI,KAAK,IAAI;AACf;AAGA,SAAS,iBAAiB,SAA8B;AACtD,QAAM,OAAO,YAAY,EAAE,OAAO,SAAS,OAAO,GAAG;AACrD,OAAI,6BAAM,WAAU,aAAc,QAAO;AACzC,QAAM,WAAW,YAAY,EAAE,OAAO,SAAS,OAAO,KAAK,MAAM;AACjE,OAAI,qCAAU,WAAU,oBAAqB,QAAO;AACpD,QAAM,SAAS,YAAY,EAAE,OAAO,SAAS,OAAO,SAAS,MAAM;AACnE,SAAO,WAAW,QAAQ,OAAO,OAAO,OAAO,UAAU,QAAQ;AACnE;AAOO,SAAS,8BAA8B;AAAA,EAC5C;AAAA,EACA;AACF,GAGe;AACb,MAAI,aAAa,WAAW,KAAK,CAAC,iBAAiB,OAAO,EAAG,QAAO;AACpE,QAAM,UAAoB,CAAA;AAC1B,eAAa,EAAE,KAAK,SAAS,OAAO,gCAAgC;AACpE,eAAa,EAAE,KAAK,SAAS,OAAO,aAAa,QAAQ;AACzD,QAAM,OAAO,IAAI,YAAA;AACjB,aAAW,EAAE,GAAG,EAAA,KAAO,cAAc;AACnC,eAAW,QAAQ,CAAC,GAAG,CAAC,GAAG;AACzB,YAAM,QAAQ,KAAK,OAAO,IAAI;AAC9B,mBAAa,EAAE,KAAK,SAAS,OAAO,MAAM,QAAQ;AAClD,iBAAW,QAAQ,MAAO,SAAQ,KAAK,IAAI;AAAA,IAC7C;AAAA,EACF;AACA,QAAM,MAAM,IAAI,WAAW,QAAQ,SAAS,QAAQ,MAAM;AAC1D,MAAI,IAAI,SAAS,CAAC;AAClB,MAAI,IAAI,SAAS,QAAQ,MAAM;AAC/B,SAAO;AACT;AA4BA,SAAS,cAAc,MAAkC;AACvD,MAAI,gBAAgB,YAAa,QAAO,IAAI,WAAW,IAAI;AAC3D,MAAI,YAAY,OAAO,IAAI;AACzB,WAAO,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;AACrE,SAAO;AACT;AAMA,SAAS,eAAe;AAAA,EACtB;AAAA,EACA;AACF,GAGY;AACV,MAAI,EAAE,sBAAsB,WAAW,OAAO,OAAO,qBAAqB,YAAY;AACpF,WAAO;AAAA,EACT;AACA,SAAO,iBAAiB,WAAW,CAAC,UAA8B;AAChE,UAAM,QAAQ,cAAc,MAAM,IAAI;AACtC,QAAI,eAAe,KAAK;AAAA,EAC1B,CAAC;AACD,SAAO;AACT;AASO,SAAS,qBAA4E;AAAA,EAC1F;AAAA,EACA;AAAA,EACA;AACF,GAIU;AAGR,MAAI,OAAO,SAAS,WAAY,QAAO;AACvC,SAAO,IAAI,MAAM,MAAM;AAAA,IACrB,UAAU,QAAQ,MAAM;AACtB,YAAM,SAAwB,QAAQ,UAAU,QAAQ,IAAI;AAC5D,YAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,UAAI,aAA4C;AAChD,UAAI,aAAa;AACf,cAAM,QAAQ,eAAe,EAAE,QAAQ,SAAS,CAAC,UAAU,yCAAY,SAAS,QAAQ;AACxF,qBAAa,YAAY,QAAQ,EAAE,MAAM,OAAO;AAAA,MAClD;AACA,aAAO,OAAO,CAAC,SAAS;AACtB,YAAI,EAAE,gBAAgB,aAAa;AACjC,eAAK,IAAI;AACT;AAAA,QACF;AACA,cAAM,eAAe,gBAAA;AACrB,cAAM,UAAU,eACZ,8BAA8B,EAAE,SAAS,MAAM,aAAA,CAAc,IAC7D;AACJ,YAAI,WAAY,YAAW,KAAK,OAAO;AAAA,kBAC7B,OAAO;AAAA,MACnB;AACA,aAAO;AAAA,IACT;AAAA,EAAA,CACD;AACH;"}

package/dist/lib/owner-document.cjs

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("react/jsx-runtime");
-const react = require("react");
-const OwnerDocumentContext = react.createContext(null);
+const require$$0 = require("react");
+const OwnerDocumentContext = require$$0.createContext(null);
 function OwnerDocumentProvider({ document: doc, children }) {
   return /* @__PURE__ */ jsxRuntime.jsx(OwnerDocumentContext.Provider, { value: doc, children });
 }
 function useOwnerDocument() {
-  const provided = react.useContext(OwnerDocumentContext);
+  const provided = require$$0.useContext(OwnerDocumentContext);
   if (provided) return provided;
   return typeof document !== "undefined" ? document : null;
 }
 function useIsInPopoutDocument() {
-  const provided = react.useContext(OwnerDocumentContext);
+  const provided = require$$0.useContext(OwnerDocumentContext);
   return provided !== null && typeof document !== "undefined" && provided !== document;
 }
 function usePortalContainer() {
-  const provided = react.useContext(OwnerDocumentContext);
-  return react.useMemo(() => {
+  const provided = require$$0.useContext(OwnerDocumentContext);
+  return require$$0.useMemo(() => {
     var _a;
     if (!provided) return void 0;
     if (typeof document !== "undefined" && provided === document) return void 0;

package/dist/lib/owner-document.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"owner-document.cjs","sources":["../../src/lib/owner-document.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, type ReactNode, useContext, useMemo } from 'react';\n\n/**\n * Which browser document a component is rendered into.\n *\n * A host pops a pane out by portaling it into a second browser window (Olympus's\n * Spaces popouts, a desktop shell's pop-out windows): the React tree keeps\n * running in the main window while its DOM lives in the popout's document.\n * Anything that reaches for the global `document` then talks to the wrong\n * window — most visibly Radix/shadcn portals, which mount menus, dialogs and\n * tooltips into the MAIN window's body while their trigger sits in the popout.\n *\n * `OwnerDocumentProvider` is mounted by the host around every popped-out\n * subtree (Olympus's Spaces popout frame wraps every tab and the popout\n * window's own layout chrome). The SDK's own portaled UI (popover, tooltip,\n * the composer's mention menu) and the host's portals read the same context.\n * In the main window nothing is provided and the hooks fall back to the\n * globals, with `usePortalContainer()` returning `undefined` so every library\n * keeps its default container.\n */\nconst OwnerDocumentContext = createContext<Document | null>(null);\n\nexport interface OwnerDocumentProviderProps {\n  /** The document hosting this subtree; `null` for the main window. */\n  document: Document | null;\n  children: ReactNode;\n}\n\nexport function OwnerDocumentProvider({ document: doc, children }: OwnerDocumentProviderProps) {\n  return <OwnerDocumentContext.Provider value={doc}>{children}</OwnerDocumentContext.Provider>;\n}\n\n/** The document this subtree renders into, or the global document when not in a popout. */\nexport function useOwnerDocument(): Document | null {\n  const provided = useContext(OwnerDocumentContext);\n  if (provided) return provided;\n  return typeof document !== 'undefined' ? document : null;\n}\n\n/** `true` when the subtree is hosted by a popout window rather than the main document. */\nexport function useIsInPopoutDocument(): boolean {\n  const provided = useContext(OwnerDocumentContext);\n  return provided !== null && typeof document !== 'undefined' && provided !== document;\n}\n\n/**\n * The `container` to hand a portal so it opens in the window its trigger is\n * in: the popout's `body`, or `undefined` in the main window so the library\n * default applies. Guards against a since-closed popout window.\n */\nexport function usePortalContainer(): HTMLElement | undefined {\n  const provided = useContext(OwnerDocumentContext);\n  return useMemo(() => {\n    if (!provided) return undefined;\n    if (typeof document !== 'undefined' && provided === document) return undefined;\n    if (provided.defaultView?.closed) return undefined;\n    return provided.body;\n  }, [provided]);\n}\n"],"names":["createContext","useContext","useMemo"],"mappings":";;;;AAsBA,MAAM,uBAAuBA,MAAAA,cAA+B,IAAI;AAQzD,SAAS,sBAAsB,EAAE,UAAU,KAAK,YAAwC;AAC7F,wCAAQ,qBAAqB,UAArB,EAA8B,OAAO,KAAM,UAAS;AAC9D;AAGO,SAAS,mBAAoC;AAClD,QAAM,WAAWC,MAAAA,WAAW,oBAAoB;AAChD,MAAI,SAAU,QAAO;AACrB,SAAO,OAAO,aAAa,cAAc,WAAW;AACtD;AAGO,SAAS,wBAAiC;AAC/C,QAAM,WAAWA,MAAAA,WAAW,oBAAoB;AAChD,SAAO,aAAa,QAAQ,OAAO,aAAa,eAAe,aAAa;AAC9E;AAOO,SAAS,qBAA8C;AAC5D,QAAM,WAAWA,MAAAA,WAAW,oBAAoB;AAChD,SAAOC,MAAAA,QAAQ,MAAM;;AACnB,QAAI,CAAC,SAAU,QAAO;AACtB,QAAI,OAAO,aAAa,eAAe,aAAa,SAAU,QAAO;AACrE,SAAI,cAAS,gBAAT,mBAAsB,OAAQ,QAAO;AACzC,WAAO,SAAS;AAAA,EAClB,GAAG,CAAC,QAAQ,CAAC;AACf;;;;;"}
+{"version":3,"file":"owner-document.cjs","sources":["../../src/lib/owner-document.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, type ReactNode, useContext, useMemo } from 'react';\n\n/**\n * Which browser document a component is rendered into.\n *\n * A host pops a pane out by portaling it into a second browser window (Olympus's\n * Spaces popouts, a desktop shell's pop-out windows): the React tree keeps\n * running in the main window while its DOM lives in the popout's document.\n * Anything that reaches for the global `document` then talks to the wrong\n * window — most visibly Radix/shadcn portals, which mount menus, dialogs and\n * tooltips into the MAIN window's body while their trigger sits in the popout.\n *\n * `OwnerDocumentProvider` is mounted by the host around every popped-out\n * subtree (Olympus's Spaces popout frame wraps every tab and the popout\n * window's own layout chrome). The SDK's own portaled UI (popover, tooltip,\n * the composer's mention menu) and the host's portals read the same context.\n * In the main window nothing is provided and the hooks fall back to the\n * globals, with `usePortalContainer()` returning `undefined` so every library\n * keeps its default container.\n */\nconst OwnerDocumentContext = createContext<Document | null>(null);\n\nexport interface OwnerDocumentProviderProps {\n  /** The document hosting this subtree; `null` for the main window. */\n  document: Document | null;\n  children: ReactNode;\n}\n\nexport function OwnerDocumentProvider({ document: doc, children }: OwnerDocumentProviderProps) {\n  return <OwnerDocumentContext.Provider value={doc}>{children}</OwnerDocumentContext.Provider>;\n}\n\n/** The document this subtree renders into, or the global document when not in a popout. */\nexport function useOwnerDocument(): Document | null {\n  const provided = useContext(OwnerDocumentContext);\n  if (provided) return provided;\n  return typeof document !== 'undefined' ? document : null;\n}\n\n/** `true` when the subtree is hosted by a popout window rather than the main document. */\nexport function useIsInPopoutDocument(): boolean {\n  const provided = useContext(OwnerDocumentContext);\n  return provided !== null && typeof document !== 'undefined' && provided !== document;\n}\n\n/**\n * The `container` to hand a portal so it opens in the window its trigger is\n * in: the popout's `body`, or `undefined` in the main window so the library\n * default applies. Guards against a since-closed popout window.\n */\nexport function usePortalContainer(): HTMLElement | undefined {\n  const provided = useContext(OwnerDocumentContext);\n  return useMemo(() => {\n    if (!provided) return undefined;\n    if (typeof document !== 'undefined' && provided === document) return undefined;\n    if (provided.defaultView?.closed) return undefined;\n    return provided.body;\n  }, [provided]);\n}\n"],"names":["createContext","useContext","useMemo"],"mappings":";;;;AAsBA,MAAM,uBAAuBA,WAAAA,cAA+B,IAAI;AAQzD,SAAS,sBAAsB,EAAE,UAAU,KAAK,YAAwC;AAC7F,wCAAQ,qBAAqB,UAArB,EAA8B,OAAO,KAAM,UAAS;AAC9D;AAGO,SAAS,mBAAoC;AAClD,QAAM,WAAWC,WAAAA,WAAW,oBAAoB;AAChD,MAAI,SAAU,QAAO;AACrB,SAAO,OAAO,aAAa,cAAc,WAAW;AACtD;AAGO,SAAS,wBAAiC;AAC/C,QAAM,WAAWA,WAAAA,WAAW,oBAAoB;AAChD,SAAO,aAAa,QAAQ,OAAO,aAAa,eAAe,aAAa;AAC9E;AAOO,SAAS,qBAA8C;AAC5D,QAAM,WAAWA,WAAAA,WAAW,oBAAoB;AAChD,SAAOC,WAAAA,QAAQ,MAAM;;AACnB,QAAI,CAAC,SAAU,QAAO;AACtB,QAAI,OAAO,aAAa,eAAe,aAAa,SAAU,QAAO;AACrE,SAAI,cAAS,gBAAT,mBAAsB,OAAQ,QAAO;AACzC,WAAO,SAAS;AAAA,EAClB,GAAG,CAAC,QAAQ,CAAC;AACf;;;;;"}

package/dist/lib/use-athena-rest-query.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const reactQuery = require("@tanstack/react-query");
-const react = require("react");
+const require$$0 = require("react");
 const AthenaAuthContext = require("../auth/AthenaAuthContext.cjs");
 function useAthenaQueryClient() {
-  const contextClient = react.useContext(reactQuery.QueryClientContext);
-  const fallbackRef = react.useRef(null);
+  const contextClient = require$$0.useContext(reactQuery.QueryClientContext);
+  const fallbackRef = require$$0.useRef(null);
   if (contextClient) return contextClient;
   fallbackRef.current ?? (fallbackRef.current = new reactQuery.QueryClient());
   return fallbackRef.current;
@@ -28,7 +28,7 @@ function credentialFingerprint(auth) {
 }
 function useAthenaQueryIdentity(auth) {
   var _a, _b;
-  const principal = ((_b = (_a = react.useContext(AthenaAuthContext.AthenaAuthContext)) == null ? void 0 : _a.user) == null ? void 0 : _b.userId) ?? "";
+  const principal = ((_b = (_a = require$$0.useContext(AthenaAuthContext.AthenaAuthContext)) == null ? void 0 : _a.user) == null ? void 0 : _b.userId) ?? "";
   return [principal, credentialFingerprint(auth)];
 }
 exports.credentialFingerprint = credentialFingerprint;

package/dist/lib/use-athena-rest-query.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-athena-rest-query.cjs","sources":["../../src/lib/use-athena-rest-query.ts"],"sourcesContent":["/**\n * The two pieces every SDK hook that reads an Agora REST route through\n * TanStack Query needs: a `QueryClient` under any `<AthenaProvider>`, and a\n * query-key component naming who the read is made as — without ever putting\n * the credential itself in a key.\n */\nimport { QueryClient, QueryClientContext } from '@tanstack/react-query';\nimport { useContext, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport type { StatewireAuthSource } from '../runtime/statewire-auth-headers';\n\n/**\n * The host's `QueryClient` when one is in context (`enableThreadList` mounts\n * the SDK's own), else a client scoped to the calling hook's component.\n */\nexport function useAthenaQueryClient(): QueryClient {\n  const contextClient = useContext(QueryClientContext);\n  const fallbackRef = useRef<QueryClient | null>(null);\n  if (contextClient) return contextClient;\n  fallbackRef.current ??= new QueryClient();\n  return fallbackRef.current;\n}\n\n/** 32-bit FNV-1a of `text`, as hex. */\nfunction fnv1a(text: string): string {\n  let hash = 0x811c9dc5;\n  for (let index = 0; index < text.length; index += 1) {\n    hash ^= text.charCodeAt(index);\n    hash = Math.imul(hash, 0x01000193);\n  }\n  return (hash >>> 0).toString(16).padStart(8, '0');\n}\n\n/**\n * A one-way fingerprint of a query-key part that can carry a credential (an\n * opaque token or an API key inside an identity string), so the key names\n * whose it is without holding the secret.\n */\nexport function keyPartFingerprint(text: string): string {\n  return fnv1a(text);\n}\n\n/**\n * A short, one-way fingerprint of the credential a request presents (the API\n * key, the token the host holds, whether a live `getToken` resolves it). It is\n * the same for every hook and every mount that reads with the same\n * credential, and different once the credential changes, so a cache entry\n * written with one credential is never read with another — while the key\n * itself carries 32 bits of hash, never the secret.\n */\nexport function credentialFingerprint(auth: StatewireAuthSource): string {\n  return fnv1a(\n    [auth.apiKey ?? '', auth.token ?? '', auth.getToken === undefined ? '0' : '1'].join('\\u0000'),\n  );\n}\n\n/**\n * Who a query reads as, for its key: the signed-in principal (`''` when the\n * provider knows none) and the credential fingerprint. The principal covers\n * an identity switch the credential cannot show — a stable `getToken`, or a\n * same-origin cookie; the fingerprint covers a swapped API key or token. Both\n * are stable across mounts, so a pane mounted after a switch never reads the\n * previous account's cached answer.\n */\nexport function useAthenaQueryIdentity(auth: StatewireAuthSource): readonly [string, string] {\n  const principal = useContext(AthenaAuthContext)?.user?.userId ?? '';\n  return [principal, credentialFingerprint(auth)];\n}\n"],"names":["useContext","QueryClientContext","useRef","QueryClient","AthenaAuthContext"],"mappings":";;;;;AAeO,SAAS,uBAAoC;AAClD,QAAM,gBAAgBA,MAAAA,WAAWC,6BAAkB;AACnD,QAAM,cAAcC,MAAAA,OAA2B,IAAI;AACnD,MAAI,cAAe,QAAO;AAC1B,cAAY,YAAZ,YAAY,UAAY,IAAIC,uBAAA;AAC5B,SAAO,YAAY;AACrB;AAGA,SAAS,MAAM,MAAsB;AACnC,MAAI,OAAO;AACX,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;AACnD,YAAQ,KAAK,WAAW,KAAK;AAC7B,WAAO,KAAK,KAAK,MAAM,QAAU;AAAA,EACnC;AACA,UAAQ,SAAS,GAAG,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAClD;AAOO,SAAS,mBAAmB,MAAsB;AACvD,SAAO,MAAM,IAAI;AACnB;AAUO,SAAS,sBAAsB,MAAmC;AACvE,SAAO;AAAA,IACL,CAAC,KAAK,UAAU,IAAI,KAAK,SAAS,IAAI,KAAK,aAAa,SAAY,MAAM,GAAG,EAAE,KAAK,IAAQ;AAAA,EAAA;AAEhG;AAUO,SAAS,uBAAuB,MAAsD;;AAC3F,QAAM,cAAYH,iBAAAA,WAAWI,kBAAAA,iBAAiB,MAA5BJ,mBAA+B,SAA/BA,mBAAqC,WAAU;AACjE,SAAO,CAAC,WAAW,sBAAsB,IAAI,CAAC;AAChD;;;;;"}
+{"version":3,"file":"use-athena-rest-query.cjs","sources":["../../src/lib/use-athena-rest-query.ts"],"sourcesContent":["/**\n * The two pieces every SDK hook that reads an Agora REST route through\n * TanStack Query needs: a `QueryClient` under any `<AthenaProvider>`, and a\n * query-key component naming who the read is made as — without ever putting\n * the credential itself in a key.\n */\nimport { QueryClient, QueryClientContext } from '@tanstack/react-query';\nimport { useContext, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport type { StatewireAuthSource } from '../runtime/statewire-auth-headers';\n\n/**\n * The host's `QueryClient` when one is in context (`enableThreadList` mounts\n * the SDK's own), else a client scoped to the calling hook's component.\n */\nexport function useAthenaQueryClient(): QueryClient {\n  const contextClient = useContext(QueryClientContext);\n  const fallbackRef = useRef<QueryClient | null>(null);\n  if (contextClient) return contextClient;\n  fallbackRef.current ??= new QueryClient();\n  return fallbackRef.current;\n}\n\n/** 32-bit FNV-1a of `text`, as hex. */\nfunction fnv1a(text: string): string {\n  let hash = 0x811c9dc5;\n  for (let index = 0; index < text.length; index += 1) {\n    hash ^= text.charCodeAt(index);\n    hash = Math.imul(hash, 0x01000193);\n  }\n  return (hash >>> 0).toString(16).padStart(8, '0');\n}\n\n/**\n * A one-way fingerprint of a query-key part that can carry a credential (an\n * opaque token or an API key inside an identity string), so the key names\n * whose it is without holding the secret.\n */\nexport function keyPartFingerprint(text: string): string {\n  return fnv1a(text);\n}\n\n/**\n * A short, one-way fingerprint of the credential a request presents (the API\n * key, the token the host holds, whether a live `getToken` resolves it). It is\n * the same for every hook and every mount that reads with the same\n * credential, and different once the credential changes, so a cache entry\n * written with one credential is never read with another — while the key\n * itself carries 32 bits of hash, never the secret.\n */\nexport function credentialFingerprint(auth: StatewireAuthSource): string {\n  return fnv1a(\n    [auth.apiKey ?? '', auth.token ?? '', auth.getToken === undefined ? '0' : '1'].join('\\u0000'),\n  );\n}\n\n/**\n * Who a query reads as, for its key: the signed-in principal (`''` when the\n * provider knows none) and the credential fingerprint. The principal covers\n * an identity switch the credential cannot show — a stable `getToken`, or a\n * same-origin cookie; the fingerprint covers a swapped API key or token. Both\n * are stable across mounts, so a pane mounted after a switch never reads the\n * previous account's cached answer.\n */\nexport function useAthenaQueryIdentity(auth: StatewireAuthSource): readonly [string, string] {\n  const principal = useContext(AthenaAuthContext)?.user?.userId ?? '';\n  return [principal, credentialFingerprint(auth)];\n}\n"],"names":["useContext","QueryClientContext","useRef","QueryClient","AthenaAuthContext"],"mappings":";;;;;AAeO,SAAS,uBAAoC;AAClD,QAAM,gBAAgBA,WAAAA,WAAWC,6BAAkB;AACnD,QAAM,cAAcC,WAAAA,OAA2B,IAAI;AACnD,MAAI,cAAe,QAAO;AAC1B,cAAY,YAAZ,YAAY,UAAY,IAAIC,uBAAA;AAC5B,SAAO,YAAY;AACrB;AAGA,SAAS,MAAM,MAAsB;AACnC,MAAI,OAAO;AACX,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;AACnD,YAAQ,KAAK,WAAW,KAAK;AAC7B,WAAO,KAAK,KAAK,MAAM,QAAU;AAAA,EACnC;AACA,UAAQ,SAAS,GAAG,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAClD;AAOO,SAAS,mBAAmB,MAAsB;AACvD,SAAO,MAAM,IAAI;AACnB;AAUO,SAAS,sBAAsB,MAAmC;AACvE,SAAO;AAAA,IACL,CAAC,KAAK,UAAU,IAAI,KAAK,SAAS,IAAI,KAAK,aAAa,SAAY,MAAM,GAAG,EAAE,KAAK,IAAQ;AAAA,EAAA;AAEhG;AAUO,SAAS,uBAAuB,MAAsD;;AAC3F,QAAM,cAAYH,sBAAAA,WAAWI,kBAAAA,iBAAiB,MAA5BJ,mBAA+B,SAA/BA,mBAAqC,WAAU;AACjE,SAAO,CAAC,WAAW,sBAAsB,IAAI,CAAC;AAChD;;;;;"}

package/dist/lib/use-document-active.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const react = require("react");
+const require$$0 = require("react");
 function isActive(doc) {
   if (!doc) return false;
   return doc.visibilityState === "visible" && doc.hasFocus();
@@ -32,9 +32,9 @@ function subscribeTo(doc, onChange) {
   };
 }
 function useDocumentActive(doc) {
-  const subscribe = react.useCallback((onChange) => subscribeTo(doc, onChange), [doc]);
-  const getSnapshot = react.useCallback(() => isActive(doc), [doc]);
-  return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  const subscribe = require$$0.useCallback((onChange) => subscribeTo(doc, onChange), [doc]);
+  const getSnapshot = require$$0.useCallback(() => isActive(doc), [doc]);
+  return require$$0.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
 }
 exports.useDocumentActive = useDocumentActive;
 //# sourceMappingURL=use-document-active.cjs.map

package/dist/lib/use-document-active.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-document-active.cjs","sources":["../../src/lib/use-document-active.ts"],"sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\n\nfunction isActive(doc: Document | null): boolean {\n  if (!doc) return false;\n  return doc.visibilityState === 'visible' && doc.hasFocus();\n}\n\nfunction getServerSnapshot(): boolean {\n  return false;\n}\n\nfunction subscribeTo(doc: Document | null, onChange: () => void): () => void {\n  const view = doc?.defaultView;\n  if (!doc || !view) return () => {};\n  let afterBlur: ReturnType<typeof setTimeout> | null = null;\n  // `blur` fires before focus has landed. Focus that moved into a frame of\n  // this page (a computer's live desktop, an embedded asset) leaves the\n  // document focused, so it is read again once the browser has moved it.\n  const onBlur = () => {\n    onChange();\n    if (afterBlur !== null) clearTimeout(afterBlur);\n    afterBlur = setTimeout(() => {\n      afterBlur = null;\n      onChange();\n    }, 0);\n  };\n  view.addEventListener('focus', onChange);\n  view.addEventListener('blur', onBlur);\n  doc.addEventListener('visibilitychange', onChange);\n  return () => {\n    view.removeEventListener('focus', onChange);\n    view.removeEventListener('blur', onBlur);\n    doc.removeEventListener('visibilitychange', onChange);\n    if (afterBlur !== null) clearTimeout(afterBlur);\n  };\n}\n\n/**\n * Whether `doc` is in front of the person: visible and focused\n * (`hasFocus()`, which stays true while focus is inside a frame of the page).\n * Pass the document a subtree renders into (`useOwnerDocument()`), so a pane\n * popped out into another window reads that window. Re-read on its window's\n * `focus` / `blur` and its `visibilitychange`; nothing polls. `false` on the\n * server and without a document.\n */\nexport function useDocumentActive(doc: Document | null): boolean {\n  const subscribe = useCallback((onChange: () => void) => subscribeTo(doc, onChange), [doc]);\n  const getSnapshot = useCallback(() => isActive(doc), [doc]);\n  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n}\n"],"names":["useCallback","useSyncExternalStore"],"mappings":";;;AAEA,SAAS,SAAS,KAA+B;AAC/C,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO,IAAI,oBAAoB,aAAa,IAAI,SAAA;AAClD;AAEA,SAAS,oBAA6B;AACpC,SAAO;AACT;AAEA,SAAS,YAAY,KAAsB,UAAkC;AAC3E,QAAM,OAAO,2BAAK;AAClB,MAAI,CAAC,OAAO,CAAC,aAAa,MAAM;AAAA,EAAC;AACjC,MAAI,YAAkD;AAItD,QAAM,SAAS,MAAM;AACnB,aAAA;AACA,QAAI,cAAc,KAAM,cAAa,SAAS;AAC9C,gBAAY,WAAW,MAAM;AAC3B,kBAAY;AACZ,eAAA;AAAA,IACF,GAAG,CAAC;AAAA,EACN;AACA,OAAK,iBAAiB,SAAS,QAAQ;AACvC,OAAK,iBAAiB,QAAQ,MAAM;AACpC,MAAI,iBAAiB,oBAAoB,QAAQ;AACjD,SAAO,MAAM;AACX,SAAK,oBAAoB,SAAS,QAAQ;AAC1C,SAAK,oBAAoB,QAAQ,MAAM;AACvC,QAAI,oBAAoB,oBAAoB,QAAQ;AACpD,QAAI,cAAc,KAAM,cAAa,SAAS;AAAA,EAChD;AACF;AAUO,SAAS,kBAAkB,KAA+B;AAC/D,QAAM,YAAYA,kBAAY,CAAC,aAAyB,YAAY,KAAK,QAAQ,GAAG,CAAC,GAAG,CAAC;AACzF,QAAM,cAAcA,MAAAA,YAAY,MAAM,SAAS,GAAG,GAAG,CAAC,GAAG,CAAC;AAC1D,SAAOC,2BAAqB,WAAW,aAAa,iBAAiB;AACvE;;"}
+{"version":3,"file":"use-document-active.cjs","sources":["../../src/lib/use-document-active.ts"],"sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\n\nfunction isActive(doc: Document | null): boolean {\n  if (!doc) return false;\n  return doc.visibilityState === 'visible' && doc.hasFocus();\n}\n\nfunction getServerSnapshot(): boolean {\n  return false;\n}\n\nfunction subscribeTo(doc: Document | null, onChange: () => void): () => void {\n  const view = doc?.defaultView;\n  if (!doc || !view) return () => {};\n  let afterBlur: ReturnType<typeof setTimeout> | null = null;\n  // `blur` fires before focus has landed. Focus that moved into a frame of\n  // this page (a computer's live desktop, an embedded asset) leaves the\n  // document focused, so it is read again once the browser has moved it.\n  const onBlur = () => {\n    onChange();\n    if (afterBlur !== null) clearTimeout(afterBlur);\n    afterBlur = setTimeout(() => {\n      afterBlur = null;\n      onChange();\n    }, 0);\n  };\n  view.addEventListener('focus', onChange);\n  view.addEventListener('blur', onBlur);\n  doc.addEventListener('visibilitychange', onChange);\n  return () => {\n    view.removeEventListener('focus', onChange);\n    view.removeEventListener('blur', onBlur);\n    doc.removeEventListener('visibilitychange', onChange);\n    if (afterBlur !== null) clearTimeout(afterBlur);\n  };\n}\n\n/**\n * Whether `doc` is in front of the person: visible and focused\n * (`hasFocus()`, which stays true while focus is inside a frame of the page).\n * Pass the document a subtree renders into (`useOwnerDocument()`), so a pane\n * popped out into another window reads that window. Re-read on its window's\n * `focus` / `blur` and its `visibilitychange`; nothing polls. `false` on the\n * server and without a document.\n */\nexport function useDocumentActive(doc: Document | null): boolean {\n  const subscribe = useCallback((onChange: () => void) => subscribeTo(doc, onChange), [doc]);\n  const getSnapshot = useCallback(() => isActive(doc), [doc]);\n  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n}\n"],"names":["useCallback","useSyncExternalStore"],"mappings":";;;AAEA,SAAS,SAAS,KAA+B;AAC/C,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO,IAAI,oBAAoB,aAAa,IAAI,SAAA;AAClD;AAEA,SAAS,oBAA6B;AACpC,SAAO;AACT;AAEA,SAAS,YAAY,KAAsB,UAAkC;AAC3E,QAAM,OAAO,2BAAK;AAClB,MAAI,CAAC,OAAO,CAAC,aAAa,MAAM;AAAA,EAAC;AACjC,MAAI,YAAkD;AAItD,QAAM,SAAS,MAAM;AACnB,aAAA;AACA,QAAI,cAAc,KAAM,cAAa,SAAS;AAC9C,gBAAY,WAAW,MAAM;AAC3B,kBAAY;AACZ,eAAA;AAAA,IACF,GAAG,CAAC;AAAA,EACN;AACA,OAAK,iBAAiB,SAAS,QAAQ;AACvC,OAAK,iBAAiB,QAAQ,MAAM;AACpC,MAAI,iBAAiB,oBAAoB,QAAQ;AACjD,SAAO,MAAM;AACX,SAAK,oBAAoB,SAAS,QAAQ;AAC1C,SAAK,oBAAoB,QAAQ,MAAM;AACvC,QAAI,oBAAoB,oBAAoB,QAAQ;AACpD,QAAI,cAAc,KAAM,cAAa,SAAS;AAAA,EAChD;AACF;AAUO,SAAS,kBAAkB,KAA+B;AAC/D,QAAM,YAAYA,uBAAY,CAAC,aAAyB,YAAY,KAAK,QAAQ,GAAG,CAAC,GAAG,CAAC;AACzF,QAAM,cAAcA,WAAAA,YAAY,MAAM,SAAS,GAAG,GAAG,CAAC,GAAG,CAAC;AAC1D,SAAOC,gCAAqB,WAAW,aAAa,iBAAiB;AACvE;;"}