@athenaintel/react 0.42.2 → 0.48.0

package/dist/index.d.ts

@@ -20,15 +20,21 @@ 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, 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 TurnSegment, type TurnTiming, useActivityExpansion, 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, 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, } from './chat/StatewireApprovalCard';
+export type { StatewireApprovalCardProps, StatewireApprovalEditorContext, StatewireApprovalRequestContext, StatewireDecisionAnswer, StatewireDecisionConfirmer, } from './chat/StatewireApprovalCard';
 export { useStatewireApprovalRequest } from './chat/use-statewire-approval-request';
+export { DeviceOperationProvider, deviceOperationStamp, UNREADABLE_DEVICE_OPERATION, useDeviceOperationReader, } from './chat/device-operation';
+export type { DeviceOperationReader } from './chat/device-operation';
+export { agoraApiRoot, useAthenaBrowserDecisionConfirmer, useBrowserDecisionConfirmer, } from './chat/browser-decision-check';
+export type { AthenaBrowserDecisionConfirmerOptions, BrowserDecisionConfirmerOptions, PendingBrowserDecisionConfirm, } from './chat/browser-decision-check';
 export type { StatewireApprovalRequest, StatewireInterruptPredicate, UseStatewireApprovalRequestOptions, } from './chat/use-statewire-approval-request';
 export { useStatewireApprovalWait } from './chat/use-statewire-approval-request';
 export type { StatewireApprovalWait } from './chat/use-statewire-approval-request';
 export { useTurnToolCallsAwaitingApproval } from './agent-runtime/src/index';
 export { useAthenaRunLive } from './chat/use-athena-run-live';
+export { useAthenaVoiceLive } from './chat/use-athena-voice-live';
+export { AthenaTurnEndStatus, type AthenaTurnEndStatusProps, useAthenaTurnEnded, } from './chat/athena-turn-end-status';
 export { StatewireHistoryEdge } from './chat-ui/thread/statewire-history-edge';
 export type { StatewireHistoryEdgeProps } from './chat-ui/thread/statewire-history-edge';
 export { ThreadLoadingOverlay } from './chat-ui/thread/thread-loading-overlay';
@@ -50,6 +56,8 @@ export { athenaStatewireErrorNotice } from './runtime/statewire-lifecycle';
 export type { AthenaStatewireErrorNotice, AthenaStatewireLifecycleState, } from './runtime/statewire-lifecycle';
 export { threadSummaryFromConversation, useAthenaStatewireThreadList, } from './threads/statewire-thread-list';
 export type { AthenaStatewireThreadListState, AthenaStatewireThreadSummary, } from './threads/statewire-thread-list';
+export { DrivingOnChip } from './chat/DrivingOnChip';
+export type { DrivingOnChipProps } from './chat/DrivingOnChip';
 export { WaitingOnYouBanner, WaitingOnYouBannerView } from './chat/WaitingOnYouBanner';
 export type { WaitingOnYouBannerProps, WaitingOnYouBannerViewProps, } from './chat/WaitingOnYouBanner';
 export { WakeMarkerCard, WakeMarkerMessage } from './chat-ui/messages/wake-marker';
@@ -158,6 +166,8 @@ export type { ThreadFavoriteResponse, ThreadInboxDismissResponse, ThreadListFilt
 export { useRefreshThreadList } from './threads/statewire-thread-list';
 export { useAthenaThreadId, AthenaThreadIdContext, useAthenaStatewireThreadId, } from './threads/thread-id-context';
 export { useAthenaThreadModel } from './threads/use-athena-thread-model';
+export { useAthenaSessionPersistence } from './provider/session-persistence-context';
+export type { AthenaSessionPersistence } from './provider/session-persistence-context';
 export type { AthenaThreadModel } from './threads/use-athena-thread-model';
 export { listThreads, archiveThread, getThreadState, createThread, renameThread, setThreadReadState, setThreadFavorite, dismissThreadFromInbox, isThreadArchiveUnavailableError, isThreadFavoriteUnavailableError, isThreadRenameUnavailableError, THREAD_TITLE_MAX_LENGTH, } from './threads/api';
 export type { ThreadFavoriteTarget } from './threads/use-thread-favorite';
@@ -178,7 +188,7 @@ export type { DictationTranscribeContext, DictationTranscriber, RecordedDictatio
 export { useAthenaDictationEngine } from './dictation/use-athena-dictation-engine';
 export { composeDictationDraft, DICTATION_STATUSES } from './dictation/dictation-state';
 export type { DictationStatus, DictationTranscript } from './dictation/dictation-state';
-export type { AthenaChatComposerSlots, AthenaChatDictationOptions } from './chat/AthenaChat';
+export type { AthenaChatComposerSlots, AthenaChatContinueByVoice, AthenaChatDictationOptions, } from './chat/AthenaChat';
 export { useAppendToComposer } from './composer/useAppendToComposer';
 export type { AppendToComposerOptions } from './composer/useAppendToComposer';
 export { useComposerReady, useFocusComposer } from './composer/composer-handoff';
@@ -218,6 +228,8 @@ export type { AthenaEnvironment } from './lib/athena-urls';
 export { Button, buttonVariants } from './ui/button';
 export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from './ui/tooltip';
 export { Collapsible, CollapsibleTrigger, CollapsibleContent } from './ui/collapsible';
+export { ImageViewer } from './ui/image-viewer';
+export type { ImageViewerImage, ImageViewerProps } from './ui/image-viewer';
 export { OwnerDocumentProvider, useIsInPopoutDocument, useOwnerDocument, usePortalContainer, } from './lib/owner-document';
 export type { OwnerDocumentProviderProps } from './lib/owner-document';
 export { a1AnchorCell, a1RangeBounds, columnLettersToNumber, columnNumberToLetters, formatA1Cell, formatA1Range, parseA1Range, RANGE_PREVIEW_MAX_COLUMNS, RANGE_PREVIEW_MAX_ROWS, RangePreviewTable, rangePreviewFromCellMap, rangePreviewFromRows, rangePreviewToTableData, SHEET_MAX_COLUMN, SHEET_MAX_ROW, splitSheetPrefix, } from './sheet-range';

package/dist/index.js

@@ -10,18 +10,24 @@ import { capturePosthogEvent, capturePosthogException, getPosthogCaptureGate, wr
 import { buildCoalescedCaptureProperties, isCriticalPosthogEvent, withCaptureGateBypass } from "./lib/posthog/capture-gate.js";
 import { AthenaAssistantActionBar, AthenaAssistantMessage, AthenaChat, AthenaReasoningPart, AthenaUserMessage } from "./chat/AthenaChat.js";
 import { AthenaChatErrorBoundary } from "./chat/AthenaChatErrorBoundary.js";
-import { buildActivityTimeline, countActivityTools, excludeFinalTextFromGroups, excludePartsFromGroups, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, getFinalTextParts, getReasoningLabel, resolveActivityPhase } from "./chat/super-grouping/activity-timeline.js";
+import { buildActivityTimeline, countActivityDelegations, countActivityTools, excludeFinalTextFromGroups, excludePartsFromGroups, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, getFinalTextParts, getReasoningLabel, resolveActivityPhase } from "./chat/super-grouping/activity-timeline.js";
 import { CollapsibleGroup, DEFAULT_TOOLKIT_THEME, SuperGroupingProvider, TOOLKIT_THEMES } from "./chat/super-grouping/CollapsibleGroup.js";
 import { GroupedMessageParts } from "./chat/super-grouping/GroupedMessageParts.js";
 import { createToolBasedGroupingFunction } from "./chat/super-grouping/grouping-function.js";
 import { SuperGroupingCard, SuperGroupingFinalText, resetRememberedExpansionsForTests, useActivityExpansion } from "./chat/super-grouping/SuperGroupingCard.js";
 import { SuperGroupingTranscript } from "./chat/super-grouping/SuperGroupingTranscript.js";
+import { ToolPartPlacementProvider, useToolPartPlacement } from "./chat/super-grouping/tool-part-placement.js";
 import { splitTurnSegments } from "./chat/super-grouping/turn-segments.js";
 import { formatWorkDuration, readTurnTiming, workedDurationMs } from "./chat/super-grouping/turn-timing.js";
 import { defaultGetToolGroupKey } from "./chat/super-grouping/toolkit-map.js";
+import { isSdkInlineTool } from "./tools/inline-tools.js";
 import { StatewireApprovalCard } from "./chat/StatewireApprovalCard.js";
 import { useStatewireApprovalRequest, useStatewireApprovalWait } from "./chat/use-statewire-approval-request.js";
+import { DeviceOperationProvider, UNREADABLE_DEVICE_OPERATION, deviceOperationStamp, useDeviceOperationReader } from "./chat/device-operation.js";
+import { agoraApiRoot, useAthenaBrowserDecisionConfirmer, useBrowserDecisionConfirmer } from "./chat/browser-decision-check.js";
 import { useAthenaRunLive } from "./chat/use-athena-run-live.js";
+import { useAthenaVoiceLive } from "./chat/use-athena-voice-live.js";
+import { AthenaTurnEndStatus, useAthenaTurnEnded } from "./chat/athena-turn-end-status.js";
 import { StatewireHistoryEdge } from "./chat-ui/thread/statewire-history-edge.js";
 import { ThreadLoadingOverlay } from "./chat-ui/thread/thread-loading-overlay.js";
 import { useStatewireToolOutputs } from "./provider/statewire-window-context.js";
@@ -34,6 +40,7 @@ import { collectStatewireClientTools, statewireClientToolWireEntries } from "./c
 import { useAthenaStatewireLifecycle } from "./provider/statewire-lifecycle-context.js";
 import { athenaStatewireErrorNotice } from "./runtime/statewire-lifecycle.js";
 import { threadSummaryFromConversation, useAthenaStatewireThreadList, useRefreshThreadList } from "./threads/statewire-thread-list.js";
+import { DrivingOnChip } from "./chat/DrivingOnChip.js";
 import { WaitingOnYouBanner, WaitingOnYouBannerView } from "./chat/WaitingOnYouBanner.js";
 import { WakeMarkerCard, WakeMarkerMessage } from "./chat-ui/messages/wake-marker.js";
 import { OFFLINE_SNAPSHOT_READ_WAIT_MS, OfflineSnapshotBanner, formatOfflineSnapshotTime, useAthenaOfflineSnapshotAt } from "./offline/offline-history.js";
@@ -54,7 +61,6 @@ import { ToolFallback, ToolFallbackAppearanceProvider, ToolFallbackArgs, ToolFal
 import { VoiceUpdateCard, VoiceUpdateToolUI } from "./tools/voice-update-tool-ui.js";
 import { TestRecordingMarkToolUI, TestRecordingReportCard, TestRecordingStartToolUI, TestRecordingStopToolUI } from "./tools/test-recording-tool-uis.js";
 import { TEST_RECORDING_MARK_TOOL, TEST_RECORDING_START_TOOL, TEST_RECORDING_STOP_TOOL, describeTestRecordingMark, describeTestRecordingStart, formatRecordingClock, formatTestRecordingCounts, parseTestRecordingStopResult } from "./tools/test-recording-report.js";
-import { isSdkInlineTool } from "./tools/inline-tools.js";
 import { VoiceDelegationCard, VoiceDelegationMessage } from "./chat-ui/messages/voice-delegation-card.js";
 import { NestedPtcComponentsProvider, NestedPtcMessages, useNestedPtcComponents } from "./tools/NestedPtcMessages.js";
 import { ReadAssetToolUI } from "./tools/read-asset-tool-ui.js";
@@ -89,6 +95,7 @@ import { SESSIONS_COLUMNS, agentLabel, channelLabel, creatorLabel, groupSessions
 import { WEB_APP_ORIGIN_LABEL, groupSessions, orderedPullRequests, pullRequestChip, pullRequestChipState, sessionIndicator, sessionListGroupOf, sessionOriginBadge, sessionOriginLabel, sessionSecondaryLine } from "./threads/session-list-model.js";
 import { AthenaThreadIdContext, useAthenaStatewireThreadId, useAthenaThreadId } from "./threads/thread-id-context.js";
 import { useAthenaThreadModel } from "./threads/use-athena-thread-model.js";
+import { useAthenaSessionPersistence } from "./provider/session-persistence-context.js";
 import { THREAD_TITLE_MAX_LENGTH, archiveThread, createThread, dismissThreadFromInbox, getThreadState, isThreadArchiveUnavailableError, isThreadFavoriteUnavailableError, isThreadRenameUnavailableError, listThreads, renameThread, setThreadFavorite, setThreadReadState } from "./threads/api.js";
 import { THREAD_PREFETCH_HOVER_DELAY_MS, THREAD_PREFETCH_MAX_CONCURRENT } from "./threads/thread-prefetcher.js";
 import { conversationDisplayTitle, useRestConversationHistory } from "./threads/use-rest-conversation-history.js";
@@ -119,6 +126,7 @@ import { DEFAULT_APP_URL, DEFAULT_STATEWIRE_SYNC_URL, athenaLinkAppUrl, createAt
 import { Button, buttonVariants } from "./ui/button.js";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "./ui/tooltip.js";
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "./ui/collapsible.js";
+import { ImageViewer } from "./ui/image-viewer.js";
 import { OwnerDocumentProvider, useIsInPopoutDocument, useOwnerDocument, usePortalContainer } from "./lib/owner-document.js";
 import { SHEET_MAX_COLUMN, SHEET_MAX_ROW, a1AnchorCell, a1RangeBounds, columnLettersToNumber, columnNumberToLetters, formatA1Cell, formatA1Range, parseA1Range, splitSheetPrefix } from "./sheet-range/a1.js";
 import { RANGE_PREVIEW_MAX_COLUMNS, RANGE_PREVIEW_MAX_ROWS, rangePreviewFromCellMap, rangePreviewFromRows, rangePreviewToTableData } from "./sheet-range/range-preview.js";
@@ -153,6 +161,7 @@ export {
   AthenaReasoningPart,
   AthenaSdkError,
   AthenaThreadIdContext,
+  AthenaTurnEndStatus,
   AthenaUserMessage,
   AttachmentProvider,
   BrowseToolUI,
@@ -187,8 +196,10 @@ export {
   DICTATION_ENGINE_ERROR_KINDS,
   DICTATION_STATUSES,
   DescribeDatabaseToolUI,
+  DeviceOperationProvider,
   DictationStrip,
   DictationWaveform,
+  DrivingOnChip,
   EditFileToolUI,
   EmailSearchToolUI,
   ExpandableSection,
@@ -200,6 +211,7 @@ export {
   INBOX_PAGE_SIZE,
   INBOX_QUERY,
   INBOX_UNREAD_QUERY,
+  ImageViewer,
   Inbox,
   InboxButton,
   InstallPackageToolUI,
@@ -287,12 +299,14 @@ export {
   ToolFallbackResult,
   ToolFallbackRoot,
   ToolFallbackTrigger,
+  ToolPartPlacementProvider,
   Toolkits,
   Tooltip,
   TooltipContent,
   TooltipIconButton,
   TooltipProvider,
   TooltipTrigger,
+  UNREADABLE_DEVICE_OPERATION,
   UpdateSheetRangeToolUI,
   VoiceDelegationCard,
   VoiceDelegationMessage,
@@ -309,6 +323,7 @@ export {
   a1AnchorCell,
   a1RangeBounds,
   agentLabel,
+  agoraApiRoot,
   appendCitationReferenceParams,
   archiveThread,
   asHitlApproval,
@@ -341,6 +356,7 @@ export {
   computerStatusPath,
   conversationDisplayTitle,
   conversationSummaryFromIndexEntry,
+  countActivityDelegations,
   countActivityTools,
   countChatOutboxMessages,
   createAssetToolUI,
@@ -364,6 +380,7 @@ export {
   describeTestRecordingMark,
   describeTestRecordingStart,
   describeToolArgs,
+  deviceOperationStamp,
   dismissThreadFromInbox,
   excludeFinalTextFromGroups,
   excludePartsFromGroups,
@@ -492,6 +509,7 @@ export {
   useAthenaAgentCatalog,
   useAthenaAgentModelOptions,
   useAthenaAssetContent,
+  useAthenaBrowserDecisionConfirmer,
   useAthenaChatMode,
   useAthenaCitationLinkHandler,
   useAthenaComputerSshAccess,
@@ -506,6 +524,7 @@ export {
   useAthenaRepoSearch,
   useAthenaRunLive,
   useAthenaSessionAttention,
+  useAthenaSessionPersistence,
   useAthenaSessionWorkspace,
   useAthenaSessions,
   useAthenaStatewireLifecycle,
@@ -515,9 +534,13 @@ export {
   useAthenaThreadId,
   useAthenaThreadManager,
   useAthenaThreadModel,
+  useAthenaTurnEnded,
+  useAthenaVoiceLive,
   useAttachments,
+  useBrowserDecisionConfirmer,
   useComposerAttachment,
   useComposerReady,
+  useDeviceOperationReader,
   useDictation,
   useFileUpload,
   useFocusComposer,
@@ -542,6 +565,7 @@ export {
   useStatewireHistory,
   useStatewireToolOutputs,
   useToolAppearance,
+  useToolPartPlacement,
   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/receive-only-socket.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const updateAttributions = require("./update-attributions.cjs");
+const MESSAGE_SYNC = 0;
+const MESSAGE_SYNC_STEP_1 = 0;
+function isDocContentFrame(frame) {
+  const type = updateAttributions.readVarUint({ bytes: frame, start: 0 });
+  if ((type == null ? void 0 : type.value) !== MESSAGE_SYNC) return false;
+  const syncType = updateAttributions.readVarUint({ bytes: frame, start: type.next });
+  if ((syncType == null ? void 0 : syncType.value) !== MESSAGE_SYNC_STEP_1) return true;
+  const length = updateAttributions.readVarUint({ bytes: frame, start: syncType.next });
+  return length === null || length.next + length.value !== frame.length;
+}
+function frameBytes(data) {
+  if (data instanceof Uint8Array) return data;
+  if (ArrayBuffer.isView(data))
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return null;
+}
+function receiveOnlyWebSocket({
+  Base
+}) {
+  if (typeof Base !== "function") return Base;
+  return new Proxy(Base, {
+    construct(target, args) {
+      const socket = Reflect.construct(target, args);
+      const send = socket.send.bind(socket);
+      socket.send = (data) => {
+        const bytes = frameBytes(data);
+        if (bytes === null || isDocContentFrame(bytes)) return;
+        send(data);
+      };
+      return socket;
+    }
+  });
+}
+exports.isDocContentFrame = isDocContentFrame;
+exports.receiveOnlyWebSocket = receiveOnlyWebSocket;
+//# sourceMappingURL=receive-only-socket.cjs.map

package/dist/keryx-http/src/receive-only-socket.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"receive-only-socket.cjs","sources":["../../../../keryx-http/src/receive-only-socket.ts"],"sourcesContent":["/**\n * The socket of a receive-only Keryx room (Olympus's `KeryxYjsProviderV14` with `receiveOnly`;\n * `@athenaintel/react/collab`'s `connectGenericDoc` on a read-only grant): no frame that carries\n * document content leaves it, whatever the room's token would let Keryx accept.\n *\n * y-websocket writes a sync message as `messageSync` (0), then the sync type: a sync step 1 (0)\n * holds only the client's state vector, a sync step 2 (1) and an update (2) hold content. A\n * client answers the sync step 1 Keryx sends as the socket opens with a sync step 2 of everything\n * its doc holds that Keryx lacks, so a write the client made locally would reach the room that way\n * even when its own update was never sent. Awareness, query-awareness and auth frames pass.\n */\nimport { readVarUint, type SendingSocket } from './update-attributions.js';\n\n/** y-protocols: a sync message, and its state-vector-only sub-type. */\nconst MESSAGE_SYNC = 0;\nconst MESSAGE_SYNC_STEP_1 = 0;\n\n/**\n * Whether `frame` could write to the document: a sync message that is not exactly one sync step 1\n * (the state vector and nothing after it). A frame that cannot be read is judged by its first\n * field alone, so only a sync frame is ever dropped.\n */\nexport function isDocContentFrame(frame: Uint8Array): boolean {\n  const type = readVarUint({ bytes: frame, start: 0 });\n  if (type?.value !== MESSAGE_SYNC) return false;\n  const syncType = readVarUint({ bytes: frame, start: type.next });\n  if (syncType?.value !== MESSAGE_SYNC_STEP_1) return true;\n  const length = readVarUint({ bytes: frame, start: syncType.next });\n  return length === null || length.next + length.value !== frame.length;\n}\n\n/** The bytes of a binary frame, or `null` for a frame that is not binary (a string, a `Blob`). */\nfunction frameBytes(data: string | ArrayBufferLike | Blob | ArrayBufferView): Uint8Array | null {\n  if (data instanceof Uint8Array) return data;\n  if (ArrayBuffer.isView(data))\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  return null;\n}\n\n/**\n * `Base` with `send` dropping every frame that could write to the document. A frame it cannot\n * read as bytes is dropped too: y-websocket sends only binary frames, so nothing it needs is lost.\n * A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's\n * `WebSocketPolyfill`.\n */\nexport function receiveOnlyWebSocket<TBase extends new (...args: never[]) => SendingSocket>({\n  Base,\n}: {\n  Base: TBase;\n}): TBase {\n  // No WebSocket where the provider is built (server render, a test without one): nothing to wrap,\n  // and the transport fails at connect as it always did.\n  if (typeof Base !== 'function') return Base;\n  return new Proxy(Base, {\n    construct(target, args) {\n      const socket: SendingSocket = Reflect.construct(target, args);\n      const send = socket.send.bind(socket);\n      socket.send = (data) => {\n        const bytes = frameBytes(data);\n        if (bytes === null || isDocContentFrame(bytes)) return;\n        send(data);\n      };\n      return socket;\n    },\n  });\n}\n"],"names":["readVarUint"],"mappings":";;;AAcA,MAAM,eAAe;AACrB,MAAM,sBAAsB;AAOrB,SAAS,kBAAkB,OAA4B;AAC5D,QAAM,OAAOA,mBAAAA,YAAY,EAAE,OAAO,OAAO,OAAO,GAAG;AACnD,OAAI,6BAAM,WAAU,aAAc,QAAO;AACzC,QAAM,WAAWA,mBAAAA,YAAY,EAAE,OAAO,OAAO,OAAO,KAAK,MAAM;AAC/D,OAAI,qCAAU,WAAU,oBAAqB,QAAO;AACpD,QAAM,SAASA,mBAAAA,YAAY,EAAE,OAAO,OAAO,OAAO,SAAS,MAAM;AACjE,SAAO,WAAW,QAAQ,OAAO,OAAO,OAAO,UAAU,MAAM;AACjE;AAGA,SAAS,WAAW,MAA4E;AAC9F,MAAI,gBAAgB,WAAY,QAAO;AACvC,MAAI,YAAY,OAAO,IAAI;AACzB,WAAO,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;AACrE,MAAI,gBAAgB,YAAa,QAAO,IAAI,WAAW,IAAI;AAC3D,SAAO;AACT;AAQO,SAAS,qBAA4E;AAAA,EAC1F;AACF,GAEU;AAGR,MAAI,OAAO,SAAS,WAAY,QAAO;AACvC,SAAO,IAAI,MAAM,MAAM;AAAA,IACrB,UAAU,QAAQ,MAAM;AACtB,YAAM,SAAwB,QAAQ,UAAU,QAAQ,IAAI;AAC5D,YAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,aAAO,OAAO,CAAC,SAAS;AACtB,cAAM,QAAQ,WAAW,IAAI;AAC7B,YAAI,UAAU,QAAQ,kBAAkB,KAAK,EAAG;AAChD,aAAK,IAAI;AAAA,MACX;AACA,aAAO;AAAA,IACT;AAAA,EAAA,CACD;AACH;;;"}

package/dist/keryx-http/src/receive-only-socket.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The socket of a receive-only Keryx room (Olympus's `KeryxYjsProviderV14` with `receiveOnly`;
+ * `@athenaintel/react/collab`'s `connectGenericDoc` on a read-only grant): no frame that carries
+ * document content leaves it, whatever the room's token would let Keryx accept.
+ *
+ * y-websocket writes a sync message as `messageSync` (0), then the sync type: a sync step 1 (0)
+ * holds only the client's state vector, a sync step 2 (1) and an update (2) hold content. A
+ * client answers the sync step 1 Keryx sends as the socket opens with a sync step 2 of everything
+ * its doc holds that Keryx lacks, so a write the client made locally would reach the room that way
+ * even when its own update was never sent. Awareness, query-awareness and auth frames pass.
+ */
+import { type SendingSocket } from './update-attributions.js';
+/**
+ * Whether `frame` could write to the document: a sync message that is not exactly one sync step 1
+ * (the state vector and nothing after it). A frame that cannot be read is judged by its first
+ * field alone, so only a sync frame is ever dropped.
+ */
+export declare function isDocContentFrame(frame: Uint8Array): boolean;
+/**
+ * `Base` with `send` dropping every frame that could write to the document. A frame it cannot
+ * read as bytes is dropped too: y-websocket sends only binary frames, so nothing it needs is lost.
+ * A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's
+ * `WebSocketPolyfill`.
+ */
+export declare function receiveOnlyWebSocket<TBase extends new (...args: never[]) => SendingSocket>({ Base, }: {
+    Base: TBase;
+}): TBase;

package/dist/keryx-http/src/receive-only-socket.js

@@ -0,0 +1,40 @@
+import { readVarUint } from "./update-attributions.js";
+const MESSAGE_SYNC = 0;
+const MESSAGE_SYNC_STEP_1 = 0;
+function isDocContentFrame(frame) {
+  const type = readVarUint({ bytes: frame, start: 0 });
+  if ((type == null ? void 0 : type.value) !== MESSAGE_SYNC) return false;
+  const syncType = readVarUint({ bytes: frame, start: type.next });
+  if ((syncType == null ? void 0 : syncType.value) !== MESSAGE_SYNC_STEP_1) return true;
+  const length = readVarUint({ bytes: frame, start: syncType.next });
+  return length === null || length.next + length.value !== frame.length;
+}
+function frameBytes(data) {
+  if (data instanceof Uint8Array) return data;
+  if (ArrayBuffer.isView(data))
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return null;
+}
+function receiveOnlyWebSocket({
+  Base
+}) {
+  if (typeof Base !== "function") return Base;
+  return new Proxy(Base, {
+    construct(target, args) {
+      const socket = Reflect.construct(target, args);
+      const send = socket.send.bind(socket);
+      socket.send = (data) => {
+        const bytes = frameBytes(data);
+        if (bytes === null || isDocContentFrame(bytes)) return;
+        send(data);
+      };
+      return socket;
+    }
+  });
+}
+export {
+  isDocContentFrame,
+  receiveOnlyWebSocket
+};
+//# sourceMappingURL=receive-only-socket.js.map

package/dist/keryx-http/src/receive-only-socket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"receive-only-socket.js","sources":["../../../../keryx-http/src/receive-only-socket.ts"],"sourcesContent":["/**\n * The socket of a receive-only Keryx room (Olympus's `KeryxYjsProviderV14` with `receiveOnly`;\n * `@athenaintel/react/collab`'s `connectGenericDoc` on a read-only grant): no frame that carries\n * document content leaves it, whatever the room's token would let Keryx accept.\n *\n * y-websocket writes a sync message as `messageSync` (0), then the sync type: a sync step 1 (0)\n * holds only the client's state vector, a sync step 2 (1) and an update (2) hold content. A\n * client answers the sync step 1 Keryx sends as the socket opens with a sync step 2 of everything\n * its doc holds that Keryx lacks, so a write the client made locally would reach the room that way\n * even when its own update was never sent. Awareness, query-awareness and auth frames pass.\n */\nimport { readVarUint, type SendingSocket } from './update-attributions.js';\n\n/** y-protocols: a sync message, and its state-vector-only sub-type. */\nconst MESSAGE_SYNC = 0;\nconst MESSAGE_SYNC_STEP_1 = 0;\n\n/**\n * Whether `frame` could write to the document: a sync message that is not exactly one sync step 1\n * (the state vector and nothing after it). A frame that cannot be read is judged by its first\n * field alone, so only a sync frame is ever dropped.\n */\nexport function isDocContentFrame(frame: Uint8Array): boolean {\n  const type = readVarUint({ bytes: frame, start: 0 });\n  if (type?.value !== MESSAGE_SYNC) return false;\n  const syncType = readVarUint({ bytes: frame, start: type.next });\n  if (syncType?.value !== MESSAGE_SYNC_STEP_1) return true;\n  const length = readVarUint({ bytes: frame, start: syncType.next });\n  return length === null || length.next + length.value !== frame.length;\n}\n\n/** The bytes of a binary frame, or `null` for a frame that is not binary (a string, a `Blob`). */\nfunction frameBytes(data: string | ArrayBufferLike | Blob | ArrayBufferView): Uint8Array | null {\n  if (data instanceof Uint8Array) return data;\n  if (ArrayBuffer.isView(data))\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  return null;\n}\n\n/**\n * `Base` with `send` dropping every frame that could write to the document. A frame it cannot\n * read as bytes is dropped too: y-websocket sends only binary frames, so nothing it needs is lost.\n * A `Proxy` keeps the constructor's statics and type, so it drops in as y-websocket's\n * `WebSocketPolyfill`.\n */\nexport function receiveOnlyWebSocket<TBase extends new (...args: never[]) => SendingSocket>({\n  Base,\n}: {\n  Base: TBase;\n}): TBase {\n  // No WebSocket where the provider is built (server render, a test without one): nothing to wrap,\n  // and the transport fails at connect as it always did.\n  if (typeof Base !== 'function') return Base;\n  return new Proxy(Base, {\n    construct(target, args) {\n      const socket: SendingSocket = Reflect.construct(target, args);\n      const send = socket.send.bind(socket);\n      socket.send = (data) => {\n        const bytes = frameBytes(data);\n        if (bytes === null || isDocContentFrame(bytes)) return;\n        send(data);\n      };\n      return socket;\n    },\n  });\n}\n"],"names":[],"mappings":";AAcA,MAAM,eAAe;AACrB,MAAM,sBAAsB;AAOrB,SAAS,kBAAkB,OAA4B;AAC5D,QAAM,OAAO,YAAY,EAAE,OAAO,OAAO,OAAO,GAAG;AACnD,OAAI,6BAAM,WAAU,aAAc,QAAO;AACzC,QAAM,WAAW,YAAY,EAAE,OAAO,OAAO,OAAO,KAAK,MAAM;AAC/D,OAAI,qCAAU,WAAU,oBAAqB,QAAO;AACpD,QAAM,SAAS,YAAY,EAAE,OAAO,OAAO,OAAO,SAAS,MAAM;AACjE,SAAO,WAAW,QAAQ,OAAO,OAAO,OAAO,UAAU,MAAM;AACjE;AAGA,SAAS,WAAW,MAA4E;AAC9F,MAAI,gBAAgB,WAAY,QAAO;AACvC,MAAI,YAAY,OAAO,IAAI;AACzB,WAAO,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;AACrE,MAAI,gBAAgB,YAAa,QAAO,IAAI,WAAW,IAAI;AAC3D,SAAO;AACT;AAQO,SAAS,qBAA4E;AAAA,EAC1F;AACF,GAEU;AAGR,MAAI,OAAO,SAAS,WAAY,QAAO;AACvC,SAAO,IAAI,MAAM,MAAM;AAAA,IACrB,UAAU,QAAQ,MAAM;AACtB,YAAM,SAAwB,QAAQ,UAAU,QAAQ,IAAI;AAC5D,YAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,aAAO,OAAO,CAAC,SAAS;AACtB,cAAM,QAAQ,WAAW,IAAI;AAC7B,YAAI,UAAU,QAAQ,kBAAkB,KAAK,EAAG;AAChD,aAAK,IAAI;AAAA,MACX;AACA,aAAO;AAAA,IACT;AAAA,EAAA,CACD;AACH;"}

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

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

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

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

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

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