mere-kernel 0.0.2

Portable identity, authority, and mutation kernel for the Mere browser.
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
// Copyright 2026 Mark AB (markik)
// SPDX-License-Identifier: MIT OR Apache-2.0

//! `Graph::to_snapshot` — serialize the runtime graph into a
//! [`GraphSnapshot`] for persistence.
//!
//! Extracted from `graph/snapshot.rs` per the 2026-05-11 kernel
//! decomposition pass (the original file was 724 LOC).

use petgraph::visit::EdgeRef;

use super::super::*;
use crate::persistence::{
    GraphSnapshot, PersistedAddress, PersistedArrangementEdgeData, PersistedArrangementSubKind,
    PersistedContainmentEdgeData, PersistedContainmentSubKind, PersistedCoupling,
    PersistedCouplingResponse, PersistedEdge, PersistedEdgeFamily, PersistedField,
    PersistedFieldExtent, PersistedFieldLifecycle, PersistedImportedEdgeData,
    PersistedImportedSubKind, PersistedNavigationTrigger, PersistedNode, PersistedNodeSelector,
    PersistedNodeSessionState, PersistedProvenanceEdgeData, PersistedProvenanceSubKind,
    PersistedSemanticEdgeData, PersistedSemanticStatement, PersistedSemanticSubKind,
    PersistedTraversalEdgeData, PersistedTraversalMetrics, PersistedTraversalRecord,
};
fn persisted_semantic_sub_kind(sub_kind: SemanticSubKind) -> PersistedSemanticSubKind {
    match sub_kind {
        SemanticSubKind::Hyperlink => PersistedSemanticSubKind::Hyperlink,
        SemanticSubKind::UserGrouped => PersistedSemanticSubKind::UserGrouped,
        SemanticSubKind::AgentDerived => PersistedSemanticSubKind::AgentDerived,
        SemanticSubKind::Cites => PersistedSemanticSubKind::Cites,
        SemanticSubKind::Quotes => PersistedSemanticSubKind::Quotes,
        SemanticSubKind::Summarizes => PersistedSemanticSubKind::Summarizes,
        SemanticSubKind::Elaborates => PersistedSemanticSubKind::Elaborates,
        SemanticSubKind::ExampleOf => PersistedSemanticSubKind::ExampleOf,
        SemanticSubKind::Supports => PersistedSemanticSubKind::Supports,
        SemanticSubKind::Contradicts => PersistedSemanticSubKind::Contradicts,
        SemanticSubKind::Questions => PersistedSemanticSubKind::Questions,
        SemanticSubKind::SameEntityAs => PersistedSemanticSubKind::SameEntityAs,
        SemanticSubKind::DuplicateOf => PersistedSemanticSubKind::DuplicateOf,
        SemanticSubKind::CanonicalMirrorOf => PersistedSemanticSubKind::CanonicalMirrorOf,
        SemanticSubKind::DependsOn => PersistedSemanticSubKind::DependsOn,
        SemanticSubKind::Blocks => PersistedSemanticSubKind::Blocks,
        SemanticSubKind::NextStep => PersistedSemanticSubKind::NextStep,
    }
}

impl Graph {
    pub fn to_snapshot(&self) -> GraphSnapshot {
        let nodes = self
            .nodes()
            .map(|(_, node)| PersistedNode {
                node_id: node.id.to_string(),
                // Legacy wire field only. Hostnames are derived from the
                // Container's primary address and are never stored anew.
                cached_host: None,
                title: node.title.clone(),
                tags: {
                    let mut tags = node.tags.iter().cloned().collect::<Vec<_>>();
                    tags.sort();
                    tags
                },
                tag_presentation: Default::default(),
                import_provenance: Vec::new(),
                is_pinned: false,
                images: node.images.clone(),
                // Never written: a saved snapshot carries references only.
                legacy_thumbnail_png: None,
                legacy_thumbnail_width: 0,
                legacy_thumbnail_height: 0,
                legacy_favicon_rgba: None,
                legacy_favicon_width: 0,
                legacy_favicon_height: 0,
                // Scroll / form draft left for the host's BrowserNodeState
                // sidecar (boundary pass slice C); the snapshot now carries
                // only the last-visited clock here. `session_state` itself
                // stays for legacy readers and the one-time load migration.
                session_state: Some(PersistedNodeSessionState {
                    scroll_x: None,
                    scroll_y: None,
                    form_draft: None,
                    last_visited_ms: None,
                }),
                address: match node.primary_address() {
                    Address::Http(s) => PersistedAddress::Http(s.clone()),
                    Address::File(s) => PersistedAddress::File(s.clone()),
                    Address::Data(s) => PersistedAddress::Data(s.clone()),
                    Address::Clip(s) => PersistedAddress::Clip(s.clone()),
                    Address::Directory(s) => PersistedAddress::Directory(s.clone()),
                    Address::Custom(s) => PersistedAddress::Custom(s.clone()),
                },
                // Written for backward compat: pre-Stage C.2 readers use this field.
                url: node.primary_address().as_url_str().to_string(),
                classifications: Vec::new(),
                mime_hint: node.media_type.clone(),
                frame_layout_hints: Vec::new(),
                frame_split_offer_suppressed: false,
                properties: Vec::new(),
                derivations: Vec::new(),
                body: node.body.clone(),
                last_session_visited: 0,
                nested: node.nested.as_ref().map(|log| log.as_str().to_string()),
                content_hash: node.content.map(|hash| hash.to_hex()),
            })
            .collect();

        let edges = self
            .inner
            .inner()
            .edge_references()
            .map(|edge| {
                let from_node_id = self
                    .get_node(edge.source())
                    .map(|n| n.id.to_string())
                    .unwrap_or_default();
                let to_node_id = self
                    .get_node(edge.target())
                    .map(|n| n.id.to_string())
                    .unwrap_or_default();
                let payload = edge.weight();
                PersistedEdge {
                    from_node_id,
                    to_node_id,
                    families: payload
                        .families()
                        .iter()
                        .map(|family| match family {
                            EdgeFamily::Semantic => PersistedEdgeFamily::Semantic,
                            EdgeFamily::Traversal => PersistedEdgeFamily::Traversal,
                            EdgeFamily::Containment => PersistedEdgeFamily::Containment,
                            EdgeFamily::Arrangement => PersistedEdgeFamily::Arrangement,
                            EdgeFamily::Imported => PersistedEdgeFamily::Imported,
                            EdgeFamily::Provenance => PersistedEdgeFamily::Provenance,
                        })
                        .collect(),
                    semantic: Some(PersistedSemanticEdgeData {
                        sub_kinds: payload
                            .semantic_data()
                            .map(|data| {
                                data.sub_kinds
                                    .iter()
                                    .copied()
                                    .map(persisted_semantic_sub_kind)
                                    .collect()
                            })
                            .unwrap_or_default(),
                        label: payload.semantic_data().and_then(|data| data.label.clone()),
                        agent_decay_progress: payload
                            .has_relation(RelationSelector::Semantic(SemanticSubKind::AgentDerived))
                            .then_some(0.0),
                        predicate: payload
                            .semantic_data()
                            .and_then(|data| data.predicate.clone()),
                        statements: payload
                            .semantic_statements()
                            .iter()
                            .map(|statement| PersistedSemanticStatement {
                                statement_id: statement.statement_id.clone(),
                                predicate: statement.predicate.clone(),
                                recognized_sub_kind: statement
                                    .recognized_sub_kind
                                    .map(persisted_semantic_sub_kind),
                                label: statement.label.clone(),
                                graph_scope: statement.graph_scope.clone(),
                                provenance_iri: statement.provenance_iri.clone(),
                                asserted_at_ms: statement.asserted_at_ms,
                            })
                            .collect(),
                    })
                    .filter(|data| {
                        !data.sub_kinds.is_empty()
                            || data.label.is_some()
                            || data.predicate.is_some()
                            || !data.statements.is_empty()
                    }),
                    traversal: payload
                        .traversal_data()
                        .map(|data| PersistedTraversalEdgeData {
                            traversals: data
                                .traversals
                                .iter()
                                .map(|traversal| PersistedTraversalRecord {
                                    timestamp_ms: traversal.timestamp_ms,
                                    trigger: match traversal.trigger {
                                        NavigationTrigger::Unknown => {
                                            PersistedNavigationTrigger::Unknown
                                        }
                                        NavigationTrigger::LinkClick => {
                                            PersistedNavigationTrigger::LinkClick
                                        }
                                        NavigationTrigger::Back => PersistedNavigationTrigger::Back,
                                        NavigationTrigger::Forward => {
                                            PersistedNavigationTrigger::Forward
                                        }
                                        NavigationTrigger::AddressBarEntry => {
                                            PersistedNavigationTrigger::AddressBarEntry
                                        }
                                        NavigationTrigger::PanePromotion => {
                                            PersistedNavigationTrigger::PanePromotion
                                        }
                                        NavigationTrigger::Programmatic => {
                                            PersistedNavigationTrigger::Programmatic
                                        }
                                        NavigationTrigger::Redirect => {
                                            PersistedNavigationTrigger::Redirect
                                        }
                                        NavigationTrigger::ReopenSession => {
                                            PersistedNavigationTrigger::ReopenSession
                                        }
                                        NavigationTrigger::JumpAnchor => {
                                            PersistedNavigationTrigger::JumpAnchor
                                        }
                                        NavigationTrigger::InPageSearchJump => {
                                            PersistedNavigationTrigger::InPageSearchJump
                                        }
                                        NavigationTrigger::ImportedHistory => {
                                            PersistedNavigationTrigger::ImportedHistory
                                        }
                                    },
                                })
                                .collect(),
                            metrics: PersistedTraversalMetrics {
                                total_navigations: data.metrics.total_navigations,
                                forward_navigations: data.metrics.forward_navigations,
                                backward_navigations: data.metrics.backward_navigations,
                                last_navigated_at: data.metrics.last_navigated_at,
                            },
                        }),
                    containment: payload.containment_data().map(|data| {
                        PersistedContainmentEdgeData {
                            sub_kinds: data
                                .sub_kinds
                                .iter()
                                .map(|sub_kind| match sub_kind {
                                    ContainmentSubKind::UrlPath => {
                                        PersistedContainmentSubKind::UrlPath
                                    }
                                    ContainmentSubKind::Domain => {
                                        PersistedContainmentSubKind::Domain
                                    }
                                    ContainmentSubKind::FileSystem => {
                                        PersistedContainmentSubKind::FileSystem
                                    }
                                    ContainmentSubKind::UserFolder => {
                                        PersistedContainmentSubKind::UserFolder
                                    }
                                    ContainmentSubKind::ClipSource => {
                                        PersistedContainmentSubKind::ClipSource
                                    }
                                    ContainmentSubKind::NotebookSection => {
                                        PersistedContainmentSubKind::NotebookSection
                                    }
                                    ContainmentSubKind::CollectionMember => {
                                        PersistedContainmentSubKind::CollectionMember
                                    }
                                })
                                .collect(),
                        }
                    }),
                    arrangement: payload.arrangement_data().map(|data| {
                        PersistedArrangementEdgeData {
                            sub_kinds: data
                                .sub_kinds
                                .iter()
                                .copied()
                                .filter(|sub_kind| {
                                    sub_kind.durability() == RelationDurability::Durable
                                })
                                .map(|sub_kind| match sub_kind {
                                    ArrangementSubKind::FrameMember => {
                                        PersistedArrangementSubKind::FrameMember
                                    }
                                    ArrangementSubKind::TileGroup => {
                                        PersistedArrangementSubKind::TileGroup
                                    }
                                    ArrangementSubKind::SplitPair => {
                                        PersistedArrangementSubKind::SplitPair
                                    }
                                })
                                .collect(),
                        }
                    }),
                    imported: payload
                        .imported_data()
                        .map(|data| PersistedImportedEdgeData {
                            sub_kinds: data
                                .sub_kinds
                                .iter()
                                .map(|sub_kind| match sub_kind {
                                    ImportedSubKind::BookmarkFolder => {
                                        PersistedImportedSubKind::BookmarkFolder
                                    }
                                    ImportedSubKind::HistoryImport => {
                                        PersistedImportedSubKind::HistoryImport
                                    }
                                    ImportedSubKind::SessionImport => {
                                        PersistedImportedSubKind::SessionImport
                                    }
                                    ImportedSubKind::RssMembership => {
                                        PersistedImportedSubKind::RssMembership
                                    }
                                    ImportedSubKind::FileSystemImport => {
                                        PersistedImportedSubKind::FileSystemImport
                                    }
                                    ImportedSubKind::ArchiveMembership => {
                                        PersistedImportedSubKind::ArchiveMembership
                                    }
                                    ImportedSubKind::SharedCollection => {
                                        PersistedImportedSubKind::SharedCollection
                                    }
                                })
                                .collect(),
                        }),
                    provenance: payload
                        .provenance_data()
                        .map(|data| PersistedProvenanceEdgeData {
                            sub_kinds: data
                                .sub_kinds
                                .iter()
                                .map(|sub_kind| match sub_kind {
                                    ProvenanceSubKind::ClippedFrom => {
                                        PersistedProvenanceSubKind::ClippedFrom
                                    }
                                    ProvenanceSubKind::ExcerptedFrom => {
                                        PersistedProvenanceSubKind::ExcerptedFrom
                                    }
                                    ProvenanceSubKind::SummarizedFrom => {
                                        PersistedProvenanceSubKind::SummarizedFrom
                                    }
                                    ProvenanceSubKind::TranslatedFrom => {
                                        PersistedProvenanceSubKind::TranslatedFrom
                                    }
                                    ProvenanceSubKind::RewrittenFrom => {
                                        PersistedProvenanceSubKind::RewrittenFrom
                                    }
                                    ProvenanceSubKind::GeneratedFrom => {
                                        PersistedProvenanceSubKind::GeneratedFrom
                                    }
                                    ProvenanceSubKind::ExtractedFrom => {
                                        PersistedProvenanceSubKind::ExtractedFrom
                                    }
                                    ProvenanceSubKind::ImportedFromSource => {
                                        PersistedProvenanceSubKind::ImportedFromSource
                                    }
                                    ProvenanceSubKind::CopiedFrom => {
                                        PersistedProvenanceSubKind::CopiedFrom
                                    }
                                })
                                .collect(),
                        }),
                }
            })
            .collect();

        let fields = self
            .fields()
            .map(|f| PersistedField {
                id: f.id.as_uuid().to_string(),
                name: f.name.clone(),
                // The recursive AST rides as a JSON blob (see persistence_fields).
                definition_json: serde_json::to_string(&f.definition).unwrap_or_default(),
                extent: match &f.extent {
                    FieldExtent::Global => PersistedFieldExtent::Global,
                    FieldExtent::Region {
                        min_x,
                        min_y,
                        max_x,
                        max_y,
                    } => PersistedFieldExtent::Region {
                        min_x: *min_x,
                        min_y: *min_y,
                        max_x: *max_x,
                        max_y: *max_y,
                    },
                    FieldExtent::AttachedToNode(id) => {
                        PersistedFieldExtent::AttachedToNode(id.to_string())
                    }
                    FieldExtent::Polygon { points } => PersistedFieldExtent::Polygon {
                        points: points.clone(),
                    },
                },
                lifecycle: match f.lifecycle {
                    FieldLifecycle::Active => PersistedFieldLifecycle::Active,
                    FieldLifecycle::Retired => PersistedFieldLifecycle::Retired,
                },
            })
            .collect();

        let couplings = self
            .couplings()
            .map(|c| PersistedCoupling {
                id: c.id.as_uuid().to_string(),
                field_id: c.field.as_uuid().to_string(),
                selector: match &c.selector {
                    NodeSelector::All => PersistedNodeSelector::All,
                    NodeSelector::Tagged(t) => PersistedNodeSelector::Tagged(t.clone()),
                    NodeSelector::Kind(k) => PersistedNodeSelector::Kind(k.clone()),
                    NodeSelector::NotTagged(t) => PersistedNodeSelector::NotTagged(t.clone()),
                },
                response: match &c.response {
                    CouplingResponse::AttractToMin => PersistedCouplingResponse::AttractToMin,
                    CouplingResponse::RepelFromMax => PersistedCouplingResponse::RepelFromMax,
                    CouplingResponse::AlignVelocity => PersistedCouplingResponse::AlignVelocity,
                    CouplingResponse::FlowAdvect => PersistedCouplingResponse::FlowAdvect,
                    CouplingResponse::DampenInside { factor } => {
                        PersistedCouplingResponse::DampenInside { factor: *factor }
                    }
                    CouplingResponse::ContainmentWall => PersistedCouplingResponse::ContainmentWall,
                    CouplingResponse::Open { predicate } => PersistedCouplingResponse::Open {
                        predicate: predicate.clone(),
                    },
                },
                strength: c.strength,
            })
            .collect();

        let timestamp_secs = crate::time::unix_epoch_seconds();

        GraphSnapshot {
            nodes,
            edges,
            import_records: self.import_records.clone(),
            timestamp_secs,
            fields,
            couplings,
            navigation: self.nav.clone(),
        }
    }
}