Struct NativeRuntime 

pub struct NativeRuntime;

Native filesystem Runtime implementation using std::fs.

This implementation provides async wrappers around synchronous std::fs operations using tokio’s spawn_blocking to avoid blocking the async runtime.

Educational Note: Async File I/O

Standard library file operations are blocking (they wait for the OS). To use them in async code without blocking the executor, we run them in a separate thread pool using tokio::task::spawn_blocking.

Example

use crate::runtime::native::NativeRuntime;
use crate::runtime::Runtime;

let runtime = NativeRuntime;
let content = runtime.read_file(Path::new("file.txt")).await?;

Implementations

impl NativeRuntime

pub fn new() -> NativeRuntime

Create a new NativeRuntime instance.

Trait Implementations

impl Clone for NativeRuntime

fn clone(&self) -> NativeRuntime

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for NativeRuntime

impl Debug for NativeRuntime

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for NativeRuntime

fn default() -> NativeRuntime

Returns the “default value” for a type.

impl Runtime for NativeRuntime

fn read_file<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, RuntimeError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NativeRuntime: 'async_trait,

Read a file from the native filesystem.

Educational Note: spawn_blocking

std::fs::read is a blocking operation that waits for disk I/O. We use spawn_blocking to run it in a dedicated thread pool, preventing it from blocking async tasks.

fn write_file<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 Path, content: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, NativeRuntime: 'async_trait,

Write a file to the native filesystem.

fn metadata<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<FileMetadata, RuntimeError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NativeRuntime: 'async_trait,

Get file metadata from the native filesystem.

fn exists(&self, path: &Path) -> bool

Check if a path exists on the native filesystem.

Educational Note: Synchronous Methods

This method is synchronous in the trait (no async), so we can call std::path::Path::exists() directly without spawn_blocking. It’s a quick metadata check that won’t block significantly.

fn resolve(&self, specifier: &str, from: &Path) -> Result<PathBuf, RuntimeError>

Resolve a module specifier on the native filesystem.

Educational Note: Path Resolution

This handles relative and absolute path resolution. For bare specifiers (like “lodash”), the bundler’s node resolution logic will handle them separately.

fn create_dir<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, recursive: bool, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NativeRuntime: 'async_trait,

Create a directory on the native filesystem.

fn remove_file<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NativeRuntime: 'async_trait,

Remove a file from the native filesystem.

fn read_dir<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RuntimeError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NativeRuntime: 'async_trait,

Read directory contents from the native filesystem.

fn get_cwd(&self) -> Result<PathBuf, RuntimeError>

Get the current working directory from the operating system.

Educational Note: OS Working Directory

Delegates to std::env::current_dir() to get the actual OS-level current working directory. This method abstracts the OS call behind the Runtime trait, enabling platform-agnostic code.