cojson 0.7.35 → 0.8.3

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

@@ -2,7 +2,7 @@ import { AgentSecret, CryptoProvider } from "./crypto/crypto.js";
 import {
     CoValueCore,
     CoValueHeader,
-    newRandomSessionID,
+    CoValueUniqueness,
 } from "./coValueCore.js";
 import {
     InviteSecret,
@@ -19,12 +19,13 @@ import {
     ControlledAccountOrAgent,
     RawControlledAccount,
     ControlledAgent,
-    AccountID,
+    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";
 
@@ -81,14 +82,14 @@ export class LocalNode {
         initialAgentSecret?: AgentSecret;
     }): Promise<{
         node: LocalNode;
-        accountID: AccountID;
+        accountID: RawAccountID;
         accountSecret: AgentSecret;
         sessionID: SessionID;
     }> {
         const throwawayAgent = crypto.newRandomAgentSecret();
         const setupNode = new LocalNode(
             new ControlledAgent(throwawayAgent, crypto),
-            newRandomSessionID(crypto.getAgentID(throwawayAgent)),
+            crypto.newRandomSessionID(crypto.getAgentID(throwawayAgent)),
             crypto,
         );
 
@@ -96,7 +97,7 @@ export class LocalNode {
 
         const nodeWithAccount = account.core.node.testWithDifferentAccount(
             account,
-            newRandomSessionID(account.id),
+            crypto.newRandomSessionID(account.id),
         );
 
         const accountOnNodeWithAccount =
@@ -173,73 +174,78 @@ export class LocalNode {
         crypto,
         migration,
     }: {
-        accountID: AccountID;
+        accountID: RawAccountID;
         accountSecret: AgentSecret;
         sessionID: SessionID | undefined;
         peersToLoadFrom: Peer[];
         crypto: CryptoProvider;
         migration?: RawAccountMigration<Meta>;
     }): Promise<LocalNode> {
-        const loadingNode = new LocalNode(
-            new ControlledAgent(accountSecret, 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 || 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 */
@@ -429,7 +435,7 @@ export class LocalNode {
             group.core
                 .testWithDifferentAccount(
                     new ControlledAgent(inviteAgentSecret, this.crypto),
-                    newRandomSessionID(inviteAgentID),
+                    this.crypto.newRandomSessionID(inviteAgentID),
                 )
                 .getCurrentContent(),
         );
@@ -470,7 +476,7 @@ export class LocalNode {
     }
 
     /** @internal */
-    expectProfileLoaded(id: AccountID, expectation?: string): RawProfile {
+    expectProfileLoaded(id: RawAccountID, expectation?: string): RawProfile {
         const account = this.expectCoValueLoaded(id, expectation);
         const profileID = expectGroup(account.getCurrentContent()).get(
             "profile",
@@ -499,7 +505,7 @@ export class LocalNode {
             )
                 .testWithDifferentAccount(
                     new ControlledAgent(agentSecret, this.crypto),
-                    newRandomSessionID(accountAgentID),
+                    this.crypto.newRandomSessionID(accountAgentID),
                 )
                 .getCurrentContent(),
         );
@@ -533,7 +539,7 @@ export class LocalNode {
 
     /** @internal */
     resolveAccountAgent(
-        id: AccountID | AgentID,
+        id: RawAccountID | AgentID,
         expectation?: string,
     ): Result<AgentID, ResolveAccountAgentError> {
         if (isAgentID(id)) {
@@ -560,7 +566,7 @@ export class LocalNode {
     }
 
     resolveAccountAgentAsync(
-        id: AccountID | AgentID,
+        id: RawAccountID | AgentID,
         expectation?: string,
     ): ResultAsync<AgentID, ResolveAccountAgentError> {
         if (isAgentID(id)) {
@@ -606,12 +612,14 @@ export class LocalNode {
     /**
      * @deprecated use Account.createGroup() instead
      */
-    createGroup(): RawGroup {
+    createGroup(
+        uniqueness: CoValueUniqueness = this.crypto.createdNowUnique(),
+    ): RawGroup {
         const groupCoValue = this.createCoValue({
             type: "comap",
             ruleset: { type: "group", initialAdmin: this.account.id },
             meta: null,
-            ...this.crypto.createdNowUnique(),
+            ...uniqueness,
         });
 
         const group = expectGroup(groupCoValue.getCurrentContent());
@@ -731,19 +739,19 @@ export type LoadCoValueCoreError = {
     type: "ErrorLoadingCoValueCore";
     error: unknown;
     expectation?: string;
-    id: AccountID;
+    id: RawAccountID;
 };
 
 export type AccountUnavailableFromAllPeersError = {
     type: "AccountUnavailableFromAllPeers";
     expectation?: string;
-    id: AccountID;
+    id: RawAccountID;
 };
 
 export type UnexpectedlyNotAccountError = {
     type: "UnexpectedlyNotAccount";
     expectation?: string;
-    id: AccountID;
+    id: RawAccountID;
 };
 
 export type ResolveAccountAgentError =

package/src/permissions.ts

@@ -5,13 +5,13 @@ import { KeyID } from "./crypto/crypto.js";
 import { CoValueCore, Transaction } from "./coValueCore.js";
 import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
 import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
-import { RawAccount, AccountID, RawProfile } from "./coValues/account.js";
+import { RawAccount, RawAccountID, RawProfile } from "./coValues/account.js";
 import { parseJSON } from "./jsonStringify.js";
 import { EVERYONE, Everyone } from "./coValues/group.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
 
 export type PermissionsDef =
-    | { type: "group"; initialAdmin: AccountID | AgentID }
+    | { type: "group"; initialAdmin: RawAccountID | AgentID }
     | { type: "ownedByGroup"; group: RawCoID }
     | { type: "unsafeAllowAll" };
 
@@ -53,7 +53,7 @@ export function determineValidTransactions(
         }
 
         const memberState: {
-            [agent: AccountID | AgentID]: Role;
+            [agent: RawAccountID | AgentID]: Role;
             [EVERYONE]?: Role;
         } = {};
 
@@ -99,7 +99,7 @@ export function determineValidTransactions(
             }
 
             const change = changes[0] as
-                | MapOpPayload<AccountID | AgentID | Everyone, Role>
+                | MapOpPayload<RawAccountID | AgentID | Everyone, Role>
                 | MapOpPayload<"readKey", JsonValue>
                 | MapOpPayload<"profile", CoID<RawProfile>>;
             if (changes.length !== 1) {
@@ -303,7 +303,7 @@ export function isKeyForKeyField(co: string): co is `${KeyID}_for_${KeyID}` {
 
 export function isKeyForAccountField(
     co: string,
-): co is `${KeyID}_for_${AccountID | AgentID}` {
+): co is `${KeyID}_for_${RawAccountID | AgentID}` {
     return (
         (co.startsWith("key_") &&
             (co.includes("_for_sealer") || co.includes("_for_co"))) ||

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/account.test.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "vitest";
-import { newRandomSessionID } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
@@ -65,7 +64,7 @@ test("Can create account with one node, and then load it on another", async () =
     const node2 = await LocalNode.withLoadedAccount({
         accountID,
         accountSecret,
-        sessionID: newRandomSessionID(accountID),
+        sessionID: Crypto.newRandomSessionID(accountID),
         peersToLoadFrom: [node1asPeer],
         crypto: Crypto,
     });

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();