@athenaintel/react 0.48.0 → 0.52.1

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

@@ -57,6 +57,7 @@ const miscToolUis = require("./tools/misc-tool-uis.cjs");
 const toolIcons = require("./tools/tool-icons.cjs");
 const writeTodosToolUi = require("./tools/write-todos-tool-ui.cjs");
 const todoPlanStore = require("./tools/todo-plan-store.cjs");
+const AthenaPlanStrip = require("./chat/AthenaPlanStrip.cjs");
 const fileToolUis = require("./tools/file-tool-uis.cjs");
 const toolSummary = require("./tools/tool-summary.cjs");
 const toolFallback = require("./tools/tool-fallback.cjs");
@@ -109,6 +110,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");
@@ -296,6 +298,7 @@ exports.PlanStepMarker = writeTodosToolUi.PlanStepMarker;
 exports.WriteTodosToolUI = writeTodosToolUi.WriteTodosToolUI;
 exports.parseTodoPlan = writeTodosToolUi.parseTodoPlan;
 exports.useLatestTodoPlan = todoPlanStore.useLatestTodoPlan;
+exports.AthenaPlanStrip = AthenaPlanStrip.AthenaPlanStrip;
 exports.EditFileToolUI = fileToolUis.EditFileToolUI;
 exports.ListFilesToolUI = fileToolUis.ListFilesToolUI;
 exports.ReadFileToolUI = fileToolUis.ReadFileToolUI;
@@ -477,10 +480,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

@@ -20,7 +20,7 @@ export { AthenaAssistantActionBar, AthenaAssistantMessage, AthenaChat, AthenaRea
 export type { AthenaAssistantActionBarProps, AthenaAssistantMessageProps, AthenaChatComponents, AthenaChatMessagePartComponents, AthenaChatProps, AthenaChatVoiceOptions, AthenaReasoningPartProps, AthenaUserMessageProps, } from './chat/AthenaChat';
 export type { WelcomeSuggestion } from './chat/athena-chat-welcome';
 export { AthenaChatErrorBoundary } from './chat/AthenaChatErrorBoundary';
-export { type ActivityItem, type ActivityPhase, type ActivityTimelineOptions, type ActivityToolState, buildActivityTimeline, CollapsibleGroup, type CollapsibleGroupProps, countActivityDelegations, countActivityTools, createToolBasedGroupingFunction, DEFAULT_TOOLKIT_THEME, defaultGetToolGroupKey, excludeFinalTextFromGroups, excludePartsFromGroups, type FinalTextPart, type FinalTextSegment, formatWorkDuration, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, getFinalTextParts, getReasoningLabel, type GetToolGroupKey, type GroupablePart, GroupedMessageParts, type GroupedMessagePartsProps, type GroupingFunction, type MessagePartGroup, readTurnTiming, resetRememberedExpansionsForTests, resolveActivityPhase, splitTurnSegments, SuperGroupingCard, type SuperGroupingCardProps, SuperGroupingFinalText, SuperGroupingProvider, SuperGroupingTranscript, type SuperGroupingTranscriptProps, TOOLKIT_THEMES, type ToolGroupKeyOptions, type ToolkitTheme, type ToolPartPlacement, ToolPartPlacementProvider, type TurnSegment, type TurnTiming, useActivityExpansion, useToolPartPlacement, workedDurationMs, } from './chat/super-grouping';
+export { type ActivityItem, type ActivityPhase, type ActivityTimelineOptions, type ActivityToolState, buildActivityTimeline, CollapsibleGroup, type CollapsibleGroupProps, countActivityDelegations, countActivityTools, createToolBasedGroupingFunction, DEFAULT_TOOLKIT_THEME, defaultGetToolGroupKey, excludeFinalTextFromGroups, excludePartsFromGroups, type FinalTextPart, type FinalTextSegment, formatWorkDuration, type ActivitySummaryOptions, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, getFinalTextParts, getReasoningLabel, type GetToolGroupKey, type GroupablePart, GroupedMessageParts, type GroupedMessagePartsProps, type GroupingFunction, type MessagePartGroup, readTurnTiming, resetRememberedExpansionsForTests, resolveActivityPhase, splitTurnSegments, SuperGroupingCard, type SuperGroupingCardProps, SuperGroupingFinalText, SuperGroupingProvider, SuperGroupingTranscript, type SuperGroupingTranscriptProps, TOOLKIT_THEMES, type ToolGroupKeyOptions, type ToolkitTheme, type ToolPartPlacement, ToolPartPlacementProvider, type TurnSegment, type TurnTiming, useActivityExpansion, useToolPartPlacement, workedDurationMs, } from './chat/super-grouping';
 export { StatewireApprovalCard } from './chat/StatewireApprovalCard';
 export type { StatewireApprovalCardProps, StatewireApprovalEditorContext, StatewireApprovalRequestContext, StatewireDecisionAnswer, StatewireDecisionConfirmer, } from './chat/StatewireApprovalCard';
 export { useStatewireApprovalRequest } from './chat/use-statewire-approval-request';
@@ -85,6 +85,7 @@ export { classifyToolResult, describeToolArgs, getToolDisplayMeta, isToolResultS
 export type { ToolDisplayMeta, ToolIconKey, ToolResultClassification, } from './agent-runtime/src/index';
 export { HiddenWriteTodosToolUI, PlanStepMarker, WriteTodosToolUI, parseTodoPlan, } from './tools/write-todos-tool-ui';
 export { useLatestTodoPlan } from './tools/todo-plan-store';
+export { AthenaPlanStrip, type AthenaPlanStripProps } from './chat/AthenaPlanStrip';
 export type { LatestTodoPlan } from './tools/todo-plan-store';
 export { EditFileToolUI, friendlyWorkspacePath, ListFilesToolUI, ReadFileToolUI, SearchFilesToolUI, WriteFileToolUI, } from './tools/file-tool-uis';
 export { collectAssetTitles, humanizeToolName, summarizeToolCall, type SummarizeToolCallInput, type ToolCallSummary, type ToolSummaryState, } from './tools/tool-summary';
@@ -189,10 +190,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

@@ -55,6 +55,7 @@ import { InstallPackageToolUI } from "./tools/misc-tool-uis.js";
 import { TOOL_ICONS, toolIcon } from "./tools/tool-icons.js";
 import { HiddenWriteTodosToolUI, PlanStepMarker, WriteTodosToolUI, parseTodoPlan } from "./tools/write-todos-tool-ui.js";
 import { useLatestTodoPlan } from "./tools/todo-plan-store.js";
+import { AthenaPlanStrip } from "./chat/AthenaPlanStrip.js";
 import { EditFileToolUI, ListFilesToolUI, ReadFileToolUI, SearchFilesToolUI, WriteFileToolUI } from "./tools/file-tool-uis.js";
 import { collectAssetTitles, friendlyWorkspacePath, humanizeToolName, summarizeToolCall } from "./tools/tool-summary.js";
 import { ToolFallback, ToolFallbackAppearanceProvider, ToolFallbackArgs, ToolFallbackContent, ToolFallbackError, ToolFallbackNotice, ToolFallbackResult, ToolFallbackRoot, ToolFallbackTrigger, clearAutoOpenedAssets } from "./tools/tool-fallback.js";
@@ -107,9 +108,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";
@@ -157,6 +159,7 @@ export {
   AthenaChat,
   AthenaChatErrorBoundary,
   AthenaLayout,
+  AthenaPlanStrip,
   AthenaProvider,
   AthenaReasoningPart,
   AthenaSdkError,
@@ -538,6 +541,7 @@ export {
   useAthenaVoiceLive,
   useAttachments,
   useBrowserDecisionConfirmer,
+  useChatVoiceEnabled,
   useComposerAttachment,
   useComposerReady,
   useDeviceOperationReader,
@@ -566,6 +570,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,207 @@
+"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_1 = 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 namesNoClient(stateVector) {
+  try {
+    return Y.decodeStateVector(stateVector).size === 0;
+  } catch {
+    return false;
+  }
+}
+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. When Keryx's sync step 1 names no client, the room is new
+   * to Keryx: its answer goes out whole, born as one write, and what the room kept waits for its
+   * echo. Nothing kept, or a socket that cannot hear Keryx: every frame goes out as it is sent.
+   */
+  connect({
+    send,
+    hears
+  }) {
+    let held = null;
+    let roomIsNew = false;
+    const sendNow = (frame) => {
+      for (const out of this.framesFor(frame)) send(out);
+    };
+    return {
+      received: (frame) => {
+        const message = readSyncFrame(frame);
+        if ((message == null ? void 0 : message.syncType) === SYNC_STEP_1) roomIsNew = namesNoClient(message.payload);
+        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;
+        }
+        const syncType = (_a = readSyncFrame(frame)) == null ? void 0 : _a.syncType;
+        if (roomIsNew && syncType === SYNC_STEP_2) {
+          send(frame);
+          return;
+        }
+        if (hears && this.runs.length > 0 && 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 * A room Keryx holds nothing of (its sync step 1 names no client: a document created on the device,\n * its first push) is born whole: assets are born as one write of their real initial state, signed by\n * their creator, and housekeeping inside a new room is part of that state, not system work on\n * anyone's content. Its sync step 2 goes out whole, as the creator's write. What the room kept stays\n * kept until Keryx echoes the push, like any write: a push lost with the socket goes out whole again\n * if Keryx still holds nothing when the room reconnects, and is split like any reconnect's if\n * someone wrote to the room meanwhile.\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  decodeStateVector,\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, the sync step 1 (a state vector) and the sub-types that carry content. */\nconst MESSAGE_SYNC = 0;\nconst SYNC_STEP_1 = 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/** Whether `stateVector` (a sync step 1's) names no client: Keryx holds nothing of the room. */\nfunction namesNoClient(stateVector: Uint8Array): boolean {\n  try {\n    return decodeStateVector(stateVector).size === 0;\n  } catch {\n    return false;\n  }\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. When Keryx's sync step 1 names no client, the room is new\n   * to Keryx: its answer goes out whole, born as one write, and what the room kept waits for its\n   * echo. Nothing kept, or a socket that cannot hear Keryx: every 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    /** Keryx's sync step 1 on this socket named no client: it holds nothing of the room. */\n    let roomIsNew = false;\n    const sendNow = (frame: Uint8Array) => {\n      for (const out of this.framesFor(frame)) send(out);\n    };\n    return {\n      received: (frame) => {\n        const message = readSyncFrame(frame);\n        if (message?.syncType === SYNC_STEP_1) roomIsNew = namesNoClient(message.payload);\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        const syncType = readSyncFrame(frame)?.syncType;\n        if (roomIsNew && syncType === SYNC_STEP_2) {\n          send(frame);\n          return;\n        }\n        if (hears && this.runs.length > 0 && 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","decodeStateVector","createContentIdsFromUpdate","mergeContentIds","excludeContentIds","intersectContentIds","withUpdateAttributionsTrailer","intersectUpdateWithContentIds"],"mappings":"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"}

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

@@ -0,0 +1,141 @@
+/**
+ * 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.
+ *
+ * A room Keryx holds nothing of (its sync step 1 names no client: a document created on the device,
+ * its first push) is born whole: assets are born as one write of their real initial state, signed by
+ * their creator, and housekeeping inside a new room is part of that state, not system work on
+ * anyone's content. Its sync step 2 goes out whole, as the creator's write. What the room kept stays
+ * kept until Keryx echoes the push, like any write: a push lost with the socket goes out whole again
+ * if Keryx still holds nothing when the room reconnects, and is split like any reconnect's if
+ * someone wrote to the room meanwhile.
+ *
+ * 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. When Keryx's sync step 1 names no client, the room is new
+     * to Keryx: its answer goes out whole, born as one write, and what the room kept waits for its
+     * echo. 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 {};