Struct KernelManifest 

#[non_exhaustive]
pub struct KernelManifest {
    pub name: String,
    pub version: String,
    pub sm_version: u32,
    pub digest: [u8; 32],
    pub signature: [u8; 32],
    pub published_unix_ms: u64,
    pub publisher: String,
    pub launch_geometry: Option<(u32, u32)>,
}

Signed kernel manifest. Cargo for vetted PTX.

Marked #[non_exhaustive] so future revisions can add fields without breaking downstream pattern-matching consumers. Construct instances via KernelManifest::new from outside this crate (the non_exhaustive attribute disallows struct-literal construction from foreign crates).

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

Stable name (e.g. "matmul.f32").

version: String

SemVer-style version ("1.0.0").

sm_version: u32

Compute capability the PTX was built for (e.g. 80 for sm_80).

digest: [u8; 32]

BLAKE3 hash of the PTX text. Content-addresses the artifact.

signature: [u8; 32]

HMAC-SHA256 tag computed over the canonical signed-bytes of this manifest — see the module-level docstring for the exact envelope layout (v2). Covers name, version, publisher, published_unix_ms, sm_version, and digest.

The tag is PUBLIC by design. It authenticates the manifest’s authorship (i.e. proves the holder of the publishing HMAC key produced it) but is NOT a private signature in the asymmetric-crypto sense and MUST NOT be treated as a secret. KernelManifest deliberately derives Serialize / Deserialize and the field is pub so the tag travels with the manifest over the wire and through storage — that is the intended, audited behaviour, not an oversight.

What IS a secret is the HMAC key used to compute the tag (the publisher’s signing key); see sign_manifest. Leaking the signing key — not the tag — is what would let an attacker forge manifests.

published_unix_ms: u64

Wall-clock publish timestamp (Unix millis). Covered by the v2 signature envelope — tampering with this field invalidates the signature.

publisher: String

Publisher identifier (typically a tenant id or signing-key id). Covered by the v2 signature envelope — tampering with this field invalidates the signature.

launch_geometry: Option<(u32, u32)>

Optional launch geometry hint (grid_size, block_size) the kernel expects, mirroring EmittedPtx::launch_geometry on the freshly-emitted path. Used by the JIT L3 registry-promotion path (KernelCache::get_with_registry_fallback) to populate the promoted L1 entry’s geometry instead of falling back to (0, 0).

Deliberately NOT covered by the v2 signature envelope. Launch geometry is an advisory launch hint, not a security boundary — the PTX content itself is authenticated by digest (and transitively by the signature, which binds digest). Folding geometry into KernelManifest::canonical_signed_bytes would invalidate every previously-signed twasm-kmf-v2 blob (a magic bump to -v3 plus a dual-version verify path) for no security gain, so it is carried as an unsigned hint instead. A bad actor who could rewrite this field could at worst mis-hint a launch grid for a kernel whose code is already separately authenticated.

#[serde(default)] makes manifests serialized before this field existed deserialize cleanly (the field reads back as None), so older on-disk blobs and wire payloads remain forward-compatible.

Implementations

impl KernelManifest

pub fn new( name: String, version: String, sm_version: u32, digest: [u8; 32], signature: [u8; 32], published_unix_ms: u64, publisher: String, ) -> Self

Construct a manifest from its component fields.

KernelManifest is #[non_exhaustive], so foreign crates cannot build one via a struct literal — they must go through this constructor. The signature field is typically left as [0u8; 32] here and filled in afterwards by sign_manifest, because the publisher’s HMAC key is what produces the signature value.

The optional launch_geometry hint defaults to None; publishers that know the kernel’s grid/block geometry chain Self::with_launch_geometry after this constructor to set it. Keeping this signature stable (geometry is set via the builder, not a new positional argument) is intentional so the cross-crate callers in tensor-wasm-cli / tensor-wasm-api and the integration tests keep compiling unchanged.

pub fn with_launch_geometry(self, launch_geometry: Option<(u32, u32)>) -> Self

Builder: attach an optional launch-geometry hint (grid_size, block_size) to this manifest and return it.

This is the publisher-facing way to populate the KernelManifest::launch_geometry field without widening KernelManifest::new’s signature. Because geometry is carried as an unsigned hint (see the field docs), this may be called either before or after sign_manifest without affecting signature verification — the canonical signed bytes do not include it. Pass None to explicitly clear any previously-set hint.

pub fn digest_as_u64(&self) -> u64

First 8 bytes of digest interpreted as a little-endian u64. Used as the synthetic fingerprint field on the CachedKernel that the registry path promotes into L1.

Trait Implementations

impl Clone for KernelManifest

fn clone(&self) -> KernelManifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KernelManifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KernelManifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for KernelManifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.