movehat 0.2.6 → 0.2.7

package/dist/core/AccountManager.d.ts

@@ -14,183 +14,165 @@ export interface SaveAccountPoolOptions {
      */
     includeImported?: boolean | undefined;
 }
+export interface AccountManagerOptions {
+    /**
+     * Filesystem location where `saveAccountPool` writes `test-pool.json`
+     * and `loadAccountPool` reads from. When omitted, the path is computed
+     * LAZILY on each call from `join(process.cwd(), ".movehat", "accounts")`
+     * — so `process.chdir()` between construction and pool I/O is respected.
+     *
+     * Pass an explicit value when per-instance isolation matters (parallel
+     * test files, harness pools that must not collide with another suite's).
+     *
+     * The process-wide static facade exposed on the `AccountManager` class
+     * itself uses a separate singleton whose `poolPath` is EAGERLY captured
+     * at module-import time. That preserves the legacy F8(b) behavior for
+     * any code still on the static API during the 0.2.7 deprecation window;
+     * the static facade is removed in 0.3.0.
+     */
+    poolPath?: string | undefined;
+}
 /**
  * Centralized Account Manager for movehat
  *
  * Manages all account creation, loading, and lifecycle operations.
- * Provides a pool of reusable test accounts with labels for better test readability.
+ * Provides a pool of reusable test accounts with labels for better test
+ * readability.
+ *
+ * Two API surfaces are exposed:
+ *
+ * **Instance API (recommended; M9.1+)** — `new AccountManager(options?)`
+ * gives a fully isolated pool. Two instances in the same process have
+ * independent labelMaps, private-key maps, and account pools. Each
+ * `Harness` constructed in 0.3.0+ will own one of these; user code
+ * accesses labeled accounts via `harness.accounts.<label>` (Harness
+ * snapshots them at construction time).
+ *
+ * **Static facade (deprecated; will be removed in 0.3.0)** — every
+ * former static method (`AccountManager.createAccount(...)`, etc.) still
+ * works and forwards to a single process-wide singleton. This preserves
+ * the existing label-sharing behavior across calls during the
+ * deprecation window. Migration target is the instance API; see M9 meta
+ * (#270) and migration guide at `/docs/upgrading/0.3.0` (published in
+ * M9.4).
  */
 export declare class AccountManager {
-    private static pool;
-    private static privateKeys;
-    private static labelMap;
-    private static generatedAccountAddresses;
-    private static poolLoaded;
-    private static defaultPoolPath;
-    /**
-     * Get a test account from the pool. If label is provided and exists, returns that account.
-     * Otherwise creates a new account with the optional label.
-     *
-     * @param label Optional label for the account (e.g., "alice", "bob", "deployer")
+    private readonly pool;
+    private readonly privateKeys;
+    private readonly labelMap;
+    private readonly generatedAccountAddresses;
+    private poolLoaded;
+    private readonly poolPathOverride;
+    constructor(options?: AccountManagerOptions);
+    /**
+     * Resolved pool directory. When the caller supplied an explicit
+     * `poolPath` to the constructor, that value is returned verbatim.
+     * Otherwise the path is computed LAZILY from the current
+     * `process.cwd()` on each access — so `process.chdir()` performed
+     * between construction and pool I/O takes effect, unlike the legacy
+     * static-only API which captured cwd at module import time
+     * (audit finding F8(b)).
+     */
+    private get poolPath();
+    /**
+     * Get a test account from the pool. If label is provided and exists,
+     * returns that account. Otherwise creates a new account with the
+     * optional label.
+     *
+     * @param label Optional label for the account (e.g., "alice", "bob")
      * @returns An Account instance
-     *
-     * @example
-     * const alice = AccountManager.getTestAccount("alice");
-     * const randomAccount = AccountManager.getTestAccount();
      */
-    static getTestAccount(label?: string): Account;
+    getTestAccount(label?: string): Account;
     /**
-     * Create a new account and optionally add it to the pool with a label
-     *
-     * @param label Optional label for the account
-     * @param fund Whether to fund the account (handled externally)
-     * @returns A new Account instance
-     *
-     * @example
-     * const deployer = AccountManager.createAccount("deployer");
-     * const bob = AccountManager.createAccount("bob", true);
+     * Create a new account and optionally add it to the pool with a
+     * label. The `fund` parameter is accepted for API symmetry; actual
+     * funding is the caller's responsibility.
      */
-    static createAccount(label?: string, fund?: boolean): Account;
+    createAccount(label?: string, _fund?: boolean): Account;
     /**
-     * Get an account by its label
-     *
-     * @param label The label to look up
-     * @returns The Account if found, undefined otherwise
-     *
-     * @example
-     * const alice = AccountManager.getAccountByLabel("alice");
-     * if (alice) {
-     *   console.log(`Alice's address: ${alice.accountAddress.toString()}`);
-     * }
+     * Get an account by its label, or undefined if not present.
      */
-    static getAccountByLabel(label: string): Account | undefined;
+    getAccountByLabel(label: string): Account | undefined;
     /**
-     * Load account from environment variable
-     *
-     * @param envVar The environment variable name (defaults to "PRIVATE_KEY")
-     * @returns Account instance
-     * @throws Error if environment variable is not set
+     * Load account from environment variable.
      *
-     * @example
-     * const account = AccountManager.loadAccountFromEnv("MH_PRIVATE_KEY");
+     * @throws Error if the environment variable is not set
      */
-    static loadAccountFromEnv(envVar?: string): Account;
+    loadAccountFromEnv(envVar?: string): Account;
     /**
-     * Load account from a private key hex string
-     *
-     * @param privateKeyHex The private key as a hex string (with or without 0x prefix)
-     * @returns Account instance
-     *
-     * @example
-     * const account = AccountManager.loadAccountFromPrivateKey("0xabc123...");
+     * Load account from a private key hex string (with or without 0x prefix).
      */
-    static loadAccountFromPrivateKey(privateKeyHex: string): Account;
+    loadAccountFromPrivateKey(privateKeyHex: string): Account;
     /**
-     * Load all accounts from movehat config
-     *
-     * @param config The resolved MovehatConfig
-     * @returns Array of Account instances
-     *
-     * @example
-     * const config = await resolveNetworkConfig(userConfig);
-     * const accounts = AccountManager.loadAccountsFromConfig(config);
+     * Load all accounts from movehat config.
      */
-    static loadAccountsFromConfig(config: MovehatConfig): Account[];
+    loadAccountsFromConfig(config: MovehatConfig): Account[];
     /**
-     * Get all labeled accounts in the pool
-     *
-     * @returns Record of label to Account mappings
-     *
-     * @example
-     * const labeled = AccountManager.getLabeledAccounts();
-     * console.log(`Deployer: ${labeled.deployer?.accountAddress.toString()}`);
+     * Get all labeled accounts in the pool.
      */
-    static getLabeledAccounts(): Record<string, Account>;
+    getLabeledAccounts(): Record<string, Account>;
     /**
-     * Save the current account pool to disk for persistence
-     *
-     * @param poolPath Optional custom path (defaults to .movehat/accounts)
-     *
-     * @example
-     * AccountManager.saveAccountPool();
+     * Save the current account pool to disk for persistence.
      */
-    static saveAccountPool(): void;
-    static saveAccountPool(poolPath: string): void;
-    static saveAccountPool(options: SaveAccountPoolOptions): void;
-    static saveAccountPool(poolPath: string, options: SaveAccountPoolOptions): void;
+    saveAccountPool(): void;
+    saveAccountPool(poolPath: string): void;
+    saveAccountPool(options: SaveAccountPoolOptions): void;
+    saveAccountPool(poolPath: string, options: SaveAccountPoolOptions): void;
     /**
-     * Load account pool from disk
-     *
-     * @param poolPath Optional custom path (defaults to .movehat/accounts)
-     * @returns true if pool was loaded, false if file doesn't exist
-     *
-     * @example
-     * if (AccountManager.loadAccountPool()) {
-     *   console.log("Pool loaded successfully");
-     * }
+     * Load account pool from disk. Returns true if a pool file was found
+     * and parsed, false if the file does not exist or parsing failed.
      */
-    static loadAccountPool(poolPath?: string): boolean;
+    loadAccountPool(poolPath?: string): boolean;
     /**
-     * Clear the entire account pool
-     * Useful for test isolation
-     *
-     * @example
-     * after(() => {
-     *   AccountManager.clearPool();
-     * });
+     * Clear the entire account pool. Useful for test isolation.
      */
-    static clearPool(): void;
+    clearPool(): void;
     /**
-     * Get the current size of the account pool
-     *
-     * @returns Number of accounts in the pool
+     * Number of accounts in the pool.
      */
-    static getPoolSize(): number;
+    getPoolSize(): number;
     /**
-     * Get all accounts in the pool
-     *
-     * @returns Array of all Account instances
+     * All accounts in the pool.
      */
-    static getAllAccounts(): Account[];
+    getAllAccounts(): Account[];
     /**
-     * Check if a label is already in use
-     *
-     * @param label The label to check
-     * @returns true if label exists, false otherwise
+     * Whether a label is currently bound to an account in this pool.
      */
-    static hasLabel(label: string): boolean;
+    hasLabel(label: string): boolean;
     /**
-     * Get or create an account with a specific label
-     * If the label exists, returns the existing account
-     * Otherwise creates a new account with that label
-     *
-     * @param label The label for the account
-     * @returns Account instance
-     *
-     * @example
-     * const alice = AccountManager.getOrCreateLabeled("alice");
-     * const aliceAgain = AccountManager.getOrCreateLabeled("alice"); // Same account
+     * Get or create an account with a specific label.
      */
-    static getOrCreateLabeled(label: string): Account;
+    getOrCreateLabeled(label: string): Account;
     /**
-     * Batch create multiple labeled accounts
-     *
-     * @param labels Array of labels to create
-     * @returns Record of label to Account mappings
-     *
-     * @example
-     * const accounts = AccountManager.createBatch(["alice", "bob", "charlie"]);
-     * console.log(accounts.alice.accountAddress.toString());
+     * Batch create multiple labeled accounts.
      */
-    static createBatch(labels: readonly string[]): Record<string, Account>;
+    createBatch(labels: readonly string[]): Record<string, Account>;
     /**
-     * Export account private keys for backup/sharing
-     * WARNING: Only use this for test accounts, never production keys
-     *
-     * @param labels Optional array of labels to export (exports all if not provided)
-     * @returns Record of label/address to private key hex string
+     * Export account private keys for backup/sharing.
+     * WARNING: Only use this for test accounts, never production keys.
      */
+    exportPrivateKeys(labels?: string[]): Record<string, string>;
+    private accountFromPrivateKey;
+    private trackAccount;
+    static getTestAccount(label?: string): Account;
+    static createAccount(label?: string, fund?: boolean): Account;
+    static getAccountByLabel(label: string): Account | undefined;
+    static loadAccountFromEnv(envVar?: string): Account;
+    static loadAccountFromPrivateKey(privateKeyHex: string): Account;
+    static loadAccountsFromConfig(config: MovehatConfig): Account[];
+    static getLabeledAccounts(): Record<string, Account>;
+    static saveAccountPool(): void;
+    static saveAccountPool(poolPath: string): void;
+    static saveAccountPool(options: SaveAccountPoolOptions): void;
+    static saveAccountPool(poolPath: string, options: SaveAccountPoolOptions): void;
+    static loadAccountPool(poolPath?: string): boolean;
+    static clearPool(): void;
+    static getPoolSize(): number;
+    static getAllAccounts(): Account[];
+    static hasLabel(label: string): boolean;
+    static getOrCreateLabeled(label: string): Account;
+    static createBatch(labels: readonly string[]): Record<string, Account>;
     static exportPrivateKeys(labels?: string[]): Record<string, string>;
-    private static accountFromPrivateKey;
-    private static trackAccount;
 }
+/** @internal — test-only. Resets the once-per-method dedup Set. */
+export declare function _resetDeprecationWarnings(): void;

package/dist/core/AccountManager.js

@@ -1,59 +1,82 @@
 import { Account, Ed25519PrivateKey, PrivateKey, PrivateKeyVariants, } from "@aptos-labs/ts-sdk";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
+import { logger } from "../ui/index.js";
 /**
  * Centralized Account Manager for movehat
  *
  * Manages all account creation, loading, and lifecycle operations.
- * Provides a pool of reusable test accounts with labels for better test readability.
+ * Provides a pool of reusable test accounts with labels for better test
+ * readability.
+ *
+ * Two API surfaces are exposed:
+ *
+ * **Instance API (recommended; M9.1+)** — `new AccountManager(options?)`
+ * gives a fully isolated pool. Two instances in the same process have
+ * independent labelMaps, private-key maps, and account pools. Each
+ * `Harness` constructed in 0.3.0+ will own one of these; user code
+ * accesses labeled accounts via `harness.accounts.<label>` (Harness
+ * snapshots them at construction time).
+ *
+ * **Static facade (deprecated; will be removed in 0.3.0)** — every
+ * former static method (`AccountManager.createAccount(...)`, etc.) still
+ * works and forwards to a single process-wide singleton. This preserves
+ * the existing label-sharing behavior across calls during the
+ * deprecation window. Migration target is the instance API; see M9 meta
+ * (#270) and migration guide at `/docs/upgrading/0.3.0` (published in
+ * M9.4).
  */
 export class AccountManager {
-    // Class-static maps: shared across every consumer in the same Node
-    // process (e.g. two Harness instances). Re-using a label across
-    // "sessions" overwrites the labelMap entry. Documented + fixed by
-    // contract in `AccountManager.global-state.test.ts` (audit F8).
-    static pool = new Map(); // address → Account
-    static privateKeys = new Map(); // address → privateKey hex
-    static labelMap = new Map(); // label → address
-    static generatedAccountAddresses = new Set();
-    static poolLoaded = false;
-    // `defaultPoolPath` is captured ONCE at module-import time. A later
-    // `process.chdir(...)` does NOT redirect the save destination — pass
-    // an explicit `poolPath` to `saveAccountPool`/`loadAccountPool` when
-    // per-test isolation matters. See audit finding F8.
-    static defaultPoolPath = join(process.cwd(), ".movehat", "accounts");
+    // ── Instance state ──────────────────────────────────────────────
+    // All former class-static fields are now instance fields. Two
+    // `new AccountManager()` calls produce fully isolated state. The
+    // static facade below operates on a single module-level singleton,
+    // so existing callers see no behavior change.
+    pool = new Map(); // address → Account
+    privateKeys = new Map(); // address → privateKey hex
+    labelMap = new Map(); // label → address
+    generatedAccountAddresses = new Set();
+    poolLoaded = false;
+    poolPathOverride;
+    constructor(options = {}) {
+        this.poolPathOverride = options.poolPath;
+    }
     /**
-     * Get a test account from the pool. If label is provided and exists, returns that account.
-     * Otherwise creates a new account with the optional label.
+     * Resolved pool directory. When the caller supplied an explicit
+     * `poolPath` to the constructor, that value is returned verbatim.
+     * Otherwise the path is computed LAZILY from the current
+     * `process.cwd()` on each access — so `process.chdir()` performed
+     * between construction and pool I/O takes effect, unlike the legacy
+     * static-only API which captured cwd at module import time
+     * (audit finding F8(b)).
+     */
+    get poolPath() {
+        return this.poolPathOverride ?? join(process.cwd(), ".movehat", "accounts");
+    }
+    // ── Instance methods (real implementations) ─────────────────────
+    /**
+     * Get a test account from the pool. If label is provided and exists,
+     * returns that account. Otherwise creates a new account with the
+     * optional label.
      *
-     * @param label Optional label for the account (e.g., "alice", "bob", "deployer")
+     * @param label Optional label for the account (e.g., "alice", "bob")
      * @returns An Account instance
-     *
-     * @example
-     * const alice = AccountManager.getTestAccount("alice");
-     * const randomAccount = AccountManager.getTestAccount();
      */
-    static getTestAccount(label) {
+    getTestAccount(label) {
         if (label) {
-            const existingAccount = this.getAccountByLabel(label);
-            if (existingAccount) {
-                return existingAccount;
+            const existing = this.getAccountByLabel(label);
+            if (existing) {
+                return existing;
             }
         }
         return this.createAccount(label, false);
     }
     /**
-     * Create a new account and optionally add it to the pool with a label
-     *
-     * @param label Optional label for the account
-     * @param fund Whether to fund the account (handled externally)
-     * @returns A new Account instance
-     *
-     * @example
-     * const deployer = AccountManager.createAccount("deployer");
-     * const bob = AccountManager.createAccount("bob", true);
+     * Create a new account and optionally add it to the pool with a
+     * label. The `fund` parameter is accepted for API symmetry; actual
+     * funding is the caller's responsibility.
      */
-    static createAccount(label, fund = false) {
+    createAccount(label, _fund = false) {
         const account = Account.generate();
         const address = account.accountAddress.toString();
         this.pool.set(address, account);
@@ -65,18 +88,9 @@ export class AccountManager {
         return account;
     }
     /**
-     * Get an account by its label
-     *
-     * @param label The label to look up
-     * @returns The Account if found, undefined otherwise
-     *
-     * @example
-     * const alice = AccountManager.getAccountByLabel("alice");
-     * if (alice) {
-     *   console.log(`Alice's address: ${alice.accountAddress.toString()}`);
-     * }
+     * Get an account by its label, or undefined if not present.
      */
-    static getAccountByLabel(label) {
+    getAccountByLabel(label) {
         const address = this.labelMap.get(label);
         if (!address) {
             return undefined;
@@ -84,16 +98,11 @@ export class AccountManager {
         return this.pool.get(address);
     }
     /**
-     * Load account from environment variable
-     *
-     * @param envVar The environment variable name (defaults to "PRIVATE_KEY")
-     * @returns Account instance
-     * @throws Error if environment variable is not set
+     * Load account from environment variable.
      *
-     * @example
-     * const account = AccountManager.loadAccountFromEnv("MH_PRIVATE_KEY");
+     * @throws Error if the environment variable is not set
      */
-    static loadAccountFromEnv(envVar = "PRIVATE_KEY") {
+    loadAccountFromEnv(envVar = "PRIVATE_KEY") {
         const privateKeyHex = process.env[envVar];
         if (!privateKeyHex) {
             throw new Error(`Environment variable ${envVar} not found. ` +
@@ -102,15 +111,9 @@ export class AccountManager {
         return this.loadAccountFromPrivateKey(privateKeyHex);
     }
     /**
-     * Load account from a private key hex string
-     *
-     * @param privateKeyHex The private key as a hex string (with or without 0x prefix)
-     * @returns Account instance
-     *
-     * @example
-     * const account = AccountManager.loadAccountFromPrivateKey("0xabc123...");
+     * Load account from a private key hex string (with or without 0x prefix).
      */
-    static loadAccountFromPrivateKey(privateKeyHex) {
+    loadAccountFromPrivateKey(privateKeyHex) {
         // Format into AIP-80 shape (`ed25519-priv-0x…`) before constructing
         // the SDK type. Without this, raw-hex inputs trigger a noisy
         // deprecation warning from `@aptos-labs/ts-sdk` on every call.
@@ -119,16 +122,9 @@ export class AccountManager {
         return account;
     }
     /**
-     * Load all accounts from movehat config
-     *
-     * @param config The resolved MovehatConfig
-     * @returns Array of Account instances
-     *
-     * @example
-     * const config = await resolveNetworkConfig(userConfig);
-     * const accounts = AccountManager.loadAccountsFromConfig(config);
+     * Load all accounts from movehat config.
      */
-    static loadAccountsFromConfig(config) {
+    loadAccountsFromConfig(config) {
         const accounts = [];
         for (const privateKeyHex of config.allAccounts) {
             try {
@@ -137,21 +133,15 @@ export class AccountManager {
             }
             catch (error) {
                 const msg = error instanceof Error ? error.message : String(error);
-                console.warn(`Warning: Failed to load account from config: ${msg}`);
+                logger.warning(`Failed to load account from config: ${msg}`);
             }
         }
         return accounts;
     }
     /**
-     * Get all labeled accounts in the pool
-     *
-     * @returns Record of label to Account mappings
-     *
-     * @example
-     * const labeled = AccountManager.getLabeledAccounts();
-     * console.log(`Deployer: ${labeled.deployer?.accountAddress.toString()}`);
+     * Get all labeled accounts in the pool.
      */
-    static getLabeledAccounts() {
+    getLabeledAccounts() {
         const result = {};
         for (const [label, address] of this.labelMap.entries()) {
             const account = this.pool.get(address);
@@ -161,25 +151,25 @@ export class AccountManager {
         }
         return result;
     }
-    static saveAccountPool(poolPathOrOptions, options = {}) {
-        const poolPath = typeof poolPathOrOptions === "string" ? poolPathOrOptions : undefined;
+    saveAccountPool(poolPathOrOptions, options = {}) {
+        const explicitPath = typeof poolPathOrOptions === "string" ? poolPathOrOptions : undefined;
         const effectiveOptions = typeof poolPathOrOptions === "object" && poolPathOrOptions !== null
             ? poolPathOrOptions
             : options;
         const includeImported = effectiveOptions.includeImported ?? false;
-        const basePath = poolPath || this.defaultPoolPath;
+        const basePath = explicitPath || this.poolPath;
         // Ensure directory exists with restrictive perms (the pool file holds
         // plaintext private keys, so the directory must not be world-readable).
-        // Note: mkdirSync's mode is masked by the process umask, so we chmod
-        // explicitly afterwards to guarantee 0o700 regardless of umask.
+        // mkdirSync's mode is masked by the process umask; chmod explicitly
+        // afterwards to guarantee 0o700.
         if (!existsSync(basePath)) {
             mkdirSync(basePath, { recursive: true, mode: 0o700 });
         }
         chmodSync(basePath, 0o700);
-        // Build stored accounts array
         const storedAccounts = [];
         const labelMapObject = {};
         for (const [address, account] of this.pool.entries()) {
+            void account;
             if (!includeImported && !this.generatedAccountAddresses.has(address)) {
                 continue;
             }
@@ -194,7 +184,7 @@ export class AccountManager {
             }
             const privateKey = this.privateKeys.get(address);
             if (!privateKey) {
-                console.warn(`Warning: No private key found for account ${address}, skipping`);
+                logger.warning(`No private key found for account ${address}, skipping`);
                 continue;
             }
             storedAccounts.push({
@@ -208,10 +198,6 @@ export class AccountManager {
             accounts: storedAccounts,
             labelMap: labelMapObject,
         };
-        // Write to file with owner-only permissions — file contains plaintext
-        // private keys for test accounts. writeFileSync's mode is masked by
-        // the process umask, so we chmod explicitly afterwards to guarantee
-        // 0o600 regardless of umask.
         const poolFilePath = join(basePath, "test-pool.json");
         writeFileSync(poolFilePath, JSON.stringify(poolData, null, 2), {
             encoding: "utf-8",
@@ -220,31 +206,22 @@ export class AccountManager {
         chmodSync(poolFilePath, 0o600);
     }
     /**
-     * Load account pool from disk
-     *
-     * @param poolPath Optional custom path (defaults to .movehat/accounts)
-     * @returns true if pool was loaded, false if file doesn't exist
-     *
-     * @example
-     * if (AccountManager.loadAccountPool()) {
-     *   console.log("Pool loaded successfully");
-     * }
+     * Load account pool from disk. Returns true if a pool file was found
+     * and parsed, false if the file does not exist or parsing failed.
      */
-    static loadAccountPool(poolPath) {
+    loadAccountPool(poolPath) {
         if (this.poolLoaded) {
-            return true; // Already loaded
+            return true;
         }
-        const basePath = poolPath || this.defaultPoolPath;
+        const basePath = poolPath || this.poolPath;
         const poolFilePath = join(basePath, "test-pool.json");
         if (!existsSync(poolFilePath)) {
             return false;
         }
         try {
             const poolData = JSON.parse(readFileSync(poolFilePath, "utf-8"));
-            // Clear existing pool
             this.pool.clear();
             this.labelMap.clear();
-            // Restore accounts
             for (const stored of poolData.accounts) {
                 const account = this.accountFromPrivateKey(stored.privateKey);
                 this.trackAccount(account, stored.privateKey, "generated");
@@ -263,20 +240,14 @@ export class AccountManager {
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            console.warn(`Warning: Failed to load account pool: ${msg}`);
+            logger.warning(`Failed to load account pool: ${msg}`);
             return false;
         }
     }
     /**
-     * Clear the entire account pool
-     * Useful for test isolation
-     *
-     * @example
-     * after(() => {
-     *   AccountManager.clearPool();
-     * });
+     * Clear the entire account pool. Useful for test isolation.
      */
-    static clearPool() {
+    clearPool() {
         this.pool.clear();
         this.privateKeys.clear();
         this.labelMap.clear();
@@ -284,43 +255,27 @@ export class AccountManager {
         this.poolLoaded = false;
     }
     /**
-     * Get the current size of the account pool
-     *
-     * @returns Number of accounts in the pool
+     * Number of accounts in the pool.
      */
-    static getPoolSize() {
+    getPoolSize() {
         return this.pool.size;
     }
     /**
-     * Get all accounts in the pool
-     *
-     * @returns Array of all Account instances
+     * All accounts in the pool.
      */
-    static getAllAccounts() {
+    getAllAccounts() {
         return Array.from(this.pool.values());
     }
     /**
-     * Check if a label is already in use
-     *
-     * @param label The label to check
-     * @returns true if label exists, false otherwise
+     * Whether a label is currently bound to an account in this pool.
      */
-    static hasLabel(label) {
+    hasLabel(label) {
         return this.labelMap.has(label);
     }
     /**
-     * Get or create an account with a specific label
-     * If the label exists, returns the existing account
-     * Otherwise creates a new account with that label
-     *
-     * @param label The label for the account
-     * @returns Account instance
-     *
-     * @example
-     * const alice = AccountManager.getOrCreateLabeled("alice");
-     * const aliceAgain = AccountManager.getOrCreateLabeled("alice"); // Same account
+     * Get or create an account with a specific label.
      */
-    static getOrCreateLabeled(label) {
+    getOrCreateLabeled(label) {
         const existing = this.getAccountByLabel(label);
         if (existing) {
             return existing;
@@ -328,16 +283,9 @@ export class AccountManager {
         return this.createAccount(label, false);
     }
     /**
-     * Batch create multiple labeled accounts
-     *
-     * @param labels Array of labels to create
-     * @returns Record of label to Account mappings
-     *
-     * @example
-     * const accounts = AccountManager.createBatch(["alice", "bob", "charlie"]);
-     * console.log(accounts.alice.accountAddress.toString());
+     * Batch create multiple labeled accounts.
      */
-    static createBatch(labels) {
+    createBatch(labels) {
         const result = {};
         for (const label of labels) {
             result[label] = this.getOrCreateLabeled(label);
@@ -345,16 +293,12 @@ export class AccountManager {
         return result;
     }
     /**
-     * Export account private keys for backup/sharing
-     * WARNING: Only use this for test accounts, never production keys
-     *
-     * @param labels Optional array of labels to export (exports all if not provided)
-     * @returns Record of label/address to private key hex string
+     * Export account private keys for backup/sharing.
+     * WARNING: Only use this for test accounts, never production keys.
      */
-    static exportPrivateKeys(labels) {
+    exportPrivateKeys(labels) {
         const result = {};
         if (labels) {
-            // Export specific labels
             for (const label of labels) {
                 const address = this.labelMap.get(label);
                 if (address) {
@@ -366,7 +310,6 @@ export class AccountManager {
             }
         }
         else {
-            // Export all labeled accounts
             for (const [label, address] of this.labelMap.entries()) {
                 const privateKey = this.privateKeys.get(address);
                 if (privateKey) {
@@ -376,12 +319,12 @@ export class AccountManager {
         }
         return result;
     }
-    static accountFromPrivateKey(privateKeyHex) {
+    accountFromPrivateKey(privateKeyHex) {
         const formatted = PrivateKey.formatPrivateKey(privateKeyHex, PrivateKeyVariants.Ed25519);
         const privateKey = new Ed25519PrivateKey(formatted);
         return Account.fromPrivateKey({ privateKey });
     }
-    static trackAccount(account, privateKeyHex, source) {
+    trackAccount(account, privateKeyHex, source) {
         const address = account.accountAddress.toString();
         this.pool.set(address, account);
         this.privateKeys.set(address, privateKeyHex);
@@ -392,4 +335,120 @@ export class AccountManager {
             this.generatedAccountAddresses.delete(address);
         }
     }
+    // ── Static facade (deprecated; removed in 0.3.0) ────────────────
+    //
+    // Every former static method below forwards to `__defaultManager`,
+    // a module-level singleton constructed once at import time. This
+    // preserves the legacy "process-wide pool shared across consumers"
+    // behavior so existing callers see no change during the 0.2.7
+    // deprecation window. The singleton is constructed with its
+    // `poolPath` eagerly captured from the import-time `process.cwd()`
+    // — preserving F8(b) for the static API specifically.
+    //
+    // Removal happens in M9.4 (0.3.0). Until then the runtime warning
+    // added in M9.3 nudges users toward `harness.accounts.<label>` or
+    // `harness.runtime.accountManager.*`.
+    static getTestAccount(label) {
+        __warnDeprecated("getTestAccount");
+        return __defaultManager.getTestAccount(label);
+    }
+    static createAccount(label, fund = false) {
+        __warnDeprecated("createAccount");
+        return __defaultManager.createAccount(label, fund);
+    }
+    static getAccountByLabel(label) {
+        __warnDeprecated("getAccountByLabel");
+        return __defaultManager.getAccountByLabel(label);
+    }
+    static loadAccountFromEnv(envVar = "PRIVATE_KEY") {
+        __warnDeprecated("loadAccountFromEnv");
+        return __defaultManager.loadAccountFromEnv(envVar);
+    }
+    static loadAccountFromPrivateKey(privateKeyHex) {
+        __warnDeprecated("loadAccountFromPrivateKey");
+        return __defaultManager.loadAccountFromPrivateKey(privateKeyHex);
+    }
+    static loadAccountsFromConfig(config) {
+        __warnDeprecated("loadAccountsFromConfig");
+        return __defaultManager.loadAccountsFromConfig(config);
+    }
+    static getLabeledAccounts() {
+        __warnDeprecated("getLabeledAccounts");
+        return __defaultManager.getLabeledAccounts();
+    }
+    static saveAccountPool(poolPathOrOptions, options = {}) {
+        __warnDeprecated("saveAccountPool");
+        // Re-dispatch via the instance overloads, preserving caller intent.
+        if (poolPathOrOptions === undefined) {
+            __defaultManager.saveAccountPool();
+        }
+        else if (typeof poolPathOrOptions === "string") {
+            __defaultManager.saveAccountPool(poolPathOrOptions, options);
+        }
+        else {
+            __defaultManager.saveAccountPool(poolPathOrOptions);
+        }
+    }
+    static loadAccountPool(poolPath) {
+        __warnDeprecated("loadAccountPool");
+        return __defaultManager.loadAccountPool(poolPath);
+    }
+    static clearPool() {
+        __warnDeprecated("clearPool");
+        __defaultManager.clearPool();
+    }
+    static getPoolSize() {
+        __warnDeprecated("getPoolSize");
+        return __defaultManager.getPoolSize();
+    }
+    static getAllAccounts() {
+        __warnDeprecated("getAllAccounts");
+        return __defaultManager.getAllAccounts();
+    }
+    static hasLabel(label) {
+        __warnDeprecated("hasLabel");
+        return __defaultManager.hasLabel(label);
+    }
+    static getOrCreateLabeled(label) {
+        __warnDeprecated("getOrCreateLabeled");
+        return __defaultManager.getOrCreateLabeled(label);
+    }
+    static createBatch(labels) {
+        __warnDeprecated("createBatch");
+        return __defaultManager.createBatch(labels);
+    }
+    static exportPrivateKeys(labels) {
+        __warnDeprecated("exportPrivateKeys");
+        return __defaultManager.exportPrivateKeys(labels);
+    }
+}
+// Module-level singleton backing the static facade. The eager poolPath
+// capture mirrors the pre-M9 behavior — `process.chdir` after import
+// does NOT redirect static-facade pool I/O. F8(b) is preserved for
+// the static API and only flips for callers using the instance API.
+const __defaultManager = new AccountManager({
+    poolPath: join(process.cwd(), ".movehat", "accounts"),
+});
+// Once-per-method-per-process deprecation tracking for the static
+// facade. The warning fires on the FIRST call to each static method
+// per process, then stays silent for subsequent calls. A user with
+// 50 tests calling `AccountManager.getLabeledAccounts()` sees the
+// warning once, not 50 times.
+//
+// Exported as `_resetDeprecationWarnings` for tests that need to
+// verify warning behavior across multiple `it` blocks (vitest workers
+// share module state within a single test file).
+const __warnedMethods = new Set();
+/** @internal — test-only. Resets the once-per-method dedup Set. */
+export function _resetDeprecationWarnings() {
+    __warnedMethods.clear();
+}
+function __warnDeprecated(method) {
+    if (__warnedMethods.has(method))
+        return;
+    __warnedMethods.add(method);
+    logger.warning(`AccountManager.${method} is deprecated and will be removed in 0.3.0. ` +
+        `Use 'harness.accounts.<label>' for labeled-account access, or ` +
+        `'harness.runtime.accountManager.${method}' for direct manager calls. ` +
+        `See migration tracker: https://github.com/gilbertsahumada/movehat/issues/270`);
 }

package/dist/harness/Harness.d.ts

@@ -1,3 +1,4 @@
+import type { Account } from "@aptos-labs/ts-sdk";
 import type { MovehatRuntime } from "../types/runtime.js";
 import type { LocalNodeManager } from "../node/LocalNodeManager.js";
 import type { ForkServer } from "../fork/server.js";
@@ -13,14 +14,41 @@ export type HarnessMode = "local" | "fork" | "live";
  * a Proxy that synchronously throws {@link HarnessDisposedError} on any
  * post-`cleanup()` call to one of the deployment / script / view methods.
  *
- * AccountManager note: the underlying account pool is a process-wide
- * static (see `core/AccountManager.ts`). Two Harness instances in the
- * same process share account labels; this is the same constraint that
- * already governs `setupTestFixture`.
+ * Account isolation: each Harness owns a per-instance `AccountManager`
+ * (see `core/AccountManager.ts`) reachable at `harness.runtime.accountManager`.
+ * Two Harness instances in the same process have independent account
+ * pools and label maps — `Harness.createLocal({ accountLabels: ["alice"] })`
+ * twice produces two DIFFERENT alice accounts.
+ *
+ * Labeled accounts created during construction (via `accountLabels` in
+ * `createLocal`) are snapshotted onto `harness.accounts` at construction
+ * time. Late additions via `harness.runtime.accountManager.createAccount(...)`
+ * are NOT reflected in the `accounts` Record — that's a snapshot, not a
+ * live view. For live mode (`Harness.createLive`), `accounts` is `{}`
+ * because the live factory does not create labeled accounts; reach into
+ * `harness.runtime.accountManager.*` for advanced operations.
+ *
+ * The `AccountManager` class-static methods remain available in 0.2.x
+ * for backward compatibility (deprecation warning lands in 0.2.7,
+ * removal in 0.3.0 — see #270). New code should prefer
+ * `harness.accounts.<label>` for the common read path.
  */
 export declare class Harness {
     readonly mode: HarnessMode;
     readonly runtime: MovehatRuntime;
+    /**
+     * Labeled accounts snapshotted from `runtime.accountManager` at
+     * construction time. For `createLocal`, this is populated from the
+     * `accountLabels` option. For `createFork`, populated the same way.
+     * For `createLive`, empty (live mode does not create labeled accounts;
+     * use `harness.runtime.accountManager.loadAccountFromPrivateKey(...)`
+     * for direct key loading).
+     *
+     * Typed `Readonly` so the snapshot can't be mutated via
+     * `harness.accounts.alice = X`. Reach into
+     * `harness.runtime.accountManager.*` when you need mutable access.
+     */
+    readonly accounts: Readonly<Record<string, Account>>;
     /** @internal */
     readonly localNode?: LocalNodeManager;
     /** @internal */

package/dist/harness/Harness.js

@@ -12,14 +12,41 @@ import { runMoveScript } from "./script.js";
  * a Proxy that synchronously throws {@link HarnessDisposedError} on any
  * post-`cleanup()` call to one of the deployment / script / view methods.
  *
- * AccountManager note: the underlying account pool is a process-wide
- * static (see `core/AccountManager.ts`). Two Harness instances in the
- * same process share account labels; this is the same constraint that
- * already governs `setupTestFixture`.
+ * Account isolation: each Harness owns a per-instance `AccountManager`
+ * (see `core/AccountManager.ts`) reachable at `harness.runtime.accountManager`.
+ * Two Harness instances in the same process have independent account
+ * pools and label maps — `Harness.createLocal({ accountLabels: ["alice"] })`
+ * twice produces two DIFFERENT alice accounts.
+ *
+ * Labeled accounts created during construction (via `accountLabels` in
+ * `createLocal`) are snapshotted onto `harness.accounts` at construction
+ * time. Late additions via `harness.runtime.accountManager.createAccount(...)`
+ * are NOT reflected in the `accounts` Record — that's a snapshot, not a
+ * live view. For live mode (`Harness.createLive`), `accounts` is `{}`
+ * because the live factory does not create labeled accounts; reach into
+ * `harness.runtime.accountManager.*` for advanced operations.
+ *
+ * The `AccountManager` class-static methods remain available in 0.2.x
+ * for backward compatibility (deprecation warning lands in 0.2.7,
+ * removal in 0.3.0 — see #270). New code should prefer
+ * `harness.accounts.<label>` for the common read path.
  */
 export class Harness {
     mode;
     runtime;
+    /**
+     * Labeled accounts snapshotted from `runtime.accountManager` at
+     * construction time. For `createLocal`, this is populated from the
+     * `accountLabels` option. For `createFork`, populated the same way.
+     * For `createLive`, empty (live mode does not create labeled accounts;
+     * use `harness.runtime.accountManager.loadAccountFromPrivateKey(...)`
+     * for direct key loading).
+     *
+     * Typed `Readonly` so the snapshot can't be mutated via
+     * `harness.accounts.alice = X`. Reach into
+     * `harness.runtime.accountManager.*` when you need mutable access.
+     */
+    accounts;
     /** @internal */
     localNode;
     /** @internal */
@@ -30,6 +57,7 @@ export class Harness {
     constructor(init) {
         this.mode = init.mode;
         this.runtime = init.runtime;
+        this.accounts = init.runtime.accountManager.getLabeledAccounts();
         if (init.localNode)
             this.localNode = init.localNode;
         if (init.forkServer)

package/dist/helpers/setup.js

@@ -14,8 +14,10 @@ export async function setupTestEnvironment(networkName) {
         fullnode: config.rpc,
     });
     const aptos = new Aptos(aptosConfig);
-    // Load account using AccountManager
-    const account = AccountManager.loadAccountFromPrivateKey(config.privateKey);
+    // Load account using a throwaway AccountManager instance. This helper
+    // returns Aptos+Account directly (no runtime exposure), so a local
+    // instance suffices — no shared pool needed.
+    const account = new AccountManager().loadAccountFromPrivateKey(config.privateKey);
     logger.success("Test environment ready");
     logger.plain(`   Account: ${account.accountAddress.toString()}`);
     logger.plain(`   Network: ${config.network}`);
@@ -28,5 +30,6 @@ export async function setupTestEnvironment(networkName) {
     };
 }
 export function createTestAccount() {
-    return AccountManager.createAccount();
+    // Throwaway instance — see setupTestEnvironment for rationale.
+    return new AccountManager().createAccount();
 }

package/dist/helpers/setupLocalTesting.js

@@ -118,8 +118,12 @@ async function setupWithLocalNode(options, accountLabels, autoFund, defaultBalan
     // leaks and port 8080 stays bound until the OS reaps it (manifests as
     // "Movement command failed" on the next test:example run).
     try {
+        // Per-context AccountManager. Threaded into initRuntime below so
+        // the runtime exposes the SAME instance — the labels created by
+        // createBatch here are visible on `runtime.accountManager`.
+        const accountManager = new AccountManager();
         logger.step(`Generating ${accountLabels.length} test accounts...`);
-        const accounts = AccountManager.createBatch(accountLabels);
+        const accounts = accountManager.createBatch(accountLabels);
         for (const [label, account] of Object.entries(accounts)) {
             logger.plain(`   ${label}: ${account.accountAddress.toString()}`);
         }
@@ -129,12 +133,13 @@ async function setupWithLocalNode(options, accountLabels, autoFund, defaultBalan
             await localNode.fundAccounts(accountsList, defaultBalance);
         }
         logger.step("Initializing runtime for local network...");
-        const deployerPrivateKey = AccountManager.exportPrivateKeys(["deployer"]).deployer;
+        const deployerPrivateKey = accountManager.exportPrivateKeys(["deployer"]).deployer;
         if (!deployerPrivateKey) {
             throw new Error("Failed to get deployer private key");
         }
         const runtime = await initRuntime({
             network: "local",
+            accountManager,
             configOverride: {
                 networks: {
                     local: {
@@ -256,8 +261,10 @@ async function setupWithFork(options, accountLabels, autoFund, defaultBalance) {
     // we leak the listener.
     try {
         await new Promise((resolve) => setTimeout(resolve, 500));
+        // Per-context AccountManager (mirror of setupWithLocalNode pattern).
+        const accountManager = new AccountManager();
         logger.step(`Generating ${accountLabels.length} test accounts...`);
-        const accounts = AccountManager.createBatch(accountLabels);
+        const accounts = accountManager.createBatch(accountLabels);
         for (const [label, account] of Object.entries(accounts)) {
             logger.plain(`   ${label}: ${account.accountAddress.toString()}`);
         }
@@ -267,12 +274,13 @@ async function setupWithFork(options, accountLabels, autoFund, defaultBalance) {
             await forkManager.fundMultipleAccounts(addresses, defaultBalance);
         }
         logger.step("Initializing runtime for local network...");
-        const deployerPrivateKey = AccountManager.exportPrivateKeys(["deployer"]).deployer;
+        const deployerPrivateKey = accountManager.exportPrivateKeys(["deployer"]).deployer;
         if (!deployerPrivateKey) {
             throw new Error("Failed to get deployer private key");
         }
         const runtime = await initRuntime({
             network: "local",
+            accountManager,
             configOverride: {
                 networks: {
                     local: {

package/dist/helpers/testFixtures.d.ts

@@ -22,10 +22,11 @@ export interface TestFixture<TModules extends string = string> {
     /**
      * Stop the local node / fork server this fixture started.
      *
-     * Does **not** clear the shared `AccountManager` pool — clearing it
-     * would break parallel `setupTestFixture` invocations that share the
-     * pool. The pool grows for the lifetime of the process; the process
-     * exit reclaims it.
+     * Each fixture owns its own `AccountManager` instance (via
+     * `setupLocalTesting` → `initRuntime`), so there is no shared pool
+     * to clear — accounts are garbage-collected when the fixture goes
+     * out of scope. Parallel `setupTestFixture` invocations have fully
+     * isolated label maps and pools (M9.2, #270).
      */
     teardown: () => Promise<void>;
 }

package/dist/helpers/testFixtures.js

@@ -1,4 +1,3 @@
-import { AccountManager } from "../core/AccountManager.js";
 import { setupLocalTesting } from "./setupLocalTesting.js";
 import { logger } from "../ui/index.js";
 /**
@@ -59,7 +58,7 @@ export async function setupTestFixture(modules, accountLabels = ["alice", "bob"]
     // the original assembly error unchanged.
     try {
         const mh = ctx.runtime;
-        const labeledAccounts = AccountManager.getLabeledAccounts();
+        const labeledAccounts = mh.accountManager.getLabeledAccounts();
         // any: TestFixture.accounts has a structural shape with required
         // `deployer/alice/bob` plus a `[key: string]: Account` index. The
         // builder fills the index dynamically; typing this as the exact
@@ -72,7 +71,7 @@ export async function setupTestFixture(modules, accountLabels = ["alice", "bob"]
             deployer: labeledAccounts.deployer,
         };
         for (const label of accountLabels) {
-            accounts[label] = labeledAccounts[label] || AccountManager.getOrCreateLabeled(label);
+            accounts[label] = labeledAccounts[label] || mh.accountManager.getOrCreateLabeled(label);
         }
         const contracts = {};
         for (const moduleName of modules) {
@@ -119,14 +118,14 @@ export async function setupMinimalFixture(accountLabels = ["alice", "bob"], opti
     // Same teardown-on-assembly-failure pattern as setupTestFixture.
     try {
         const mh = ctx.runtime;
-        const labeledAccounts = AccountManager.getLabeledAccounts();
+        const labeledAccounts = mh.accountManager.getLabeledAccounts();
         // any: see setupTestFixture above — same dynamic-key builder pattern.
         const accounts = {
             // non-null: deployer is unconditionally added to allLabels at L156 above.
             deployer: labeledAccounts.deployer,
         };
         for (const label of accountLabels) {
-            accounts[label] = labeledAccounts[label] || AccountManager.getOrCreateLabeled(label);
+            accounts[label] = labeledAccounts[label] || mh.accountManager.getOrCreateLabeled(label);
         }
         logger.newline();
         logger.success("Minimal fixture ready!");

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export * from "./helpers/index.js";
-export type { MovehatConfig } from "./types/config.js";
+export type { MovehatConfig, NetworkConfig, LocalTestingMode, } from "./types/config.js";
 export { initRuntime } from "./runtime.js";
+export type { InitRuntimeOptions } from "./runtime.js";
 export type { MovehatRuntime, NetworkInfo } from "./types/runtime.js";
+export type { ChildProcessAdapter } from "./utils/childProcessAdapter.js";
 export { ForkManager } from "./fork/manager.js";
 export { MovementApiClient } from "./fork/api.js";
 export { ForkStorage } from "./fork/storage.js";

package/dist/runtime.d.ts

@@ -1,9 +1,22 @@
 import { MovehatRuntime } from "./types/runtime.js";
 import { MovehatUserConfig } from "./types/config.js";
+import { AccountManager } from "./core/AccountManager.js";
 export interface InitRuntimeOptions {
     network?: string;
     accountIndex?: number;
     configOverride?: Partial<MovehatUserConfig>;
+    /**
+     * Optional pre-constructed `AccountManager` instance. When supplied,
+     * the returned runtime's `accountManager` field is THIS instance —
+     * so labeled accounts created BEFORE `initRuntime` are visible on
+     * the runtime. When omitted, `initRuntime` constructs a fresh
+     * `new AccountManager()` per call.
+     *
+     * `setupLocalTesting` uses this option to thread one manager through
+     * `createBatch` → `exportPrivateKeys` → `initRuntime` so the deployer
+     * key it extracts ends up on the same manager the runtime exposes.
+     */
+    accountManager?: AccountManager;
 }
 /**
  * Initialize the Movehat Runtime Environment.

package/dist/runtime.js

@@ -35,9 +35,12 @@ export async function initRuntime(options = {}) {
         fullnode: config.rpc,
     });
     const aptos = new Aptos(aptosConfig);
-    // Setup accounts using AccountManager
+    // Setup accounts using AccountManager. Use the caller-supplied
+    // instance when threaded in (preserves labels created before
+    // initRuntime); otherwise construct a fresh one.
+    const accountManager = options.accountManager ?? new AccountManager();
     const accountIndex = options.accountIndex || 0;
-    const accounts = AccountManager.loadAccountsFromConfig(config);
+    const accounts = accountManager.loadAccountsFromConfig(config);
     // Primary account (accounts[0] or selected index)
     const account = accounts[accountIndex];
     if (!account) {
@@ -73,10 +76,10 @@ export async function initRuntime(options = {}) {
         return getDeployedAddress(config.network, moduleName);
     };
     const createAccount = () => {
-        return AccountManager.createAccount();
+        return accountManager.createAccount();
     };
     const getAccountHelper = (privateKeyHex) => {
-        return AccountManager.loadAccountFromPrivateKey(privateKeyHex);
+        return accountManager.loadAccountFromPrivateKey(privateKeyHex);
     };
     const getAccountByIndex = (index) => {
         const acc = accounts[index];
@@ -95,6 +98,7 @@ export async function initRuntime(options = {}) {
         aptos,
         account,
         accounts,
+        accountManager,
         getContract: getContractHelper,
         deployContract,
         getDeployment,

package/dist/templates/tests/Counter.test.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck - This is a template file, dependencies are installed in user projects
 import { describe, it, before, after } from "mocha";
 import { expect } from "chai";
-import { Harness, AccountManager } from "movehat";
+import { Harness } from "movehat";
 
 describe("Counter Contract", () => {
   let harness;
@@ -23,10 +23,11 @@ describe("Counter Contract", () => {
       autoDeploy: ["counter"],
     });
 
-    const labeled = AccountManager.getLabeledAccounts();
-    deployer = labeled.deployer;
-    alice = labeled.alice;
-    bob = labeled.bob;
+    // harness.accounts is a snapshot of the labeled accounts created
+    // during Harness construction. Two `Harness.createLocal({ accountLabels:
+    // ["alice"] })` calls in the same process now produce DIFFERENT
+    // alice accounts (per-Harness isolation introduced in 0.2.7).
+    ({ deployer, alice, bob } = harness.accounts);
 
     const counterAddr = harness.runtime.getDeploymentAddress("counter");
     counter = harness.runtime.getContract(counterAddr, "counter");

package/dist/types/runtime.d.ts

@@ -2,6 +2,7 @@ import { Aptos, Account } from "@aptos-labs/ts-sdk";
 import { MovehatConfig } from "./config.js";
 import { MoveContract } from "../core/contract.js";
 import { DeploymentInfo } from "../core/deployments.js";
+import type { AccountManager } from "../core/AccountManager.js";
 import type { ChildProcessAdapter } from "../utils/childProcessAdapter.js";
 export interface NetworkInfo {
     name: string;
@@ -14,6 +15,7 @@ export interface MovehatRuntime {
     aptos: Aptos;
     account: Account;
     accounts: Account[];
+    accountManager: AccountManager;
     getContract: (address: string, moduleName: string) => MoveContract;
     deployContract: (moduleName: string, options?: {
         packageDir?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "movehat",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "type": "module",
   "description": "Hardhat-like development framework for Movement L1 smart contracts",
   "bin": {