Compiled products

Compiler outputs carry their own identity.

Hara does not treat compiled bytes as anonymous files. HBC modules, HBC packages and whole-Wasm artifacts share one immutable manifest contract so compiler targets, runtimes and browser hosts can verify exactly what they exchange.

hara.compiled-product.manifest/0-alpha

HBC0hbc-module

HBX0hbc-package

HNW0whole-wasm

SHA-256source, module, options and artifact identities

Product identity

Kind, format and ABI are separate.

Product: hbc-module, hbc-package, whole-wasm
Format: HBC0, HBX0, HNW0
ABI: target-owned version such as hbc0 or hnw0/2
Compiler: versioned compiler-id

Inputs

The manifest records what produced the bytes.

Source: source-digest
Modules: module-digests
Options: options-digest
Compiler: compiler-id

Output proof

The bytes are self-verifiable.

artifact-digest and artifact-bytes are checked against the actual payload. A cache refuses a product whose recorded size or digest no longer matches its bytes.

Whole-Wasm additions

Host-facing Wasm metadata is explicit.

Whole-Wasm manifests additionally expose the stable hara_entry entrypoint, hara_error and hara_heap globals, and the hara import module expected by the host.

Cache identity

Reuse is a function of exact compiler inputs.

ProductCacheKey contains the product kind, source digest, module digests, compiler ID, ABI version and options digest. Two products with the same source bytes but different target kinds or module dependencies therefore occupy different cache identities.

Manifest, verification and cache keycore/rust/src/compiled_product.rs Compiler target constructioncore/rust/compiler/src/lib.rs

HBC module

The canonical compiled program.

The ordinary source compiler produces HbcModule first. Its HBC bytes are executable by VM hosts and also become a recorded module dependency when the same source is packaged as whole-Wasm.

HBC package

A package product has its own format identity.

HbcPackage is represented as HBX0 in the shared compiled-product layer. It is distinct from a single HbcModule even though both are bytecode-family products.

Whole-Wasm

A Wasm host product built from HBC.

WholeWasm records the digest of its HBC module input. That provenance is what lets a build system prove that the Wasm artifact and the canonical Hara bytecode came from the same source compilation.

Foreign Wasm package

Bindgen uses a different product family.

The Wasm binding generator packages an existing foreign .wasm module from a semantic interface. It does not turn that module into an HBC compiled product. Keep compiled Hara products and foreign-Wasm binding packages separate when reasoning about provenance.

Wasm binding guide

Start with the compiler stack, then inspect product identity.

The stack guide explains how source becomes HBC and whole-Wasm. This page explains the immutable manifest wrapped around those bytes.

Source-language pipelineCompiler stack Authoritative implementationCompiledProductManifest