Struct OrgPolicyV1 

pub struct OrgPolicyV1 {
    pub schema_version: u32,
    pub kind: String,
    pub org: String,
    pub policy_version: String,
    pub issued_at: String,
    pub enforced: bool,
    pub pack_toml: String,
    pub signer_public_key: Option<String>,
    pub signature: Option<String>,
}

A signed, centrally distributed org policy.

signature / signer_public_key are excluded from the signed payload (set to None while computing the canonical bytes), exactly like the other signed artifacts in the engine.

Fields

schema_version: u32

kind: String

Discriminator so a verifier can refuse unrelated signed JSON.

org: String

Organisation identifier (acme) — also selects the signing key.

policy_version: String

Admin-set distribution version (2026.06.1) — lets a client see which rollout it currently holds (independent of the pack’s own version).

issued_at: String

When the admin signed this rollout (RFC 3339).

enforced: bool

When true, a client that has pinned this org’s key MUST apply the pack as a floor (the runtime does; this flag is the admin’s declared intent and is surfaced by policy org status).

pack_toml: String

The authoritative pack source (verbatim TOML). Re-parsed + re-validated client-side, so the body cannot be swapped without breaking validation.

signer_public_key: Option<String>

Ed25519 public key of the signing org key (hex). None until signed.

signature: Option<String>

Ed25519 signature over the canonical bytes (hex). None until signed.

Implementations

impl OrgPolicyV1

pub fn build( org: &str, policy_version: &str, enforced: bool, pack_toml: &str, ) -> Result<Self, PolicyError>

Build an unsigned artifact from an authored pack source. The TOML is parsed + validated + resolved up front so an admin never distributes a pack that would be rejected on the endpoint.

pub fn pack(&self) -> Result<PolicyPack, PolicyError>

The wrapped pack, re-parsed and validated from pack_toml.

pub fn resolved(&self) -> Result<ResolvedPolicy, PolicyError>

The wrapped pack, fully resolved (its extends chain folded in).

pub fn canonical_bytes(&self) -> Result<Vec<u8>, String>

Deterministic bytes that get signed/verified: the whole struct with the two signature fields cleared. Identical on sign and verify.

pub fn sign(&mut self) -> Result<(), String>

Sign with the org signing key from the keystore (created on first use).

pub fn sign_with_key(&mut self, key: &SigningKey)

Sign with an explicit key (used by sign and by hermetic tests). The public key is embedded so the artifact is self-verifying.

pub fn verify(&self) -> OrgVerifyResult

Verify the embedded signature against the embedded public key — offline, no audit trail, no network. A failure means the artifact was altered or was never validly signed. Trust (is this key ours?) is a separate check in super::trust.

pub fn to_json(&self) -> Result<String, String>

Serialize to the pretty JSON artifact written to disk / distributed.

pub fn from_json(text: &str) -> Result<Self, String>

Parse an artifact, rejecting unrelated JSON by kind.

Trait Implementations

impl Clone for OrgPolicyV1

fn clone(&self) -> OrgPolicyV1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrgPolicyV1

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OrgPolicyV1

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OrgPolicyV1

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for OrgPolicyV1

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 OrgPolicyV1