@athenaintel/react 0.48.0 → 0.50.0

package/dist/composer/useReadComposerDraft.d.ts

@@ -1,6 +1,28 @@
+import { type ComposerHandoffStore } from './composer-handoff';
+/**
+ * The composer's text, or `null` when there is no draft to read. Inside `AthenaProvider` (a
+ * `store`), the runtime's text is the person's draft only while the editor is mounted (it
+ * registers `focusEnd`) and no write made before it mounted is still waiting: until then the
+ * runtime holds an empty text that is not what the person sees. A read that throws (no composer
+ * in scope) is `null` too.
+ */
+export declare function tryReadComposerText({ read, store, }: {
+    read: () => {
+        text?: string | null;
+    };
+    store: Pick<ComposerHandoffStore, 'focusEnd' | 'pending'> | null;
+}): string | null;
+/**
+ * Reads the composer's draft (its text) when called, or `null` when there is no draft to read:
+ * the editor has not mounted, a write is still waiting for it, or the read fails. For a host that
+ * must tell a blank composer (`''`) from one it could not read, such as "Continue on…", where a
+ * blank composer clears the draft of a reused handover ticket and an unread one must leave it as
+ * it was.
+ */
+export declare function useTryReadComposerDraft(): () => string | null;
 /**
  * Reads the composer's draft (its text) when called, for a host that hands the chat elsewhere and
  * carries what was not sent yet along (a launcher window's "open in the app"). An empty string
- * before the composer exists.
+ * before the composer exists; {@link useTryReadComposerDraft} tells that case apart.
  */
 export declare function useReadComposerDraft(): () => string;

package/dist/composer/useReadComposerDraft.js

@@ -1,16 +1,35 @@
 import { useCallback } from "react";
 import { useAui } from "@assistant-ui/react";
+import { useComposerHandoffStore } from "./composer-handoff.js";
+function tryReadComposerText({
+  read,
+  store
+}) {
+  if (store !== null && (store.focusEnd === null || store.pending.length > 0)) return null;
+  try {
+    return read().text ?? null;
+  } catch {
+    return null;
+  }
+}
+function useTryReadComposerDraft() {
+  const aui = useAui();
+  const store = useComposerHandoffStore();
+  return useCallback(
+    () => tryReadComposerText({ read: () => aui.composer.getState(), store }),
+    [aui, store]
+  );
+}
 function useReadComposerDraft() {
   const aui = useAui();
-  return useCallback(() => {
-    try {
-      return aui.composer.getState().text ?? "";
-    } catch {
-      return "";
-    }
-  }, [aui]);
+  return useCallback(
+    () => tryReadComposerText({ read: () => aui.composer.getState(), store: null }) ?? "",
+    [aui]
+  );
 }
 export {
-  useReadComposerDraft
+  tryReadComposerText,
+  useReadComposerDraft,
+  useTryReadComposerDraft
 };
 //# sourceMappingURL=useReadComposerDraft.js.map

package/dist/composer/useReadComposerDraft.js.map

@@ -1 +1 @@
-{"version":3,"file":"useReadComposerDraft.js","sources":["../../src/composer/useReadComposerDraft.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useAui } from '@assistant-ui/react';\n\n/**\n * Reads the composer's draft (its text) when called, for a host that hands the chat elsewhere and\n * carries what was not sent yet along (a launcher window's \"open in the app\"). An empty string\n * before the composer exists.\n */\nexport function useReadComposerDraft(): () => string {\n  const aui = useAui();\n  return useCallback(() => {\n    try {\n      return aui.composer.getState().text ?? '';\n    } catch {\n      return '';\n    }\n  }, [aui]);\n}\n"],"names":[],"mappings":";;AAQO,SAAS,uBAAqC;AACnD,QAAM,MAAM,OAAA;AACZ,SAAO,YAAY,MAAM;AACvB,QAAI;AACF,aAAO,IAAI,SAAS,SAAA,EAAW,QAAQ;AAAA,IACzC,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF,GAAG,CAAC,GAAG,CAAC;AACV;"}
+{"version":3,"file":"useReadComposerDraft.js","sources":["../../src/composer/useReadComposerDraft.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useAui } from '@assistant-ui/react';\nimport { type ComposerHandoffStore, useComposerHandoffStore } from './composer-handoff';\n\n/**\n * The composer's text, or `null` when there is no draft to read. Inside `AthenaProvider` (a\n * `store`), the runtime's text is the person's draft only while the editor is mounted (it\n * registers `focusEnd`) and no write made before it mounted is still waiting: until then the\n * runtime holds an empty text that is not what the person sees. A read that throws (no composer\n * in scope) is `null` too.\n */\nexport function tryReadComposerText({\n  read,\n  store,\n}: {\n  read: () => { text?: string | null };\n  store: Pick<ComposerHandoffStore, 'focusEnd' | 'pending'> | null;\n}): string | null {\n  if (store !== null && (store.focusEnd === null || store.pending.length > 0)) return null;\n  try {\n    return read().text ?? null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Reads the composer's draft (its text) when called, or `null` when there is no draft to read:\n * the editor has not mounted, a write is still waiting for it, or the read fails. For a host that\n * must tell a blank composer (`''`) from one it could not read, such as \"Continue on…\", where a\n * blank composer clears the draft of a reused handover ticket and an unread one must leave it as\n * it was.\n */\nexport function useTryReadComposerDraft(): () => string | null {\n  const aui = useAui();\n  const store = useComposerHandoffStore();\n  return useCallback(\n    () => tryReadComposerText({ read: () => aui.composer.getState(), store }),\n    [aui, store]\n  );\n}\n\n/**\n * Reads the composer's draft (its text) when called, for a host that hands the chat elsewhere and\n * carries what was not sent yet along (a launcher window's \"open in the app\"). An empty string\n * before the composer exists; {@link useTryReadComposerDraft} tells that case apart.\n */\nexport function useReadComposerDraft(): () => string {\n  const aui = useAui();\n  return useCallback(\n    () => tryReadComposerText({ read: () => aui.composer.getState(), store: null }) ?? '',\n    [aui]\n  );\n}\n"],"names":[],"mappings":";;;AAWO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AACF,GAGkB;AAChB,MAAI,UAAU,SAAS,MAAM,aAAa,QAAQ,MAAM,QAAQ,SAAS,GAAI,QAAO;AACpF,MAAI;AACF,WAAO,KAAA,EAAO,QAAQ;AAAA,EACxB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AASO,SAAS,0BAA+C;AAC7D,QAAM,MAAM,OAAA;AACZ,QAAM,QAAQ,wBAAA;AACd,SAAO;AAAA,IACL,MAAM,oBAAoB,EAAE,MAAM,MAAM,IAAI,SAAS,SAAA,GAAY,OAAO;AAAA,IACxE,CAAC,KAAK,KAAK;AAAA,EAAA;AAEf;AAOO,SAAS,uBAAqC;AACnD,QAAM,MAAM,OAAA;AACZ,SAAO;AAAA,IACL,MAAM,oBAAoB,EAAE,MAAM,MAAM,IAAI,SAAS,SAAA,GAAY,OAAO,KAAA,CAAM,KAAK;AAAA,IACnF,CAAC,GAAG;AAAA,EAAA;AAER;"}

package/dist/index.cjs

@@ -109,6 +109,7 @@ const dictationEngine = require("./dictation/dictation-engine.cjs");
 const recordedDictationEngine = require("./dictation/recorded-dictation-engine.cjs");
 const useAthenaDictationEngine = require("./dictation/use-athena-dictation-engine.cjs");
 const dictationState = require("./dictation/dictation-state.cjs");
+const useChatVoiceEnabled = require("./voice/use-chat-voice-enabled.cjs");
 const useAppendToComposer = require("./composer/useAppendToComposer.cjs");
 const composerHandoff = require("./composer/composer-handoff.cjs");
 const useReadComposerDraft = require("./composer/useReadComposerDraft.cjs");
@@ -477,10 +478,12 @@ exports.createRecordedDictationEngine = recordedDictationEngine.createRecordedDi
 exports.useAthenaDictationEngine = useAthenaDictationEngine.useAthenaDictationEngine;
 exports.DICTATION_STATUSES = dictationState.DICTATION_STATUSES;
 exports.composeDictationDraft = dictationState.composeDictationDraft;
+exports.useChatVoiceEnabled = useChatVoiceEnabled.useChatVoiceEnabled;
 exports.useAppendToComposer = useAppendToComposer.useAppendToComposer;
 exports.useComposerReady = composerHandoff.useComposerReady;
 exports.useFocusComposer = composerHandoff.useFocusComposer;
 exports.useReadComposerDraft = useReadComposerDraft.useReadComposerDraft;
+exports.useTryReadComposerDraft = useReadComposerDraft.useTryReadComposerDraft;
 exports.useSendMessage = useSendMessage.useSendMessage;
 exports.useComposerAttachment = useComposerAttachment.useComposerAttachment;
 exports.ChatAgentPicker = chatPickers.ChatAgentPicker;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -189,10 +189,12 @@ export { useAthenaDictationEngine } from './dictation/use-athena-dictation-engin
 export { composeDictationDraft, DICTATION_STATUSES } from './dictation/dictation-state';
 export type { DictationStatus, DictationTranscript } from './dictation/dictation-state';
 export type { AthenaChatComposerSlots, AthenaChatContinueByVoice, AthenaChatDictationOptions, } from './chat/AthenaChat';
+/** Whether the chat's voice control shows for this sign-in: the gate `AthenaChat`'s mic uses. */
+export { useChatVoiceEnabled } from './voice/use-chat-voice-enabled';
 export { useAppendToComposer } from './composer/useAppendToComposer';
 export type { AppendToComposerOptions } from './composer/useAppendToComposer';
 export { useComposerReady, useFocusComposer } from './composer/composer-handoff';
-export { useReadComposerDraft } from './composer/useReadComposerDraft';
+export { useReadComposerDraft, useTryReadComposerDraft } from './composer/useReadComposerDraft';
 export { useSendMessage } from './composer/useSendMessage';
 export type { SendMessageOptions } from './composer/useSendMessage';
 export { useComposerAttachment } from './composer/useComposerAttachment';

package/dist/index.js

@@ -107,9 +107,10 @@ import { DICTATION_ENGINE_ERROR_KINDS, createWebSpeechDictationEngine } from "./
 import { createRecordedDictationEngine } from "./dictation/recorded-dictation-engine.js";
 import { useAthenaDictationEngine } from "./dictation/use-athena-dictation-engine.js";
 import { DICTATION_STATUSES, composeDictationDraft } from "./dictation/dictation-state.js";
+import { useChatVoiceEnabled } from "./voice/use-chat-voice-enabled.js";
 import { useAppendToComposer } from "./composer/useAppendToComposer.js";
 import { useComposerReady, useFocusComposer } from "./composer/composer-handoff.js";
-import { useReadComposerDraft } from "./composer/useReadComposerDraft.js";
+import { useReadComposerDraft, useTryReadComposerDraft } from "./composer/useReadComposerDraft.js";
 import { useSendMessage } from "./composer/useSendMessage.js";
 import { useComposerAttachment } from "./composer/useComposerAttachment.js";
 import { ChatAgentPicker, ChatModePicker, ChatModelPicker } from "./catalog/chat-pickers.js";
@@ -538,6 +539,7 @@ export {
   useAthenaVoiceLive,
   useAttachments,
   useBrowserDecisionConfirmer,
+  useChatVoiceEnabled,
   useComposerAttachment,
   useComposerReady,
   useDeviceOperationReader,
@@ -566,6 +568,7 @@ export {
   useStatewireToolOutputs,
   useToolAppearance,
   useToolPartPlacement,
+  useTryReadComposerDraft,
   useTurnToolCallsAwaitingApproval,
   windowInFrontSignal,
   withCaptureGateBypass,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,190 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Y = require("@y/y");
+const updateAttributions = require("./update-attributions.cjs");
+const MESSAGE_SYNC = 0;
+const SYNC_STEP_2 = 1;
+const SYNC_UPDATE = 2;
+const MAX_ATTRIBUTED_RUNS = 64;
+function noIds(ids) {
+  return ids.inserts.isEmpty() && ids.deletes.isEmpty();
+}
+function sameAttributions(a, b) {
+  return a.length === b.length && a.every((pair, index) => {
+    var _a, _b;
+    return pair.k === ((_a = b[index]) == null ? void 0 : _a.k) && pair.v === ((_b = b[index]) == null ? void 0 : _b.v);
+  });
+}
+function readSyncFrame(frame) {
+  const type = updateAttributions.readVarUint({ bytes: frame, start: 0 });
+  if ((type == null ? void 0 : type.value) !== MESSAGE_SYNC) return null;
+  const syncType = updateAttributions.readVarUint({ bytes: frame, start: type.next });
+  if (syncType === null) return null;
+  const length = updateAttributions.readVarUint({ bytes: frame, start: syncType.next });
+  if (length === null || length.next + length.value !== frame.length) return null;
+  return { syncType: syncType.value, payload: frame.subarray(length.next) };
+}
+function syncFrame({ syncType, payload }) {
+  const head = [];
+  updateAttributions.writeVarUint({ out: head, value: MESSAGE_SYNC });
+  updateAttributions.writeVarUint({ out: head, value: syncType });
+  updateAttributions.writeVarUint({ out: head, value: payload.length });
+  const frame = new Uint8Array(head.length + payload.length);
+  frame.set(head, 0);
+  frame.set(payload, head.length);
+  return frame;
+}
+function idsOf(update) {
+  try {
+    return Y.createContentIdsFromUpdate(update);
+  } catch {
+    return null;
+  }
+}
+function copyOf({ ids, attributions }) {
+  return { ids, attributions: attributions.map(({ k, v }) => ({ k, v })) };
+}
+function bounded(runs) {
+  return runs.length > MAX_ATTRIBUTED_RUNS ? runs.slice(runs.length - MAX_ATTRIBUTED_RUNS) : runs;
+}
+const ROOMS = Symbol.for("@athenaintel/keryx-http/unconfirmed-update-attributions");
+function rooms() {
+  const host = globalThis;
+  return host[ROOMS] ?? (host[ROOMS] = { live: /* @__PURE__ */ new WeakMap(), left: /* @__PURE__ */ new WeakMap() });
+}
+class UnconfirmedUpdateAttributions {
+  constructor({
+    doc,
+    attributionsFor,
+    isRemoteOrigin
+  }) {
+    __publicField(this, "runs");
+    __publicField(this, "doc");
+    __publicField(this, "attributionsFor");
+    __publicField(this, "isRemoteOrigin");
+    __publicField(this, "handleUpdate", (update, origin) => {
+      if (this.isRemoteOrigin(origin)) return;
+      const attributions = this.attributionsFor();
+      if (!attributions || attributions.length === 0) return;
+      const ids = idsOf(update);
+      if (!ids || noIds(ids)) return;
+      const last = this.runs.at(-1);
+      if (last && sameAttributions(last.attributions, attributions)) {
+        last.ids = Y.mergeContentIds([last.ids, ids]);
+        return;
+      }
+      this.runs = bounded([...this.runs, copyOf({ ids, attributions })]);
+    });
+    this.doc = doc;
+    this.attributionsFor = attributionsFor;
+    this.isRemoteOrigin = isRemoteOrigin;
+    const { live, left } = rooms();
+    this.runs = left.get(doc) ?? [];
+    left.delete(doc);
+    live.set(doc, this);
+    doc.on("update", this.handleUpdate);
+  }
+  /** The attributed writes Keryx has not acknowledged, oldest first. */
+  get pending() {
+    return this.runs.map(copyOf);
+  }
+  /** Writes an earlier session kept, older than any written here: they go out first. */
+  restore(writes) {
+    this.runs = bounded([...writes.map(copyOf), ...this.runs]);
+  }
+  /**
+   * One socket of the room. While the room keeps writes, the socket's sync step 2 (its answer to
+   * Keryx's sync step 1) waits for the next frame Keryx sends, its whole document, which drops what
+   * Keryx already holds before the answer is split (see the module comment); every frame sent
+   * meanwhile waits behind it, in order. Nothing kept, or a socket that cannot hear Keryx: every
+   * frame goes out as it is sent.
+   */
+  connect({
+    send,
+    hears
+  }) {
+    let held = null;
+    const sendNow = (frame) => {
+      for (const out of this.framesFor(frame)) send(out);
+    };
+    return {
+      received: (frame) => {
+        this.received(frame);
+        if (held === null) return;
+        const waiting = held;
+        held = null;
+        for (const next of waiting) sendNow(next);
+      },
+      send: (frame) => {
+        var _a;
+        if (held !== null) {
+          held.push(frame);
+          return;
+        }
+        if (hears && this.runs.length > 0 && ((_a = readSyncFrame(frame)) == null ? void 0 : _a.syncType) === SYNC_STEP_2) {
+          held = [frame];
+          return;
+        }
+        sendNow(frame);
+      }
+    };
+  }
+  /** Keryx sent `frame`: the ids it carries are Keryx's, kept no longer. */
+  received(frame) {
+    if (this.runs.length === 0) return;
+    const message = readSyncFrame(frame);
+    if (message === null) return;
+    if (message.syncType !== SYNC_STEP_2 && message.syncType !== SYNC_UPDATE) return;
+    const held = idsOf(message.payload);
+    if (!held) return;
+    this.runs = this.runs.map(({ ids, attributions }) => ({ ids: Y.excludeContentIds(ids, held), attributions })).filter((run) => !noIds(run.ids));
+  }
+  /**
+   * What goes out in place of `frame`: `[frame]` itself, except a sync step 2 carrying kept writes,
+   * which goes out behind each of them as its own marked sync update.
+   */
+  framesFor(frame) {
+    if (this.runs.length === 0) return [frame];
+    const message = readSyncFrame(frame);
+    if (message === null || message.syncType !== SYNC_STEP_2) return [frame];
+    const answer = message.payload;
+    const all = idsOf(answer);
+    if (!all) return [frame];
+    const frames = [];
+    const marked = [];
+    for (const run of this.runs) {
+      const part = Y.intersectContentIds(run.ids, all);
+      if (noIds(part)) continue;
+      frames.push(
+        updateAttributions.withUpdateAttributionsTrailer({
+          message: syncFrame({
+            syncType: SYNC_UPDATE,
+            payload: Y.intersectUpdateWithContentIds(answer, part)
+          }),
+          attributions: run.attributions
+        })
+      );
+      marked.push(part);
+    }
+    if (marked.length === 0) return [frame];
+    const rest = Y.excludeContentIds(all, Y.mergeContentIds(marked));
+    frames.push(
+      syncFrame({ syncType: SYNC_STEP_2, payload: Y.intersectUpdateWithContentIds(answer, rest) })
+    );
+    return frames;
+  }
+  /** Stops keeping; what is still kept waits for the next tracker made for the document. */
+  destroy() {
+    this.doc.off("update", this.handleUpdate);
+    const { live, left } = rooms();
+    if (live.get(this.doc) === this) live.delete(this.doc);
+    if (this.runs.length > 0) left.set(this.doc, this.runs);
+    this.runs = [];
+  }
+}
+exports.MAX_ATTRIBUTED_RUNS = MAX_ATTRIBUTED_RUNS;
+exports.UnconfirmedUpdateAttributions = UnconfirmedUpdateAttributions;
+//# sourceMappingURL=unconfirmed-update-attributions.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unconfirmed-update-attributions.cjs","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":["readVarUint","writeVarUint","createContentIdsFromUpdate","mergeContentIds","excludeContentIds","intersectContentIds","withUpdateAttributionsTrailer","intersectUpdateWithContentIds"],"mappings":"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"}

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

@@ -0,0 +1,132 @@
+/**
+ * The attributed writes a room has not seen Keryx acknowledge, kept so that a write made while the
+ * room's socket is closed still reaches Keryx with its attributions.
+ *
+ * A write made inside `runWithDocUpdateAttributions` leaves as its own sync update followed by the
+ * attributions trailer (`attributingWebSocket`), but only if the room's socket is open as it is
+ * made. One made while it is closed (offline, reconnecting, before the first connection) reaches
+ * Keryx inside the reconnect's sync step 2: the client's answer to Keryx's sync step 1, everything
+ * it holds that Keryx lacks. Keryx reads no trailer after a sync step 2, so it would count the
+ * write as the person's edit.
+ *
+ * So the room keeps the content ids of every write made in a scope, with the scope's attributions,
+ * until Keryx sends those ids back: the echo of the update that carried them, or the whole document
+ * Keryx sends when a socket opens (`received`; `@y/websocket` confirms its own unconfirmed updates
+ * the same way). When the socket sends a sync step 2, each kept write's part of it goes out first,
+ * oldest first, as its own sync update with its trailer, and the sync step 2 follows without those
+ * ids (`framesFor`). The parts are cut from the sync step 2 itself, which already holds only what
+ * Keryx lacks past its state vector. One socket keeps the order, so Keryx appends each marked update
+ * before the person's sync step 2.
+ *
+ * That answer waits for Keryx's document (`connect`). Keryx sends its sync step 1 and, in the same
+ * cork, its whole document, but `@y/websocket` answers the sync step 1 as it arrives. A kept write
+ * Keryx already appended (its echo lost with the socket) is still kept then, and the sync step 2
+ * holds the client's whole delete set, so its deletes would go out again as a marked update, which
+ * Keryx appends: it drops what it holds from the first sync step 2 only. Held until the next frame,
+ * the answer is split once Keryx's document has dropped what it holds.
+ *
+ * What Keryx records (`patches/@y%2Fhub@0.10.1.patch`):
+ * - An update's content map attributes every id it carries, inserts and deletes, read from its
+ *   bytes: an update that cannot integrate yet (an item next to one the person typed offline, the
+ *   next clocks of the person's own client) is attributed like any other. Peers hold it until the
+ *   sync step 2 behind it brings what it needs.
+ * - An id is attributed by the first stream entry that carries it (`getDoc`'s `excludeContentMap`),
+ *   so a later copy changes no merged history. The live change notices read each entry's own
+ *   content map, though (keryx/src/doc-watcher.ts), and the first sync step 2's strip of what Keryx
+ *   holds reads the known ids when the frame arrives, possibly before the update ahead of it is in
+ *   the stream (one whose content map the compute pool builds). A copy inside the sync step 2
+ *   would then be announced as the person's: the sync step 2 never carries a kept write's ids.
+ *
+ * Bounded: consecutive writes of one scope merge into one run, and past
+ * {@link MAX_ATTRIBUTED_RUNS} runs the oldest is let go (its content then reaches Keryx in a sync
+ * step 2, as the person's). A room's local copy keeps them across sessions
+ * ({@link unconfirmedAttributedWritesOf}, {@link restoreUnconfirmedAttributedWrites}); without one,
+ * a write the room kept is forgotten with the page.
+ */
+import { type ContentIds, type Doc } from '@y/y';
+import { type AttributedWritesSocket, type UnconfirmedAttributedWrites, type UpdateAttribution } from './update-attributions.js';
+/** Writes made in one attribution scope, by the content ids they wrote (inserts and deletes). */
+export interface AttributedWrites {
+    ids: ContentIds;
+    attributions: readonly UpdateAttribution[];
+}
+/**
+ * The most runs a room keeps; a run is one scope's writes since a write of another scope. Housekeeping
+ * all shares one scope, so runs pile up only as Quick Edit steps interleave with it.
+ */
+export declare const MAX_ATTRIBUTED_RUNS = 64;
+/** What a page reads of a room's tracker, whichever copy of this module made it. */
+interface KeptWrites {
+    readonly pending: readonly AttributedWrites[];
+    restore(writes: readonly AttributedWrites[]): void;
+}
+/**
+ * The attributed writes Keryx has not acknowledged for `doc`, oldest first: its room's, or what a
+ * destroyed room left for the next. What a room's local copy keeps of them.
+ */
+export declare function unconfirmedAttributedWritesOf(doc: object): readonly AttributedWrites[];
+/**
+ * Hands `doc`'s room attributed writes an earlier session kept (the room's local copy), or keeps
+ * them for the next tracker made for it. They are older than anything written since, so they go
+ * out first.
+ */
+export declare function restoreUnconfirmedAttributedWrites({ doc, writes, }: {
+    doc: object;
+    writes: readonly AttributedWrites[];
+}): void;
+/**
+ * The two above, as a page hands them to its local copies (`@athenaintel/local-copy`'s
+ * `openLocalCopyStore({ attributedWrites })`, `createLocalCopiesPage({ attributedWrites })`): the
+ * copy records a room's kept writes with its edits and restores an ended session's to its room.
+ */
+export declare const roomAttributedWrites: {
+    of: typeof unconfirmedAttributedWritesOf;
+    restore: typeof restoreUnconfirmedAttributedWrites;
+};
+/**
+ * One room's attributed writes Keryx has not acknowledged (see the module comment). Made once per
+ * room by its transport, which hands it to every socket it opens (`attributingWebSocket`'s
+ * `unconfirmed`) and destroys it with the room; a tracker made for the same document later takes
+ * over what it still kept, and what its local copy kept from an earlier session
+ * ({@link restoreUnconfirmedAttributedWrites}). Not for a room that only listens: its socket sends
+ * nothing to split.
+ */
+export declare class UnconfirmedUpdateAttributions implements UnconfirmedAttributedWrites, KeptWrites {
+    private runs;
+    private readonly doc;
+    private readonly attributionsFor;
+    private readonly isRemoteOrigin;
+    constructor({ doc, attributionsFor, isRemoteOrigin, }: {
+        doc: Doc;
+        /** The attributions of the update being written now: what the socket's trailer reads. */
+        attributionsFor: () => readonly UpdateAttribution[] | undefined;
+        /** True for a transaction the transport applied (Keryx's state, a peer's edit). */
+        isRemoteOrigin: (origin: unknown) => boolean;
+    });
+    private readonly handleUpdate;
+    /** The attributed writes Keryx has not acknowledged, oldest first. */
+    get pending(): readonly AttributedWrites[];
+    /** Writes an earlier session kept, older than any written here: they go out first. */
+    restore(writes: readonly AttributedWrites[]): void;
+    /**
+     * One socket of the room. While the room keeps writes, the socket's sync step 2 (its answer to
+     * Keryx's sync step 1) waits for the next frame Keryx sends, its whole document, which drops what
+     * Keryx already holds before the answer is split (see the module comment); every frame sent
+     * meanwhile waits behind it, in order. Nothing kept, or a socket that cannot hear Keryx: every
+     * frame goes out as it is sent.
+     */
+    connect({ send, hears, }: {
+        send: (frame: Uint8Array) => void;
+        hears: boolean;
+    }): AttributedWritesSocket;
+    /** Keryx sent `frame`: the ids it carries are Keryx's, kept no longer. */
+    received(frame: Uint8Array): void;
+    /**
+     * What goes out in place of `frame`: `[frame]` itself, except a sync step 2 carrying kept writes,
+     * which goes out behind each of them as its own marked sync update.
+     */
+    framesFor(frame: Uint8Array): readonly Uint8Array[];
+    /** Stops keeping; what is still kept waits for the next tracker made for the document. */
+    destroy(): void;
+}
+export {};