jazz-tools 0.9.23 → 0.10.1

package/dist/{chunk-OJIEP4WE.js → chunk-24EJ3CKA.js}

@@ -9,8 +9,12 @@ var ActiveAccountContext = class {
     this.guestMode = false;
   }
   setGuestMode() {
+    this.activeAccount = null;
     this.guestMode = true;
   }
+  maybeGet() {
+    return this.activeAccount;
+  }
   get() {
     if (!this.activeAccount) {
       if (this.guestMode) {
@@ -414,128 +418,136 @@ import {
 var RegisteredSchemas = {};
 
 // src/implementation/createContext.ts
-var fixedCredentialsAuth = (credentials) => {
+async function randomSessionProvider(accountID, crypto) {
   return {
-    start: async () => ({
-      type: "existing",
-      credentials,
-      saveCredentials: async () => {
-      },
-      onSuccess: () => {
-      },
-      onError: () => {
-      },
-      logOut: () => {
-      }
-    })
+    sessionID: crypto.newRandomSessionID(accountID),
+    sessionDone: () => {
+    }
   };
-};
-var ephemeralCredentialsAuth = () => {
+}
+async function createJazzContextFromExistingCredentials({
+  credentials,
+  peersToLoadFrom,
+  crypto,
+  AccountSchema: PropsAccountSchema,
+  sessionProvider,
+  onLogOut
+}) {
+  const { sessionID, sessionDone } = await sessionProvider(
+    credentials.accountID,
+    crypto
+  );
+  const CurrentAccountSchema = PropsAccountSchema ?? RegisteredSchemas["Account"];
+  const node = await LocalNode.withLoadedAccount({
+    accountID: credentials.accountID,
+    accountSecret: credentials.secret,
+    sessionID,
+    peersToLoadFrom,
+    crypto
+  });
+  const account = CurrentAccountSchema.fromNode(node);
+  activeAccountContext.set(account);
+  await account.applyMigration();
   return {
-    start: async () => ({
-      type: "new",
-      creationProps: { name: "Ephemeral" },
-      saveCredentials: async () => {
-      },
-      onSuccess: () => {
-      },
-      onError: () => {
-      },
-      logOut: () => {
-      }
-    })
+    node,
+    account,
+    done: () => {
+      node.gracefulShutdown();
+      sessionDone();
+    },
+    logOut: async () => {
+      node.gracefulShutdown();
+      sessionDone();
+      await onLogOut?.();
+    }
   };
-};
-async function randomSessionProvider(accountID, crypto) {
+}
+async function createJazzContextForNewAccount({
+  creationProps,
+  initialAgentSecret,
+  peersToLoadFrom,
+  crypto,
+  AccountSchema: PropsAccountSchema,
+  onLogOut
+}) {
+  const CurrentAccountSchema = PropsAccountSchema ?? RegisteredSchemas["Account"];
+  const { node } = await LocalNode.withNewlyCreatedAccount({
+    creationProps,
+    peersToLoadFrom,
+    crypto,
+    initialAgentSecret,
+    migration: async (rawAccount, _node, creationProps2) => {
+      const account2 = new CurrentAccountSchema({
+        fromRaw: rawAccount
+      });
+      activeAccountContext.set(account2);
+      await account2.applyMigration(creationProps2);
+    }
+  });
+  const account = CurrentAccountSchema.fromNode(node);
+  activeAccountContext.set(account);
   return {
-    sessionID: crypto.newRandomSessionID(accountID),
-    sessionDone: () => {
+    node,
+    account,
+    done: () => {
+      node.gracefulShutdown();
+    },
+    logOut: async () => {
+      node.gracefulShutdown();
+      await onLogOut?.();
     }
   };
 }
 async function createJazzContext(options) {
-  if (!("auth" in options)) {
-    return createAnonymousJazzContext({
+  const crypto = options.crypto;
+  let context;
+  const authSecretStorage = options.authSecretStorage;
+  await authSecretStorage.migrate();
+  const credentials = options.credentials ?? await authSecretStorage.get();
+  if (credentials && !options.newAccountProps) {
+    context = await createJazzContextFromExistingCredentials({
+      credentials: {
+        accountID: credentials.accountID,
+        secret: credentials.accountSecret
+      },
       peersToLoadFrom: options.peersToLoadFrom,
-      crypto: options.crypto
-    });
-  }
-  const { auth, sessionProvider, peersToLoadFrom, crypto } = options;
-  const AccountSchema = options.AccountSchema ?? RegisteredSchemas["Account"];
-  const authResult = await auth.start(crypto);
-  if (authResult.type === "existing") {
-    const { sessionID, sessionDone } = await sessionProvider(
-      authResult.credentials.accountID,
-      crypto
-    );
-    const node = await LocalNode.withLoadedAccount({
-      accountID: authResult.credentials.accountID,
-      accountSecret: authResult.credentials.secret,
-      sessionID,
-      peersToLoadFrom,
       crypto,
-      migration: async (rawAccount, _node, creationProps) => {
-        const account2 = new AccountSchema({
-          fromRaw: rawAccount
-        });
-        activeAccountContext.set(account2);
-        await account2.applyMigration(creationProps);
+      AccountSchema: options.AccountSchema,
+      sessionProvider: options.sessionProvider,
+      onLogOut: () => {
+        authSecretStorage.clear();
       }
     });
-    const account = AccountSchema.fromNode(node);
-    activeAccountContext.set(account);
-    if (authResult.saveCredentials) {
-      await authResult.saveCredentials({
-        accountID: node.account.id,
-        secret: node.account.agentSecret
-      });
-    }
-    authResult.onSuccess();
-    return {
-      account,
-      done: () => {
-        node.gracefulShutdown();
-        sessionDone();
-      },
-      logOut: () => {
-        node.gracefulShutdown();
-        sessionDone();
-        authResult.logOut();
-      }
+    authSecretStorage.emitUpdate(credentials);
+  } else {
+    const secretSeed = options.crypto.newRandomSecretSeed();
+    const initialAgentSecret = options.newAccountProps?.secret ?? crypto.agentSecretFromSecretSeed(secretSeed);
+    const creationProps = options.newAccountProps?.creationProps ?? {
+      name: options.defaultProfileName ?? "Anonymous user"
     };
-  } else if (authResult.type === "new") {
-    const { node } = await LocalNode.withNewlyCreatedAccount({
-      creationProps: authResult.creationProps,
-      peersToLoadFrom,
+    context = await createJazzContextForNewAccount({
+      creationProps,
+      initialAgentSecret,
+      peersToLoadFrom: options.peersToLoadFrom,
       crypto,
-      initialAgentSecret: authResult.initialSecret,
-      migration: async (rawAccount, _node, creationProps) => {
-        const account2 = new AccountSchema({
-          fromRaw: rawAccount
-        });
-        activeAccountContext.set(account2);
-        await account2.applyMigration(creationProps);
+      AccountSchema: options.AccountSchema,
+      onLogOut: async () => {
+        await authSecretStorage.clear();
       }
     });
-    const account = AccountSchema.fromNode(node);
-    activeAccountContext.set(account);
-    await authResult.saveCredentials({
-      accountID: node.account.id,
-      secret: node.account.agentSecret
-    });
-    authResult.onSuccess();
-    return {
-      account,
-      done: () => {
-        node.gracefulShutdown();
-      },
-      logOut: () => {
-        node.gracefulShutdown();
-        authResult.logOut();
-      }
-    };
+    if (!options.newAccountProps) {
+      await authSecretStorage.set({
+        accountID: context.account.id,
+        secretSeed,
+        accountSecret: context.node.account.agentSecret,
+        provider: "anonymous"
+      });
+    }
   }
-  throw new Error("Invalid auth result");
+  return {
+    ...context,
+    authSecretStorage
+  };
 }
 async function createAnonymousJazzContext({
   peersToLoadFrom,
@@ -556,7 +568,7 @@ async function createAnonymousJazzContext({
     agent: new AnonymousJazzAgent(node),
     done: () => {
     },
-    logOut: () => {
+    logOut: async () => {
     }
   };
 }
@@ -723,13 +735,17 @@ function loadCoValue(cls, id, as, depth) {
     );
   });
 }
-function ensureCoValueLoaded(existing, depth) {
-  return loadCoValue(
+async function ensureCoValueLoaded(existing, depth) {
+  const response = await loadCoValue(
     existing.constructor,
     existing.id,
     existing._loadedAs,
     depth
   );
+  if (!response) {
+    throw new Error("Failed to deeply load CoValue " + existing.id);
+  }
+  return response;
 }
 function subscribeToCoValueWithoutMe(cls, id, asOrDepth, depthOrListener, listener) {
   if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
@@ -806,7 +822,10 @@ function createCoValueObservable(options) {
         currentValue = value;
         listener();
       },
-      onUnavailable,
+      () => {
+        currentValue = null;
+        onUnavailable?.();
+      },
       options?.syncResolution
     );
     return () => {
@@ -2699,11 +2718,9 @@ var _Group = class _Group extends CoValueBase {
   }
   addMember(member, role) {
     this._raw.addMember(member === "everyone" ? member : member._raw, role);
-    return this;
   }
   removeMember(member) {
-    this._raw.removeMember(member === "everyone" ? member : member._raw);
-    return this;
+    return this._raw.removeMember(member === "everyone" ? member : member._raw);
   }
   get members() {
     return this._raw.keys().filter((key) => {
@@ -2727,8 +2744,8 @@ var _Group = class _Group extends CoValueBase {
       };
     });
   }
-  extend(parent) {
-    this._raw.extend(parent._raw);
+  extend(parent, roleMapping) {
+    this._raw.extend(parent._raw, roleMapping);
     return this;
   }
   static load(id, asOrDepth, depth) {
@@ -3378,8 +3395,433 @@ var SchemaUnion = class _SchemaUnion extends CoValueBase {
   }
 };
 
-// src/implementation/invites.ts
+// src/auth/KvStoreContext.ts
+var KvStoreContext = class _KvStoreContext {
+  constructor() {
+    this.storageInstance = null;
+  }
+  static getInstance() {
+    if (!_KvStoreContext.instance) {
+      _KvStoreContext.instance = new _KvStoreContext();
+    }
+    return _KvStoreContext.instance;
+  }
+  isInitialized() {
+    return this.storageInstance !== null;
+  }
+  initialize(store) {
+    if (!this.storageInstance) {
+      this.storageInstance = store;
+    }
+  }
+  getStorage() {
+    if (!this.storageInstance) {
+      throw new Error("Storage instance is not initialized.");
+    }
+    return this.storageInstance;
+  }
+};
+var KvStoreContext_default = KvStoreContext;
+
+// src/auth/AuthSecretStorage.ts
+var STORAGE_KEY = "jazz-logged-in-secret";
+var AuthSecretStorage = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.isAuthenticated = false;
+  }
+  async migrate() {
+    const kvStore = KvStoreContext_default.getInstance().getStorage();
+    if (!await kvStore.get(STORAGE_KEY)) {
+      const demoAuthSecret = await kvStore.get("demo-auth-logged-in-secret");
+      if (demoAuthSecret) {
+        await kvStore.set(STORAGE_KEY, demoAuthSecret);
+        await kvStore.delete("demo-auth-logged-in-secret");
+      }
+      const clerkAuthSecret = await kvStore.get("jazz-clerk-auth");
+      if (clerkAuthSecret) {
+        await kvStore.set(STORAGE_KEY, clerkAuthSecret);
+        await kvStore.delete("jazz-clerk-auth");
+      }
+    }
+  }
+  async get() {
+    const kvStore = KvStoreContext_default.getInstance().getStorage();
+    const data = await kvStore.get(STORAGE_KEY);
+    if (!data) return null;
+    const parsed = JSON.parse(data);
+    if (!parsed.accountID || !parsed.accountSecret) {
+      throw new Error("Invalid auth secret storage data");
+    }
+    return {
+      accountID: parsed.accountID,
+      secretSeed: parsed.secretSeed ? new Uint8Array(parsed.secretSeed) : void 0,
+      accountSecret: parsed.accountSecret,
+      provider: parsed.provider
+    };
+  }
+  async set(payload) {
+    const kvStore = KvStoreContext_default.getInstance().getStorage();
+    await kvStore.set(
+      STORAGE_KEY,
+      JSON.stringify({
+        accountID: payload.accountID,
+        secretSeed: payload.secretSeed ? Array.from(payload.secretSeed) : void 0,
+        accountSecret: payload.accountSecret,
+        provider: payload.provider
+      })
+    );
+    this.emitUpdate(payload);
+  }
+  getIsAuthenticated(data) {
+    if (!data) return false;
+    return data.provider !== "anonymous";
+  }
+  onUpdate(handler) {
+    this.listeners.add(handler);
+    return () => {
+      this.listeners.delete(handler);
+    };
+  }
+  emitUpdate(data) {
+    const isAuthenticated = this.getIsAuthenticated(data);
+    if (this.isAuthenticated === isAuthenticated) return;
+    this.isAuthenticated = isAuthenticated;
+    for (const listener of this.listeners) {
+      listener(this.isAuthenticated);
+    }
+  }
+  async clear() {
+    const kvStore = KvStoreContext_default.getInstance().getStorage();
+    await kvStore.delete(STORAGE_KEY);
+    this.emitUpdate(null);
+  }
+};
+
+// src/auth/InMemoryKVStore.ts
+var InMemoryKVStore = class {
+  constructor() {
+    this.store = {};
+  }
+  async get(key) {
+    const data = this.store[key];
+    if (!data) return null;
+    return data;
+  }
+  async set(key, value) {
+    this.store[key] = value;
+  }
+  async delete(key) {
+    delete this.store[key];
+  }
+  async clearAll() {
+    this.store = {};
+  }
+};
+
+// src/implementation/ContextManager.ts
 import { cojsonInternals as cojsonInternals4 } from "cojson";
+var JazzContextManager = class {
+  constructor() {
+    this.authSecretStorage = new AuthSecretStorage();
+    this.authenticating = false;
+    this.logOut = async () => {
+      if (!this.context || !this.props) {
+        return;
+      }
+      await this.context.logOut();
+      this.props.onLogOut?.();
+      return this.createContext(this.props);
+    };
+    this.done = () => {
+      if (!this.context) {
+        return;
+      }
+      this.context.done();
+    };
+    this.authenticate = async (credentials) => {
+      if (!this.props) {
+        throw new Error("Props required");
+      }
+      const prevContext = this.context;
+      const prevCredentials = await this.authSecretStorage.get();
+      const wasAnonymous = this.authSecretStorage.getIsAuthenticated(prevCredentials) === false;
+      this.authenticating = true;
+      await this.createContext(this.props, { credentials }).finally(() => {
+        this.authenticating = false;
+      });
+      const currentContext = this.context;
+      if (prevContext && currentContext && "me" in prevContext && "me" in currentContext && wasAnonymous) {
+        const [prevAccountAsPeer, currentAccountAsPeer] = cojsonInternals4.connectedPeers(
+          prevContext.me.id,
+          currentContext.me.id,
+          {
+            peer1role: "client",
+            peer2role: "server"
+          }
+        );
+        prevContext.node.syncManager.addPeer(currentAccountAsPeer);
+        currentContext.node.syncManager.addPeer(prevAccountAsPeer);
+        try {
+          await this.props.onAnonymousAccountDiscarded?.(prevContext.me);
+          await prevContext.me.waitForAllCoValuesSync();
+        } catch (error) {
+          console.error("Error onAnonymousAccountDiscarded", error);
+        }
+        prevAccountAsPeer.outgoing.close();
+        currentAccountAsPeer.outgoing.close();
+      }
+      prevContext?.done();
+    };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (callback) => {
+      this.listeners.add(callback);
+      return () => {
+        this.listeners.delete(callback);
+      };
+    };
+    KvStoreContext.getInstance().initialize(this.getKvStore());
+  }
+  getKvStore() {
+    return new InMemoryKVStore();
+  }
+  async createContext(props, authProps) {
+    props;
+    authProps;
+    throw new Error("Not implemented");
+  }
+  updateContext(props, context) {
+    if (!this.authenticating) {
+      this.context?.done();
+    }
+    this.context = context;
+    this.props = props;
+    this.value = {
+      ...context,
+      node: context.node,
+      authenticate: this.authenticate,
+      logOut: this.logOut
+    };
+    this.notify();
+  }
+  propsChanged(props) {
+    props;
+    throw new Error("Not implemented");
+  }
+  getCurrentValue() {
+    return this.value;
+  }
+  getAuthSecretStorage() {
+    return this.authSecretStorage;
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+};
+
+// src/auth/DemoAuth.ts
+var DemoAuth = class {
+  constructor(authenticate, authSecretStorage) {
+    this.authenticate = authenticate;
+    this.authSecretStorage = authSecretStorage;
+    this.logIn = async (username) => {
+      const existingUsers = await this.getExisitingUsersWithData();
+      const storageData = existingUsers[username];
+      if (!storageData?.accountID) {
+        throw new Error("User not found");
+      }
+      await this.authenticate({
+        accountID: storageData.accountID,
+        accountSecret: storageData.accountSecret
+      });
+      await this.authSecretStorage.set({
+        accountID: storageData.accountID,
+        accountSecret: storageData.accountSecret,
+        secretSeed: storageData.secretSeed ? new Uint8Array(storageData.secretSeed) : void 0,
+        provider: "demo"
+      });
+    };
+    this.signUp = async (username) => {
+      const existingUsers = await this.getExistingUsers();
+      if (existingUsers.includes(username)) {
+        throw new Error("User already registered");
+      }
+      const credentials = await this.authSecretStorage.get();
+      if (!credentials) {
+        throw new Error("No credentials found");
+      }
+      const currentAccount = await Account.getMe().ensureLoaded({
+        profile: {}
+      });
+      currentAccount.profile.name = username;
+      await this.authSecretStorage.set({
+        accountID: credentials.accountID,
+        accountSecret: credentials.accountSecret,
+        secretSeed: credentials.secretSeed ? new Uint8Array(credentials.secretSeed) : void 0,
+        provider: "demo"
+      });
+      await this.addToExistingUsers(username, {
+        accountID: credentials.accountID,
+        accountSecret: credentials.accountSecret,
+        secretSeed: credentials.secretSeed ? Array.from(credentials.secretSeed) : void 0
+      });
+    };
+    this.getExistingUsers = async () => {
+      return Object.keys(await this.getExisitingUsersWithData());
+    };
+  }
+  async addToExistingUsers(username, data) {
+    const existingUsers = await this.getExisitingUsersWithData();
+    if (existingUsers[username]) {
+      return;
+    }
+    existingUsers[username] = data;
+    const kvStore = KvStoreContext.getInstance().getStorage();
+    await kvStore.set("demo-auth-users", JSON.stringify(existingUsers));
+  }
+  async getExisitingUsersWithData() {
+    const kvStore = KvStoreContext.getInstance().getStorage();
+    await migrateExistingUsers(kvStore);
+    const existingUsers = await kvStore.get("demo-auth-users");
+    return existingUsers ? JSON.parse(existingUsers) : {};
+  }
+};
+function encodeUsername(username) {
+  return btoa(username).replace(/=/g, "-").replace(/\+/g, "_").replace(/\//g, ".");
+}
+async function getStorageVersion(kvStore) {
+  try {
+    const version = await kvStore.get("demo-auth-storage-version");
+    return version ? parseInt(version) : 1;
+  } catch (error) {
+    return 1;
+  }
+}
+async function setStorageVersion(kvStore, version) {
+  await kvStore.set("demo-auth-storage-version", version.toString());
+}
+async function getExistingUsersList(kvStore) {
+  const existingUsers = await kvStore.get("demo-auth-existing-users");
+  return existingUsers ? existingUsers.split(",") : [];
+}
+async function migrateExistingUsers(kvStore) {
+  if (await getStorageVersion(kvStore) < 2) {
+    const existingUsers = await getExistingUsersList(kvStore);
+    for (const username of existingUsers) {
+      const legacyKey = `demo-auth-existing-users-${username}`;
+      const storageData = await kvStore.get(legacyKey);
+      if (storageData) {
+        await kvStore.set(
+          `demo-auth-existing-users-${encodeUsername(username)}`,
+          storageData
+        );
+        await kvStore.delete(legacyKey);
+      }
+    }
+    await setStorageVersion(kvStore, 2);
+  }
+  if (await getStorageVersion(kvStore) < 3) {
+    const existingUsersList = await getExistingUsersList(kvStore);
+    const existingUsers = {};
+    const keysToDelete = ["demo-auth-existing-users"];
+    for (const username of existingUsersList) {
+      const key = `demo-auth-existing-users-${encodeUsername(username)}`;
+      const storageData = await kvStore.get(key);
+      if (storageData) {
+        existingUsers[username] = JSON.parse(storageData);
+        keysToDelete.push(key);
+      }
+    }
+    await kvStore.set("demo-auth-users", JSON.stringify(existingUsers));
+    for (const key of keysToDelete) {
+      await kvStore.delete(key);
+    }
+    await setStorageVersion(kvStore, 3);
+  }
+}
+
+// src/auth/PassphraseAuth.ts
+import * as bip39 from "@scure/bip39";
+import { entropyToMnemonic } from "@scure/bip39";
+import { cojsonInternals as cojsonInternals5 } from "cojson";
+var PassphraseAuth = class {
+  constructor(crypto, authenticate, authSecretStorage, wordlist) {
+    this.crypto = crypto;
+    this.authenticate = authenticate;
+    this.authSecretStorage = authSecretStorage;
+    this.wordlist = wordlist;
+    this.passphrase = "";
+    this.logIn = async (passphrase) => {
+      const { crypto, authenticate } = this;
+      let secretSeed;
+      try {
+        secretSeed = bip39.mnemonicToEntropy(passphrase, this.wordlist);
+      } catch (e) {
+        throw new Error("Invalid passphrase");
+      }
+      const accountSecret = crypto.agentSecretFromSecretSeed(secretSeed);
+      const accountID = cojsonInternals5.idforHeader(
+        cojsonInternals5.accountHeaderForInitialAgentSecret(accountSecret, crypto),
+        crypto
+      );
+      await authenticate({
+        accountID,
+        accountSecret
+      });
+      await this.authSecretStorage.set({
+        accountID,
+        secretSeed,
+        accountSecret,
+        provider: "passphrase"
+      });
+      this.passphrase = passphrase;
+      this.notify();
+    };
+    this.signUp = async () => {
+      const credentials = await this.authSecretStorage.get();
+      if (!credentials || !credentials.secretSeed) {
+        throw new Error("No credentials found");
+      }
+      const passphrase = entropyToMnemonic(credentials.secretSeed, this.wordlist);
+      await this.authSecretStorage.set({
+        accountID: credentials.accountID,
+        secretSeed: credentials.secretSeed,
+        accountSecret: credentials.accountSecret,
+        provider: "passphrase"
+      });
+      return passphrase;
+    };
+    this.getCurrentAccountPassphrase = async () => {
+      const credentials = await this.authSecretStorage.get();
+      if (!credentials || !credentials.secretSeed) {
+        throw new Error("No credentials found");
+      }
+      return entropyToMnemonic(credentials.secretSeed, this.wordlist);
+    };
+    this.loadCurrentAccountPassphrase = async () => {
+      const passphrase = await this.getCurrentAccountPassphrase();
+      this.passphrase = passphrase;
+      this.notify();
+    };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (callback) => {
+      this.listeners.add(callback);
+      return () => {
+        this.listeners.delete(callback);
+      };
+    };
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+};
+
+// src/implementation/invites.ts
+import { cojsonInternals as cojsonInternals6 } from "cojson";
 function createInviteLink(value, role, baseURL, valueHint) {
   const coValueCore = value._raw.core;
   let currentCoValue = coValueCore;
@@ -3390,7 +3832,7 @@ function createInviteLink(value, role, baseURL, valueHint) {
   if (ruleset.type !== "group" || meta?.type === "account") {
     throw new Error("Can't create invite link for object without group");
   }
-  const group = cojsonInternals4.expectGroup(currentCoValue.getCurrentContent());
+  const group = cojsonInternals6.expectGroup(currentCoValue.getCurrentContent());
   const inviteSecret = group.createInvite(role);
   return `${baseURL}#/invite/${valueHint ? valueHint + "/" : ""}${value.id}/${inviteSecret}`;
 }
@@ -3442,9 +3884,9 @@ export {
   createCoValueObservable,
   Encoders,
   co,
-  fixedCredentialsAuth,
-  ephemeralCredentialsAuth,
   randomSessionProvider,
+  createJazzContextFromExistingCredentials,
+  createJazzContextForNewAccount,
   createJazzContext,
   createAnonymousJazzContext,
   Inbox,
@@ -3462,9 +3904,15 @@ export {
   Marks,
   ImageDefinition,
   SchemaUnion,
+  KvStoreContext,
+  AuthSecretStorage,
+  InMemoryKVStore,
+  JazzContextManager,
+  DemoAuth,
+  PassphraseAuth,
   createInviteLink,
   parseInviteLink,
   consumeInviteLink
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-OJIEP4WE.js.map
+//# sourceMappingURL=chunk-24EJ3CKA.js.map