cojson 0.18.26 → 0.18.27

package/src/coValueCore/verifiedState.ts

@@ -17,11 +17,11 @@ import { RawCoID, SessionID, TransactionID } from "../ids.js";
 import { Stringified } from "../jsonStringify.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { PermissionsDef as RulesetDef } from "../permissions.js";
-import { CoValueKnownState, NewContentMessage } from "../sync.js";
+import { NewContentMessage } from "../sync.js";
 import { TryAddTransactionsError } from "./coValueCore.js";
 import { SessionLog, SessionMap } from "./SessionMap.js";
 import { ControlledAccountOrAgent } from "../coValues/account.js";
-import { logger } from "../logger.js";
+import { cloneKnownState, CoValueKnownState } from "../knownState.js";
 
 export type CoValueHeader = {
   type: AnyRawCoValue["type"];
@@ -56,8 +56,8 @@ export class VerifiedState {
   readonly header: CoValueHeader;
   readonly sessions: SessionMap;
   private _cachedKnownState?: CoValueKnownState;
+  private _cachedKnownStateWithStreaming?: CoValueKnownState;
   private _cachedNewContentSinceEmpty: NewContentMessage[] | undefined;
-  private streamingKnownState?: CoValueKnownState["sessions"];
   public lastAccessed: number | undefined;
   public branchSourceId?: RawCoID;
   public branchName?: string;
@@ -67,15 +67,11 @@ export class VerifiedState {
     crypto: CryptoProvider,
     header: CoValueHeader,
     sessions?: SessionMap,
-    streamingKnownState?: CoValueKnownState["sessions"],
   ) {
     this.id = id;
     this.crypto = crypto;
     this.header = header;
     this.sessions = sessions ?? new SessionMap(id, crypto);
-    this.streamingKnownState = streamingKnownState
-      ? { ...streamingKnownState }
-      : undefined;
     this.branchSourceId = header.meta?.source as RawCoID | undefined;
     this.branchName = header.meta?.branch as string | undefined;
   }
@@ -86,7 +82,6 @@ export class VerifiedState {
       this.crypto,
       this.header,
       this.sessions.clone(),
-      this.streamingKnownState ? { ...this.streamingKnownState } : undefined,
     );
   }
 
@@ -108,6 +103,7 @@ export class VerifiedState {
     if (result.isOk()) {
       this._cachedNewContentSinceEmpty = undefined;
       this._cachedKnownState = undefined;
+      this._cachedKnownStateWithStreaming = undefined;
     }
 
     return result;
@@ -130,6 +126,7 @@ export class VerifiedState {
 
     this._cachedNewContentSinceEmpty = undefined;
     this._cachedKnownState = undefined;
+    this._cachedKnownStateWithStreaming = undefined;
 
     return result;
   }
@@ -155,6 +152,7 @@ export class VerifiedState {
 
     this._cachedNewContentSinceEmpty = undefined;
     this._cachedKnownState = undefined;
+    this._cachedKnownStateWithStreaming = undefined;
 
     return result;
   }
@@ -289,72 +287,42 @@ export class VerifiedState {
   }
 
   /**
-   * Returns the known state considering the known state of the streaming source
+   * Returns the known state of the CoValue
    *
-   * Used to correctly manage the content & subscriptions during the content streaming process
+   * The return value identity is going to be stable as long as the CoValue is not modified.
+   *
+   * On change the knownState is invalidated and a new object is returned.
    */
-  knownStateWithStreaming(): CoValueKnownState {
-    const knownState = this.knownState();
-
-    if (this.streamingKnownState) {
-      const newSessions: CoValueKnownState["sessions"] = {};
-      const entries = Object.entries(this.streamingKnownState);
-
-      for (const [sessionID, txs] of entries) {
-        newSessions[sessionID as SessionID] = txs;
-        if ((knownState.sessions[sessionID as SessionID] ?? 0) < txs) {
-          newSessions[sessionID as SessionID] = txs;
-        } else {
-          newSessions[sessionID as SessionID] = txs;
-          delete this.streamingKnownState[sessionID as SessionID];
-        }
-      }
-
-      if (Object.keys(this.streamingKnownState).length === 0) {
-        this.streamingKnownState = undefined;
-        return knownState;
-      } else {
-        return {
-          id: knownState.id,
-          header: knownState.header,
-          sessions: newSessions,
-        };
-      }
-    }
-
-    return knownState;
-  }
-
-  isStreaming(): boolean {
-    // Call knownStateWithStreaming to delete the streamingKnownState when it matches the current knownState
-    this.knownStateWithStreaming();
-
-    return this.streamingKnownState !== undefined;
-  }
-
-  knownState(): CoValueKnownState {
+  knownState() {
     if (this._cachedKnownState) {
       return this._cachedKnownState;
-    } else {
-      const knownState = this.knownStateUncached();
-      this._cachedKnownState = knownState;
-      return knownState;
     }
+    this._cachedKnownState = cloneKnownState(this.sessions.knownState);
+    return this._cachedKnownState;
   }
 
-  /** @internal */
-  knownStateUncached(): CoValueKnownState {
-    const sessions: CoValueKnownState["sessions"] = {};
+  /**
+   * Returns the known state considering the known state of the streaming source
+   *
+   * Used to correctly manage the content & subscriptions during the content streaming process
+   */
+  knownStateWithStreaming() {
+    if (!this.sessions.knownStateWithStreaming) {
+      return this.knownState();
+    }
 
-    for (const [sessionID, sessionLog] of this.sessions.entries()) {
-      sessions[sessionID] = sessionLog.transactions.length;
+    if (this._cachedKnownStateWithStreaming) {
+      return this._cachedKnownStateWithStreaming;
     }
+    this._cachedKnownStateWithStreaming = cloneKnownState(
+      this.sessions.knownStateWithStreaming,
+    );
 
-    return {
-      id: this.id,
-      header: true,
-      sessions,
-    };
+    return this._cachedKnownStateWithStreaming;
+  }
+
+  isStreaming(): boolean {
+    return Boolean(this.sessions.knownStateWithStreaming);
   }
 
   decryptTransaction(

package/src/coValues/coMap.ts

@@ -1,11 +1,7 @@
 import { CoID, RawCoValue } from "../coValue.js";
-import {
-  AvailableCoValueCore,
-  CoValueCore,
-} from "../coValueCore/coValueCore.js";
+import { AvailableCoValueCore } from "../coValueCore/coValueCore.js";
 import { AgentID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
-import { CoValueKnownState } from "../sync.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";
 import { RawAccountID } from "./account.js";

package/src/coValues/coStream.ts

@@ -1,13 +1,9 @@
 import { base64URLtoBytes, bytesToBase64url } from "../base64url.js";
 import { CoID, RawCoValue } from "../coValue.js";
-import {
-  AvailableCoValueCore,
-  CoValueCore,
-} from "../coValueCore/coValueCore.js";
+import { AvailableCoValueCore } from "../coValueCore/coValueCore.js";
 import { AgentID, SessionID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { logger } from "../logger.js";
-import { CoValueKnownState } from "../sync.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { isAccountID } from "../typeUtils/isAccountID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";

package/src/exports.ts

@@ -65,9 +65,9 @@ import type { Peer, SyncMessage } from "./sync.js";
 import {
   DisconnectedError,
   SyncManager,
-  emptyKnownState,
   hwrServerPeerSelector,
 } from "./sync.js";
+import { emptyKnownState } from "./knownState.js";
 
 import {
   getContentMessageSize,
@@ -189,7 +189,7 @@ export * from "./storage/index.js";
 // biome-ignore format: off
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace CojsonInternalTypes {
-  export type CoValueKnownState = import("./sync.js").CoValueKnownState;
+  export type CoValueKnownState = import("./knownState.js").CoValueKnownState;
   export type CoJsonValue<T> = import("./jsonValue.js").CoJsonValue<T>;
   export type DoneMessage = import("./sync.js").DoneMessage;
   export type Encrypted<T extends JsonValue, N extends JsonValue> = import("./crypto/crypto.js").Encrypted<T, N>;

package/src/knownState.ts

@@ -1,17 +1,123 @@
-import type { SessionID } from "./exports.js";
-import type { CoValueKnownState } from "./sync.js";
+import type { RawCoID, SessionID } from "./exports.js";
 
+export type KnownStateSessions = { [sessionID: SessionID]: number };
+
+export type CoValueKnownState = {
+  id: RawCoID;
+  header: boolean;
+  sessions: KnownStateSessions;
+};
+
+/**
+ * Returns an empty known state for a CoValue, with no header and empty sessions.
+ */
+export function emptyKnownState(id: RawCoID): CoValueKnownState {
+  return {
+    id,
+    header: false,
+    sessions: {},
+  };
+}
+
+/**
+ * Picks the knownState properties from the input object
+ */
+export function knownStateFrom(input: CoValueKnownState) {
+  return {
+    id: input.id,
+    header: input.header,
+    sessions: input.sessions,
+  };
+}
+
+/**
+ * Mutate the target known state by combining the sessions from the source.
+ *
+ * The function assigns the sessions to the target only when the value in the source is greater.
+ */
+export function combineKnownStates(
+  target: CoValueKnownState,
+  source: CoValueKnownState,
+): CoValueKnownState {
+  combineKnownStateSessions(target.sessions, source.sessions);
+
+  if (source.header && !target.header) {
+    target.header = true;
+  }
+
+  return target;
+}
+
+/**
+ * Mutate the target sessions counter by combining the entries from the source.
+ *
+ * The function assigns the sessions to the target only when the value in the source is greater.
+ */
 export function combineKnownStateSessions(
-  a: CoValueKnownState["sessions"],
-  b: CoValueKnownState["sessions"],
-): CoValueKnownState["sessions"] {
-  const sessionStates: CoValueKnownState["sessions"] = {};
-
-  for (const sessionID of Object.keys(a).concat(
-    Object.keys(b),
-  ) as SessionID[]) {
-    sessionStates[sessionID] = Math.max(a[sessionID] || 0, b[sessionID] || 0);
+  target: KnownStateSessions,
+  source: KnownStateSessions,
+) {
+  for (const [sessionID, count] of Object.entries(source) as [
+    SessionID,
+    number,
+  ][]) {
+    const currentCount = target[sessionID] || 0;
+
+    if (count > currentCount) {
+      target[sessionID] = count;
+    }
+  }
+
+  return target;
+}
+
+/**
+ * Set the session counter for a sessionId in the known state.
+ */
+export function setSessionCounter(
+  knownState: KnownStateSessions,
+  sessionId: SessionID,
+  value: number,
+) {
+  knownState[sessionId] = value;
+}
+
+/**
+ * Update the session counter for a sessionId in the known state.
+ *
+ * The function assigns the value to the target only when the value in the knownState is less than the provided value.
+ */
+export function updateSessionCounter(
+  knownState: KnownStateSessions,
+  sessionId: SessionID,
+  value: number,
+) {
+  knownState[sessionId] = Math.max(knownState[sessionId] || 0, value);
+}
+
+/**
+ * Efficient cloning of a known state.
+ */
+export function cloneKnownState(knownState: CoValueKnownState) {
+  return {
+    id: knownState.id,
+    header: knownState.header,
+    sessions: { ...knownState.sessions },
+  };
+}
+
+/**
+ * Checks if all the local sessions have the same counters as in remote.
+ */
+export function areLocalSessionsUploaded(
+  local: Record<string, number>,
+  remote: Record<string, number>,
+) {
+  for (const sessionId of Object.keys(local)) {
+    if (local[sessionId] !== remote[sessionId]) {
+      return false;
+    }
   }
 
-  return sessionStates;
+  return true;
 }

package/src/permissions.ts

@@ -15,15 +15,12 @@ import {
   AgentID,
   ParentGroupReference,
   RawCoID,
-  SessionID,
   TransactionID,
   getParentGroupId,
 } from "./ids.js";
 import { parseJSON } from "./jsonStringify.js";
 import { JsonValue } from "./jsonValue.js";
 import { logger } from "./logger.js";
-import { CoValueKnownState } from "./sync.js";
-import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
 
 export type PermissionsDef =

package/src/storage/knownState.ts

@@ -1,7 +1,10 @@
-import { getIsUploaded } from "../SyncStateManager.js";
 import { type CoValueCore } from "../exports.js";
 import { RawCoID } from "../ids.js";
-import { CoValueKnownState, emptyKnownState } from "../sync.js";
+import {
+  CoValueKnownState,
+  emptyKnownState,
+  areLocalSessionsUploaded,
+} from "../knownState.js";
 
 /**
  * Track how much data we have stored inside our storage
@@ -84,5 +87,8 @@ function isInSync(
     return false;
   }
 
-  return getIsUploaded(knownState.sessions, knownStateFromStorage.sessions);
+  return areLocalSessionsUploaded(
+    knownState.sessions,
+    knownStateFromStorage.sessions,
+  );
 }

package/src/storage/storageAsync.ts

@@ -10,11 +10,12 @@ import {
   logger,
 } from "../exports.js";
 import { StoreQueue } from "../queue/StoreQueue.js";
+import { NewContentMessage } from "../sync.js";
 import {
   CoValueKnownState,
-  NewContentMessage,
   emptyKnownState,
-} from "../sync.js";
+  setSessionCounter,
+} from "../knownState.js";
 import { StorageKnownState } from "./knownState.js";
 import {
   collectNewTxs,
@@ -93,7 +94,11 @@ export class StorageApiAsync implements StorageAPI {
     knownState.header = true;
 
     for (const sessionRow of allCoValueSessions) {
-      knownState.sessions[sessionRow.sessionID] = sessionRow.lastIdx;
+      setSessionCounter(
+        knownState.sessions,
+        sessionRow.sessionID,
+        sessionRow.lastIdx,
+      );
     }
 
     this.loadedCoValues.add(coValueRow.id);
@@ -101,7 +106,7 @@ export class StorageApiAsync implements StorageAPI {
     let contentMessage = createContentMessage(coValueRow.id, coValueRow.header);
 
     if (contentStreaming) {
-      contentMessage.expectContentUntil = knownState["sessions"];
+      contentMessage.expectContentUntil = knownState.sessions;
     }
 
     for (const sessionRow of allCoValueSessions) {
@@ -282,14 +287,17 @@ export class StorageApiAsync implements StorageAPI {
         );
 
         if (sessionRow) {
-          knownState.sessions[sessionRow.sessionID] = sessionRow.lastIdx;
+          setSessionCounter(
+            knownState.sessions,
+            sessionRow.sessionID,
+            sessionRow.lastIdx,
+          );
         }
 
         const lastIdx = sessionRow?.lastIdx || 0;
         const after = msg.new[sessionID]?.after || 0;
 
         if (lastIdx < after) {
-          knownState.sessions[sessionID] = lastIdx;
           invalidAssumptions = true;
         } else {
           const newLastIdx = await this.putNewTxs(
@@ -298,7 +306,7 @@ export class StorageApiAsync implements StorageAPI {
             sessionRow,
             storedCoValueRowID,
           );
-          knownState.sessions[sessionID] = newLastIdx;
+          setSessionCounter(knownState.sessions, sessionID, newLastIdx);
         }
       });
     }

package/src/storage/storageSync.ts

@@ -2,7 +2,6 @@ import { UpDownCounter, metrics } from "@opentelemetry/api";
 import {
   createContentMessage,
   exceedsRecommendedSize,
-  getTransactionSize,
 } from "../coValueContentMessage.js";
 import {
   CoValueCore,
@@ -11,12 +10,13 @@ import {
   type StorageAPI,
   logger,
 } from "../exports.js";
+import { NewContentMessage } from "../sync.js";
+import { StorageKnownState } from "./knownState.js";
 import {
   CoValueKnownState,
-  NewContentMessage,
   emptyKnownState,
-} from "../sync.js";
-import { StorageKnownState } from "./knownState.js";
+  setSessionCounter,
+} from "../knownState.js";
 import {
   collectNewTxs,
   getDependedOnCoValues,
@@ -96,7 +96,11 @@ export class StorageApiSync implements StorageAPI {
     knownState.header = true;
 
     for (const sessionRow of allCoValueSessions) {
-      knownState.sessions[sessionRow.sessionID] = sessionRow.lastIdx;
+      setSessionCounter(
+        knownState.sessions,
+        sessionRow.sessionID,
+        sessionRow.lastIdx,
+      );
     }
 
     this.loadedCoValues.add(coValueRow.id);
@@ -105,7 +109,7 @@ export class StorageApiSync implements StorageAPI {
 
     if (contentStreaming) {
       this.streamingCounter.add(1);
-      contentMessage.expectContentUntil = knownState["sessions"];
+      contentMessage.expectContentUntil = knownState.sessions;
     }
 
     for (const sessionRow of allCoValueSessions) {
@@ -260,7 +264,11 @@ export class StorageApiSync implements StorageAPI {
         );
 
         if (sessionRow) {
-          knownState.sessions[sessionRow.sessionID] = sessionRow.lastIdx;
+          setSessionCounter(
+            knownState.sessions,
+            sessionRow.sessionID,
+            sessionRow.lastIdx,
+          );
         }
 
         if ((sessionRow?.lastIdx || 0) < (msg.new[sessionID]?.after || 0)) {
@@ -272,7 +280,7 @@ export class StorageApiSync implements StorageAPI {
             sessionRow,
             storedCoValueRowID,
           );
-          knownState.sessions[sessionID] = newLastIdx;
+          setSessionCounter(knownState.sessions, sessionID, newLastIdx);
         }
       });
     }

package/src/storage/types.ts

@@ -4,7 +4,8 @@ import type {
 } from "../coValueCore/verifiedState.js";
 import { Signature } from "../crypto/crypto.js";
 import type { CoValueCore, RawCoID, SessionID } from "../exports.js";
-import { CoValueKnownState, NewContentMessage } from "../sync.js";
+import { NewContentMessage } from "../sync.js";
+import { CoValueKnownState } from "../knownState.js";
 
 export type CorrectionCallback = (
   correction: CoValueKnownState,

package/src/sync.ts

@@ -16,20 +16,11 @@ import { logger } from "./logger.js";
 import { CoValuePriority } from "./priority.js";
 import { IncomingMessagesQueue } from "./queue/IncomingMessagesQueue.js";
 import { LocalTransactionsSyncQueue } from "./queue/LocalTransactionsSyncQueue.js";
-
-export type CoValueKnownState = {
-  id: RawCoID;
-  header: boolean;
-  sessions: { [sessionID: SessionID]: number };
-};
-
-export function emptyKnownState(id: RawCoID): CoValueKnownState {
-  return {
-    id,
-    header: false,
-    sessions: {},
-  };
-}
+import {
+  CoValueKnownState,
+  knownStateFrom,
+  KnownStateSessions,
+} from "./knownState.js";
 
 export type SyncMessage =
   | LoadMessage
@@ -55,9 +46,7 @@ export type NewContentMessage = {
   new: {
     [sessionID: SessionID]: SessionNewContent;
   };
-  expectContentUntil?: {
-    [sessionID: SessionID]: number;
-  };
+  expectContentUntil?: KnownStateSessions;
 };
 
 export type SessionNewContent = {
@@ -97,31 +86,6 @@ export interface Peer {
   persistent?: boolean;
 }
 
-export function combinedKnownStates(
-  stateA: CoValueKnownState,
-  stateB: CoValueKnownState,
-): CoValueKnownState {
-  const sessionStates: CoValueKnownState["sessions"] = {};
-
-  const allSessions = new Set([
-    ...Object.keys(stateA.sessions),
-    ...Object.keys(stateB.sessions),
-  ] as SessionID[]);
-
-  for (const sessionID of allSessions) {
-    const stateAValue = stateA.sessions[sessionID];
-    const stateBValue = stateB.sessions[sessionID];
-
-    sessionStates[sessionID] = Math.max(stateAValue || 0, stateBValue || 0);
-  }
-
-  return {
-    id: stateA.id,
-    header: stateA.header || stateB.header,
-    sessions: sessionStates,
-  };
-}
-
 export type ServerPeerSelector = (
   id: RawCoID,
   serverPeers: PeerState[],
@@ -446,7 +410,7 @@ export class SyncManager {
      * This way we can track part of the data loss that may occur when the other peer is restarted
      *
      */
-    peer.setKnownState(msg.id, knownStateIn(msg));
+    peer.setKnownState(msg.id, knownStateFrom(msg));
     const coValue = this.local.getCoValue(msg.id);
 
     if (coValue.isAvailable()) {
@@ -482,7 +446,7 @@ export class SyncManager {
   handleKnownState(msg: KnownStateMessage, peer: PeerState) {
     const coValue = this.local.getCoValue(msg.id);
 
-    peer.combineWith(msg.id, knownStateIn(msg));
+    peer.combineWith(msg.id, knownStateFrom(msg));
 
     // The header is a boolean value that tells us if the other peer do have information about the header.
     // If it's false in this point it means that the coValue is unavailable on the other peer.
@@ -706,12 +670,10 @@ export class SyncManager {
         contentToStore.new[sessionID] = newContentForSession;
       }
 
-      peer?.updateSessionCounter(
-        msg.id,
-        sessionID,
+      const transactionsCount =
         newContentForSession.after +
-          newContentForSession.newTransactions.length,
-      );
+        newContentForSession.newTransactions.length;
+      peer?.updateSessionCounter(msg.id, sessionID, transactionsCount);
     }
 
     /**
@@ -804,7 +766,7 @@ export class SyncManager {
   }
 
   handleCorrection(msg: KnownStateMessage, peer: PeerState) {
-    peer.setKnownState(msg.id, knownStateIn(msg));
+    peer.setKnownState(msg.id, knownStateFrom(msg));
 
     return this.sendNewContent(msg.id, peer);
   }
@@ -952,14 +914,6 @@ export class SyncManager {
   }
 }
 
-function knownStateIn(msg: LoadMessage | KnownStateMessage) {
-  return {
-    id: msg.id,
-    header: msg.header,
-    sessions: msg.sessions,
-  };
-}
-
 /**
  * Returns a ServerPeerSelector that implements the Highest Weighted Random (HWR) algorithm.
  *

package/src/tests/PeerKnownStates.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test, vi } from "vitest";
 import { PeerKnownStates } from "../PeerKnownStates.js";
 import { RawCoID, SessionID } from "../ids.js";
-import { CoValueKnownState, emptyKnownState } from "../sync.js";
+import { CoValueKnownState, emptyKnownState } from "../knownState.js";
 
 describe("PeerKnownStates", () => {
   test("should set and get a known state", () => {