Struct DeclaredEditPlan 

pub struct DeclaredEditPlan(/* private fields */);

An EditPlan decoded without materializing any extension member.

Decoding an envelope through EditPlan retains every undeclared member as an owned JSON value at all three levels. That is required to round-trip a plan, and it is the dominant cost of decoding a large multi-file plan. A consumer that only validates or applies a plan never reads those values and should not pay for them.

This wrapper accepts and rejects exactly the documents EditPlan accepts and rejects, with the same error messages, but skips undeclared members structurally instead of building a key and a value tree for each one. The EditPlan it yields has empty extensions at every level.

Extensions are dropped, not hidden

The recovered plan is not round-trippable: re-serializing it emits only declared members. Decode through EditPlan whenever the extension members must survive. Validation is unaffected either way — a reserved member name can never reach an extension map through the wire, because a JSON member spelled like a declared field always binds to that field.

Examples

use weavatrix_edit::DeclaredEditPlan;

let json = r#"{
    "schemaVersion": "weavatrix.edit-plan.v1",
    "operation": "rename_symbol",
    "createdAt": "2026-08-01T12:00:00Z",
    "files": [{
        "path": "src/user.ts",
        "sha256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
        "language": "typescript",
        "edits": [{
            "startLine": 10, "startChar": 8, "endLine": 10, "endChar": 15,
            "before": "getUser", "after": "getCustomer", "provenance": "EXACT_LSP"
        }]
    }]
}"#;

let declared: DeclaredEditPlan = blazingly_json::from_str(json)?;
let plan = declared.into_plan();
assert!(plan.validate().is_ok());
assert!(plan.extensions.is_empty());
assert!(plan.files[0].extensions.is_empty());

Implementations

impl DeclaredEditPlan

pub const fn plan(&self) -> &EditPlan

Borrows the recovered plan.

pub fn into_plan(self) -> EditPlan

Takes the recovered plan, whose extension maps are all empty.

Trait Implementations

impl AsRef<EditPlan> for DeclaredEditPlan

fn as_ref(&self) -> &EditPlan

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for DeclaredEditPlan

fn clone(&self) -> DeclaredEditPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeclaredEditPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DeclaredEditPlan

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DeclaredEditPlan> for EditPlan

fn from(declared: DeclaredEditPlan) -> Self

Converts to this type from the input type.

impl PartialEq for DeclaredEditPlan

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DeclaredEditPlan