Module resolvers 

Resolver implementations: leaves and combinators.

Leaf Resolvers

Terminal resolvers that directly produce values.

Resolver	Source	Match condition	Use case
MemoryResolver	HashMap<String, String>	Name is registered	include_str! embedding, preload
NativeResolver	Fn(&Lua) -> Result<Value>	Name is registered	Build tables from Rust (@std/*, etc.)
FsResolver	Filesystem	File exists	Sandboxed, init.lua fallback
AssetResolver	Filesystem	Known extension + file exists	Auto-convert non-Lua resources (JSON->Table, etc.)

Combinators

Resolvers that compose other Resolvers. Since they implement the Resolver trait, they can be added to a Registry just like leaves, and combinators can nest.

Combinator	Behavior	Use case
PrefixResolver	"prefix.rest" -> strip prefix -> delegate to inner Resolver	Namespace mounting

Composition patterns

Registry (Chain)
+- NativeResolver                 @std/http  -> Rust factory
+- PrefixResolver("game", ...)    game.xxx   -> delegate to inner Resolver
|   +- FsResolver(game_dir/)      xxx        -> game_dir/xxx.lua
+- FsResolver(scripts/)           game       -> scripts/game/init.lua
|                                  lib.utils  -> scripts/lib/utils.lua
+- AssetResolver(assets/)         config.json -> JSON parse -> Table

PrefixResolver acts as a namespace mount point. require("game") (init.lua) is handled by the outer FsResolver, while require("game.engine") is handled by PrefixResolver. Responsibilities are clearly separated.

Structs

AssetResolver

Resolver that registers parsers by extension and auto-converts non-Lua resources.

FsResolver

Sandboxed filesystem Resolver.

MemoryResolver

Resolver that holds Lua source strings in memory.

NativeResolver

Resolver that builds Lua Values directly from Rust functions.

PrefixResolver

Combinator that routes to an inner Resolver by name prefix.

Functions

json_parser

JSON -> Lua Table parser.

text_parser

Text -> Lua String parser.