cojson 0.20.6 → 0.20.8

package/src/coValues/binaryCoStream.ts

@@ -0,0 +1,217 @@
+import { base64URLtoBytes, bytesToBase64url } from "../base64url.js";
+import type { CoID, RawCoValue } from "../coValue.js";
+import type { AvailableCoValueCore } from "../coValueCore/coValueCore.js";
+import type { RawCoID } from "../ids.js";
+import type { JsonObject } from "../jsonValue.js";
+import type { RawGroup } from "./group.js";
+
+export type BinaryStreamInfo = {
+  mimeType: string;
+  fileName?: string;
+  totalSizeBytes?: number;
+};
+
+export type BinaryStreamStart = {
+  type: "start";
+} & BinaryStreamInfo;
+
+export type BinaryStreamChunk = {
+  type: "chunk";
+  chunk: `binary_U${string}`;
+};
+
+export type BinaryStreamEnd = {
+  type: "end";
+};
+
+export type BinaryCoStreamMeta = JsonObject & { type: "binary" };
+
+export type BinaryStreamItem =
+  | BinaryStreamStart
+  | BinaryStreamChunk
+  | BinaryStreamEnd;
+
+const binary_U_prefixLength = 8; // "binary_U".length;
+
+export class RawBinaryCoStreamView<
+  Meta extends BinaryCoStreamMeta = { type: "binary" },
+> implements RawCoValue
+{
+  id: CoID<this>;
+  type = "costream" as const;
+  core: AvailableCoValueCore;
+  knownTransactions: Record<RawCoID, number>;
+  totalValidTransactions: number = 0;
+  version: number = 0;
+  private chunks: string[];
+  private start: BinaryStreamStart | undefined;
+  private ended: boolean;
+
+  private resetInternalState() {
+    this.chunks = [];
+    this.start = undefined;
+    this.ended = false;
+    this.knownTransactions = { [this.core.id]: 0 };
+    this.totalValidTransactions = 0;
+  }
+
+  constructor(core: AvailableCoValueCore) {
+    this.id = core.id as CoID<this>;
+    this.core = core;
+    this.ended = false;
+    this.chunks = [];
+    this.knownTransactions = { [core.id]: 0 };
+    this.processNewTransactions();
+  }
+
+  rebuildFromCore() {
+    this.version++;
+
+    this.resetInternalState();
+    this.processNewTransactions();
+  }
+
+  get headerMeta(): Meta {
+    return this.core.verified.header.meta as Meta;
+  }
+
+  get group(): RawGroup {
+    return this.core.getGroup();
+  }
+
+  /** Not yet implemented */
+  atTime(_time: number): this {
+    throw new Error("Not yet implemented");
+  }
+
+  processNewTransactions() {
+    if (this.ended) return;
+
+    const newValidTransactions = this.core.getValidTransactions({
+      ignorePrivateTransactions: false,
+      knownTransactions: this.knownTransactions,
+    });
+
+    if (newValidTransactions.length === 0) {
+      return;
+    }
+
+    for (const { txID, madeAt, changes } of newValidTransactions) {
+      for (const changeUntyped of changes) {
+        const change = changeUntyped as BinaryStreamItem;
+
+        if (change.type === "chunk") {
+          this.chunks.push(change.chunk.slice(binary_U_prefixLength));
+        } else if (change.type === "start") {
+          this.start = change;
+        } else if (change.type === "end") {
+          this.ended = true;
+        }
+      }
+    }
+
+    this.totalValidTransactions += newValidTransactions.length;
+  }
+
+  isBinaryStreamEnded() {
+    return this.ended;
+  }
+
+  getBinaryStreamInfo(): BinaryStreamInfo | undefined {
+    if (!this.start) return;
+
+    const start = this.start;
+
+    return {
+      mimeType: start.mimeType,
+      fileName: start.fileName,
+      totalSizeBytes: start.totalSizeBytes,
+    };
+  }
+
+  getBinaryChunks(
+    allowUnfinished?: boolean,
+  ):
+    | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
+    | undefined {
+    if (!this.start) return;
+    if (!this.ended && !allowUnfinished) return;
+
+    const start = this.start;
+
+    return {
+      mimeType: start.mimeType,
+      fileName: start.fileName,
+      totalSizeBytes: start.totalSizeBytes,
+      chunks: this.chunks.map(base64URLtoBytes),
+      finished: this.ended,
+    };
+  }
+
+  toJSON() {
+    return {};
+  }
+
+  subscribe(listener: (coStream: this) => void): () => void {
+    return this.core.subscribe((core) => {
+      listener(core.getCurrentContent() as this);
+    });
+  }
+}
+
+export class RawBinaryCoStream<
+    Meta extends BinaryCoStreamMeta = { type: "binary" },
+  >
+  extends RawBinaryCoStreamView<Meta>
+  implements RawCoValue
+{
+  /** @internal */
+  push(
+    item: BinaryStreamItem,
+    privacy: "private" | "trusting" = "private",
+    updateView: boolean = true,
+  ): void {
+    this.core.makeTransaction([item], privacy);
+    if (updateView) {
+      this.processNewTransactions();
+    }
+  }
+
+  startBinaryStream(
+    settings: BinaryStreamInfo,
+    privacy: "private" | "trusting" = "private",
+  ): void {
+    this.push(
+      {
+        type: "start",
+        ...settings,
+      } satisfies BinaryStreamStart,
+      privacy,
+      false,
+    );
+  }
+
+  pushBinaryStreamChunk(
+    chunk: Uint8Array,
+    privacy: "private" | "trusting" = "private",
+  ): void {
+    this.push(
+      {
+        type: "chunk",
+        chunk: `binary_U${bytesToBase64url(chunk)}`,
+      } satisfies BinaryStreamChunk,
+      privacy,
+      false,
+    );
+  }
+
+  endBinaryStream(privacy: "private" | "trusting" = "private") {
+    this.push(
+      {
+        type: "end",
+      } satisfies BinaryStreamEnd,
+      privacy,
+      true,
+    );
+  }
+}

package/src/coValues/coList.ts

@@ -35,6 +35,8 @@ type InsertionEntry<T extends JsonValue> = {
   predecessors: OpID[];
   successors: OpID[];
   change: InsertionOpPayload<T>;
+  /** Whether this entry comes from a valid transaction */
+  isValid: boolean;
 };
 
 type DeletionEntry = {
@@ -207,9 +209,12 @@ export class RawCoList<
   }
 
   private _processNewTransactions() {
+    // Get all transactions including invalid ones, so that items referencing
+    // entries from invalid init transactions can still find their references.
     const transactions = this.core.getValidSortedTransactions({
       ignorePrivateTransactions: false,
       knownTransactions: this.knownTransactions,
+      includeInvalidMetaTransactions: true,
     });
 
     if (transactions.length === 0) {
@@ -220,15 +225,19 @@ export class RawCoList<
     let oldestValidTransaction: number | undefined = undefined;
     this._cachedEntries = undefined;
 
-    for (const { txID, changes, madeAt } of transactions) {
+    for (const { txID, changes, madeAt, isValid } of transactions) {
       if (this.isFilteredOut(madeAt)) {
         continue;
       }
-      lastValidTransaction = Math.max(lastValidTransaction ?? 0, madeAt);
-      oldestValidTransaction = Math.min(
-        oldestValidTransaction ?? Infinity,
-        madeAt,
-      );
+
+      // Only track valid transactions for the lastValidTransaction/oldestValidTransaction
+      if (isValid) {
+        lastValidTransaction = Math.max(lastValidTransaction ?? 0, madeAt);
+        oldestValidTransaction = Math.min(
+          oldestValidTransaction ?? Infinity,
+          madeAt,
+        );
+      }
 
       for (const [changeIdx, changeUntyped] of changes.entries()) {
         const change = changeUntyped as ListOpPayload<Item>;
@@ -246,6 +255,7 @@ export class RawCoList<
             predecessors: [],
             successors: [],
             change,
+            isValid,
           });
 
           // If the change index already exists, we don't need to process it again
@@ -438,7 +448,9 @@ export class RawCoList<
 
         const deleted = this.isDeleted(currentOpID);
 
-        if (!deleted) {
+        // Skip entries that are deleted or from invalid transactions
+        // (e.g., losing init transactions in firstComesWins scenarios)
+        if (!deleted && entry.isValid) {
           arr.push({
             value: entry.change.value,
             madeAt: entry.madeAt,
@@ -563,6 +575,7 @@ export class RawCoList<
     items: Item[],
     after?: number,
     privacy: "private" | "trusting" = "private",
+    meta?: JsonObject,
   ) {
     const entries = this.entries();
     after =
@@ -597,7 +610,7 @@ export class RawCoList<
       changes.reverse();
     }
 
-    this.core.makeTransaction(changes, privacy);
+    this.core.makeTransaction(changes, privacy, meta);
     this.processNewTransactions();
   }
 

package/src/coValues/coMap.ts

@@ -120,6 +120,7 @@ export class RawCoMap<
 
     for (const transaction of newValidTransactions) {
       const { txID, changes, madeAt, tx } = transaction;
+
       for (let changeIdx = 0; changeIdx < changes.length; changeIdx++) {
         const change = changes[changeIdx] as MapOpPayload<
           keyof Shape & string,
@@ -400,6 +401,7 @@ export class RawCoMap<
   assign(
     entries: Partial<Shape>,
     privacy: "private" | "trusting" = "private",
+    meta?: JsonObject,
   ): void {
     if (this.isTimeTravelEntity()) {
       throw new Error("Cannot set value on a time travel entity");
@@ -412,6 +414,7 @@ export class RawCoMap<
         value: isCoValue(value) ? value.id : value,
       })),
       privacy,
+      meta,
     );
 
     this.processNewTransactions();

package/src/coValues/coStream.ts

@@ -1,9 +1,7 @@
-import { base64URLtoBytes, bytesToBase64url } from "../base64url.js";
 import { CoID, RawCoValue } from "../coValue.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 { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { isAccountID } from "../typeUtils/isAccountID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";
@@ -11,32 +9,6 @@ import { RawAccountID } from "./account.js";
 import { RawGroup } from "./group.js";
 import { RawCoID } from "../ids.js";
 
-export type BinaryStreamInfo = {
-  mimeType: string;
-  fileName?: string;
-  totalSizeBytes?: number;
-};
-
-export type BinaryStreamStart = {
-  type: "start";
-} & BinaryStreamInfo;
-
-export type BinaryStreamChunk = {
-  type: "chunk";
-  chunk: `binary_U${string}`;
-};
-
-export type BinaryStreamEnd = {
-  type: "end";
-};
-
-export type BinaryCoStreamMeta = JsonObject & { type: "binary" };
-
-export type BinaryStreamItem =
-  | BinaryStreamStart
-  | BinaryStreamChunk
-  | BinaryStreamEnd;
-
 export type CoStreamItem<Item extends JsonValue> = {
   value: Item;
   tx: TransactionID;
@@ -306,145 +278,3 @@ export class RawCoStream<
     this.processNewTransactions();
   }
 }
-
-const binary_U_prefixLength = 8; // "binary_U".length;
-
-export class RawBinaryCoStreamView<
-    Meta extends BinaryCoStreamMeta = { type: "binary" },
-  >
-  extends RawCoStreamView<BinaryStreamItem, Meta>
-  implements RawCoValue
-{
-  isBinaryStreamEnded() {
-    const items = this.getSingleStream();
-
-    if (!items || items.length === 0) {
-      return false;
-    }
-
-    const lastItem = items[items.length - 1];
-
-    return lastItem?.type === "end";
-  }
-
-  getBinaryStreamInfo(): BinaryStreamInfo | undefined {
-    const items = this.getSingleStream();
-
-    // No active streams
-    if (!items) return;
-
-    const start = items[0];
-
-    if (start?.type !== "start") {
-      logger.error("Invalid binary stream start", start);
-      return;
-    }
-
-    return {
-      mimeType: start.mimeType,
-      fileName: start.fileName,
-      totalSizeBytes: start.totalSizeBytes,
-    };
-  }
-
-  getBinaryChunks(
-    allowUnfinished?: boolean,
-  ):
-    | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
-    | undefined {
-    const items = this.getSingleStream();
-
-    // No active streams
-    if (!items) return;
-
-    const info = this.getBinaryStreamInfo();
-
-    if (!info) return;
-
-    const end = items[items.length - 1];
-
-    if (end?.type !== "end" && !allowUnfinished) return;
-
-    const chunks: Uint8Array[] = [];
-
-    let finished = false;
-
-    for (const item of items.slice(1)) {
-      if (item.type === "end") {
-        finished = true;
-        break;
-      }
-
-      if (item.type !== "chunk") {
-        logger.error("Invalid binary stream chunk", item);
-        return undefined;
-      }
-
-      const chunk = base64URLtoBytes(item.chunk.slice(binary_U_prefixLength));
-      chunks.push(chunk);
-    }
-
-    return {
-      ...info,
-      chunks,
-      finished,
-    };
-  }
-}
-
-export class RawBinaryCoStream<
-    Meta extends BinaryCoStreamMeta = { type: "binary" },
-  >
-  extends RawBinaryCoStreamView<Meta>
-  implements RawCoValue
-{
-  /** @internal */
-  push(
-    item: BinaryStreamItem,
-    privacy: "private" | "trusting" = "private",
-    updateView: boolean = true,
-  ): void {
-    this.core.makeTransaction([item], privacy);
-    if (updateView) {
-      this.processNewTransactions();
-    }
-  }
-
-  startBinaryStream(
-    settings: BinaryStreamInfo,
-    privacy: "private" | "trusting" = "private",
-  ): void {
-    this.push(
-      {
-        type: "start",
-        ...settings,
-      } satisfies BinaryStreamStart,
-      privacy,
-      false,
-    );
-  }
-
-  pushBinaryStreamChunk(
-    chunk: Uint8Array,
-    privacy: "private" | "trusting" = "private",
-  ): void {
-    this.push(
-      {
-        type: "chunk",
-        chunk: `binary_U${bytesToBase64url(chunk)}`,
-      } satisfies BinaryStreamChunk,
-      privacy,
-      false,
-    );
-  }
-
-  endBinaryStream(privacy: "private" | "trusting" = "private") {
-    this.push(
-      {
-        type: "end",
-      } satisfies BinaryStreamEnd,
-      privacy,
-      true,
-    );
-  }
-}