@anuma/sdk 1.3.0 → 1.3.1

package/dist/expo/index.cjs

@@ -16768,8 +16768,18 @@ function getMigrationReloadKey(prefix, walletAddress) {
 }
 var DatabaseManager = class {
   constructor(options) {
-    this.database = null;
-    this.currentWalletAddress = void 0;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    this.databases = /* @__PURE__ */ new Map();
     this.migrationInProgress = false;
     this.dbNamePrefix = options.dbNamePrefix;
     this.createAdapter = options.createAdapter;
@@ -16786,8 +16796,9 @@ var DatabaseManager = class {
   /**
    * Get or create a WatermelonDB Database instance for the given wallet.
    *
-   * If the wallet address has changed since the last call, the previous
-   * database instance is discarded and a new one is created.
+   * Instances are cached per derived dbName and reused across calls (including
+   * repeat/guest-interleaved requests for the same wallet); a new one is built
+   * only for a dbName not yet seen. See the `databases` field for why.
    *
    * @param walletAddress - The wallet address to scope the database to.
    *   If undefined, uses a "guest" database.
@@ -16795,46 +16806,47 @@ var DatabaseManager = class {
    * @throws If a destructive migration is in progress
    */
   getDatabase(walletAddress) {
-    if (this.database && this.currentWalletAddress !== walletAddress) {
-      this.logger.debug?.("Wallet changed, switching database", {
-        component: "DatabaseManager",
-        from: this.currentWalletAddress,
-        to: walletAddress
-      });
-      this.database = null;
-    }
-    if (this.database) {
-      return this.database;
+    const dbName = this.getDbName(walletAddress);
+    const cached = this.databases.get(dbName);
+    if (cached) {
+      return cached;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
       throw new Error("Database migration in progress - app will restart");
     }
-    this.currentWalletAddress = walletAddress;
-    const dbName = this.getDbName(walletAddress);
     this.logger.debug?.("Initializing database", {
       component: "DatabaseManager",
       dbName,
       walletAddress
     });
     const adapter = this.createAdapter(dbName, sdkSchema, sdkMigrations);
-    this.database = new import_watermelondb20.Database({
+    const database = new import_watermelondb20.Database({
       adapter,
       modelClasses: sdkModelClasses
     });
-    return this.database;
+    this.databases.set(dbName, database);
+    return database;
   }
   /**
-   * Reset the current database (useful for logout or testing).
+   * Reset ALL cached databases (useful for logout or testing).
    */
   async resetDatabase() {
-    const db = this.database;
-    if (db) {
-      await db.write(async () => {
-        await db.unsafeResetDatabase();
-      });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+    const errors = [];
+    for (const [dbName, db] of [...this.databases.entries()]) {
+      try {
+        await db.write(async () => {
+          await db.unsafeResetDatabase();
+        });
+        this.databases.delete(dbName);
+      } catch (error) {
+        errors.push({ dbName, error });
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Failed to reset ${errors.length} database(s): ${errors.map((e) => e.dbName).join(", ")}`
+      );
     }
   }
   /**

package/dist/expo/index.d.mts

@@ -6542,8 +6542,18 @@ interface DatabaseManagerOptions {
  * ```
  */
 declare class DatabaseManager {
-    private database;
-    private currentWalletAddress;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    private readonly databases;
     private migrationInProgress;
     private readonly dbNamePrefix;
     private readonly createAdapter;
@@ -6558,8 +6568,9 @@ declare class DatabaseManager {
     /**
      * Get or create a WatermelonDB Database instance for the given wallet.
      *
-     * If the wallet address has changed since the last call, the previous
-     * database instance is discarded and a new one is created.
+     * Instances are cached per derived dbName and reused across calls (including
+     * repeat/guest-interleaved requests for the same wallet); a new one is built
+     * only for a dbName not yet seen. See the `databases` field for why.
      *
      * @param walletAddress - The wallet address to scope the database to.
      *   If undefined, uses a "guest" database.
@@ -6568,7 +6579,7 @@ declare class DatabaseManager {
      */
     getDatabase(walletAddress?: string): Database;
     /**
-     * Reset the current database (useful for logout or testing).
+     * Reset ALL cached databases (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
     /**

package/dist/expo/index.d.ts

@@ -6542,8 +6542,18 @@ interface DatabaseManagerOptions {
  * ```
  */
 declare class DatabaseManager {
-    private database;
-    private currentWalletAddress;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    private readonly databases;
     private migrationInProgress;
     private readonly dbNamePrefix;
     private readonly createAdapter;
@@ -6558,8 +6568,9 @@ declare class DatabaseManager {
     /**
      * Get or create a WatermelonDB Database instance for the given wallet.
      *
-     * If the wallet address has changed since the last call, the previous
-     * database instance is discarded and a new one is created.
+     * Instances are cached per derived dbName and reused across calls (including
+     * repeat/guest-interleaved requests for the same wallet); a new one is built
+     * only for a dbName not yet seen. See the `databases` field for why.
      *
      * @param walletAddress - The wallet address to scope the database to.
      *   If undefined, uses a "guest" database.
@@ -6568,7 +6579,7 @@ declare class DatabaseManager {
      */
     getDatabase(walletAddress?: string): Database;
     /**
-     * Reset the current database (useful for logout or testing).
+     * Reset ALL cached databases (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
     /**

package/dist/expo/index.mjs

@@ -10020,8 +10020,18 @@ function getMigrationReloadKey(prefix, walletAddress) {
 }
 var DatabaseManager = class {
   constructor(options) {
-    this.database = null;
-    this.currentWalletAddress = void 0;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    this.databases = /* @__PURE__ */ new Map();
     this.migrationInProgress = false;
     this.dbNamePrefix = options.dbNamePrefix;
     this.createAdapter = options.createAdapter;
@@ -10038,8 +10048,9 @@ var DatabaseManager = class {
   /**
    * Get or create a WatermelonDB Database instance for the given wallet.
    *
-   * If the wallet address has changed since the last call, the previous
-   * database instance is discarded and a new one is created.
+   * Instances are cached per derived dbName and reused across calls (including
+   * repeat/guest-interleaved requests for the same wallet); a new one is built
+   * only for a dbName not yet seen. See the `databases` field for why.
    *
    * @param walletAddress - The wallet address to scope the database to.
    *   If undefined, uses a "guest" database.
@@ -10047,46 +10058,47 @@ var DatabaseManager = class {
    * @throws If a destructive migration is in progress
    */
   getDatabase(walletAddress) {
-    if (this.database && this.currentWalletAddress !== walletAddress) {
-      this.logger.debug?.("Wallet changed, switching database", {
-        component: "DatabaseManager",
-        from: this.currentWalletAddress,
-        to: walletAddress
-      });
-      this.database = null;
-    }
-    if (this.database) {
-      return this.database;
+    const dbName = this.getDbName(walletAddress);
+    const cached = this.databases.get(dbName);
+    if (cached) {
+      return cached;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
       throw new Error("Database migration in progress - app will restart");
     }
-    this.currentWalletAddress = walletAddress;
-    const dbName = this.getDbName(walletAddress);
     this.logger.debug?.("Initializing database", {
       component: "DatabaseManager",
       dbName,
       walletAddress
     });
     const adapter = this.createAdapter(dbName, sdkSchema, sdkMigrations);
-    this.database = new Database({
+    const database = new Database({
       adapter,
       modelClasses: sdkModelClasses
     });
-    return this.database;
+    this.databases.set(dbName, database);
+    return database;
   }
   /**
-   * Reset the current database (useful for logout or testing).
+   * Reset ALL cached databases (useful for logout or testing).
    */
   async resetDatabase() {
-    const db = this.database;
-    if (db) {
-      await db.write(async () => {
-        await db.unsafeResetDatabase();
-      });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+    const errors = [];
+    for (const [dbName, db] of [...this.databases.entries()]) {
+      try {
+        await db.write(async () => {
+          await db.unsafeResetDatabase();
+        });
+        this.databases.delete(dbName);
+      } catch (error) {
+        errors.push({ dbName, error });
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Failed to reset ${errors.length} database(s): ${errors.map((e) => e.dbName).join(", ")}`
+      );
     }
   }
   /**

package/dist/react/index.cjs

@@ -19962,8 +19962,18 @@ function getMigrationReloadKey(prefix, walletAddress) {
 }
 var DatabaseManager = class {
   constructor(options) {
-    this.database = null;
-    this.currentWalletAddress = void 0;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    this.databases = /* @__PURE__ */ new Map();
     this.migrationInProgress = false;
     this.dbNamePrefix = options.dbNamePrefix;
     this.createAdapter = options.createAdapter;
@@ -19980,8 +19990,9 @@ var DatabaseManager = class {
   /**
    * Get or create a WatermelonDB Database instance for the given wallet.
    *
-   * If the wallet address has changed since the last call, the previous
-   * database instance is discarded and a new one is created.
+   * Instances are cached per derived dbName and reused across calls (including
+   * repeat/guest-interleaved requests for the same wallet); a new one is built
+   * only for a dbName not yet seen. See the `databases` field for why.
    *
    * @param walletAddress - The wallet address to scope the database to.
    *   If undefined, uses a "guest" database.
@@ -19989,46 +20000,47 @@ var DatabaseManager = class {
    * @throws If a destructive migration is in progress
    */
   getDatabase(walletAddress) {
-    if (this.database && this.currentWalletAddress !== walletAddress) {
-      this.logger.debug?.("Wallet changed, switching database", {
-        component: "DatabaseManager",
-        from: this.currentWalletAddress,
-        to: walletAddress
-      });
-      this.database = null;
-    }
-    if (this.database) {
-      return this.database;
+    const dbName = this.getDbName(walletAddress);
+    const cached = this.databases.get(dbName);
+    if (cached) {
+      return cached;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
       throw new Error("Database migration in progress - app will restart");
     }
-    this.currentWalletAddress = walletAddress;
-    const dbName = this.getDbName(walletAddress);
     this.logger.debug?.("Initializing database", {
       component: "DatabaseManager",
       dbName,
       walletAddress
     });
     const adapter = this.createAdapter(dbName, sdkSchema, sdkMigrations);
-    this.database = new import_watermelondb21.Database({
+    const database = new import_watermelondb21.Database({
       adapter,
       modelClasses: sdkModelClasses
     });
-    return this.database;
+    this.databases.set(dbName, database);
+    return database;
   }
   /**
-   * Reset the current database (useful for logout or testing).
+   * Reset ALL cached databases (useful for logout or testing).
    */
   async resetDatabase() {
-    const db = this.database;
-    if (db) {
-      await db.write(async () => {
-        await db.unsafeResetDatabase();
-      });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+    const errors = [];
+    for (const [dbName, db] of [...this.databases.entries()]) {
+      try {
+        await db.write(async () => {
+          await db.unsafeResetDatabase();
+        });
+        this.databases.delete(dbName);
+      } catch (error) {
+        errors.push({ dbName, error });
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Failed to reset ${errors.length} database(s): ${errors.map((e) => e.dbName).join(", ")}`
+      );
     }
   }
   /**

package/dist/react/index.d.mts

@@ -8077,8 +8077,18 @@ declare const webPlatformStorage: PlatformStorage;
  * ```
  */
 declare class DatabaseManager {
-    private database;
-    private currentWalletAddress;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    private readonly databases;
     private migrationInProgress;
     private readonly dbNamePrefix;
     private readonly createAdapter;
@@ -8093,8 +8103,9 @@ declare class DatabaseManager {
     /**
      * Get or create a WatermelonDB Database instance for the given wallet.
      *
-     * If the wallet address has changed since the last call, the previous
-     * database instance is discarded and a new one is created.
+     * Instances are cached per derived dbName and reused across calls (including
+     * repeat/guest-interleaved requests for the same wallet); a new one is built
+     * only for a dbName not yet seen. See the `databases` field for why.
      *
      * @param walletAddress - The wallet address to scope the database to.
      *   If undefined, uses a "guest" database.
@@ -8103,7 +8114,7 @@ declare class DatabaseManager {
      */
     getDatabase(walletAddress?: string): Database;
     /**
-     * Reset the current database (useful for logout or testing).
+     * Reset ALL cached databases (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
     /**

package/dist/react/index.d.ts

@@ -8077,8 +8077,18 @@ declare const webPlatformStorage: PlatformStorage;
  * ```
  */
 declare class DatabaseManager {
-    private database;
-    private currentWalletAddress;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    private readonly databases;
     private migrationInProgress;
     private readonly dbNamePrefix;
     private readonly createAdapter;
@@ -8093,8 +8103,9 @@ declare class DatabaseManager {
     /**
      * Get or create a WatermelonDB Database instance for the given wallet.
      *
-     * If the wallet address has changed since the last call, the previous
-     * database instance is discarded and a new one is created.
+     * Instances are cached per derived dbName and reused across calls (including
+     * repeat/guest-interleaved requests for the same wallet); a new one is built
+     * only for a dbName not yet seen. See the `databases` field for why.
      *
      * @param walletAddress - The wallet address to scope the database to.
      *   If undefined, uses a "guest" database.
@@ -8103,7 +8114,7 @@ declare class DatabaseManager {
      */
     getDatabase(walletAddress?: string): Database;
     /**
-     * Reset the current database (useful for logout or testing).
+     * Reset ALL cached databases (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
     /**

package/dist/react/index.mjs

@@ -12680,8 +12680,18 @@ function getMigrationReloadKey(prefix, walletAddress) {
 }
 var DatabaseManager = class {
   constructor(options) {
-    this.database = null;
-    this.currentWalletAddress = void 0;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    this.databases = /* @__PURE__ */ new Map();
     this.migrationInProgress = false;
     this.dbNamePrefix = options.dbNamePrefix;
     this.createAdapter = options.createAdapter;
@@ -12698,8 +12708,9 @@ var DatabaseManager = class {
   /**
    * Get or create a WatermelonDB Database instance for the given wallet.
    *
-   * If the wallet address has changed since the last call, the previous
-   * database instance is discarded and a new one is created.
+   * Instances are cached per derived dbName and reused across calls (including
+   * repeat/guest-interleaved requests for the same wallet); a new one is built
+   * only for a dbName not yet seen. See the `databases` field for why.
    *
    * @param walletAddress - The wallet address to scope the database to.
    *   If undefined, uses a "guest" database.
@@ -12707,46 +12718,47 @@ var DatabaseManager = class {
    * @throws If a destructive migration is in progress
    */
   getDatabase(walletAddress) {
-    if (this.database && this.currentWalletAddress !== walletAddress) {
-      this.logger.debug?.("Wallet changed, switching database", {
-        component: "DatabaseManager",
-        from: this.currentWalletAddress,
-        to: walletAddress
-      });
-      this.database = null;
-    }
-    if (this.database) {
-      return this.database;
+    const dbName = this.getDbName(walletAddress);
+    const cached = this.databases.get(dbName);
+    if (cached) {
+      return cached;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
       throw new Error("Database migration in progress - app will restart");
     }
-    this.currentWalletAddress = walletAddress;
-    const dbName = this.getDbName(walletAddress);
     this.logger.debug?.("Initializing database", {
       component: "DatabaseManager",
       dbName,
       walletAddress
     });
     const adapter = this.createAdapter(dbName, sdkSchema, sdkMigrations);
-    this.database = new Database({
+    const database = new Database({
       adapter,
       modelClasses: sdkModelClasses
     });
-    return this.database;
+    this.databases.set(dbName, database);
+    return database;
   }
   /**
-   * Reset the current database (useful for logout or testing).
+   * Reset ALL cached databases (useful for logout or testing).
    */
   async resetDatabase() {
-    const db = this.database;
-    if (db) {
-      await db.write(async () => {
-        await db.unsafeResetDatabase();
-      });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+    const errors = [];
+    for (const [dbName, db] of [...this.databases.entries()]) {
+      try {
+        await db.write(async () => {
+          await db.unsafeResetDatabase();
+        });
+        this.databases.delete(dbName);
+      } catch (error) {
+        errors.push({ dbName, error });
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Failed to reset ${errors.length} database(s): ${errors.map((e) => e.dbName).join(", ")}`
+      );
     }
   }
   /**

package/dist/server/index.cjs

@@ -22893,8 +22893,18 @@ function getMigrationReloadKey(prefix, walletAddress) {
 }
 var DatabaseManager = class {
   constructor(options) {
-    this.database = null;
-    this.currentWalletAddress = void 0;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    this.databases = /* @__PURE__ */ new Map();
     this.migrationInProgress = false;
     this.dbNamePrefix = options.dbNamePrefix;
     this.createAdapter = options.createAdapter;
@@ -22911,8 +22921,9 @@ var DatabaseManager = class {
   /**
    * Get or create a WatermelonDB Database instance for the given wallet.
    *
-   * If the wallet address has changed since the last call, the previous
-   * database instance is discarded and a new one is created.
+   * Instances are cached per derived dbName and reused across calls (including
+   * repeat/guest-interleaved requests for the same wallet); a new one is built
+   * only for a dbName not yet seen. See the `databases` field for why.
    *
    * @param walletAddress - The wallet address to scope the database to.
    *   If undefined, uses a "guest" database.
@@ -22920,46 +22931,47 @@ var DatabaseManager = class {
    * @throws If a destructive migration is in progress
    */
   getDatabase(walletAddress) {
-    if (this.database && this.currentWalletAddress !== walletAddress) {
-      this.logger.debug?.("Wallet changed, switching database", {
-        component: "DatabaseManager",
-        from: this.currentWalletAddress,
-        to: walletAddress
-      });
-      this.database = null;
-    }
-    if (this.database) {
-      return this.database;
+    const dbName = this.getDbName(walletAddress);
+    const cached = this.databases.get(dbName);
+    if (cached) {
+      return cached;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
       throw new Error("Database migration in progress - app will restart");
     }
-    this.currentWalletAddress = walletAddress;
-    const dbName = this.getDbName(walletAddress);
     this.logger.debug?.("Initializing database", {
       component: "DatabaseManager",
       dbName,
       walletAddress
     });
     const adapter = this.createAdapter(dbName, sdkSchema, sdkMigrations);
-    this.database = new import_watermelondb13.Database({
+    const database = new import_watermelondb13.Database({
       adapter,
       modelClasses: sdkModelClasses
     });
-    return this.database;
+    this.databases.set(dbName, database);
+    return database;
   }
   /**
-   * Reset the current database (useful for logout or testing).
+   * Reset ALL cached databases (useful for logout or testing).
    */
   async resetDatabase() {
-    const db = this.database;
-    if (db) {
-      await db.write(async () => {
-        await db.unsafeResetDatabase();
-      });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+    const errors = [];
+    for (const [dbName, db] of [...this.databases.entries()]) {
+      try {
+        await db.write(async () => {
+          await db.unsafeResetDatabase();
+        });
+        this.databases.delete(dbName);
+      } catch (error) {
+        errors.push({ dbName, error });
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Failed to reset ${errors.length} database(s): ${errors.map((e) => e.dbName).join(", ")}`
+      );
     }
   }
   /**

package/dist/server/index.d.mts

@@ -248,8 +248,18 @@ interface DatabaseManagerOptions {
  * ```
  */
 declare class DatabaseManager {
-    private database;
-    private currentWalletAddress;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    private readonly databases;
     private migrationInProgress;
     private readonly dbNamePrefix;
     private readonly createAdapter;
@@ -264,8 +274,9 @@ declare class DatabaseManager {
     /**
      * Get or create a WatermelonDB Database instance for the given wallet.
      *
-     * If the wallet address has changed since the last call, the previous
-     * database instance is discarded and a new one is created.
+     * Instances are cached per derived dbName and reused across calls (including
+     * repeat/guest-interleaved requests for the same wallet); a new one is built
+     * only for a dbName not yet seen. See the `databases` field for why.
      *
      * @param walletAddress - The wallet address to scope the database to.
      *   If undefined, uses a "guest" database.
@@ -274,7 +285,7 @@ declare class DatabaseManager {
      */
     getDatabase(walletAddress?: string): Database;
     /**
-     * Reset the current database (useful for logout or testing).
+     * Reset ALL cached databases (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
     /**

package/dist/server/index.d.ts

@@ -248,8 +248,18 @@ interface DatabaseManagerOptions {
  * ```
  */
 declare class DatabaseManager {
-    private database;
-    private currentWalletAddress;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    private readonly databases;
     private migrationInProgress;
     private readonly dbNamePrefix;
     private readonly createAdapter;
@@ -264,8 +274,9 @@ declare class DatabaseManager {
     /**
      * Get or create a WatermelonDB Database instance for the given wallet.
      *
-     * If the wallet address has changed since the last call, the previous
-     * database instance is discarded and a new one is created.
+     * Instances are cached per derived dbName and reused across calls (including
+     * repeat/guest-interleaved requests for the same wallet); a new one is built
+     * only for a dbName not yet seen. See the `databases` field for why.
      *
      * @param walletAddress - The wallet address to scope the database to.
      *   If undefined, uses a "guest" database.
@@ -274,7 +285,7 @@ declare class DatabaseManager {
      */
     getDatabase(walletAddress?: string): Database;
     /**
-     * Reset the current database (useful for logout or testing).
+     * Reset ALL cached databases (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
     /**

package/dist/server/index.mjs

@@ -2000,8 +2000,18 @@ function getMigrationReloadKey(prefix, walletAddress) {
 }
 var DatabaseManager = class {
   constructor(options) {
-    this.database = null;
-    this.currentWalletAddress = void 0;
+    /**
+     * WatermelonDB instances cached by their derived `dbName` (not by raw wallet
+     * address). Caching per dbName makes {@link getDatabase} idempotent: a wallet
+     * that is requested again — including after a transient `undefined`/guest
+     * excursion or an address that briefly arrives in a different form during
+     * sign-up — reuses the SAME instance instead of being torn down and rebuilt.
+     * The rebuild was what left the web OPFS adapter disposed/orphaned mid-session
+     * (client#4821). Instances are kept for the lifetime of the manager (typically
+     * guest + one wallet); switching wallets keeps prior ones cached rather than
+     * disposing an instance the app may still hold a reference to.
+     */
+    this.databases = /* @__PURE__ */ new Map();
     this.migrationInProgress = false;
     this.dbNamePrefix = options.dbNamePrefix;
     this.createAdapter = options.createAdapter;
@@ -2018,8 +2028,9 @@ var DatabaseManager = class {
   /**
    * Get or create a WatermelonDB Database instance for the given wallet.
    *
-   * If the wallet address has changed since the last call, the previous
-   * database instance is discarded and a new one is created.
+   * Instances are cached per derived dbName and reused across calls (including
+   * repeat/guest-interleaved requests for the same wallet); a new one is built
+   * only for a dbName not yet seen. See the `databases` field for why.
    *
    * @param walletAddress - The wallet address to scope the database to.
    *   If undefined, uses a "guest" database.
@@ -2027,46 +2038,47 @@ var DatabaseManager = class {
    * @throws If a destructive migration is in progress
    */
   getDatabase(walletAddress) {
-    if (this.database && this.currentWalletAddress !== walletAddress) {
-      this.logger.debug?.("Wallet changed, switching database", {
-        component: "DatabaseManager",
-        from: this.currentWalletAddress,
-        to: walletAddress
-      });
-      this.database = null;
-    }
-    if (this.database) {
-      return this.database;
+    const dbName = this.getDbName(walletAddress);
+    const cached = this.databases.get(dbName);
+    if (cached) {
+      return cached;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
       throw new Error("Database migration in progress - app will restart");
     }
-    this.currentWalletAddress = walletAddress;
-    const dbName = this.getDbName(walletAddress);
     this.logger.debug?.("Initializing database", {
       component: "DatabaseManager",
       dbName,
       walletAddress
     });
     const adapter = this.createAdapter(dbName, sdkSchema, sdkMigrations);
-    this.database = new import_watermelondb13.Database({
+    const database = new import_watermelondb13.Database({
       adapter,
       modelClasses: sdkModelClasses
     });
-    return this.database;
+    this.databases.set(dbName, database);
+    return database;
   }
   /**
-   * Reset the current database (useful for logout or testing).
+   * Reset ALL cached databases (useful for logout or testing).
    */
   async resetDatabase() {
-    const db = this.database;
-    if (db) {
-      await db.write(async () => {
-        await db.unsafeResetDatabase();
-      });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+    const errors = [];
+    for (const [dbName, db] of [...this.databases.entries()]) {
+      try {
+        await db.write(async () => {
+          await db.unsafeResetDatabase();
+        });
+        this.databases.delete(dbName);
+      } catch (error) {
+        errors.push({ dbName, error });
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Failed to reset ${errors.length} database(s): ${errors.map((e) => e.dbName).join(", ")}`
+      );
     }
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",