movehat 0.2.6 → 0.2.8

package/dist/fork/storage.js

@@ -1,6 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { isHexAddress } from '../utils/address.js';
+import { assertForkMetadata, assertAccountStateRecord } from './validation.js';
 /**
  * Sanitize address to create a safe filename. Validates the address through
  * the shared `isHexAddress` helper (length 1–64 hex chars, optional `0x`),
@@ -108,7 +109,7 @@ export class ForkStorage {
         if (!existsSync(metadataPath)) {
             throw new Error(`Fork metadata not found at ${metadataPath}`);
         }
-        return readJsonFile(metadataPath, 'fork metadata');
+        return assertForkMetadata(readJsonFile(metadataPath, 'fork metadata'));
     }
     /**
      * Get account state
@@ -118,7 +119,7 @@ export class ForkStorage {
         if (!existsSync(accountsPath)) {
             return null;
         }
-        const accounts = readJsonFile(accountsPath, 'fork accounts');
+        const accounts = assertAccountStateRecord(readJsonFile(accountsPath, 'fork accounts'));
         return accounts[address] || null;
     }
     /**
@@ -128,7 +129,7 @@ export class ForkStorage {
         const accountsPath = join(this.forkPath, 'accounts.json');
         let accounts = {};
         if (existsSync(accountsPath)) {
-            accounts = readJsonFile(accountsPath, 'fork accounts');
+            accounts = assertAccountStateRecord(readJsonFile(accountsPath, 'fork accounts'));
         }
         accounts[address] = state;
         writePrivateFile(accountsPath, JSON.stringify(accounts, null, 2));
@@ -193,7 +194,7 @@ export class ForkStorage {
         if (!existsSync(accountsPath)) {
             return [];
         }
-        const accounts = readJsonFile(accountsPath, 'fork accounts');
+        const accounts = assertAccountStateRecord(readJsonFile(accountsPath, 'fork accounts'));
         return Object.keys(accounts);
     }
     /**

package/dist/fork/test.d.ts

@@ -59,7 +59,7 @@ export declare function getForkInfo(path: string): Promise<ForkInfo>;
  */
 export declare function viewForkResource(sessionPath: string, account: string, resourceType: string, options?: {
     adapter?: ChildProcessAdapter;
-}): Promise<any>;
+}): Promise<unknown>;
 /**
  * Compare a resource between current network state and a fork
  * Useful for verifying state changes after tests

package/dist/fork/validation.d.ts

@@ -0,0 +1,9 @@
+import type { LedgerInfo, AccountData, AccountResource, ForkMetadata, AccountState, CoinStore } from "../types/fork.js";
+export declare function assertLedgerInfo(v: unknown): LedgerInfo;
+export declare function assertAccountData(v: unknown): AccountData;
+export declare function assertAccountResource(v: unknown): AccountResource;
+export declare function assertAccountResourceArray(v: unknown): AccountResource[];
+export declare function assertForkMetadata(v: unknown): ForkMetadata;
+export declare function assertAccountState(v: unknown): AccountState;
+export declare function assertAccountStateRecord(v: unknown): Record<string, AccountState>;
+export declare function assertCoinStore(v: unknown): CoinStore;

package/dist/fork/validation.js

@@ -0,0 +1,88 @@
+function isObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function hasString(o, key) {
+    return typeof o[key] === "string";
+}
+export function assertLedgerInfo(v) {
+    if (!isObject(v) ||
+        typeof v.chain_id !== "number" ||
+        !hasString(v, "epoch") ||
+        !hasString(v, "ledger_version") ||
+        !hasString(v, "oldest_ledger_version") ||
+        !hasString(v, "ledger_timestamp") ||
+        !hasString(v, "node_role") ||
+        !hasString(v, "oldest_block_height") ||
+        !hasString(v, "block_height")) {
+        throw new Error("Invalid LedgerInfo: missing or incorrectly typed fields");
+    }
+    return v;
+}
+export function assertAccountData(v) {
+    if (!isObject(v) ||
+        !hasString(v, "sequence_number") ||
+        !hasString(v, "authentication_key")) {
+        throw new Error("Invalid AccountData: expected object with 'sequence_number' and 'authentication_key' strings");
+    }
+    return v;
+}
+export function assertAccountResource(v) {
+    if (!isObject(v) || !hasString(v, "type") || !("data" in v)) {
+        throw new Error("Invalid AccountResource: expected object with 'type' string and 'data' field");
+    }
+    return v;
+}
+export function assertAccountResourceArray(v) {
+    if (!Array.isArray(v)) {
+        throw new Error("Invalid resources response: expected array");
+    }
+    for (let i = 0; i < v.length; i++) {
+        if (!isObject(v[i]) || !hasString(v[i], "type") || !("data" in v[i])) {
+            throw new Error(`Invalid AccountResource at index ${i}: expected object with 'type' and 'data'`);
+        }
+    }
+    return v;
+}
+export function assertForkMetadata(v) {
+    if (!isObject(v) ||
+        !hasString(v, "network") ||
+        !hasString(v, "nodeUrl") ||
+        typeof v.chainId !== "number" ||
+        !hasString(v, "ledgerVersion") ||
+        !hasString(v, "timestamp") ||
+        !hasString(v, "epoch") ||
+        !hasString(v, "blockHeight") ||
+        !hasString(v, "createdAt")) {
+        throw new Error("Invalid ForkMetadata: missing or incorrectly typed fields");
+    }
+    return v;
+}
+export function assertAccountState(v) {
+    if (!isObject(v) ||
+        !hasString(v, "sequenceNumber") ||
+        !hasString(v, "authenticationKey")) {
+        throw new Error("Invalid AccountState: expected object with 'sequenceNumber' and 'authenticationKey' strings");
+    }
+    return v;
+}
+export function assertAccountStateRecord(v) {
+    if (!isObject(v)) {
+        throw new Error("Invalid account state record: expected object");
+    }
+    for (const [key, val] of Object.entries(v)) {
+        if (!isObject(val) ||
+            !hasString(val, "sequenceNumber") ||
+            !hasString(val, "authenticationKey")) {
+            throw new Error(`Invalid AccountState for key "${key}": missing 'sequenceNumber' or 'authenticationKey'`);
+        }
+    }
+    return v;
+}
+export function assertCoinStore(v) {
+    if (!isObject(v) ||
+        !isObject(v.coin) ||
+        !hasString(v.coin, "value")) {
+        throw new Error("Invalid CoinStore: expected object with 'coin.value' string");
+    }
+    return v;
+}

package/dist/harness/Harness.d.ts

@@ -1,5 +1,6 @@
+import type { Account } from "@aptos-labs/ts-sdk";
 import type { MovehatRuntime } from "../types/runtime.js";
-import type { LocalNodeManager } from "../node/LocalNodeManager.js";
+import type { NodeProvider } from "../node/NodeProvider.js";
 import type { ForkServer } from "../fork/server.js";
 import type { ForkManager } from "../fork/manager.js";
 import type { LocalTestOptions } from "../types/config.js";
@@ -13,21 +14,49 @@ 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;
+    readonly localNode?: NodeProvider;
     /** @internal */
     readonly forkServer?: ForkServer;
     /** @internal */
     readonly forkManager?: ForkManager;
     private _poisoned;
+    private readonly ownsLocalNode;
     private constructor();
     /** True once `cleanup()` has been awaited at least once. */
     get poisoned(): boolean;

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 */
@@ -27,9 +54,12 @@ export class Harness {
     /** @internal */
     forkManager;
     _poisoned = false;
+    ownsLocalNode;
     constructor(init) {
         this.mode = init.mode;
         this.runtime = init.runtime;
+        this.accounts = init.runtime.accountManager.getLabeledAccounts();
+        this.ownsLocalNode = init.ownsLocalNode ?? true;
         if (init.localNode)
             this.localNode = init.localNode;
         if (init.forkServer)
@@ -53,6 +83,7 @@ export class Harness {
         const init = {
             mode: "local",
             runtime: ctx.runtime,
+            ownsLocalNode: !options.localNode,
         };
         if (ctx.localNode)
             init.localNode = ctx.localNode;
@@ -128,7 +159,7 @@ export class Harness {
         if (this._poisoned)
             return;
         this._poisoned = true;
-        if (this.localNode) {
+        if (this.localNode && this.ownsLocalNode) {
             await this.localNode.stop().catch(() => { });
         }
         if (this.forkServer) {

package/dist/helpers/index.d.ts

@@ -11,6 +11,7 @@ export { AccountManager } from "../core/AccountManager.js";
 export type { StoredAccount } from "../core/AccountManager.js";
 export { LocalNodeManager } from "../node/LocalNodeManager.js";
 export type { LocalNodeOptions, LocalNodeInfo } from "../node/LocalNodeManager.js";
+export { MoveliteManager, findMoveliteBinary } from "../node/MoveliteManager.js";
 export { setupLocalTesting } from "./setupLocalTesting.js";
 export type { LocalTestingContext } from "./setupLocalTesting.js";
 export { setupTestFixture, setupMinimalFixture, } from "./testFixtures.js";

package/dist/helpers/index.js

@@ -6,5 +6,6 @@ export { saveDeployment, loadDeployment, getAllDeployments, getDeployedAddress,
 export { snapshot, getForkInfo, viewForkResource, compareForkState, listSnapshots, } from "../fork/test.js";
 export { AccountManager } from "../core/AccountManager.js";
 export { LocalNodeManager } from "../node/LocalNodeManager.js";
+export { MoveliteManager, findMoveliteBinary } from "../node/MoveliteManager.js";
 export { setupLocalTesting } from "./setupLocalTesting.js";
 export { setupTestFixture, setupMinimalFixture, } from "./testFixtures.js";

package/dist/helpers/move-tests.js

@@ -2,6 +2,7 @@ import { existsSync } from "fs";
 import { resolve } from "path";
 import { loadUserConfig } from "../core/config.js";
 import { runCli } from "../utils/runCli.js";
+import { logger } from "../ui/index.js";
 /**
  * Run Move unit tests using Movement CLI
  * @param options Test options including filter, warnings, and skip behavior
@@ -12,8 +13,9 @@ export async function runMoveTests(options = {}) {
     const moveDir = resolve(process.cwd(), userConfig.moveDir || "./move");
     if (!existsSync(moveDir)) {
         if (options.skipIfMissing) {
-            console.log("⊘ No Move directory found (./move not found)");
-            console.log("   Skipping Move tests...\n");
+            logger.info("No Move directory found (./move not found)");
+            logger.plain("   Skipping Move tests...");
+            logger.newline();
             return;
         }
         else {
@@ -42,12 +44,13 @@ export async function runMoveTests(options = {}) {
     catch (error) {
         // Spawn-time failure (ENOENT, etc.). The original code logged a
         // Movement-CLI-install hint here; keep that.
-        console.error(`Failed to run Move tests: ${error.message}`);
-        console.error("   Make sure Movement CLI is installed");
+        logger.error(`Failed to run Move tests: ${error.message}`);
+        logger.error("   Make sure Movement CLI is installed");
         throw error;
     }
     if (result.exitCode === 0) {
-        console.log("\n✓ Move tests passed");
+        logger.newline();
+        logger.success("Move tests passed");
         return;
     }
     throw new Error("Move tests failed");

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.d.ts

@@ -1,7 +1,7 @@
 import type { MovehatRuntime } from "../types/runtime.js";
 import { ForkManager } from "../fork/manager.js";
 import { ForkServer } from "../fork/server.js";
-import { LocalNodeManager } from "../node/LocalNodeManager.js";
+import type { NodeProvider } from "../node/NodeProvider.js";
 import type { LocalTestOptions } from "../types/config.js";
 /**
  * Context returned by {@link setupLocalTesting}.
@@ -17,7 +17,7 @@ import type { LocalTestOptions } from "../types/config.js";
 export interface LocalTestingContext {
     runtime: MovehatRuntime;
     /** @internal */
-    localNode?: LocalNodeManager;
+    localNode?: NodeProvider;
     /** @internal */
     forkServer?: ForkServer;
     /** @internal */

package/dist/helpers/setupLocalTesting.js

@@ -4,6 +4,7 @@ import { initRuntime } from "../runtime.js";
 import { ForkManager } from "../fork/manager.js";
 import { ForkServer } from "../fork/server.js";
 import { LocalNodeManager } from "../node/LocalNodeManager.js";
+import { MoveliteManager, findMoveliteBinary } from "../node/MoveliteManager.js";
 import { AccountManager } from "../core/AccountManager.js";
 import { logger } from "../ui/index.js";
 const BUILTIN_FORK_RPCS = {
@@ -64,11 +65,13 @@ export async function setupLocalTesting(options = {}) {
     logger.kv("Accounts", accountLabels.join(", "), 2);
     logger.newline();
     if (mode === 'local-node') {
-        const { runtime, localNode } = await setupWithLocalNode(options, accountLabels, autoFund, defaultBalance);
+        const { runtime, localNode, ownsNode } = await setupWithLocalNode(options, accountLabels, autoFund, defaultBalance);
         return {
             runtime,
             localNode,
             teardown: async () => {
+                if (!ownsNode)
+                    return;
                 logger.newline();
                 logger.step("Stopping local testing environment...");
                 await localNode.stop();
@@ -97,29 +100,53 @@ export async function setupLocalTesting(options = {}) {
  * Setup using local Movement node (full blockchain)
  */
 async function setupWithLocalNode(options, accountLabels, autoFund, defaultBalance) {
-    const nodeTestDir = options.nodeTestDir || join(process.cwd(), ".movehat", "local-node");
-    const nodeForceRestart = options.nodeForceRestart !== false;
-    const nodeFaucetPort = options.nodeFaucetPort || 8081;
-    const nodeApiPort = options.nodeApiPort || 8080;
-    const nodeReadyPort = options.nodeReadyPort || 8070;
-    const nodeSilent = options.nodeSilent ?? false;
-    const localNode = new LocalNodeManager({
-        testDir: nodeTestDir,
-        forceRestart: nodeForceRestart,
-        faucetPort: nodeFaucetPort,
-        apiPort: nodeApiPort,
-        readyPort: nodeReadyPort,
-        silent: nodeSilent,
-    });
-    const nodeInfo = await localNode.start();
+    let localNode;
+    let ownsNode;
+    let nodeInfo;
+    if (options.localNode) {
+        localNode = options.localNode;
+        ownsNode = false;
+        if (!localNode.isRunning()) {
+            throw new Error("localNode was provided but isRunning() is false. " +
+                "Start the node before passing it to setupLocalTesting.");
+        }
+        nodeInfo = localNode.getNodeInfo();
+    }
+    else if (options.useMovelite !== false && findMoveliteBinary()) {
+        localNode = new MoveliteManager(findMoveliteBinary());
+        nodeInfo = await localNode.start();
+        ownsNode = true;
+    }
+    else {
+        const nodeTestDir = options.nodeTestDir || join(process.cwd(), ".movehat", "local-node");
+        const nodeForceRestart = options.nodeForceRestart !== false;
+        const nodeFaucetPort = options.nodeFaucetPort || 8081;
+        const nodeApiPort = options.nodeApiPort || 8080;
+        const nodeReadyPort = options.nodeReadyPort || 8070;
+        const nodeSilent = options.nodeSilent ?? false;
+        localNode = new LocalNodeManager({
+            testDir: nodeTestDir,
+            forceRestart: nodeForceRestart,
+            faucetPort: nodeFaucetPort,
+            apiPort: nodeApiPort,
+            readyPort: nodeReadyPort,
+            silent: nodeSilent,
+        });
+        ownsNode = true;
+        nodeInfo = await localNode.start();
+    }
     // Once the node is up, every later step (account creation, funding,
     // runtime init, autoDeploy) is fallible. If any of them throws we
     // must stop the node we just started — otherwise the child process
     // 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 +156,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: {
@@ -183,12 +211,12 @@ async function setupWithLocalNode(options, accountLabels, autoFund, defaultBalan
         logger.plain(`   Accounts: ${Array.from(accountLabels).join(", ")}`);
         logger.plain(`   Balance per account: ${defaultBalance / 100_000_000} MOVE`);
         logger.newline();
-        return { runtime, localNode };
+        return { runtime, localNode, ownsNode };
     }
     catch (error) {
-        // Best-effort cleanup. Swallow the stop() error so the original
-        // setup failure surfaces unchanged.
-        await localNode.stop().catch(() => { });
+        if (ownsNode) {
+            await localNode.stop().catch(() => { });
+        }
         throw error;
     }
 }
@@ -256,8 +284,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 +297,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/helpers/version-check.js

@@ -3,7 +3,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { isNewerVersion } from "./semver-utils.js";
 import { fetchLatestVersion } from "./npm-registry.js";
-import { box, colors, formatCommand } from "../ui/index.js";
+import { box, colors, formatCommand, logger } from "../ui/index.js";
 const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
 const CACHE_DIR = join(homedir(), ".movehat");
 const CACHE_FILE = join(CACHE_DIR, "version-cache.json");
@@ -72,7 +72,9 @@ export function checkForUpdates(currentVersion, packageName) {
             const updateMessage = box(`${colors.brandBright('Update Available!')}\n\n` +
                 `${currentVersion} ${colors.dim('→')} ${colors.success(cache.latestVersion)}\n\n` +
                 `${formatCommand('movehat update')}`, { borderColor: 'warning', padding: 1 });
-            console.error('\n' + updateMessage + '\n');
+            logger.newline();
+            logger.warning(updateMessage);
+            logger.newline();
         }
         // Update cache in background if needed (doesn't block)
         if (!cache || Date.now() - cache.lastChecked > CACHE_DURATION) {

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/node/MoveliteManager.d.ts

@@ -0,0 +1,18 @@
+import type { Account } from "@aptos-labs/ts-sdk";
+import type { LocalNodeInfo } from "./LocalNodeManager.js";
+export declare class MoveliteManager {
+    private process;
+    private port;
+    private killed;
+    private readonly binaryPath;
+    constructor(binaryPath: string, port?: number);
+    start(): Promise<LocalNodeInfo>;
+    private waitForReady;
+    fundAccount(address: string, amount: number): Promise<void>;
+    fundAccounts(accounts: Account[], balance: number): Promise<void>;
+    stop(): Promise<void>;
+    private isPortInUse;
+    isRunning(): boolean;
+    getNodeInfo(): LocalNodeInfo;
+}
+export declare function findMoveliteBinary(): string | null;