Struct LineageStore 

pub struct LineageStore {
    pub schema_version: u32,
    pub nodes: BTreeMap<String, Node>,
    pub edges: Vec<StoredEdge>,
    pub resolution_cache: BTreeMap<String, CacheEntry>,
    pub albums: BTreeMap<String, AlbumArt>,
    pub playlists: BTreeMap<String, PlaylistState>,
}

The whole lineage graph, kept relational for a clean SQLite migration.

nodes and resolution_cache are BTreeMaps and edges is sorted after every update, so serialisation is deterministic.

Fields

schema_version: u32

On-disk schema version, so a future migration can branch on it.

nodes: BTreeMap<String, Node>

Every clip ever seen (including trashed ancestors), keyed by clip id.

edges: Vec<StoredEdge>

Every observed parent link, as a flat relational list.

resolution_cache: BTreeMap<String, CacheEntry>

The last resolved (or last-known) root per clip, keyed by clip id.

albums: BTreeMap<String, AlbumArt>

The reconciled folder-art state per album, keyed by the album’s stable root id (HARDENING H2). Additive: absent in older stores, defaults empty.

playlists: BTreeMap<String, PlaylistState>

The reconciled .m3u8 state per playlist, keyed by the playlist’s Suno id (the synthetic "liked" id for the liked feed). Additive: absent in older stores, defaults empty.

Implementations

impl LineageStore

pub fn new() -> Self

Create an empty store at the current schema version.

pub fn node(&self, id: &str) -> Option<&Node>

The node for id, if present.

pub fn get_root(&self, id: &str) -> Option<&CacheEntry>

The cached root resolution for id, if present.

pub fn album_art(&self, root_id: &str) -> Option<&AlbumArt>

The reconciled folder-art state for the album rooted at root_id.

pub fn set_album_artifact( &mut self, root_id: &str, kind: ArtifactKind, state: Option<ArtifactState>, )

Set (or clear, with None) one folder-art kind for the album rooted at root_id.

A set upserts the album row; a clear that empties the row removes it, so the store never accumulates dead all-None album entries. This is the store-level counterpart the CLI persists after the executor mutates the albums map in place.

pub fn playlist(&self, id: &str) -> Option<&PlaylistState>

The reconciled .m3u8 state for the playlist with id, if present.

pub fn set_playlist(&mut self, id: &str, state: Option<PlaylistState>)

Upsert (with Some) or remove (with None) the .m3u8 state for the playlist id.

This is the store-level counterpart the CLI persists after the executor mutates the playlists map in place: a write records the new state; a delete clears the row so the store never keeps a dangling entry for a playlist whose file was removed.

pub fn context_for(&self, clip: &Clip) -> LineageContext

Build a LineageContext for clip from the durable store.

This is the source of truth for every file-affecting lineage decision (album folder, embedded tags, the change hash), so a dropped resolution call never rewrites the library (HARDENING H3). The root comes from the monotonic resolution cache (the clip’s own id when the store has no better answer) and the root title from that root’s archived node, so a transient miss keeps the last-known-good album even for a since-purged ancestor. The parent edge is read structurally from the clip itself.

pub fn colliding_root_titles(&self) -> BTreeSet<String>

The set of root titles shared by more than one distinct root.

Two distinct roots must never share an album folder (two different uploads titled “Break Through” exist), so naming appends the short root id to the album of any clip whose root title is in this set. It is computed from the whole archive — every distinct root in the resolution cache paired with its node title — so the decision is stable across runs and independent of the current batch: a --since/--limit slice that shows only one of two same-titled roots still disambiguates, instead of oscillating between a bare and a suffixed folder.

pub fn len(&self) -> usize

Number of nodes in the graph.

pub fn is_empty(&self) -> bool

True when the graph holds no nodes.

pub fn iter(&self) -> Iter<'_, String, Node>

Iterate nodes in clip-id order.

pub fn update(&mut self, clips: &[Clip], resolution: &Resolution, now: &str)

Fold this run’s clips and their Resolution into the store.

Pure: it takes now (an ISO timestamp) from the caller rather than reading a clock. Upserts a node for every clip and every gap-filled ancestor (so trashed ancestors are archived), upserts an edge for every lineage_edges link, and refreshes the monotonic resolution cache. edges is left sorted so the serialised form is deterministic.

Trait Implementations

impl Clone for LineageStore

fn clone(&self) -> LineageStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LineageStore

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

Formats the value using the given formatter.

impl Default for LineageStore

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LineageStore

where LineageStore: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LineageStore

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

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 LineageStore