cojson 0.20.7 → 0.20.9

package/src/base64url.test.ts

@@ -1,5 +1,9 @@
 import { expect, test } from "vitest";
-import { base64URLtoBytes, bytesToBase64url } from "./base64url.js";
+import {
+  base64URLtoBytes,
+  bytesToBase64url,
+  bytesToBase64,
+} from "./base64url.js";
 
 const txt = new TextEncoder();
 
@@ -31,3 +35,87 @@ test("Test our Base64 URL encoding and decoding", () => {
     "V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ=",
   );
 });
+
+test("Single special bytes: 0x00 and 0xFF", () => {
+  const zero = new Uint8Array([0x00]);
+  const encoded0 = bytesToBase64url(zero);
+  expect(base64URLtoBytes(encoded0)).toEqual(zero);
+
+  const ff = new Uint8Array([0xff]);
+  const encodedFF = bytesToBase64url(ff);
+  expect(base64URLtoBytes(encodedFF)).toEqual(ff);
+});
+
+test("All 256 byte values round-trip", () => {
+  const allBytes = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) allBytes[i] = i;
+  const encoded = bytesToBase64url(allBytes);
+  expect(base64URLtoBytes(encoded)).toEqual(allBytes);
+});
+
+test("Decoding without padding", () => {
+  expect(base64URLtoBytes("Zg")).toEqual(base64URLtoBytes("Zg=="));
+  expect(base64URLtoBytes("Zm8")).toEqual(base64URLtoBytes("Zm8="));
+  expect(base64URLtoBytes("Zm9vYg")).toEqual(base64URLtoBytes("Zm9vYg=="));
+  expect(base64URLtoBytes("Zm9vYmE")).toEqual(base64URLtoBytes("Zm9vYmE="));
+});
+
+test("Larger binary data round-trip (4KB)", () => {
+  const size = 4096;
+  const data = new Uint8Array(size);
+  // Deterministic pseudo-random fill
+  let seed = 42;
+  for (let i = 0; i < size; i++) {
+    seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+    data[i] = seed & 0xff;
+  }
+  const encoded = bytesToBase64url(data);
+  expect(base64URLtoBytes(encoded)).toEqual(data);
+});
+
+test("URL-safe characters: - and _ instead of + and /", () => {
+  // 0xFB, 0xEF, 0xBE → standard base64 "++--", base64url "----"
+  const bytes1 = new Uint8Array([0xfb, 0xef, 0xbe]);
+  const encoded1 = bytesToBase64url(bytes1);
+  expect(encoded1).not.toContain("+");
+  expect(encoded1).not.toContain("/");
+  expect(encoded1).toContain("-");
+  expect(base64URLtoBytes(encoded1)).toEqual(bytes1);
+
+  // 0xFF, 0xFF, 0xFE → standard base64 "///+", base64url "___-"
+  const bytes2 = new Uint8Array([0xff, 0xff, 0xfe]);
+  const encoded2 = bytesToBase64url(bytes2);
+  expect(encoded2).not.toContain("+");
+  expect(encoded2).not.toContain("/");
+  expect(encoded2).toContain("_");
+  expect(encoded2).toContain("-");
+  expect(base64URLtoBytes(encoded2)).toEqual(bytes2);
+});
+
+test("bytesToBase64 produces standard base64 with + and /", () => {
+  // 0xFB, 0xEF, 0xBE → standard base64 should contain "-" characters that become "+"
+  const bytes1 = new Uint8Array([0xfb, 0xef, 0xbe]);
+  const encoded1 = bytesToBase64(bytes1);
+  expect(encoded1).not.toContain("-");
+  expect(encoded1).not.toContain("_");
+  expect(encoded1).toContain("+");
+
+  // 0xFF, 0xFF, 0xFE → standard base64 "///+"
+  const bytes2 = new Uint8Array([0xff, 0xff, 0xfe]);
+  const encoded2 = bytesToBase64(bytes2);
+  expect(encoded2).not.toContain("-");
+  expect(encoded2).not.toContain("_");
+  expect(encoded2).toContain("/");
+  expect(encoded2).toContain("+");
+  expect(encoded2).toEqual("///+");
+});
+
+test("bytesToBase64 RFC test vectors", () => {
+  expect(bytesToBase64(new Uint8Array([]))).toEqual("");
+  expect(bytesToBase64(txt.encode("f"))).toEqual("Zg==");
+  expect(bytesToBase64(txt.encode("fo"))).toEqual("Zm8=");
+  expect(bytesToBase64(txt.encode("foo"))).toEqual("Zm9v");
+  expect(bytesToBase64(txt.encode("foob"))).toEqual("Zm9vYg==");
+  expect(bytesToBase64(txt.encode("fooba"))).toEqual("Zm9vYmE=");
+  expect(bytesToBase64(txt.encode("foobar"))).toEqual("Zm9vYmFy");
+});

package/src/base64url.ts

@@ -1,7 +1,104 @@
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 
-export function base64URLtoBytes(base64: string) {
+// Check for native base64 support (available in modern runtimes)
+const hasNativeBase64 =
+  typeof (Uint8Array.prototype as unknown as { toBase64?: unknown })
+    .toBase64 === "function" &&
+  typeof (Uint8Array as unknown as { fromBase64?: unknown }).fromBase64 ===
+    "function";
+
+// Native implementation hooks for React Native (set via setNativeBase64Implementation)
+let nativeBytesToBase64url: ((bytes: ArrayBuffer) => string) | undefined;
+let nativeBase64urlToBytes: ((base64: string) => ArrayBuffer) | undefined;
+let nativeBytesToBase64: ((bytes: ArrayBuffer) => string) | undefined;
+
+/**
+ * Set native base64 implementation for React Native.
+ * Called by RNCrypto.create() to register native Rust implementations.
+ * @internal
+ */
+export function setNativeBase64Implementation(impl: {
+  bytesToBase64url: (bytes: ArrayBuffer) => string;
+  base64urlToBytes: (base64: string) => ArrayBuffer;
+  bytesToBase64: (bytes: ArrayBuffer) => string;
+}): void {
+  nativeBytesToBase64url = impl.bytesToBase64url;
+  nativeBase64urlToBytes = impl.base64urlToBytes;
+  nativeBytesToBase64 = impl.bytesToBase64;
+}
+
+/**
+ * Convert Uint8Array to ArrayBuffer, handling views correctly.
+ */
+function toArrayBuffer(view: Uint8Array): ArrayBuffer {
+  if (
+    view.byteOffset === 0 &&
+    view.byteLength === view.buffer.byteLength &&
+    view.buffer instanceof ArrayBuffer
+  ) {
+    return view.buffer;
+  }
+  const buffer = new ArrayBuffer(view.byteLength);
+  new Uint8Array(buffer).set(view);
+  return buffer;
+}
+
+export function base64URLtoBytes(base64: string): Uint8Array {
+  // Use React Native native implementation if available
+  if (nativeBase64urlToBytes) {
+    return new Uint8Array(nativeBase64urlToBytes(base64));
+  }
+  // Use browser native implementation if available
+  if (hasNativeBase64) {
+    return (
+      Uint8Array as unknown as {
+        fromBase64: (s: string, opts: { alphabet: string }) => Uint8Array;
+      }
+    ).fromBase64(base64, { alphabet: "base64url" });
+  }
+  return base64URLtoBytesFallback(base64);
+}
+
+export function bytesToBase64url(bytes: Uint8Array): string {
+  // Use React Native native implementation if available
+  if (nativeBytesToBase64url) {
+    return nativeBytesToBase64url(toArrayBuffer(bytes));
+  }
+  // Use browser native implementation if available
+  if (hasNativeBase64) {
+    return (
+      bytes as unknown as {
+        toBase64: (opts: { alphabet: string }) => string;
+      }
+    ).toBase64({ alphabet: "base64url" });
+  }
+  return bytesToBase64urlFallback(bytes);
+}
+
+/**
+ * Encode bytes to standard base64 (not URL-safe).
+ * Use this for data URLs and other contexts requiring standard base64.
+ */
+export function bytesToBase64(bytes: Uint8Array): string {
+  // Use React Native native implementation if available
+  if (nativeBytesToBase64) {
+    return nativeBytesToBase64(toArrayBuffer(bytes));
+  }
+  // Use browser native implementation if available
+  if (hasNativeBase64) {
+    return (
+      bytes as unknown as {
+        toBase64: () => string;
+      }
+    ).toBase64();
+  }
+  return bytesToBase64Fallback(bytes);
+}
+
+// --- Fallback implementations ---
+
+function base64URLtoBytesFallback(base64: string): Uint8Array {
   base64 = base64.replace(/=/g, "");
   const n = base64.length;
   const rem = n % 4;
@@ -24,8 +121,7 @@ export function base64URLtoBytes(base64: string) {
   return new Uint8Array(encoded.buffer, 0, m);
 }
 
-export function bytesToBase64url(bytes: Uint8Array) {
-  // const before = performance.now();
+function bytesToBase64urlFallback(bytes: Uint8Array): string {
   const m = bytes.length;
   const k = m % 3;
   const n = Math.floor(m / 3) * 4 + (k && k + 1);
@@ -47,16 +143,48 @@ export function bytesToBase64url(bytes: Uint8Array) {
   return base64;
 }
 
-const alphabet =
+function bytesToBase64Fallback(bytes: Uint8Array): string {
+  const m = bytes.length;
+  const k = m % 3;
+  const n = Math.floor(m / 3) * 4 + (k && k + 1);
+  const N = Math.ceil(m / 3) * 4;
+  const encoded = new Uint8Array(N);
+
+  for (let i = 0, j = 0; j < m; i += 4, j += 3) {
+    const y = (bytes[j]! << 16) + (bytes[j + 1]! << 8) + (bytes[j + 2]! | 0);
+    encoded[i] = encodeLookupStd[y >> 18]!;
+    encoded[i + 1] = encodeLookupStd[(y >> 12) & 0x3f]!;
+    encoded[i + 2] = encodeLookupStd[(y >> 6) & 0x3f]!;
+    encoded[i + 3] = encodeLookupStd[y & 0x3f]!;
+  }
+
+  let base64 = decoder.decode(new Uint8Array(encoded.buffer, 0, n));
+  if (k === 1) base64 += "==";
+  if (k === 2) base64 += "=";
+
+  return base64;
+}
+
+// base64url alphabet (RFC 4648 §5)
+const alphabetUrl =
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 
+// Standard base64 alphabet (RFC 4648 §4)
+const alphabetStd =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
 const lookup = new Uint8Array(128);
-for (const [i, a] of Array.from(alphabet).entries()) {
+for (const [i, a] of Array.from(alphabetUrl).entries()) {
   lookup[a.charCodeAt(0)] = i;
 }
 lookup["=".charCodeAt(0)] = 0;
 
 const encodeLookup = new Uint8Array(64);
-for (const [i, a] of Array.from(alphabet).entries()) {
+for (const [i, a] of Array.from(alphabetUrl).entries()) {
   encodeLookup[i] = a.charCodeAt(0);
 }
+
+const encodeLookupStd = new Uint8Array(64);
+for (const [i, a] of Array.from(alphabetStd).entries()) {
+  encodeLookupStd[i] = a.charCodeAt(0);
+}

package/src/coValue.ts

@@ -3,7 +3,8 @@ import { RawProfile as Profile, RawAccount } from "./coValues/account.js";
 import { RawCoList } from "./coValues/coList.js";
 import { RawCoMap } from "./coValues/coMap.js";
 import { RawCoPlainText } from "./coValues/coPlainText.js";
-import { RawBinaryCoStream, RawCoStream } from "./coValues/coStream.js";
+import { RawBinaryCoStream } from "./coValues/binaryCoStream.js";
+import { RawCoStream } from "./coValues/coStream.js";
 import { RawGroup } from "./coValues/group.js";
 import { RawCoID } from "./ids.js";
 import { JsonObject, JsonValue } from "./jsonValue.js";

package/src/coValueCore/coValueCore.ts

@@ -42,7 +42,6 @@ import {
   Uniqueness,
   VerifiedState,
 } from "./verifiedState.js";
-import { SessionMap } from "./SessionMap.js";
 import {
   MergeCommit,
   BranchPointerCommit,
@@ -65,45 +64,6 @@ import {
 } from "../knownState.js";
 import { safeParseJSON } from "../jsonStringify.js";
 
-export type ValidationValue =
-  | { isOk: true }
-  | {
-      isOk: false;
-      message: string;
-    };
-
-function validateUniqueness(uniqueness: Uniqueness): ValidationValue {
-  if (typeof uniqueness === "number" && !Number.isInteger(uniqueness)) {
-    return {
-      isOk: false,
-      message: "Uniqueness cannot be a non-integer number, got " + uniqueness,
-    };
-  }
-
-  if (Array.isArray(uniqueness)) {
-    return {
-      isOk: false,
-      message: "Uniqueness cannot be an array, got " + uniqueness,
-    };
-  }
-
-  if (typeof uniqueness === "object" && uniqueness !== null) {
-    for (let [key, value] of Object.entries(uniqueness)) {
-      if (typeof value !== "string") {
-        return {
-          isOk: false,
-          message:
-            "Uniqueness object values must be a string, got " +
-            value +
-            " for key " +
-            key,
-        };
-      }
-    }
-  }
-  return { isOk: true };
-}
-
 export function idforHeader(
   header: CoValueHeader,
   crypto: CryptoProvider,
@@ -137,13 +97,17 @@ export class VerifiedTransaction {
   changes: JsonValue[] | undefined;
   // The decoded meta information of the transaction
   meta: JsonObject | undefined;
-  isValidated: boolean = false;
   // Whether the transaction is valid, as per membership rules
   isValid: boolean = false;
   // The error message that caused the transaction to be invalid
   validationErrorMessage: string | undefined = undefined;
   // The previous verified transaction for the same session
   previous: VerifiedTransaction | undefined;
+  // Transaction processing stage:
+  // - "to-validate": Transaction is pending validation on permissions checks
+  // - "validated": Transaction has been validated but not yet applied to content
+  // - "processed": Transaction has been validated and applied to content
+  stage: "to-validate" | "validated" | "processed" = "to-validate";
 
   constructor(
     coValueId: RawCoID,
@@ -214,18 +178,31 @@ export class VerifiedTransaction {
     return Boolean(this.isValid && this.changes);
   }
 
+  isProcessable(includeInvalidMetaTransactions: boolean): this is {
+    changes: JsonValue[];
+  } {
+    return Boolean(
+      this.changes && (includeInvalidMetaTransactions || this.isValid),
+    );
+  }
+
   markValid() {
+    const validityChanged = this.isValid === false;
     this.isValid = true;
     this.validationErrorMessage = undefined;
 
-    if (!this.isValidated) {
-      this.isValidated = true;
+    if (this.stage === "to-validate") {
+      this.stage = "validated";
+      this.dispatchTransaction(this);
+    }
+
+    if (this.stage === "processed" && validityChanged) {
       this.dispatchTransaction(this);
     }
   }
 
   markInvalid(errorMessage: string, attributes?: Record<string, JsonValue>) {
-    this.isValidated = true;
+    const validityChanged = this.isValid === true;
     this.isValid = false;
 
     this.validationErrorMessage = errorMessage;
@@ -237,6 +214,22 @@ export class VerifiedTransaction {
         ...attributes,
       });
     }
+
+    if (this.stage === "processed" && validityChanged) {
+      this.dispatchTransaction(this);
+    }
+
+    if (this.stage === "to-validate") {
+      this.stage = "validated";
+    }
+  }
+
+  markAsProcessed() {
+    this.stage = "processed";
+  }
+
+  markAsToValidate() {
+    this.stage = "to-validate";
   }
 }
 
@@ -586,36 +579,34 @@ export class CoValueCore {
     streamingKnownState?: KnownStateSessions,
     skipVerify?: boolean,
   ) {
-    if (!skipVerify) {
-      const validation = validateUniqueness(header.uniqueness);
-      if (!validation.isOk) {
-        logger.error("Invalid uniqueness", {
-          header,
-          errorMessage: validation.message,
-        });
-        return false;
-      }
-
-      const expectedId = idforHeader(header, this.node.crypto);
+    if (this._verified?.sessionCount) {
+      throw new Error(
+        "CoValueCore: provideHeader called on coValue with verified sessions present!",
+      );
+    }
 
-      if (this.id !== expectedId) {
-        return false;
-      }
+    // Create VerifiedState - Rust validates uniqueness and id match unless skipVerify is true
+    try {
+      this._verified = new VerifiedState(
+        this.id,
+        this.node.crypto,
+        header,
+        streamingKnownState,
+        skipVerify,
+      );
+    } catch (e) {
+      // Rust validation failed (invalid uniqueness or id mismatch)
+      logger.error("Header validation failed", {
+        id: this.id,
+        header,
+        error: e instanceof Error ? e.message : String(e),
+      });
+      return false;
     }
 
+    // Only add dependencies after successful validation
     this.addDependencyFromHeader(header);
 
-    if (this._verified?.sessions.size) {
-      throw new Error(
-        "CoValueCore: provideHeader called on coValue with verified sessions present!",
-      );
-    }
-    this._verified = new VerifiedState(
-      this.id,
-      this.node.crypto,
-      header,
-      new SessionMap(this.id, this.node.crypto, streamingKnownState),
-    );
     // Clean up if transitioning from garbageCollected/onlyKnownState
     if (this.isAvailable()) {
       this.cleanupLastKnownState();
@@ -651,7 +642,7 @@ export class CoValueCore {
    */
   knownStateWithStreaming(): CoValueKnownState {
     if (this.verified) {
-      return this.verified.immutableKnownStateWithStreaming();
+      return this.verified.knownStateWithStreaming();
     }
 
     return this.knownState();
@@ -660,16 +651,12 @@ export class CoValueCore {
   /**
    * Returns the known state of the CoValue
    *
-   * 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.
-   *
    * For garbageCollected/onlyKnownState CoValues, returns the cached knownState.
    */
   knownState(): CoValueKnownState {
     // 1. If we have verified content in memory, use that (authoritative)
     if (this.verified) {
-      return this.verified.immutableKnownState();
+      return this.verified.knownState();
     }
 
     // 2. If we have last known state (GC'd or onlyKnownState), use that
@@ -730,7 +717,7 @@ export class CoValueCore {
 
     return {
       sessionID,
-      txIndex: this.verified.sessions.get(sessionID)?.transactions.length || 0,
+      txIndex: this.verified.getTransactionsCount(sessionID) || 0,
     };
   }
 
@@ -761,8 +748,7 @@ export class CoValueCore {
     let deleteTransaction: Transaction | undefined = undefined;
 
     if (isDeleteSessionID(sessionID)) {
-      const txCount =
-        this.verified.sessions.get(sessionID)?.transactions.length ?? 0;
+      const txCount = this.verified.getTransactionsCount(sessionID) ?? 0;
       if (txCount > 0 || newTransactions.length > 1) {
         return {
           value: true,
@@ -1051,6 +1037,20 @@ export class CoValueCore {
     }
   }
 
+  #isContentRebuildScheduled = false;
+  scheduleContentRebuild() {
+    if (!this._cachedContent || this.#isContentRebuildScheduled) {
+      return;
+    }
+
+    this.#isContentRebuildScheduled = true;
+
+    queueMicrotask(() => {
+      this.#isContentRebuildScheduled = false;
+      this._cachedContent?.rebuildFromCore();
+    });
+  }
+
   #isNotifyUpdatePaused = false;
   pauseNotifyUpdate() {
     this.#isNotifyUpdatePaused = true;
@@ -1319,7 +1319,7 @@ export class CoValueCore {
     // Store the validity of the transactions before resetting the parsed transactions
     const validityBeforeReset = new Array<boolean>(verifiedTransactions.length);
     this.verifiedTransactions.forEach((transaction, index) => {
-      transaction.isValidated = false;
+      transaction.markAsToValidate();
       validityBeforeReset[index] = transaction.isValidTransactionWithChanges();
     });
 
@@ -1327,6 +1327,7 @@ export class CoValueCore {
     this.toProcessTransactions = [];
     this.toDecryptTransactions = [];
     this.toParseMetaTransactions = [];
+    this.#fwwWinners.clear();
 
     this.parseNewTransactions(false);
 
@@ -1378,7 +1379,7 @@ export class CoValueCore {
 
     const isBranched = this.isBranched();
 
-    for (const [sessionID, sessionLog] of this.verified.sessions.entries()) {
+    for (const [sessionID, sessionLog] of this.verified.sessionEntries()) {
       const count = this.verifiedTransactionsKnownSessions[sessionID] ?? 0;
 
       for (
@@ -1427,11 +1428,16 @@ export class CoValueCore {
   }
 
   dispatchTransaction = (transaction: VerifiedTransaction) => {
-    if (!transaction.isValidated) {
+    if (transaction.stage === "to-validate") {
       this.toValidateTransactions.push(transaction);
       return;
     }
 
+    if (transaction.stage === "processed") {
+      this.scheduleContentRebuild();
+      return;
+    }
+
     if (transaction.changes) {
       this.toProcessTransactions.push(transaction);
     } else {
@@ -1451,6 +1457,8 @@ export class CoValueCore {
     this.toValidateTransactions = [];
   }
 
+  #fwwWinners: Map<string, VerifiedTransaction> = new Map();
+
   /**
    * Parses the meta information of a transaction, and set the branchStart and mergeCommits.
    */
@@ -1489,6 +1497,30 @@ export class CoValueCore {
       this.mergeCommits.push(mergeCommit);
     }
 
+    if ("fww" in transaction.meta) {
+      const fwwKey = transaction.meta.fww as string;
+      const currentWinner = this.#fwwWinners.get(fwwKey);
+
+      // First-writer-wins: keep the transaction with the smallest madeAt
+      // compareTransactions returns < 0 if transaction is earlier than currentWinner
+      if (
+        !currentWinner ||
+        this.compareTransactions(transaction, currentWinner) < 0
+      ) {
+        if (currentWinner) {
+          currentWinner.markInvalid(
+            `Transaction is not the first writer for fww key "${fwwKey}"`,
+          );
+        }
+
+        this.#fwwWinners.set(fwwKey, transaction);
+      } else {
+        transaction.markInvalid(
+          `Transaction is not the first writer for fww key "${fwwKey}"`,
+        );
+      }
+    }
+
     // Check if the transaction has been merged from a branch
     if ("mi" in transaction.meta) {
       const meta = transaction.meta as MergedTransactionMetadata;
@@ -1570,7 +1602,7 @@ export class CoValueCore {
     from?: CoValueKnownState["sessions"];
     to?: CoValueKnownState["sessions"];
     knownTransactions?: Record<RawCoID, number>;
-
+    includeInvalidMetaTransactions?: boolean;
     // If true, the branch source transactions will be skipped. Used to gather the transactions for the merge operation.
     skipBranchSource?: boolean;
   }): DecryptedTransaction[] {
@@ -1589,6 +1621,11 @@ export class CoValueCore {
 
     const knownTransactions = options?.knownTransactions?.[this.id] ?? 0;
 
+    // Include invalid transactions in the result (only transactions invalidated by metadata parsing are included e.g. init transactions)
+    // permission errors are still not included
+    const includeInvalidMetaTransactions =
+      options?.includeInvalidMetaTransactions ?? false;
+
     for (
       let i = knownTransactions;
       i < this.toProcessTransactions.length;
@@ -1596,7 +1633,7 @@ export class CoValueCore {
     ) {
       const transaction = this.toProcessTransactions[i]!;
 
-      if (!transaction.isValidTransactionWithChanges()) {
+      if (!transaction.isProcessable(includeInvalidMetaTransactions)) {
         continue;
       }
 
@@ -1613,6 +1650,7 @@ export class CoValueCore {
         continue;
       }
 
+      transaction.markAsProcessed();
       matchingTransactions.push(transaction);
     }
 
@@ -1623,6 +1661,7 @@ export class CoValueCore {
     // If this is a branch, we load the valid transactions from the source
     if (source && this.branchStart && !options?.skipBranchSource) {
       const sourceTransactions = source.getValidTransactions({
+        includeInvalidMetaTransactions,
         knownTransactions: options?.knownTransactions,
         to: this.branchStart,
         ignorePrivateTransactions: options?.ignorePrivateTransactions ?? false,
@@ -1781,6 +1820,9 @@ export class CoValueCore {
 
     // The transactions that have already been processed, used for the incremental builds of the content views
     knownTransactions?: Record<RawCoID, number>;
+
+    // Whether to include invalid transactions in the result (only transactions invalidated by metadata parsing are included e.g. init transactions)
+    includeInvalidMetaTransactions?: boolean;
   }): DecryptedTransaction[] {
     const allTransactions = this.getValidTransactions(options);
 
@@ -1903,7 +1945,7 @@ export class CoValueCore {
   }
 
   getTx(txID: TransactionID): Transaction | undefined {
-    return this.verified?.sessions.get(txID.sessionID)?.transactions[
+    return this.verified?.getSession(txID.sessionID)?.transactions[
       txID.txIndex
     ];
   }