Module embedded 

The modules baked into the binary, as a list a caller outside this crate can read.

The host needs the embedded sources as two tables keyed by require name — that is what crate::host holds them as, and it is the only shape the require registry wants. A tool that writes one of them to disk needs something else: the whole set, each entry knowing which directory it belongs in and what its source is. Exposing the host’s constants would answer that by handing out the registry’s internals; this module answers it with one list and nothing else.

agent-block vendor is the caller. It expands an entry into a project’s .agent-block/ directory, which is the first tier both lookups search (see crate::host::lib_roots / crate::host::block_roots), so the copy is what the project resolves from then on.

Two things are deliberately not here. knl_types is embedded but generated at start from the Rust syscall surface, so it has no static source to hand out — and it is sealed, so the only correct answer to a request for it is the refusal is_sealed produces. And nothing here writes: what a copy should say at the top of it, and where it may land, belong to the tool doing the writing, not to the list.

Structs

Entry

One embedded module: the name require resolves, which kind it is, and the Lua source compiled into the binary.

Enums

Kind

Which of the host’s two embedded lists an entry came from.

Functions

entries

Every embedded entry: the blocks first, then the modules, each in the order the binary lists them.

find

The entry named name, if the binary carries one.

is_sealed

Whether name is a module a project may not shadow — the kernel, its declaration layer, and the lshape those are written in.