Struct EngateSpec 

pub struct EngateSpec {
    pub name: String,
    pub producer: TypePath,
    pub consumer: TypePath,
    pub history_required: bool,
    pub attestation_fixture: Option<String>,
}

Declarative spec for one engate attach point. Authored either by hand in Rust (EngateSpec { ... }) or via tatara-lisp’s (defengate ...) form (M5.1 — #[derive(TataraDomain)] lands when tatara-lisp’s macro story is mature enough to consume this without a manual register() boilerplate dance).

The spec is purely descriptive — it does NOT instantiate the engate machinery (that’s compile-time generics in engate-attach). It serves as:

1. A registry every operator-facing tool can enumerate (mado publishes its engate specs, kenshi publishes its, etc.).
2. The contract substrate’s mkEngateFlake Nix builder reads to generate per-consumer Nix outputs (module trio, attestation fixture verifier, test invocations).
3. The shape the (defengate ...) Lisp form serializes to.

Fields

name: String

Stable identifier for this engate point — used as the JobId subject when wrapped by engate-shigoto.

producer: TypePath

Producer crate + path. e.g. ("tear-client", "tear_client::PaneProducer").

consumer: TypePath

Consumer crate + path. e.g. ("mado", "mado::terminal::Terminal").

history_required: bool

Whether history replay is required. true (the default) = the typestate enforces snapshot-before-render; false = the consumer opts out (rare — only for genuinely stateless producers like a beep channel).

attestation_fixture: Option<String>

Optional attestation fixture path. When present, substrate emits a CI job that runs the engate and asserts the recorded fixture matches.

Trait Implementations

impl Clone for EngateSpec

fn clone(&self) -> EngateSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngateSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EngateSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for EngateSpec

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EngateSpec

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EngateSpec