movehat 0.2.7 → 0.2.8

package/dist/cli.js

@@ -66,7 +66,7 @@ program
 });
 program
     .command('compile')
-    .description('Compile Move smart contracts using Movement CLI')
+    .description('Compile Move smart contracts (auto-detects named addresses and updates Move.toml)')
     .action(compileCommand);
 program
     .command('run <script>')

package/dist/commands/fork/fund.js

@@ -34,9 +34,11 @@ export default async function forkFundCommand(options) {
         // Verify
         const resourceType = `0x1::coin::CoinStore<${coinType}>`;
         const coinStore = await forkManager.getResource(options.account, resourceType);
+        const { assertCoinStore } = await import('../../fork/validation.js');
+        const validated = assertCoinStore(coinStore);
         logger.newline();
         logger.success("Account funded successfully!");
-        logger.plain(`   New balance: ${coinStore.coin.value}`);
+        logger.plain(`   New balance: ${validated.coin.value}`);
         logger.newline();
     }
     catch (error) {

package/dist/commands/fork/serve.js

@@ -2,6 +2,7 @@ import { join } from 'path';
 import { existsSync } from 'fs';
 import { loadUserConfig } from '../../core/config.js';
 import { ForkServer } from '../../fork/server.js';
+import { logger } from '../../ui/index.js';
 /**
  * Fork serve command: Start a local RPC server serving the fork
  */
@@ -26,9 +27,11 @@ export default async function forkServeCommand(options) {
         }
         // Verify fork exists
         if (!existsSync(join(forkPath, 'metadata.json'))) {
-            console.error(`\nError: Fork not found at ${forkPath}`);
-            console.error(`\nCreate a fork first with:`);
-            console.error(`  movehat fork create --network <network> --name <name>`);
+            logger.newline();
+            logger.error(`Fork not found at ${forkPath}`);
+            logger.newline();
+            logger.error("Create a fork first with:");
+            logger.error("  movehat fork create --network <network> --name <name>");
             process.exit(1);
         }
         // Get port (already validated by Commander's parsePort in cli.ts)
@@ -38,7 +41,8 @@ export default async function forkServeCommand(options) {
         const server = new ForkServer(forkPath, port, host);
         // Handle graceful shutdown (use 'once' to prevent duplicate shutdowns)
         const shutdown = async () => {
-            console.log('\n\nShutting down...');
+            logger.newline();
+            logger.step("Shutting down...");
             await server.stop();
             process.exit(0);
         };
@@ -59,7 +63,8 @@ export default async function forkServeCommand(options) {
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        console.error(`\nError starting fork server:`, msg);
+        logger.newline();
+        logger.error(`Error starting fork server: ${msg}`);
         process.exit(1);
     }
 }

package/dist/commands/test-move.js

@@ -1,7 +1,9 @@
 import { runMoveTests } from "../helpers/move-tests.js";
+import { logger } from "../ui/index.js";
 export default async function testMoveCommand(options = {}) {
     try {
-        console.log("Running Move unit tests...\n");
+        logger.step("Running Move unit tests...");
+        logger.newline();
         await runMoveTests({
             filter: options.filter,
             ignoreWarnings: options.ignoreWarnings,
@@ -10,10 +12,11 @@ export default async function testMoveCommand(options = {}) {
         process.exit(0);
     }
     catch (err) {
-        console.error("\n✗ Move tests failed");
+        logger.newline();
+        logger.error("Move tests failed");
         const msg = err instanceof Error ? err.message : String(err);
         if (msg) {
-            console.error(`   ${msg}`);
+            logger.error(`   ${msg}`);
         }
         process.exit(1);
     }

package/dist/fork/api.d.ts

@@ -55,7 +55,7 @@ export declare class MovementApiClient {
     /**
      * Get a specific account resource
      */
-    getAccountResource(address: string, resourceType: string): Promise<any>;
+    getAccountResource(address: string, resourceType: string): Promise<AccountResource>;
     /**
      * Get all resources for an account
      */

package/dist/fork/api.js

@@ -2,6 +2,7 @@ import https from 'https';
 import http from 'http';
 import { URL } from 'url';
 import { normalizeAddressShort } from '../utils/address.js';
+import { assertLedgerInfo, assertAccountData, assertAccountResource, assertAccountResourceArray, } from './validation.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_BYTES = 16 * 1024 * 1024;
 /**
@@ -191,14 +192,16 @@ export class MovementApiClient {
      * Get ledger information
      */
     async getLedgerInfo() {
-        return this.get(this.apiPath('/'));
+        const raw = await this.get(this.apiPath('/'));
+        return assertLedgerInfo(raw);
     }
     /**
      * Get account information
      */
     async getAccount(address) {
         const normalizedAddress = normalizeAddressShort(address);
-        return this.get(this.apiPath(`/accounts/${normalizedAddress}`));
+        const raw = await this.get(this.apiPath(`/accounts/${normalizedAddress}`));
+        return assertAccountData(raw);
     }
     /**
      * Get a specific account resource
@@ -207,14 +210,16 @@ export class MovementApiClient {
         const normalizedAddress = normalizeAddressShort(address);
         // URL encode the resource type
         const encodedType = encodeURIComponent(resourceType);
-        return this.get(this.apiPath(`/accounts/${normalizedAddress}/resource/${encodedType}`));
+        const raw = await this.get(this.apiPath(`/accounts/${normalizedAddress}/resource/${encodedType}`));
+        return assertAccountResource(raw);
     }
     /**
      * Get all resources for an account
      */
     async getAccountResources(address) {
         const normalizedAddress = normalizeAddressShort(address);
-        return this.get(this.apiPath(`/accounts/${normalizedAddress}/resources`));
+        const raw = await this.get(this.apiPath(`/accounts/${normalizedAddress}/resources`));
+        return assertAccountResourceArray(raw);
     }
     /**
      * Execute a Move view function via the upstream node's POST /v1/view.

package/dist/fork/manager.d.ts

@@ -36,8 +36,8 @@ export declare class ForkManager {
     load(): void;
     getMetadata(): ForkMetadata;
     getAccount(address: string): Promise<AccountState>;
-    getResource(address: string, resourceType: string): Promise<any>;
-    getAllResources(address: string): Promise<Record<string, any>>;
+    getResource(address: string, resourceType: string): Promise<unknown>;
+    getAllResources(address: string): Promise<Record<string, unknown>>;
     /**
      * Stateless passthrough of `POST /v1/view` to the upstream RPC.
      *

package/dist/fork/manager.js

@@ -3,6 +3,7 @@ import { MovementApiClient } from './api.js';
 import { ForkStorage } from './storage.js';
 import { normalizeAddress } from '../utils/address.js';
 import { logger } from '../ui/index.js';
+import { assertCoinStore } from './validation.js';
 /**
  * Derive a deterministic 32-byte hex placeholder for the `authentication_key`
  * of a fork-funded account. The real auth_key is `sha3_256(public_key || 0x00)`
@@ -182,17 +183,12 @@ export class ForkManager {
     async fundAccount(address, amount, coinType = '0x1::aptos_coin::AptosCoin') {
         const normalizedAddress = normalizeAddress(address);
         const resourceType = `0x1::coin::CoinStore<${coinType}>`;
-        // Try to get existing coin store. The coin store is a CoinStore<T>
-        // resource whose `data` is Movement-side untyped JSON; we shape it
-        // locally as a structural object with `coin.value: string`.
-        // any: full CoinStore schema lives at the Movement REST boundary —
-        // proper validation deferred to the boundary-validation follow-up of #57.
         let coinStore;
         try {
-            coinStore = await this.getResource(normalizedAddress, resourceType);
+            const raw = await this.getResource(normalizedAddress, resourceType);
+            coinStore = assertCoinStore(raw);
         }
         catch (error) {
-            // Only catch "not found" errors, rethrow others (network, API, etc.)
             const msg = error instanceof Error ? error.message : String(error);
             if (!msg.includes('not found')) {
                 throw error;
@@ -220,7 +216,7 @@ export class ForkManager {
                 frozen: false,
             };
         }
-        const currentBalance = BigInt(coinStore.coin.value ?? '0');
+        const currentBalance = BigInt(coinStore.coin.value);
         const newBalance = currentBalance + BigInt(amount);
         coinStore.coin.value = newBalance.toString();
         await this.setResource(normalizedAddress, resourceType, coinStore);

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,6 +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";
@@ -50,12 +50,13 @@ export declare class Harness {
      */
     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

@@ -54,10 +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)
@@ -81,6 +83,7 @@ export class Harness {
         const init = {
             mode: "local",
             runtime: ctx.runtime,
+            ownsLocalNode: !options.localNode,
         };
         if (ctx.localNode)
             init.localNode = ctx.localNode;
@@ -156,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/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,21 +100,41 @@ 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
@@ -188,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;
     }
 }

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/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;

package/dist/node/MoveliteManager.js

@@ -0,0 +1,152 @@
+import { execSync, spawn } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { createRequire } from "module";
+import { logger } from "../ui/index.js";
+export class MoveliteManager {
+    process = null;
+    port;
+    killed = false;
+    binaryPath;
+    constructor(binaryPath, port = 8090) {
+        this.binaryPath = binaryPath;
+        this.port = port;
+    }
+    async start() {
+        const binary = this.binaryPath;
+        if (!binary) {
+            throw new Error("movelite binary not found");
+        }
+        if (await this.isPortInUse(this.port)) {
+            this.port = this.port + 1;
+            if (await this.isPortInUse(this.port)) {
+                throw new Error(`Ports ${this.port - 1} and ${this.port} are in use`);
+            }
+        }
+        logger.step("Starting movelite...");
+        this.process = spawn(binary, ["start", "--port", String(this.port), "--no-auth"], {
+            stdio: "pipe",
+            detached: false,
+        });
+        this.process.on("exit", () => {
+            this.process = null;
+        });
+        await this.waitForReady();
+        logger.success(`movelite ready on port ${this.port}`);
+        return this.getNodeInfo();
+    }
+    async waitForReady() {
+        const url = `http://127.0.0.1:${this.port}/v1`;
+        const timeout = 15_000;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            try {
+                const res = await fetch(url);
+                if (res.ok)
+                    return;
+            }
+            catch {
+                // not ready yet
+            }
+            await new Promise((r) => setTimeout(r, 200));
+        }
+        throw new Error(`movelite did not become ready within ${timeout}ms`);
+    }
+    async fundAccount(address, amount) {
+        const res = await fetch(`http://127.0.0.1:${this.port}/mint?address=${address}&amount=${amount}`, { method: "POST" });
+        if (!res.ok) {
+            throw new Error(`Failed to fund account: ${res.status}`);
+        }
+    }
+    async fundAccounts(accounts, balance) {
+        for (const account of accounts) {
+            await this.fundAccount(account.accountAddress.toString(), balance);
+        }
+    }
+    async stop() {
+        if (!this.process || this.killed)
+            return;
+        this.killed = true;
+        this.process.kill("SIGTERM");
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (this.process)
+                    this.process.kill("SIGKILL");
+                resolve();
+            }, 5_000);
+            if (this.process) {
+                this.process.on("exit", () => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            }
+            else {
+                clearTimeout(timer);
+                resolve();
+            }
+        });
+        this.process = null;
+    }
+    async isPortInUse(port) {
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}/v1`);
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    isRunning() {
+        return this.process !== null && !this.killed;
+    }
+    getNodeInfo() {
+        return {
+            rpcUrl: `http://127.0.0.1:${this.port}`,
+            faucetUrl: `http://127.0.0.1:${this.port}`,
+            readyUrl: `http://127.0.0.1:${this.port}/v1`,
+            testDir: "",
+        };
+    }
+}
+export function findMoveliteBinary() {
+    if (process.env.MOVELITE_PATH) {
+        return existsSync(process.env.MOVELITE_PATH)
+            ? process.env.MOVELITE_PATH
+            : null;
+    }
+    const platforms = {
+        "darwin-arm64": "movelite-darwin-arm64",
+        "darwin-x64": "movelite-darwin-x64",
+        "linux-x64": "movelite-linux-x64",
+        "linux-arm64": "movelite-linux-arm64",
+    };
+    const key = `${process.platform}-${process.arch}`;
+    const pkg = platforms[key];
+    if (pkg) {
+        try {
+            // Resolve through the `movelite` shim (movehat's direct dependency),
+            // then resolve the platform package from movelite's own context. The
+            // platform package is movelite's dependency, not movehat's, so a direct
+            // resolve from here fails under pnpm/yarn strict layouts.
+            const req = createRequire(import.meta.url);
+            const movelitePkg = req.resolve("movelite/package.json");
+            const moveliteReq = createRequire(movelitePkg);
+            const pkgPath = moveliteReq.resolve(`${pkg}/package.json`);
+            const binPath = join(pkgPath, "..", "bin", "movelite");
+            if (existsSync(binPath))
+                return binPath;
+        }
+        catch {
+            // package not installed
+        }
+    }
+    try {
+        const found = execSync("which movelite", { encoding: "utf-8" }).trim();
+        if (found && existsSync(found))
+            return found;
+    }
+    catch {
+        // not in PATH
+    }
+    return null;
+}

package/dist/node/NodeProvider.d.ts

@@ -0,0 +1,9 @@
+import type { Account } from "@aptos-labs/ts-sdk";
+import type { LocalNodeInfo } from "./LocalNodeManager.js";
+export interface NodeProvider {
+    start(): Promise<LocalNodeInfo>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    getNodeInfo(): LocalNodeInfo;
+    fundAccounts(accounts: Account[], balance: number): Promise<void>;
+}

package/dist/node/NodeProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/templates/.mocharc.json

@@ -2,6 +2,7 @@
   "node-option": ["import=tsx"],
   "extensions": ["ts"],
   "spec": ["tests/**/*.test.ts"],
+  "require": ["tests/setup.ts"],
   "timeout": 30000,
   "color": true,
   "reporter": "spec"

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

@@ -2,6 +2,7 @@
 import { describe, it, before, after } from "mocha";
 import { expect } from "chai";
 import { Harness } from "movehat";
+import { getSharedNode } from "./setup.js";
 
 describe("Counter Contract", () => {
   let harness;
@@ -9,16 +10,12 @@ describe("Counter Contract", () => {
   let deployer, alice, bob;
 
   before(async function () {
-    this.timeout(60000); // Allow time for local node startup + deployment
-
-    // Hardhat-style Harness — the primary public API.
-    // createLocal spins up a Movement local node, funds the labeled
-    // accounts from the local faucet, and (via autoDeploy) builds +
-    // publishes the named modules so they're ready to use.
-    //
-    // The setupTestFixture helper still works if you prefer the older
-    // pattern; see `import { setupTestFixture } from "movehat/helpers"`.
+    this.timeout(60000);
+
+    // Reuses the shared Movement node started by root hooks (tests/setup.ts).
+    // Each spec still gets its own accounts + deployments for isolation.
     harness = await Harness.createLocal({
+      localNode: getSharedNode(),
       accountLabels: ["deployer", "alice", "bob"],
       autoDeploy: ["counter"],
     });

package/dist/templates/tests/setup.ts

@@ -0,0 +1,34 @@
+// @ts-nocheck - This is a template file, dependencies are installed in user projects
+import { LocalNodeManager } from "movehat/helpers";
+
+let sharedNode;
+
+/**
+ * Returns the shared local Movement node started by root hooks.
+ * Pass the result as `{ localNode: getSharedNode() }` to
+ * Harness.createLocal() or setupTestFixture().
+ */
+export function getSharedNode() {
+  if (!sharedNode || !sharedNode.isRunning()) {
+    throw new Error(
+      "Shared node not available. " +
+        'Ensure tests/setup.ts is listed in .mocharc.json under "require".'
+    );
+  }
+  return sharedNode;
+}
+
+export const mochaHooks = {
+  async beforeAll() {
+    this.timeout(60000);
+    sharedNode = new LocalNodeManager({ forceRestart: true });
+    await sharedNode.start();
+  },
+
+  async afterAll() {
+    if (sharedNode) {
+      await sharedNode.stop();
+      sharedNode = undefined;
+    }
+  },
+};

package/dist/types/config.d.ts

@@ -41,6 +41,8 @@ export type LocalTestingMode = 'local-node' | 'fork';
  */
 export interface LocalTestOptions {
     mode?: LocalTestingMode;
+    localNode?: import("../node/LocalNodeManager.js").LocalNodeManager;
+    useMovelite?: boolean;
     nodeTestDir?: string;
     nodeForceRestart?: boolean;
     nodeFaucetPort?: number;

package/dist/types/fork.d.ts

@@ -40,3 +40,27 @@ export interface AccountResource {
      */
     data: unknown;
 }
+export interface CoinStore {
+    coin: {
+        value: string;
+    };
+    deposit_events: {
+        counter: string;
+        guid: {
+            id: {
+                addr: string;
+                creation_num: string;
+            };
+        };
+    };
+    withdraw_events: {
+        counter: string;
+        guid: {
+            id: {
+                addr: string;
+                creation_num: string;
+            };
+        };
+    };
+    frozen: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "movehat",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "type": "module",
   "description": "Hardhat-like development framework for Movement L1 smart contracts",
   "bin": {
@@ -70,6 +70,9 @@
     "prompts": "^2.4.2",
     "tsx": "^4.7.0"
   },
+  "optionalDependencies": {
+    "movelite": "^0.1.0"
+  },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.10.1",