Struct CacheKey 

pub struct CacheKey {
    pub source_hash: [u8; 32],
    pub context_hash: [u8; 32],
    pub harn_version: Cow<'static, str>,
    pub compiler_tag: u8,
    pub provenance: ModuleProvenance,
}

Cache key components for a single pipeline source. Equality of all fields is necessary and sufficient for cache reuse.

Fields

source_hash: [u8; 32]

context_hash: [u8; 32]

harn_version: Cow<'static, str>

Harn version stamped into, and required by, this artifact’s header.

Normally the running binary’s own HARN_VERSION. Release preparation bumps Cargo.toml after snapshotting the generator, so that one caller must stamp the version the shipped binary will report instead of the version the generator was built at — otherwise the shipped runtime rejects its own embedded payload and silently falls back to source compilation. Use CacheKey::for_artifact_version.

compiler_tag: u8

Compact tag for active CompilerOptions. Flipping HARN_DISABLE_OPTIMIZATIONS between runs would otherwise reuse a chunk compiled under the wrong setting.

provenance: ModuleProvenance

The authority the artifact was compiled under.

Part of the identity because it selects what the emitted bytecode is permitted to do: the same source compiled as ModuleProvenance::TrustedHostDispatch may call privileged builtins that the same source compiled as ModuleProvenance::User may not. Two compiles that differ in that are not one artifact, and compiler_tag cannot express the difference — it folds only the optimization and legacy-ambient bits, never privileged_wire_authority. Without this field they collide on one key and one filename.

Implementations

impl CacheKey

pub fn from_source(source_path: &Path, source: &str) -> Self

Compute the cache key for a .harn source file plus its transitive user imports. source is the entry-file contents; the import graph is walked from disk relative to source_path.

pub fn from_relocatable_source(source_path: &Path, source: &str) -> Self

Compute a relocatable entry-chunk key for a closed source tree.

Unlike Self::from_source, the dependency graph identifies files by their path relative to the entrypoint directory. Moving the complete tree therefore preserves the key, while changing a relative path, source byte, compiler build, or embedded stdlib still invalidates it. This is the key used by packaged adjacent artifacts; ordinary shared cache entries remain anchored to canonical host paths.

pub fn for_artifact_version(self, harn_version: impl Into<String>) -> Self

Restamp this key for an artifact that a different Harn version will load. Only release preparation needs this; every ordinary compile and lookup keeps the running binary’s own version.

pub fn from_module_source( source: &ModuleSource, compilation_context: &ModuleCompilationContext, provenance: ModuleProvenance, ) -> Self

Compute the cache key for one independently-compiled module artifact.

A ModuleArtifact stores unresolved import specs and never compiles dependency bodies into the parent artifact. Its lowering can still depend on the imported interface supplied explicitly here; every dependency body remains protected by its own source-local key. Diagnostic paths are rebound when the artifact is loaded, so adjacent and packaged artifacts remain relocatable without aliasing attribution.

pub fn from_module_content_hash( content_hash: [u8; 32], compilation_context: &ModuleCompilationContext, provenance: ModuleProvenance, ) -> Self

As from_module_source, but from a digest recorded earlier instead of bytes in hand.

The source digest and typed imported interface are the graph-local parts of a module key. A validated GraphLinkTable carries both so it can name an artifact without reading the file or rebuilding the graph.

pub fn from_embedded_stdlib_module_content_hash( content_hash: [u8; 32], provenance: ModuleProvenance, ) -> Self

Identity for an embedded stdlib module artifact, derived without parsing the module.

Every input to a stdlib module’s imported interface is already part of this key: its own bytes as content_hash, and the rest of the closure it can import as the embedded stdlib table, whose [embedded_stdlib_digest] every module key’s context hash folds in. The interface digest adds no discriminating power here, while deriving it costs a full lex and parse in front of the lookup that exists to avoid one. User files keep the real digest: their dependencies are mutable files no other field of the key can see, which is the aliasing that field was added to prevent.

pub fn filename(&self) -> String

Entry-chunk filename for this key. We hash by source content alone so two invocations of the same source from different paths share a cache entry; the header’s compilation-context hash still gates reuse on a per-load basis.

pub fn module_filename(&self) -> String

Module-artifact filename for this complete compilation key. Diagnostic source paths are rebound at load time, so identical source and compiler inputs share one relocatable artifact across paths.

Trait Implementations

impl Clone for CacheKey

fn clone(&self) -> CacheKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheKey

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

Formats the value using the given formatter.

impl Eq for CacheKey

impl PartialEq for CacheKey

fn eq(&self, other: &CacheKey) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CacheKey