cojson 0.18.26 → 0.18.28

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/localNode.ts

@@ -116,7 +116,7 @@ export class LocalNode {
     let entry = this.coValues.get(id);
 
     if (!entry) {
-      entry = CoValueCore.fromID(id, this);
+      entry = new CoValueCore(id, this);
       this.coValues.set(id, entry);
     }
 

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 =
@@ -118,9 +115,9 @@ export function determineValidTransactions(coValue: CoValueCore) {
       }
 
       tx.isValidated = true;
-      const wasValid = tx.isValid;
-
-      const groupAtTime = groupContent.atTime(tx.madeAt);
+      // We use the original made at to get the group at the original time when the transaction was made
+      // madeAt might be changed by the meta field (e.g. merged transactions), and so can't be used for permissions checks
+      const groupAtTime = groupContent.atTime(tx.currentMadeAt);
       const effectiveTransactor = agentInAccountOrMemberInGroup(
         tx.author,
         groupAtTime,
@@ -134,6 +131,21 @@ export function determineValidTransactions(coValue: CoValueCore) {
       const transactorRoleAtTxTime =
         groupAtTime.roleOfInternal(effectiveTransactor);
 
+      if (
+        transactorRoleAtTxTime === "reader" &&
+        tx.meta?.branch &&
+        tx.meta?.ownerId
+      ) {
+        // Force the changes and meta to only contain the branch pointer information
+        tx.meta = {
+          branch: tx.meta.branch,
+          ownerId: tx.meta.ownerId,
+        };
+        tx.changes = [];
+        tx.isValid = true;
+        continue;
+      }
+
       if (
         transactorRoleAtTxTime !== "admin" &&
         transactorRoleAtTxTime !== "writer" &&
@@ -220,13 +232,10 @@ function determineValidTransactionsForGroup(
   initialAdmin: RawAccountID | AgentID,
   extendChain?: Set<CoValueCore["id"]>,
 ): { memberState: MemberState } {
-  coValue.verifiedTransactions.sort((a, b) => {
-    return a.madeAt - b.madeAt;
-  });
+  coValue.verifiedTransactions.sort(coValue.compareTransactions);
 
   const memberState: MemberState = {};
   const writeOnlyKeys: Record<RawAccountID | AgentID, KeyID> = {};
-  const validTransactions: ValidTransactionsResult[] = [];
 
   const writeKeys = new Set<string>();
 
@@ -249,20 +258,10 @@ function determineValidTransactionsForGroup(
       }
     }
 
-    let changes = transaction.changes;
+    const changes = transaction.changes;
 
     if (!changes) {
-      try {
-        changes = parseJSON(tx.changes);
-        transaction.changes = changes;
-      } catch (e) {
-        logPermissionError("Invalid JSON in transaction", {
-          id: coValue.id,
-          tx,
-        });
-        transaction.hasInvalidChanges = true;
-        continue;
-      }
+      continue;
     }
 
     const change = changes[0] as

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,