Struct LockEntry 

#[non_exhaustive]
pub struct LockEntry {
    pub id: String,
    pub path: String,
    pub sha: String,
    pub branch: String,
    pub installed_at: DateTime<Utc>,
    pub actions_hash: String,
    pub schema_version: String,
    pub synthetic: bool,
}

One resolved pack entry. Serialized as a single JSON line.

Marked #[non_exhaustive] so future audit fields (timestamps, resolved-ref metadata, plugin signatures) can land without breaking out-of-crate consumers that struct-literal-construct entries. Within grex-core the existing struct-literal sites continue to work unchanged; external callers should use LockEntry::new (and the field-level pub mutators) instead of struct literals.

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.

id: String

Pack identifier — matches the manifest id.

path: String

Parent-relative POSIX path of this pack’s manifest within its parent’s manifest.children. Required for v1.2.0 distributed lockfile resolution: each entry knows where its manifest lives relative to the parent meta, so the walker can place the dest correctly even when the same id appears nested.

Read-fallback: v1.1.1 lockfiles do not carry this field; on deserialize a missing path is filled with id (the v1.1.1 1:1 id↔folder convention). See LockEntryRepr and openspec/feat-grex/spec.md (v1.2.0 distributed lockfile).

Validation: must be parent-relative POSIX (no .., no absolute, no backslash, non-empty). Use LockEntry::validate_path.

sha: String

Resolved commit SHA at the time of install.

branch: String

Branch or ref used to resolve sha.

installed_at: DateTime<Utc>

Timestamp of the last successful install/sync.

actions_hash: String

Content hash of the declarative actions that ran. Empty for imperative packs.

schema_version: String

Schema version of this entry.

synthetic: bool

true when the walker synthesised this pack’s manifest in-memory because the child had no .grex/pack.yaml but did carry a .git/ (v1.1.1 plain-git children). #[serde(default)] keeps pre-v1.1.1 lockfiles forward-compatible — a missing field deserialises to false. See openspec/changes/feat-v1.1.1-plain-git-children/design.md.

Implementations

impl LockEntry

pub fn new( id: impl Into<String>, sha: impl Into<String>, branch: impl Into<String>, installed_at: DateTime<Utc>, actions_hash: impl Into<String>, schema_version: impl Into<String>, ) -> Self

Construct a new entry with every required field. The synthetic flag defaults to false; callers that need a synthetic entry should set the field directly after construction (the field is pub).

path defaults to id to preserve v1.1.1 caller compatibility (v1.1.1’s 1:1 id↔folder convention). Callers that need a distinct manifest path should set the field directly after construction.

Because LockEntry is #[non_exhaustive], this is the canonical constructor for out-of-crate consumers — struct literals will not compile from outside the crate.

pub fn validate_path(path: &str) -> Result<(), LockfileError>

Validate that path is a parent-relative POSIX path.

Rejects:

• empty string
• any .. segment (parent traversal)
• absolute paths: leading /, or a Windows drive prefix like C:
• backslash separators (Windows-style — POSIX only)

Accepts: simple names (foo), nested POSIX (a/b/c).

Trait Implementations

impl Clone for LockEntry

fn clone(&self) -> LockEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LockEntry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LockEntry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LockEntry

fn eq(&self, other: &LockEntry) -> 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 LockEntry

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for LockEntry

impl StructuralPartialEq for LockEntry