cojson 0.8.0 → 0.8.5

package/src/coValueCore.ts

@@ -43,7 +43,10 @@ export type CoValueHeader = {
     meta: JsonObject | null;
 } & CoValueUniqueness;
 
-export type CoValueUniqueness = {uniqueness: JsonValue, createdAt?: `2${string}` | null}
+export type CoValueUniqueness = {
+    uniqueness: JsonValue;
+    createdAt?: `2${string}` | null;
+};
 
 export function idforHeader(
     header: CoValueHeader,

package/src/coValues/account.ts

@@ -1,4 +1,8 @@
-import { CoValueCore, CoValueHeader, CoValueUniqueness } from "../coValueCore.js";
+import {
+    CoValueCore,
+    CoValueHeader,
+    CoValueUniqueness,
+} from "../coValueCore.js";
 import { CoID, RawCoValue } from "../coValue.js";
 import {
     AgentSecret,
@@ -11,9 +15,9 @@ import {
 import { AgentID } from "../ids.js";
 import { RawCoMap } from "./coMap.js";
 import { RawGroup, InviteSecret } from "./group.js";
-import { LocalNode } from "../index.js";
 import { JsonObject } from "../jsonValue.js";
 import { err, ok, Result } from "neverthrow";
+import { LocalNode } from "../localNode.js";
 
 export function accountHeaderForInitialAgentSecret(
     agentSecret: AgentSecret,
@@ -92,7 +96,9 @@ export class RawControlledAccount<Meta extends AccountMeta = AccountMeta>
      * Creates a new group (with the current account as the group's first admin).
      * @category 1. High-level
      */
-    createGroup(uniqueness: CoValueUniqueness = this.core.crypto.createdNowUnique()) {
+    createGroup(
+        uniqueness: CoValueUniqueness = this.core.crypto.createdNowUnique(),
+    ) {
         return this.core.node.createGroup(uniqueness);
     }
 

package/src/crypto/PureJSCrypto.ts

@@ -36,6 +36,11 @@ export class PureJSCrypto extends CryptoProvider<Blake3State> {
         return blake3.create({});
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    cloneBlake3State(state: any): Blake3State {
+        return state.clone();
+    }
+
     blake3HashOnce(data: Uint8Array) {
         return blake3(data);
     }

package/src/crypto/WasmCrypto.ts

@@ -64,6 +64,10 @@ export class WasmCrypto extends CryptoProvider<Uint8Array> {
         return this.blake3Instance.init().save();
     }
 
+    cloneBlake3State(state: Uint8Array): Uint8Array {
+        return this.blake3Instance.load(state).save();
+    }
+
     blake3HashOnce(data: Uint8Array) {
         return this.blake3Instance.init().update(data).digest("binary");
     }

package/src/crypto/crypto.ts

@@ -2,7 +2,8 @@ import { JsonValue } from "../jsonValue.js";
 import { base58 } from "@scure/base";
 import { AgentID, RawCoID, TransactionID } from "../ids.js";
 import { Stringified, parseJSON, stableStringify } from "../jsonStringify.js";
-import { RawAccountID, SessionID } from "../index.js";
+import { RawAccountID } from "../coValues/account.js";
+import { SessionID } from "../ids.js";
 
 export type SignerSecret = `signerSecret_z${string}`;
 export type SignerID = `signer_z${string}`;
@@ -103,6 +104,7 @@ export abstract class CryptoProvider<Blake3State = any> {
     }
 
     abstract emptyBlake3State(): Blake3State;
+    abstract cloneBlake3State(state: Blake3State): Blake3State;
     abstract blake3HashOnce(data: Uint8Array): Uint8Array;
     abstract blake3HashOnceWithContext(
         data: Uint8Array,
@@ -323,7 +325,10 @@ export class StreamingHash {
     }
 
     clone(): StreamingHash {
-        return new StreamingHash(this.crypto, new Uint8Array(this.state));
+        return new StreamingHash(
+            this.crypto,
+            this.crypto.cloneBlake3State(this.state),
+        );
     }
 }
 

package/src/{index.ts → index.native.ts}

@@ -1,3 +1,5 @@
+import { PureJSCrypto } from "./crypto/PureJSCrypto.js";
+
 import {
     CoValueCore,
     type CoValueUniqueness,
@@ -16,8 +18,6 @@ import {
     StreamingHash,
     CryptoProvider,
 } from "./crypto/crypto.js";
-import { WasmCrypto } from "./crypto/WasmCrypto.js";
-import { PureJSCrypto } from "./crypto/PureJSCrypto.js";
 import { connectedPeers, Channel } from "./streamUtils.js";
 import { ControlledAgent, RawControlledAccount } from "./coValues/account.js";
 import type { Role } from "./permissions.js";
@@ -115,11 +115,10 @@ export {
     AgentSecret,
     InviteSecret,
     CryptoProvider,
-    WasmCrypto,
-    PureJSCrypto,
     SyncMessage,
     isRawCoID,
     LSMStorage,
+    PureJSCrypto,
 };
 
 export type {
@@ -131,7 +130,7 @@ export type {
     OutgoingSyncQueue,
     DisconnectedError,
     PingTimeoutError,
-    CoValueUniqueness
+    CoValueUniqueness,
 };
 
 // eslint-disable-next-line @typescript-eslint/no-namespace

package/src/index.web.ts

@@ -0,0 +1,152 @@
+import { WasmCrypto } from "./crypto/WasmCrypto.js";
+
+import {
+    CoValueCore,
+    type CoValueUniqueness,
+    MAX_RECOMMENDED_TX_SIZE,
+    idforHeader,
+} from "./coValueCore.js";
+import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
+import { LocalNode } from "./localNode.js";
+import { type RawCoValue } from "./coValue.js";
+import { RawCoMap } from "./coValues/coMap.js";
+import { RawCoList } from "./coValues/coList.js";
+import { RawCoStream, RawBinaryCoStream } from "./coValues/coStream.js";
+import {
+    secretSeedLength,
+    shortHashLength,
+    StreamingHash,
+    CryptoProvider,
+} from "./crypto/crypto.js";
+import { connectedPeers, Channel } from "./streamUtils.js";
+import { ControlledAgent, RawControlledAccount } from "./coValues/account.js";
+import type { Role } from "./permissions.js";
+import { rawCoIDtoBytes, rawCoIDfromBytes, isRawCoID } from "./ids.js";
+import { RawGroup, EVERYONE } from "./coValues/group.js";
+import type { Everyone } from "./coValues/group.js";
+import { base64URLtoBytes, bytesToBase64url } from "./base64url.js";
+import { parseJSON } from "./jsonStringify.js";
+import {
+    RawAccount,
+    RawProfile,
+    accountHeaderForInitialAgentSecret,
+} from "./coValues/account.js";
+import { expectGroup } from "./typeUtils/expectGroup.js";
+import { isAccountID } from "./typeUtils/isAccountID.js";
+
+import type { SessionID, AgentID } from "./ids.js";
+import type { CoID, AnyRawCoValue } from "./coValue.js";
+import type {
+    BinaryStreamInfo,
+    BinaryCoStreamMeta,
+} from "./coValues/coStream.js";
+import type { JsonValue } from "./jsonValue.js";
+import type {
+    SyncMessage,
+    Peer,
+    IncomingSyncStream,
+    OutgoingSyncQueue,
+} from "./sync.js";
+import { DisconnectedError, PingTimeoutError } from "./sync.js";
+import type { AgentSecret } from "./crypto/crypto.js";
+import type {
+    RawAccountID,
+    AccountMeta,
+    RawAccountMigration,
+} from "./coValues/account.js";
+import type { InviteSecret } from "./coValues/group.js";
+import type * as Media from "./media.js";
+
+type Value = JsonValue | AnyRawCoValue;
+
+import { LSMStorage, BlockFilename, WalFilename } from "./storage/index.js";
+import { FileSystem } from "./storage/FileSystem.js";
+import { getPriorityFromHeader } from "./priority.js";
+
+/** @hidden */
+export const cojsonInternals = {
+    connectedPeers,
+    rawCoIDtoBytes,
+    rawCoIDfromBytes,
+    secretSeedLength,
+    shortHashLength,
+    expectGroup,
+    base64URLtoBytes,
+    bytesToBase64url,
+    parseJSON,
+    accountOrAgentIDfromSessionID,
+    isAccountID,
+    accountHeaderForInitialAgentSecret,
+    idforHeader,
+    StreamingHash,
+    Channel,
+    getPriorityFromHeader,
+};
+
+export {
+    LocalNode,
+    RawGroup,
+    Role,
+    EVERYONE,
+    Everyone,
+    RawCoMap,
+    RawCoList,
+    RawCoStream,
+    RawBinaryCoStream,
+    RawCoValue,
+    CoID,
+    AnyRawCoValue,
+    RawAccount,
+    RawAccountID,
+    AccountMeta,
+    RawAccountMigration,
+    RawProfile as Profile,
+    SessionID,
+    Media,
+    CoValueCore,
+    ControlledAgent,
+    RawControlledAccount,
+    MAX_RECOMMENDED_TX_SIZE,
+    JsonValue,
+    Peer,
+    BinaryStreamInfo,
+    BinaryCoStreamMeta,
+    AgentID,
+    AgentSecret,
+    InviteSecret,
+    CryptoProvider,
+    SyncMessage,
+    isRawCoID,
+    LSMStorage,
+    WasmCrypto,
+};
+
+export type {
+    Value,
+    FileSystem,
+    BlockFilename,
+    WalFilename,
+    IncomingSyncStream,
+    OutgoingSyncQueue,
+    DisconnectedError,
+    PingTimeoutError,
+    CoValueUniqueness,
+};
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace CojsonInternalTypes {
+    export type CoValueKnownState = import("./sync.js").CoValueKnownState;
+    export type DoneMessage = import("./sync.js").DoneMessage;
+    export type KnownStateMessage = import("./sync.js").KnownStateMessage;
+    export type LoadMessage = import("./sync.js").LoadMessage;
+    export type NewContentMessage = import("./sync.js").NewContentMessage;
+    export type CoValueHeader = import("./coValueCore.js").CoValueHeader;
+    export type Transaction = import("./coValueCore.js").Transaction;
+    export type TransactionID = import("./ids.js").TransactionID;
+    export type Signature = import("./crypto/crypto.js").Signature;
+    export type RawCoID = import("./ids.js").RawCoID;
+    export type ProfileShape = import("./coValues/account.js").ProfileShape;
+    export type SealerSecret = import("./crypto/crypto.js").SealerSecret;
+    export type SignerSecret = import("./crypto/crypto.js").SignerSecret;
+    export type JsonObject = import("./jsonValue.js").JsonObject;
+}

package/src/jsonValue.ts

@@ -4,3 +4,28 @@ export type JsonAtom = string | number | boolean | null;
 export type JsonValue = JsonAtom | JsonArray | JsonObject | RawCoID;
 export type JsonArray = JsonValue[] | readonly JsonValue[];
 export type JsonObject = { [key: string]: JsonValue | undefined };
+
+type AtLeastOne<T, U = {[K in keyof T]: Pick<T, K> }> = Partial<T> & U[keyof U];
+type ExcludeEmpty<T> = T extends AtLeastOne<T> ? T : never; 
+
+export type CoJsonValue<T> = JsonValue | CoJsonObjectWithIndex<T> | CoJsonArray<T>;
+export type CoJsonArray<T> = CoJsonValue<T>[] | readonly CoJsonValue<T>[];
+
+/**
+ * Since we are forcing Typescript to elaborate the indexes from the given type passing
+ * non-object values to CoJsonObjectWithIndex will return an empty object
+ * E.g. 
+ *   CoJsonObjectWithIndex<() => void> --> {}
+ *   CoJsonObjectWithIndex<RegExp> --> {}
+ * 
+ * Applying the ExcludeEmpty type here to make sure we don't accept functions or non-serializable values
+ */
+export type CoJsonObjectWithIndex<T> = ExcludeEmpty<{ [K in keyof T & string]: CoJsonValue1L<T[K]> | undefined }>;
+
+/**
+ * Manually handling the nested interface types to not get into infinite recursion issues.
+ */
+export type CoJsonValue1L<T> = ExcludeEmpty<{ [K in keyof T & string]: CoJsonValue2L<T[K]> | undefined }> | JsonValue;
+export type CoJsonValue2L<T> = ExcludeEmpty<{ [K in keyof T & string]: CoJsonValue3L<T[K]> | undefined }> | JsonValue;
+export type CoJsonValue3L<T> = ExcludeEmpty<{ [K in keyof T & string]: CoJsonValue4L<T[K]> | undefined }> | JsonValue;
+export type CoJsonValue4L<T> = ExcludeEmpty<{ [K in keyof T & string]: JsonValue | undefined }> | JsonValue;

package/src/localNode.ts

@@ -21,10 +21,11 @@ import {
     ControlledAgent,
     RawAccountID,
     RawProfile,
+    RawProfile as Profile,
     RawAccountMigration,
     InvalidAccountAgentIDError,
 } from "./coValues/account.js";
-import { Profile, RawCoValue } from "./index.js";
+import { RawCoValue } from "./coValue.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
 import { err, ok, okAsync, Result, ResultAsync } from "neverthrow";
 
@@ -180,66 +181,71 @@ export class LocalNode {
         crypto: CryptoProvider;
         migration?: RawAccountMigration<Meta>;
     }): Promise<LocalNode> {
-        const loadingNode = new LocalNode(
-            new ControlledAgent(accountSecret, crypto),
-            crypto.newRandomSessionID(accountID),
-            crypto,
-        );
-
-        for (const peer of peersToLoadFrom) {
-            loadingNode.syncManager.addPeer(peer);
-        }
+        try {
+            const loadingNode = new LocalNode(
+                new ControlledAgent(accountSecret, crypto),
+                crypto.newRandomSessionID(accountID),
+                crypto,
+            );
 
-        const accountPromise = loadingNode.load(accountID);
+            for (const peer of peersToLoadFrom) {
+                loadingNode.syncManager.addPeer(peer);
+            }
 
-        const account = await accountPromise;
+            const accountPromise = loadingNode.load(accountID);
 
-        if (account === "unavailable") {
-            throw new Error("Account unavailable from all peers");
-        }
+            const account = await accountPromise;
 
-        const controlledAccount = new RawControlledAccount(
-            account.core,
-            accountSecret,
-        );
+            if (account === "unavailable") {
+                throw new Error("Account unavailable from all peers");
+            }
 
-        // since this is all synchronous, we can just swap out nodes for the SyncManager
-        const node = loadingNode.testWithDifferentAccount(
-            controlledAccount,
-            sessionID || crypto.newRandomSessionID(accountID),
-        );
-        node.syncManager = loadingNode.syncManager;
-        node.syncManager.local = node;
+            const controlledAccount = new RawControlledAccount(
+                account.core,
+                accountSecret,
+            );
 
-        controlledAccount.core.node = node;
-        node.coValues[accountID] = {
-            state: "loaded",
-            coValue: controlledAccount.core,
-        };
-        controlledAccount.core._cachedContent = undefined;
+            // since this is all synchronous, we can just swap out nodes for the SyncManager
+            const node = loadingNode.testWithDifferentAccount(
+                controlledAccount,
+                sessionID || crypto.newRandomSessionID(accountID),
+            );
+            node.syncManager = loadingNode.syncManager;
+            node.syncManager.local = node;
+
+            controlledAccount.core.node = node;
+            node.coValues[accountID] = {
+                state: "loaded",
+                coValue: controlledAccount.core,
+            };
+            controlledAccount.core._cachedContent = undefined;
+
+            const profileID = account.get("profile");
+            if (!profileID) {
+                throw new Error("Account has no profile");
+            }
+            const profile = await node.load(profileID);
 
-        const profileID = account.get("profile");
-        if (!profileID) {
-            throw new Error("Account has no profile");
-        }
-        const profile = await node.load(profileID);
+            if (profile === "unavailable") {
+                throw new Error("Profile unavailable from all peers");
+            }
 
-        if (profile === "unavailable") {
-            throw new Error("Profile unavailable from all peers");
-        }
+            if (migration) {
+                await migration(
+                    controlledAccount as RawControlledAccount<Meta>,
+                    node,
+                );
+                node.account = new RawControlledAccount(
+                    controlledAccount.core,
+                    controlledAccount.agentSecret,
+                );
+            }
 
-        if (migration) {
-            await migration(
-                controlledAccount as RawControlledAccount<Meta>,
-                node,
-            );
-            node.account = new RawControlledAccount(
-                controlledAccount.core,
-                controlledAccount.agentSecret,
-            );
+            return node;
+        } catch (e) {
+            console.error("Error withLoadedAccount", e);
+            throw e;
         }
-
-        return node;
     }
 
     /** @internal */
@@ -540,8 +546,19 @@ export class LocalNode {
             return ok(id);
         }
 
-        const coValue = this.expectCoValueLoaded(id, expectation);
-
+        let coValue: CoValueCore;
+        
+        try {
+            coValue = this.expectCoValueLoaded(id, expectation);
+        } catch (e) {
+            return err({
+                type: "ErrorLoadingCoValueCore",
+                expectation,
+                id,
+                error: e,
+            } satisfies LoadCoValueCoreError);
+        }
+    
         if (
             coValue.header.type !== "comap" ||
             coValue.header.ruleset.type !== "group" ||
@@ -606,12 +623,14 @@ export class LocalNode {
     /**
      * @deprecated use Account.createGroup() instead
      */
-    createGroup(uniqueness: CoValueUniqueness = this.crypto.createdNowUnique()): RawGroup {
+    createGroup(
+        uniqueness: CoValueUniqueness = this.crypto.createdNowUnique(),
+    ): RawGroup {
         const groupCoValue = this.createCoValue({
             type: "comap",
             ruleset: { type: "group", initialAdmin: this.account.id },
             meta: null,
-            ...uniqueness
+            ...uniqueness,
         });
 
         const group = expectGroup(groupCoValue.getCurrentContent());

package/src/storage/chunksAndKnownStates.ts

@@ -1,5 +1,5 @@
 import { RawCoID, SessionID } from "../ids.js";
-import { MAX_RECOMMENDED_TX_SIZE } from "../index.js";
+import { MAX_RECOMMENDED_TX_SIZE } from "../coValueCore.js";
 import { getPriorityFromHeader } from "../priority.js";
 import { CoValueKnownState, NewContentMessage } from "../sync.js";
 import { CoValueChunk } from "./index.js";

package/src/storage/index.ts

@@ -8,7 +8,7 @@ import {
     OutgoingSyncQueue,
     Peer,
 } from "../sync.js";
-import { CoID, RawCoValue } from "../index.js";
+import { CoID, RawCoValue } from "../coValue.js";
 import { connectedPeers } from "../streamUtils.js";
 import {
     chunkToKnownState,

package/src/tests/coList.test.ts

@@ -1,8 +1,8 @@
 import { expect, test } from "vitest";
 import { expectList } from "../coValue.js";
-import { WasmCrypto } from "../index.js";
 import { LocalNode } from "../localNode.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 

package/src/tests/coMap.test.ts

@@ -1,9 +1,9 @@
 import { expect, test } from "vitest";
 import { expectMap } from "../coValue.js";
-import { WasmCrypto } from "../index.js";
 import { LocalNode } from "../localNode.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 

package/src/tests/coStream.test.ts

@@ -1,9 +1,10 @@
 import { expect, test, describe } from "vitest";
 import { expectStream } from "../coValue.js";
 import { RawBinaryCoStream } from "../coValues/coStream.js";
-import { MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from "../index.js";
+import { MAX_RECOMMENDED_TX_SIZE } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 

package/src/tests/cryptoImpl.test.ts

@@ -1,8 +1,8 @@
-import { KeySecret } from "../crypto/crypto.js";
+import { KeySecret, StreamingHash } from "../crypto/crypto.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { PureJSCrypto } from "../crypto/PureJSCrypto.js";
 import { describe, test, expect } from "vitest";
-import { SessionID } from "../index.js";
+import { SessionID } from "../ids.js";
 
 describe.each([
     { impl: await WasmCrypto.create(), name: "Wasm" },
@@ -180,4 +180,26 @@ describe.each([
             ),
         ).toThrow();
     });
+
+    test("StreamingHash clone", () => {
+        const originalHash = new StreamingHash(impl);
+        originalHash.update({ foo: "bar" });
+
+        const clonedHash = originalHash.clone();
+
+        // Update the original hash
+        originalHash.update({ baz: "qux" });
+
+        // Update the cloned hash differently
+        clonedHash.update({ quux: "corge" });
+
+        // The digests should be different
+        expect(originalHash.digest()).not.toEqual(clonedHash.digest());
+
+        // The cloned hash should match a new hash with the same updates
+        const newHash = new StreamingHash(impl);
+        newHash.update({ foo: "bar" });
+        newHash.update({ quux: "corge" });
+        expect(clonedHash.digest()).toEqual(newHash.digest());
+    });
 });

package/src/tests/group.test.ts

@@ -1,13 +1,11 @@
 import { expect, test } from "vitest";
-import {
-    LocalNode,
-    RawCoMap,
-    RawCoList,
-    RawCoStream,
-    RawBinaryCoStream,
-    WasmCrypto,
-} from "../index.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
+import { LocalNode } from "../localNode.js";
+import { RawCoList } from "../coValues/coList.js";
+import { RawCoMap } from "../coValues/coMap.js";
+import { RawCoStream } from "../coValues/coStream.js";
+import { RawBinaryCoStream } from "../coValues/coStream.js";
 
 const Crypto = await WasmCrypto.create();