jazz-tools 0.18.24 → 0.18.26

package/dist/{chunk-W7JT3QUN.js → chunk-ZIAN4UY5.js}

@@ -2164,7 +2164,7 @@ var Account = class extends CoValueBase {
    *
    * @param valueID The ID of the `CoValue` or `Group` to accept the invite to.
    * @param inviteSecret The secret of the invite to accept.
-   * @param coValueClass The class of the `CoValue` or `Group` to accept the invite to.
+   * @param coValueClass [Group] The class of the `CoValue` or `Group` to accept the invite to.
    * @returns The loaded `CoValue` or `Group`.
    */
   async acceptInvite(valueID, inviteSecret, coValueClass) {
@@ -2176,7 +2176,7 @@ var Account = class extends CoValueBase {
       inviteSecret
     );
     return loadCoValue(
-      coValueClassFromCoValueClassOrSchema(coValueClass),
+      coValueClassFromCoValueClassOrSchema(coValueClass ?? Group5),
       valueID,
       {
         loadAs: this
@@ -2258,7 +2258,7 @@ var Account = class extends CoValueBase {
     const account = await this.create({
       creationProps: options.creationProps,
       crypto: as.$jazz.localNode.crypto,
-      peersToLoadFrom: [connectedPeers[0]]
+      peers: [connectedPeers[0]]
     });
     await account.$jazz.waitForAllCoValuesSync();
     return account;
@@ -2646,9 +2646,27 @@ var _Group = class _Group extends CoValueBase {
     const { options, listener } = parseSubscribeRestArgs(args);
     return subscribeToCoValueWithoutMe(this, id, options, listener);
   }
+  /** @category Invites
+   * Creates a group invite
+   * @param id The ID of the group to create an invite for
+   * @param options Optional configuration
+   * @param options.role The role to grant to the accepter of the invite. Defaults to 'reader'
+   * @param options.loadAs The account to use when loading the group. Defaults to the current account
+   * @returns An invite secret, (a string starting with "inviteSecret_"). Can be
+   * accepted using `Account.acceptInvite()`
+   */
+  static async createInvite(id, options) {
+    const group = await loadCoValueWithoutMe(this, id, {
+      loadAs: options?.loadAs
+    });
+    if (!group) {
+      throw new Error(`Group with id ${id} not found`);
+    }
+    return group.$jazz.createInvite(options?.role ?? "reader");
+  }
 };
 _Group.prototype[TypeSym] = "Group";
-var Group6 = _Group;
+var Group5 = _Group;
 var GroupJazzApi = class extends CoValueJazzApi {
   constructor(group, raw) {
     super(group);
@@ -2676,6 +2694,14 @@ var GroupJazzApi = class extends CoValueJazzApi {
     const { options, listener } = parseSubscribeRestArgs(args);
     return subscribeToExistingCoValue(this.group, options, listener);
   }
+  /**
+   * Create an invite to this group
+   *
+   * @category Invites
+   */
+  createInvite(role = "reader") {
+    return this.raw.createInvite(role);
+  }
   /**
    * Wait for the `Group` to be uploaded to the other peers.
    *
@@ -2685,7 +2711,7 @@ var GroupJazzApi = class extends CoValueJazzApi {
     return this.raw.core.waitForSync(options);
   }
 };
-RegisteredSchemas["Group"] = Group6;
+RegisteredSchemas["Group"] = Group5;
 function isAccountID(id) {
   return id.startsWith("co_");
 }
@@ -3273,6 +3299,279 @@ var SchemaUnion = class _SchemaUnion extends CoValueBase {
   }
 };
 
+// src/tools/coValues/coVector.ts
+import { cojsonInternals as cojsonInternals5 } from "cojson";
+var _CoVector = class _CoVector extends Float32Array {
+  static get [Symbol.species]() {
+    return Float32Array;
+  }
+  constructor(options) {
+    const dimensionsCount = new.target.requiredDimensionsCount;
+    if (dimensionsCount === void 0) {
+      throw new Error(
+        "Instantiating CoVector without a dimensions count is not allowed. Use co.vector(...).create() instead."
+      );
+    }
+    super(dimensionsCount);
+    const isFromRaw = "fromRaw" in options;
+    const raw = isFromRaw ? options.fromRaw : options.owner.$jazz.raw.createBinaryStream();
+    Object.defineProperties(this, {
+      [TypeSym]: { value: "BinaryCoStream", enumerable: false },
+      $jazz: {
+        value: new CoVectorJazzApi(this, raw),
+        enumerable: false
+      },
+      _isVectorLoaded: { value: false, enumerable: false, writable: true },
+      _requiredDimensionsCount: {
+        value: dimensionsCount,
+        enumerable: false,
+        writable: false
+      }
+    });
+    if (isFromRaw) {
+      this.loadVectorData();
+    }
+  }
+  /** @category Internals */
+  static fromRaw(raw) {
+    return new this({ fromRaw: raw });
+  }
+  /**
+   * Create a new `CoVector` instance with the given vector.
+   *
+   * @category Creation
+   * @deprecated Use `co.vector(...).create` instead.
+   */
+  static create(vector, options) {
+    const vectorAsFloat32Array = vector instanceof Float32Array ? vector : new Float32Array(vector);
+    const givenVectorDimensions = vectorAsFloat32Array.byteLength / vectorAsFloat32Array.BYTES_PER_ELEMENT;
+    if (this.requiredDimensionsCount !== void 0 && givenVectorDimensions !== this.requiredDimensionsCount) {
+      throw new Error(
+        `Vector dimension mismatch! Expected ${this.requiredDimensionsCount} dimensions, got ${givenVectorDimensions}`
+      );
+    }
+    const coVector = new this(parseCoValueCreateOptions(options));
+    coVector.setVectorData(vectorAsFloat32Array);
+    const byteArray = _CoVector.toByteArray(vectorAsFloat32Array);
+    coVector.$jazz.raw.startBinaryStream({
+      mimeType: "application/vector+octet-stream",
+      totalSizeBytes: byteArray.byteLength
+    });
+    const chunkSize = cojsonInternals5.TRANSACTION_CONFIG.MAX_RECOMMENDED_TX_SIZE;
+    for (let idx = 0; idx < byteArray.length; idx += chunkSize) {
+      coVector.$jazz.raw.pushBinaryStreamChunk(
+        byteArray.slice(idx, idx + chunkSize)
+      );
+    }
+    coVector.$jazz.raw.endBinaryStream();
+    return coVector;
+  }
+  static toByteArray(vector) {
+    return new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength);
+  }
+  static fromByteArray(bytesChunks) {
+    const total = bytesChunks.reduce((acc, c) => acc + c.byteLength, 0);
+    if (total % 4 !== 0)
+      throw new Error("[INTERNAL] Total byte length must be multiple of 4");
+    const u8 = new Uint8Array(total);
+    let off = 0;
+    for (const c of bytesChunks) {
+      u8.set(c, off);
+      off += c.byteLength;
+    }
+    return new Float32Array(u8.buffer, u8.byteOffset, total / 4);
+  }
+  loadVectorData() {
+    if (this._isVectorLoaded === true) {
+      return;
+    }
+    const chunks = this.$jazz.raw.getBinaryChunks();
+    if (!chunks) {
+      throw new Error(`CoVector '${this.$jazz.raw.id}' is not loaded`);
+    }
+    const vector = _CoVector.fromByteArray(chunks.chunks);
+    if (vector.length !== this._requiredDimensionsCount) {
+      throw new Error(
+        `Vector dimension mismatch! CoVector '${this.$jazz.raw.id}' loaded with ${vector.length} dimensions, but the schema requires ${this._requiredDimensionsCount} dimensions`
+      );
+    }
+    this.setVectorData(vector);
+    return;
+  }
+  setVectorData(vector) {
+    super.set(vector, 0);
+    this._isVectorLoaded = true;
+  }
+  /**
+   * Get a JSON representation of the `CoVector`
+   * @category Content
+   */
+  toJSON() {
+    return Array.from(this);
+  }
+  /** @internal */
+  [inspect]() {
+    return this.toJSON();
+  }
+  /**
+   * Load a `CoVector`
+   *
+   * @category Subscription & Loading
+   * @deprecated Use `co.vector(...).load` instead.
+   */
+  static async load(id, options) {
+    const coVector = await loadCoValueWithoutMe(this, id, options);
+    if (!coVector?.$jazz.raw.isBinaryStreamEnded()) {
+      return new Promise((resolve) => {
+        subscribeToCoValueWithoutMe(
+          this,
+          id,
+          options || {},
+          (value, unsubscribe) => {
+            if (value.$jazz.raw.isBinaryStreamEnded()) {
+              unsubscribe();
+              resolve(value);
+            }
+          }
+        );
+      });
+    }
+    coVector.loadVectorData();
+    return coVector;
+  }
+  static subscribe(id, ...args) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe(this, id, options, listener);
+  }
+  // CoVector mutation method overrides, as CoVectors aren't meant to be mutated
+  /**
+   * Calling `copyWithin` on a CoVector is forbidden. CoVectors are immutable.
+   * @deprecated If you want to change the vector, replace the former instance of CoVector with a new one.
+   */
+  copyWithin(target, start, end) {
+    throw new Error("Cannot mutate a CoVector using `copyWithin`");
+  }
+  /**
+   * Calling `fill` on a CoVector is forbidden. CoVectors are immutable.
+   * @deprecated If you want to change the vector, replace the former instance of CoVector with a new one.
+   */
+  fill(value, start, end) {
+    throw new Error("Cannot mutate a CoVector using `fill`");
+  }
+  /**
+   * Calling `reverse` on a CoVector is forbidden. CoVectors are immutable.
+   * @deprecated If you want to change the vector, replace the former instance of CoVector with a new one.
+   */
+  reverse() {
+    throw new Error("Cannot mutate a CoVector using `reverse`");
+  }
+  /**
+   * Calling `set` on a CoVector is forbidden. CoVectors are immutable.
+   * @deprecated If you want to change the vector, replace the former instance of CoVector with a new one.
+  //  */
+  set(array2, offset) {
+    throw new Error("Cannot mutate a CoVector using `set`");
+  }
+  /**
+   * Calling `sort` on a CoVector is forbidden. CoVectors are immutable.
+   * @deprecated If you want to change the vector, replace the former instance of CoVector with a new one.
+   */
+  sort(compareFn) {
+    throw new Error("Cannot mutate a CoVector using `sort`");
+  }
+};
+_CoVector.requiredDimensionsCount = void 0;
+var CoVector = _CoVector;
+var CoVectorJazzApi = class extends CoValueJazzApi {
+  constructor(coVector, raw) {
+    super(coVector);
+    this.coVector = coVector;
+    this.raw = raw;
+  }
+  get owner() {
+    return getCoValueOwner(this.coVector);
+  }
+  /**
+   * An instance method to subscribe to an existing `CoVector`
+   * @category Subscription & Loading
+   */
+  subscribe(listener) {
+    return subscribeToExistingCoValue(this.coVector, {}, listener);
+  }
+  /**
+   * Wait for the `CoVector` to be uploaded to the other peers.
+   *
+   * @category Subscription & Loading
+   */
+  waitForSync(options) {
+    return this.raw.core.waitForSync(options);
+  }
+  // Vector operations
+  /**
+   * Calculate the magnitude of this vector.
+   */
+  magnitude() {
+    return VectorCalculation.magnitude(this.coVector);
+  }
+  /**
+   * Normalize this vector.
+   * @returns A new instance of a normalized vector.
+   */
+  normalize() {
+    return VectorCalculation.normalize(this.coVector);
+  }
+  /**
+   * Calculate the dot product of this vector and another vector.
+   */
+  dotProduct(otherVector) {
+    return VectorCalculation.dotProduct(this.coVector, otherVector);
+  }
+  /**
+   * Calculate the cosine similarity between this vector and another vector.
+   *
+   * @returns A value between `-1` and `1`:
+   * - `1` means the vectors are identical
+   * - `0` means the vectors are orthogonal (i.e. no similarity)
+   * - `-1` means the vectors are opposite direction (perfectly dissimilar)
+   */
+  cosineSimilarity(otherVector) {
+    return VectorCalculation.cosineSimilarity(this.coVector, otherVector);
+  }
+};
+var VectorCalculation = {
+  magnitude: (vector) => {
+    let sum = 0;
+    for (const v of vector) {
+      sum += v * v;
+    }
+    return Math.sqrt(sum);
+  },
+  normalize: (vector) => {
+    const mag = VectorCalculation.magnitude(vector);
+    if (mag === 0) {
+      return new Float32Array(vector.length).fill(0);
+    }
+    return vector.map((v) => v / mag);
+  },
+  dotProduct: (vectorA, vectorB) => {
+    if (vectorA.length !== vectorB.length) {
+      throw new Error(
+        `Vector dimensions don't match: ${vectorA.length} vs ${vectorB.length}`
+      );
+    }
+    return vectorA.reduce((sum, a, i) => sum + a * vectorB[i], 0);
+  },
+  cosineSimilarity: (vectorA, vectorB) => {
+    const magnitudeA = VectorCalculation.magnitude(vectorA);
+    const magnitudeB = VectorCalculation.magnitude(vectorB);
+    if (magnitudeA === 0 || magnitudeB === 0) {
+      return 0;
+    }
+    const dotProductAB = VectorCalculation.dotProduct(vectorA, vectorB);
+    return dotProductAB / (magnitudeA * magnitudeB);
+  }
+};
+
 // src/tools/implementation/anonymousJazzAgent.ts
 var _a;
 _a = TypeSym;
@@ -3514,7 +3813,7 @@ function instantiateRefEncodedWithInit(schema, init, parentOwner) {
   }
   const node = parentOwner.$jazz.localNode;
   const rawGroup = node.createGroup();
-  const owner = new Group6({ fromRaw: rawGroup });
+  const owner = new Group5({ fromRaw: rawGroup });
   owner.addMember(parentOwner);
   return schema.ref.create(init, owner);
 }
@@ -3534,7 +3833,7 @@ function applyCoValueMigrations(instance) {
 
 // src/tools/subscribe/CoValueCoreSubscription.ts
 import {
-  cojsonInternals as cojsonInternals5
+  cojsonInternals as cojsonInternals6
 } from "cojson";
 var CoValueCoreSubscription = class {
   constructor(localNode, id, listener, skipRetry, branch) {
@@ -3581,7 +3880,7 @@ var CoValueCoreSubscription = class {
    * Either subscribes directly or attempts to get the requested branch.
    */
   handleAvailableSource() {
-    if (!this.branchName || !cojsonInternals5.canBeBranched(this.source)) {
+    if (!this.branchName || !cojsonInternals6.canBeBranched(this.source)) {
       this.subscribe(this.source.getCurrentContent());
       return;
     }
@@ -4344,7 +4643,7 @@ async function randomSessionProvider(accountID, crypto) {
 }
 async function createJazzContextFromExistingCredentials({
   credentials,
-  peersToLoadFrom,
+  peers,
   crypto,
   storage,
   AccountSchema: PropsAccountSchema,
@@ -4362,7 +4661,7 @@ async function createJazzContextFromExistingCredentials({
     accountID: credentials.accountID,
     accountSecret: credentials.secret,
     sessionID,
-    peersToLoadFrom,
+    peers,
     crypto,
     storage,
     migration: async (rawAccount, _node, creationProps) => {
@@ -4394,7 +4693,7 @@ async function createJazzContextFromExistingCredentials({
 async function createJazzContextForNewAccount({
   creationProps,
   initialAgentSecret,
-  peersToLoadFrom,
+  peers,
   crypto,
   AccountSchema: PropsAccountSchema,
   onLogOut,
@@ -4404,7 +4703,7 @@ async function createJazzContextForNewAccount({
   const AccountClass = coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
   const { node } = await LocalNode4.withNewlyCreatedAccount({
     creationProps,
-    peersToLoadFrom,
+    peers,
     crypto,
     initialAgentSecret,
     storage,
@@ -4440,7 +4739,7 @@ async function createJazzContext(options) {
         accountID: credentials.accountID,
         secret: credentials.accountSecret
       },
-      peersToLoadFrom: options.peersToLoadFrom,
+      peers: options.peers,
       crypto,
       AccountSchema: options.AccountSchema,
       sessionProvider: options.sessionProvider,
@@ -4459,7 +4758,7 @@ async function createJazzContext(options) {
     context = await createJazzContextForNewAccount({
       creationProps,
       initialAgentSecret,
-      peersToLoadFrom: options.peersToLoadFrom,
+      peers: options.peers,
       crypto,
       AccountSchema: options.AccountSchema,
       onLogOut: async () => {
@@ -4482,7 +4781,7 @@ async function createJazzContext(options) {
   };
 }
 function createAnonymousJazzContext({
-  peersToLoadFrom,
+  peers,
   crypto,
   storage
 }) {
@@ -4492,7 +4791,7 @@ function createAnonymousJazzContext({
     crypto.newRandomSessionID(crypto.getAgentID(agentSecret)),
     crypto
   );
-  for (const peer of peersToLoadFrom) {
+  for (const peer of peers) {
     node.syncManager.addPeer(peer);
   }
   if (storage) {
@@ -4620,19 +4919,22 @@ var GroupSchema = class {
     this.builtin = "Group";
   }
   getCoValueClass() {
-    return Group6;
+    return Group5;
   }
   optional() {
     return coOptionalDefiner(this);
   }
   create(options) {
-    return Group6.create(options);
+    return Group5.create(options);
   }
   load(id, options) {
-    return Group6.load(id, options);
+    return Group5.load(id, options);
+  }
+  createInvite(id, options) {
+    return Group5.createInvite(id, options);
   }
   subscribe(id, ...args) {
-    return Group6.subscribe(id, ...args);
+    return Group5.subscribe(id, ...args);
   }
 };
 
@@ -4711,6 +5013,16 @@ var coFileStreamDefiner = () => {
   const coreSchema = createCoreFileStreamSchema();
   return hydrateCoreCoValueSchema(coreSchema);
 };
+var coVectorDefiner = (dimensions) => {
+  const isPositiveInteger = Number.isInteger(dimensions) && dimensions > 0;
+  if (!isPositiveInteger) {
+    throw new Error(
+      "co.vector() expects the vector dimensions count to be a positive integer"
+    );
+  }
+  const coreSchema = createCoreCoVectorSchema(dimensions);
+  return hydrateCoreCoValueSchema(coreSchema);
+};
 var coPlainTextDefiner = () => {
   const coreSchema = createCoreCoPlainTextSchema();
   return hydrateCoreCoValueSchema(coreSchema);
@@ -4744,6 +5056,7 @@ __export(coExport_exports, {
   Optional: () => CoOptionalSchema,
   PlainText: () => PlainTextSchema,
   RichText: () => RichTextSchema,
+  Vector: () => CoVectorSchema,
   account: () => coAccountDefiner,
   discriminatedUnion: () => coDiscriminatedUnionDefiner,
   feed: () => coFeedDefiner,
@@ -4756,7 +5069,8 @@ __export(coExport_exports, {
   plainText: () => coPlainTextDefiner,
   profile: () => coProfileDefiner,
   record: () => coRecordDefiner,
-  richText: () => coRichTextDefiner
+  richText: () => coRichTextDefiner,
+  vector: () => coVectorDefiner
 });
 
 // src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts
@@ -5023,6 +5337,41 @@ var FileStreamSchema = class {
   }
 };
 
+// src/tools/implementation/zodSchema/schemaTypes/CoVectorSchema.ts
+function createCoreCoVectorSchema(dimensions) {
+  return {
+    collaborative: true,
+    builtin: "CoVector",
+    dimensions
+  };
+}
+var CoVectorSchema = class {
+  constructor(dimensions, coValueClass) {
+    this.dimensions = dimensions;
+    this.coValueClass = coValueClass;
+    this.collaborative = true;
+    this.builtin = "CoVector";
+  }
+  create(vector, options) {
+    return this.coValueClass.create(vector, options);
+  }
+  /**
+   * Load a `CoVector` with a given ID.
+   */
+  load(id, options) {
+    return this.coValueClass.load(id, options);
+  }
+  subscribe(...args) {
+    return this.coValueClass.subscribe(...args);
+  }
+  getCoValueClass() {
+    return this.coValueClass;
+  }
+  optional() {
+    return coOptionalDefiner(this);
+  }
+};
+
 // src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts
 function createCoreAccountSchema(shape) {
   return {
@@ -5289,6 +5638,7 @@ function isCoValueSchema(schema) {
   return isAnyCoValueSchema2(schema) && "getCoValueClass" in schema;
 }
 function hydrateCoreCoValueSchema(schema) {
+  var _a2;
   if (isCoValueSchema(schema)) {
     return schema;
   }
@@ -5337,6 +5687,14 @@ function hydrateCoreCoValueSchema(schema) {
   } else if (schema.builtin === "FileStream") {
     const coValueClass = FileStream;
     return new FileStreamSchema(coValueClass);
+  } else if (schema.builtin === "CoVector") {
+    const dimensions = schema.dimensions;
+    const coValueClass = (_a2 = class extends CoVector {
+    }, _a2.requiredDimensionsCount = dimensions, _a2);
+    return new CoVectorSchema(
+      dimensions,
+      coValueClass
+    );
   } else if (schema.builtin === "CoPlainText") {
     const coValueClass = CoPlainText;
     return new PlainTextSchema(coValueClass);
@@ -5375,7 +5733,7 @@ var ImageDefinitionBase = coMapDefiner({
 var ImageDefinition = ImageDefinitionBase;
 
 // src/tools/implementation/ContextManager.ts
-import { cojsonInternals as cojsonInternals6 } from "cojson";
+import { cojsonInternals as cojsonInternals7 } from "cojson";
 import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
 
 // src/tools/auth/KvStoreContext.ts
@@ -5407,20 +5765,26 @@ var KvStoreContext = class _KvStoreContext {
 var KvStoreContext_default = KvStoreContext;
 
 // src/tools/auth/AuthSecretStorage.ts
+import { z as z2 } from "zod/v4";
 var STORAGE_KEY = "jazz-logged-in-secret";
 var AuthSecretStorage = class {
-  constructor() {
+  constructor(storageKey = STORAGE_KEY) {
+    this.storageKey = storageKey;
+    z2.string().nonempty().parse(storageKey);
     this.listeners = /* @__PURE__ */ new Set();
     this.isAuthenticated = false;
   }
+  getStorageKey() {
+    return this.storageKey;
+  }
   async migrate() {
     const kvStore = KvStoreContext_default.getInstance().getStorage();
-    if (!await kvStore.get(STORAGE_KEY)) {
+    if (!await kvStore.get(this.storageKey)) {
       const demoAuthSecret = await kvStore.get("demo-auth-logged-in-secret");
       if (demoAuthSecret) {
         const parsed = JSON.parse(demoAuthSecret);
         await kvStore.set(
-          STORAGE_KEY,
+          this.storageKey,
           JSON.stringify({
             accountID: parsed.accountID,
             accountSecret: parsed.accountSecret,
@@ -5433,7 +5797,7 @@ var AuthSecretStorage = class {
       if (clerkAuthSecret) {
         const parsed = JSON.parse(clerkAuthSecret);
         await kvStore.set(
-          STORAGE_KEY,
+          this.storageKey,
           JSON.stringify({
             accountID: parsed.accountID,
             accountSecret: parsed.secret,
@@ -5443,12 +5807,12 @@ var AuthSecretStorage = class {
         await kvStore.delete("jazz-clerk-auth");
       }
     }
-    const value = await kvStore.get(STORAGE_KEY);
+    const value = await kvStore.get(this.storageKey);
     if (value) {
       const parsed = JSON.parse(value);
       if ("secret" in parsed) {
         await kvStore.set(
-          STORAGE_KEY,
+          this.storageKey,
           JSON.stringify({
             accountID: parsed.accountID,
             secretSeed: parsed.secretSeed,
@@ -5461,7 +5825,7 @@ var AuthSecretStorage = class {
   }
   async get() {
     const kvStore = KvStoreContext_default.getInstance().getStorage();
-    const data = await kvStore.get(STORAGE_KEY);
+    const data = await kvStore.get(this.storageKey);
     if (!data) return null;
     const parsed = JSON.parse(data);
     if (!parsed.accountID || !parsed.accountSecret) {
@@ -5477,7 +5841,7 @@ var AuthSecretStorage = class {
   async setWithoutNotify(payload) {
     const kvStore = KvStoreContext_default.getInstance().getStorage();
     await kvStore.set(
-      STORAGE_KEY,
+      this.storageKey,
       JSON.stringify({
         accountID: payload.accountID,
         secretSeed: payload.secretSeed ? Array.from(payload.secretSeed) : void 0,
@@ -5510,7 +5874,7 @@ var AuthSecretStorage = class {
   }
   async clearWithoutNotify() {
     const kvStore = KvStoreContext_default.getInstance().getStorage();
-    await kvStore.delete(STORAGE_KEY);
+    await kvStore.delete(this.storageKey);
   }
   async clear() {
     await this.clearWithoutNotify();
@@ -5542,7 +5906,7 @@ var InMemoryKVStore = class {
 // src/tools/implementation/ContextManager.ts
 function getAnonymousFallback() {
   const context = createAnonymousJazzContext({
-    peersToLoadFrom: [],
+    peers: [],
     crypto: new PureJSCrypto()
   });
   return {
@@ -5565,7 +5929,6 @@ function getAnonymousFallback() {
 }
 var JazzContextManager = class {
   constructor(opts) {
-    this.authSecretStorage = new AuthSecretStorage();
     this.keepContextOpen = false;
     this.authenticatingAccountID = null;
     this.logOut = async () => {
@@ -5669,6 +6032,7 @@ var JazzContextManager = class {
       };
     };
     KvStoreContext.getInstance().initialize(this.getKvStore());
+    this.authSecretStorage = new AuthSecretStorage(opts?.authSecretStorageKey);
     if (opts?.useAnonymousFallback) {
       this.value = getAnonymousFallback();
     }
@@ -5740,7 +6104,7 @@ var JazzContextManager = class {
     }
     const currentContext = this.context;
     if (prevContext && currentContext && "me" in prevContext && "me" in currentContext) {
-      const [prevAccountAsPeer, currentAccountAsPeer] = cojsonInternals6.connectedPeers(
+      const [prevAccountAsPeer, currentAccountAsPeer] = cojsonInternals7.connectedPeers(
         prevContext.me.$jazz.id,
         currentContext.me.$jazz.id,
         {
@@ -5960,7 +6324,9 @@ function subscribeToCoValue(cls, id, options, listener) {
     if (unsubscribed) return;
     if (value.type === "unavailable") {
       options.onUnavailable?.();
-      console.error(value.toString());
+      if (!options.skipRetry) {
+        console.error(value.toString());
+      }
     } else if (value.type === "unauthorized") {
       options.onUnauthorized?.();
       console.error(value.toString());
@@ -6006,9 +6372,9 @@ function isAccountInstance(instance) {
   return TypeSym in instance && instance[TypeSym] === "Account";
 }
 function parseCoValueCreateOptions(options) {
-  const Group17 = RegisteredSchemas["Group"];
+  const Group18 = RegisteredSchemas["Group"];
   if (!options) {
-    return { owner: Group17.create(), uniqueness: void 0 };
+    return { owner: Group18.create(), uniqueness: void 0 };
   }
   if (TypeSym in options) {
     if (options[TypeSym] === "Account") {
@@ -6019,7 +6385,7 @@ function parseCoValueCreateOptions(options) {
   }
   const uniqueness = options.unique ? { uniqueness: options.unique } : void 0;
   const opts = {
-    owner: options.owner ? accountOrGroupToGroup(options.owner) : Group17.create(),
+    owner: options.owner ? accountOrGroupToGroup(options.owner) : Group18.create(),
     uniqueness
   };
   return opts;
@@ -6168,7 +6534,7 @@ export {
   FileStream,
   Account,
   isControlledAccount,
-  Group6 as Group,
+  Group5 as Group,
   Profile,
   isCoValueId,
   Inbox,
@@ -6197,4 +6563,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-W7JT3QUN.js.map
+//# sourceMappingURL=chunk-ZIAN4UY5.js.map