Struct UpdateEntityArgs 

pub struct UpdateEntityArgs {
    pub id: EntityId,
    pub expected_hash: Option<String>,
    pub sections: IndexMap<String, String>,
    pub append_sections: IndexMap<String, String>,
    pub patch_sections: IndexMap<String, PatchArg>,
    pub metadata: IndexMap<String, String>,
    pub metadata_unset: Vec<String>,
    pub dry_run: bool,
    pub declare_relations: Vec<RelateArg>,
    pub anchors: Vec<AnchorInput>,
    pub anchors_unset: Vec<AnchorUnsetInput>,
    pub relations_unset: Vec<RelationUnsetArg>,
}

Arguments for [Engine::update_entity].

Fields

id: EntityId

expected_hash: Option<String>

Optimistic locking. None skips the check.

sections: IndexMap<String, String>

Section keys whose body should be replaced wholesale. Empty values overwrite with empty content.

append_sections: IndexMap<String, String>

Section keys whose body should be appended to. Existing body gets a \n separator before the append; empty/absent body is replaced wholesale with the append value (parity with full’s append-on-empty behaviour). The same key may not appear in both sections and append_sections; conflict is rejected with [EngineError::ConflictingSectionModes].

patch_sections: IndexMap<String, PatchArg>

Section keys whose body should be patched via find-and- replace. Each value is a crate::ops::PatchArg with old, new, and all (replace every occurrence vs first only). Errors with [EngineError::PatchSectionEmpty] when the section is absent and [EngineError::PatchOldNotFound] when old doesn’t appear. Mutually exclusive with the other two section modes for the same key.

metadata: IndexMap<String, String>

Metadata fields to set or replace. Values land as MetadataValue::String for V1.

metadata_unset: Vec<String>

Metadata field keys to unset. Silently no-ops on absent keys.

dry_run: bool

When true, validate and compute the prospective hash but do not write to disk, mutate the store, or commit. Outcome carries content_hash = the unchanged on-disk hash (so the caller can use it as expected_hash on the follow-up real call) and prospective_hash = the hash the entity would have after the proposed write. Wire-equivalent to full’s UpdateArgs.dry_run. Optimistic-lock check is skipped on the dry_run path so an agent can preview a change without holding a fresh hash — designated stale-hash recovery path.

declare_relations: Vec<RelateArg>

Atomic batched relation declarations applied before the section/metadata changes land. Each entry is validated like any individual memstead_relate call (schema-shape, cross-mem policy, target-id grammar), appended to the entity’s relationships list, and — for absent Write-target peers — auto-stubbed in the target’s mem. The strict wiki-link/relation validator then runs against the post-mutation state with the freshly-declared relations already in place, so a body wiki-link added in the same memstead_update call passes the gate without a separate memstead_relate round-trip. Empty default — omit when no batched declarations are needed.

anchors: Vec<AnchorInput>

Permissive anchors[] provenance records to attach to this entity — validated (crate::anchor::AnchorInput::validate) and, when non-empty, merged into the entity’s row in the mem-branch anchors sidecar in the SAME commit as the update so entity + anchors land atomically: an incoming anchor replaces the existing anchor with the same (artifact, grain, class) triple and appends otherwise — writing never removes an anchor this call did not name in Self::anchors_unset. Empty (the default) merges nothing and leaves the stored set untouched. A malformed element refuses the whole update with [EngineError::InvalidAnchor] (INVALID_ANCHOR) — nothing is written. Not folded into _hash (sidecar lives under .memstead/).

anchors_unset: Vec<AnchorUnsetInput>

Explicit anchor removals, applied before the Self::anchors merge in the same mutation (mirroring the metadata_unset / relations_unset conventions). Each selector names an artifact and may narrow by grain and/or class; a bare artifact removes every anchor on it. Unsetting an anchor that does not exist is a no-op, not an error — removal is idempotent. A malformed selector refuses the whole update with [EngineError::InvalidAnchor].

relations_unset: Vec<RelationUnsetArg>

Repair-shaped relation removals ({ rel_type, target }), applied atomically within this update. Accepted only when the entity currently FAILS the conformance check (against the effective schema) — a conformant entity refuses with REPAIR_NOT_NEEDED and stays unmodified; memstead_relate(remove) is the everyday detach path. Absent pairs are silent no-ops (symmetric with metadata_unset). The strict-write post-condition is unchanged: the post-repair entity must be integral or the whole update refuses with the relevant write-time code.

Trait Implementations

impl Clone for UpdateEntityArgs

fn clone(&self) -> UpdateEntityArgs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UpdateEntityArgs

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

Formats the value using the given formatter.