Skip to main content

kernel/graph/
legacy_resource_migration.rs

1// Copyright 2026 Mark Alan Boykin
2// This Source Code Form is subject to the terms of the Mozilla Public
3// License, v. 2.0. If a copy of the MPL was not distributed with this
4// file, You can obtain one at https://mozilla.org/MPL/2.0/.
5// SPDX-License-Identifier: MPL-2.0
6
7//! Explicit legacy replay. Ordinary replay keeps its recorded stores.
8//! The caller must establish a legacy placement profile before using this adapter.
9//!
10//! Legacy records repeat handles and pass through states in which both strata hold
11//! one, which ordinary edge replay refuses. The migration replays its legacy source
12//! and builds its output in an explicit staged scope, `Graph::stage_edges` to
13//! `Graph::settle_staged_edges`: edge replays are not checked one by one, and the
14//! finished output is checked once, refusing the migration if it would not reopen.
15//! Whole identical rows never reach that check: they dedupe to the first (`copies`).
16
17mod copies;
18
19use std::collections::{BTreeMap, BTreeSet};
20use std::fmt;
21
22pub use super::legacy_content_migration::LegacyContentContext;
23
24use serde::{Deserialize, Serialize};
25use uuid::Uuid;
26
27use super::capture::{
28    OnRefusal, Replay as Outcome, ReplayAttribution, replay_attributed_deltas_onto,
29    replay_graph_deltas_onto,
30};
31use super::predicate_declarations::PREDICATE_DECLARATIONS_FACET;
32use super::snapshot::{payload_from_persisted, persisted_edge_for_ids};
33use super::{AttributedDelta, CapturedDelta, EdgePayload, Graph, GraphStratum, ResourceNode};
34use crate::persistence::{
35    GraphSnapshot, PersistedContainmentEdgeData, PersistedEdge, PersistedImportedEdgeData,
36    PersistedProvenanceEdgeData, PersistedResourceFacet, PersistedResourceRecord,
37    PersistedSemanticStatement,
38};
39
40/// Baseline claims lack a retained minting event; the current endpoints are a fallback.
41pub const LEGACY_RESOURCE_MIGRATION_FACET: &str = "semantic.legacy-resource-migration/v1";
42pub const LEGACY_AGGREGATE_MIGRATION_FACET: &str = "semantic.legacy-aggregate-migration/v1";
43
44/// A legacy aggregate has no carried handle or assertion timestamp.
45#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
46pub struct LegacyAggregateMigrationNote {
47    pub from_surface_id: String,
48    pub to_surface_id: String,
49    pub from_resource_id: String,
50    pub to_resource_id: String,
51    pub from_url: String,
52    pub to_url: String,
53    pub kind: super::RelationKind,
54    pub author: Option<super::Author>,
55    pub uncertainty: String,
56}
57
58/// An explicit endpoint choice for an ambiguous carried handle. No raw handle is aliased.
59#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
60pub struct LegacyResourceOriginResolution {
61    pub statement_id: String,
62    pub from_resource_id: Uuid,
63    pub to_resource_id: Uuid,
64}
65
66/// Validate against all retained, qualified legacy entries before reading shorter prefixes.
67pub fn validate_legacy_origin_resolutions(
68    baseline: &Graph,
69    entries: &[AttributedDelta],
70    resolutions: &[LegacyResourceOriginResolution],
71) -> Result<(), LegacyMigrationError> {
72    validated_resolutions(&probe_legacy_mint_links(baseline, entries)?, resolutions).map(|_| ())
73}
74
75fn validated_resolutions(
76    diagnostics: &[LegacyMintLinkDiagnostic],
77    resolutions: &[LegacyResourceOriginResolution],
78) -> Result<BTreeMap<String, Pair>, LegacyMigrationError> {
79    let mut candidates = BTreeMap::<String, BTreeSet<Pair>>::new();
80    for diagnostic in diagnostics {
81        let pairs = candidates
82            .entry(diagnostic.statement_id.clone())
83            .or_default();
84        for pair in [
85            &diagnostic.earlier_resource_pair,
86            &diagnostic.current_resource_pair,
87        ] {
88            pairs.insert((parse_id(&pair.0)?, parse_id(&pair.1)?));
89        }
90    }
91    let mut selected = BTreeMap::new();
92    for resolution in resolutions {
93        let pair = (resolution.from_resource_id, resolution.to_resource_id);
94        if !candidates
95            .get(&resolution.statement_id)
96            .is_some_and(|pairs| pairs.contains(&pair))
97        {
98            return Err(LegacyMigrationError(format!(
99                "checkpoint C28: invalid resource origin for {}",
100                resolution.statement_id
101            )));
102        }
103        if let Some(previous) = selected.insert(resolution.statement_id.clone(), pair)
104            && previous != pair
105        {
106            return Err(LegacyMigrationError(format!(
107                "checkpoint C28: conflicting resource origins for {}",
108                resolution.statement_id
109            )));
110        }
111    }
112    if candidates.keys().any(|id| !selected.contains_key(id)) {
113        return Err(LegacyMigrationError(format!(
114            "checkpoint C28: {} unresolved legacy mint-link handles",
115            candidates
116                .keys()
117                .filter(|id| !selected.contains_key(*id))
118                .count()
119        )));
120    }
121    Ok(selected)
122}
123
124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
125pub struct LegacyMigrationNote {
126    pub from_surface_id: String,
127    pub to_surface_id: String,
128    pub from_resource_id: String,
129    pub to_resource_id: String,
130    pub from_url: String,
131    pub to_url: String,
132    pub statement: PersistedSemanticStatement,
133    pub uncertainty: String,
134}
135
136#[derive(Debug, Clone, PartialEq, Eq)]
137pub struct LegacyMigrationError(pub String);
138
139impl fmt::Display for LegacyMigrationError {
140    fn fmt(&self, out: &mut fmt::Formatter<'_>) -> fmt::Result {
141        out.write_str(&self.0)
142    }
143}
144impl std::error::Error for LegacyMigrationError {}
145
146/// The original journal is unchanged. Effective captures name the stores actually edited.
147pub struct MigratedReplay {
148    pub graph: Graph,
149    pub baseline_effects: Vec<CapturedDelta>,
150    pub entry_effects: Vec<Vec<CapturedDelta>>,
151}
152
153/// Evidence for an unresolved raw-event to carried-handle link, without selecting one.
154#[derive(Debug, Clone, PartialEq, Eq)]
155pub struct LegacyMintLinkDiagnostic {
156    pub raw_entry_index: usize,
157    pub carried_entry_index: usize,
158    pub statement_id: String,
159    pub surface_pair: (String, String),
160    pub earlier_resource_pair: (String, String),
161    pub current_resource_pair: (String, String),
162    pub explicit_source_matches: bool,
163}
164
165/// Inspect mixed histories before choosing how to link raw events to later handles.
166/// Equal content is evidence, not proof that distinct handles identify one assertion.
167pub fn probe_legacy_mint_links(
168    baseline: &Graph,
169    entries: &[AttributedDelta],
170) -> Result<Vec<LegacyMintLinkDiagnostic>, LegacyMigrationError> {
171    let mut source = baseline.clone();
172    source.stage_edges();
173    let mut attribution = ReplayAttribution::from_baseline(baseline);
174    let mut known = statement_ids(&baseline.to_snapshot().edges);
175    let mut raw = Vec::<(usize, Pair, super::SemanticStatement, Pair)>::new();
176    let mut diagnostics = Vec::new();
177    for (index, entry) in entries.iter().enumerate() {
178        let before = surface_pairs(&source)?;
179        let _ =
180            replay_attributed_deltas_onto(&mut source, &mut attribution, [entry], OnRefusal::Drop);
181        let after = surface_pairs(&source)?;
182        for (&pair, edges) in &after {
183            let old = statement_ids(before.get(&pair).map(Vec::as_slice).unwrap_or(&[]));
184            let endpoints = current_resource_pair(&source, pair)?;
185            for edge in edges {
186                let payload = payload_from_persisted(edge);
187                for statement in payload.semantic_statements() {
188                    if old.contains(&statement.statement_id) {
189                        continue;
190                    }
191                    let identity = statement.clone();
192                    if matches!(entry.delta, CapturedDelta::ReplaySetEdgesByIds { .. })
193                        && !known.contains(&statement.statement_id)
194                        && statement.recognized_sub_kind.is_none()
195                        && super::built_in_predicate_stratum(&statement.predicate).is_none()
196                    {
197                        source.effective_predicate_stratum(&statement.predicate).map_err(|error|
198                            LegacyMigrationError(format!("checkpoint C22: new carried handle {} has unresolved placement: {error}", statement.statement_id)))?;
199                    }
200                    let resource_placed =
201                        historical_statement_stratum(&source, statement) == GraphStratum::Resource;
202                    if raw_semantic_edit(&entry.delta) && resource_placed {
203                        raw.push((index, pair, identity, endpoints));
204                    } else if let CapturedDelta::ReplaySetEdgesByIds { edges, .. } = &entry.delta
205                        && !known.contains(&statement.statement_id)
206                        && resource_placed
207                    {
208                        let explicit = edges
209                            .iter()
210                            .flat_map(|edge| edge.retained_assertions())
211                            .find(|carried| carried.statement_id == statement.statement_id)
212                            .and_then(|carried| carried.provenance_iri.as_ref())
213                            .filter(|source| {
214                                source.as_str() != super::edge_data::UNKNOWN_LEGACY_ASSERTER_IRI
215                            });
216                        for (raw_index, raw_pair, earlier, earlier_endpoints) in &raw {
217                            if *raw_pair == pair
218                                && *earlier_endpoints != endpoints
219                                && earlier.predicate == identity.predicate
220                                && earlier.recognized_sub_kind == identity.recognized_sub_kind
221                                && earlier.graph_scope == identity.graph_scope
222                                && (explicit.is_none()
223                                    || earlier.provenance_iri == identity.provenance_iri)
224                            {
225                                diagnostics.push(LegacyMintLinkDiagnostic {
226                                    raw_entry_index: *raw_index,
227                                    carried_entry_index: index,
228                                    statement_id: statement.statement_id.clone(),
229                                    surface_pair: (pair.0.to_string(), pair.1.to_string()),
230                                    earlier_resource_pair: (
231                                        earlier_endpoints.0.to_string(),
232                                        earlier_endpoints.1.to_string(),
233                                    ),
234                                    current_resource_pair: (
235                                        endpoints.0.to_string(),
236                                        endpoints.1.to_string(),
237                                    ),
238                                    explicit_source_matches: explicit.is_some()
239                                        && earlier.provenance_iri == identity.provenance_iri,
240                                });
241                            }
242                        }
243                    }
244                    known.insert(statement.statement_id.clone());
245                }
246            }
247        }
248    }
249    Ok(diagnostics)
250}
251
252type Pair = (Uuid, Uuid);
253type Pairs = BTreeMap<Pair, Vec<PersistedEdge>>;
254
255#[derive(Clone)]
256struct Origin {
257    surface: Pair,
258    resource: Option<Pair>,
259    /// The statement as first seen: later records of the handle must be the same claim.
260    claim: super::SemanticStatement,
261}
262
263#[derive(Clone, PartialEq)]
264struct Membership {
265    surface: Pair,
266    resource: Pair,
267    edges: Vec<PersistedEdge>,
268}
269
270struct Replay {
271    source: Graph,
272    output: Graph,
273    attribution: ReplayAttribution,
274    origins: BTreeMap<String, Origin>,
275    active: BTreeMap<String, Membership>,
276    aggregate_origins: BTreeMap<(Pair, u32), Pair>,
277    aggregate_active: BTreeMap<(Pair, u32), Membership>,
278    resolutions: BTreeMap<String, Pair>,
279    authored_declarations: BTreeSet<String>,
280    content: super::legacy_content_migration::ContentReplay,
281    content_context: Option<super::legacy_content_migration::LegacyContentContext>,
282}
283
284/// Replay a caller-qualified legacy baseline and its retained prefix atomically.
285/// Existing typed resource records and claims keep their explicit store.
286/// Exact carried handles retain identity. Raw records keep the existing replay
287/// exception: they did not record stable handles. Unresolved mixed-history
288/// evidence stops at checkpoint C28 before any migrated graph is produced.
289pub fn migrate_legacy_prefix(
290    baseline: &Graph,
291    entries: &[AttributedDelta],
292) -> Result<MigratedReplay, LegacyMigrationError> {
293    migrate_legacy_prefix_with_resolutions(baseline, entries, &[])
294}
295
296/// Replay with explicit, evidenced choices for every ambiguous carried handle in this prefix.
297pub fn migrate_legacy_prefix_with_resolutions(
298    baseline: &Graph,
299    entries: &[AttributedDelta],
300    resolutions: &[LegacyResourceOriginResolution],
301) -> Result<MigratedReplay, LegacyMigrationError> {
302    migrate_legacy_prefix_with_content_context(baseline, entries, resolutions, None)
303}
304
305/// Supply the original mere namespace for unattributed legacy tag concepts.
306pub fn migrate_legacy_prefix_with_content_context(
307    baseline: &Graph,
308    entries: &[AttributedDelta],
309    resolutions: &[LegacyResourceOriginResolution],
310    context: Option<&super::legacy_content_migration::LegacyContentContext>,
311) -> Result<MigratedReplay, LegacyMigrationError> {
312    if let Some(context) = context {
313        let iri = url::Url::parse(&context.original_mere_iri).map_err(|_| {
314            LegacyMigrationError("original-mere content namespace must be an absolute IRI".into())
315        })?;
316        if iri.scheme().is_empty()
317            || context
318                .original_mere_iri
319                .chars()
320                .any(|c| c.is_whitespace() || c.is_control())
321        {
322            return Err(LegacyMigrationError(
323                "invalid original-mere content namespace".into(),
324            ));
325        }
326    }
327    let diagnostics = probe_legacy_mint_links(baseline, entries)?;
328    let resolutions = validated_resolutions(&diagnostics, resolutions)?;
329    let mut replay = Replay {
330        source: baseline.clone(),
331        output: baseline.clone(),
332        attribution: ReplayAttribution::from_baseline(baseline),
333        origins: BTreeMap::new(),
334        active: BTreeMap::new(),
335        aggregate_origins: BTreeMap::new(),
336        aggregate_active: BTreeMap::new(),
337        resolutions,
338        content: Default::default(),
339        content_context: context.cloned(),
340        authored_declarations: baseline
341            .to_snapshot()
342            .resources
343            .into_iter()
344            .filter(|record| {
345                record
346                    .facets
347                    .iter()
348                    .any(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
349            })
350            .map(|record| record.canonical_iri)
351            .collect(),
352    };
353    replay.source.stage_edges();
354    replay.output.stage_edges();
355    let before = replay.output.to_snapshot();
356    let before_facets = replay.output.facets().clone();
357    replay.sync(&Pairs::new(), true, None)?;
358    replay.content.sync(
359        &replay.source,
360        &mut replay.output,
361        replay.content_context.as_ref(),
362        None,
363    )?;
364    let mut baseline_effects = facet_effects_between(&before_facets, replay.output.facets());
365    baseline_effects.extend(effects_between(
366        &before,
367        &replay.output.to_snapshot(),
368        replay.output.facets(),
369    )?);
370    let mut entry_effects = Vec::with_capacity(entries.len());
371    for (index, entry) in entries.iter().enumerate() {
372        let before = replay.output.to_snapshot();
373        let before_facets = replay.output.facets().clone();
374        let old_pairs = surface_pairs(&replay.source)?;
375        let typed_pair = typed_resource_pair(&entry.delta)?;
376        replay.content.typed_record(&entry.delta);
377        if let Some(pair) = typed_pair {
378            // This explicit replacement supersedes only this resource pair's old membership.
379            replay.active.retain(|_, member| member.resource != pair);
380            replay
381                .aggregate_active
382                .retain(|_, member| member.resource != pair);
383            let Outcome::Apply(delta) = replay.attribution.replay(&entry.delta, &entry.author)
384            else {
385                return Err(LegacyMigrationError(
386                    "invalid typed resource capture".into(),
387                ));
388            };
389            let super::apply::GraphDelta::ReplaySetResourceEdgesByIds { edges, .. } = &delta else {
390                unreachable!()
391            };
392            let expected = edges.clone();
393            let _ = replay_graph_deltas_onto(&mut replay.output, [delta], OnRefusal::Drop);
394            let actual = replay
395                .output
396                .persisted_resource_edges_between(pair.0, pair.1);
397            if actual != expected {
398                return Err(LegacyMigrationError(
399                    "typed resource pair replacement was refused".into(),
400                ));
401            }
402        } else {
403            let _ = replay_attributed_deltas_onto(
404                &mut replay.source,
405                &mut replay.attribution,
406                [entry],
407                OnRefusal::Drop,
408            );
409            if !legacy_edge_edit(&entry.delta) {
410                match entry.delta.replay_as(&entry.author) {
411                    Outcome::Apply(delta) => {
412                        let _ =
413                            replay_graph_deltas_onto(&mut replay.output, [delta], OnRefusal::Drop);
414                    },
415                    Outcome::Skip => {},
416                    Outcome::Malformed(bad) => {
417                        return Err(LegacyMigrationError(format!(
418                            "legacy journal entry {index}: {bad}"
419                        )));
420                    },
421                }
422                replay.check_typed_record(&entry.delta)?;
423            }
424        }
425        if let CapturedDelta::ReplaySetResourceRecordById {
426            record: Some(record),
427            ..
428        } = &entry.delta
429            && record
430                .facets
431                .iter()
432                .any(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
433        {
434            replay
435                .authored_declarations
436                .insert(record.canonical_iri.clone());
437        }
438        let after_original = replay.output.to_snapshot();
439        let after_original_facets = replay.output.facets().clone();
440        replay.sync(&old_pairs, false, Some(entry))?;
441        replay.content.sync(
442            &replay.source,
443            &mut replay.output,
444            replay.content_context.as_ref(),
445            Some(&entry.author),
446        )?;
447        if let Some(surface) = lifecycle_surface(&entry.delta)?
448            && replay.source.get_node_key_by_id(surface).is_some()
449        {
450            let (resource, _) = replay.ensure_resource(surface)?;
451            replay.output.set_shown_resource(surface, Some(resource));
452        }
453        let mut effective = Vec::new();
454        if !legacy_edge_edit(&entry.delta) {
455            effective.push(entry.delta.clone());
456        }
457        effective.extend(facet_effects_between(
458            &before_facets,
459            replay.output.facets(),
460        ));
461        effective.extend(effects_between(
462            &before,
463            &replay.output.to_snapshot(),
464            replay.output.facets(),
465        )?);
466        // Retained raw writes can transiently touch Surface content that the
467        // migration clears back to its previous value.
468        let mut corrections = facet_effects_between(&after_original_facets, replay.output.facets());
469        corrections.extend(effects_between(
470            &after_original,
471            &replay.output.to_snapshot(),
472            replay.output.facets(),
473        )?);
474        effective.extend(corrections);
475        entry_effects.push(effective);
476    }
477    replay
478        .output
479        .settle_staged_edges()
480        .map_err(|error| LegacyMigrationError(error.to_string()))?;
481    // The same checked boundary used by ordinary loads verifies final cross-store handles.
482    Graph::try_from_snapshot(&replay.output.to_snapshot())
483        .map_err(|error| LegacyMigrationError(error.to_string()))?;
484    Ok(MigratedReplay {
485        graph: replay.output,
486        baseline_effects,
487        entry_effects,
488    })
489}
490
491impl Replay {
492    fn check_typed_record(&self, delta: &CapturedDelta) -> Result<(), LegacyMigrationError> {
493        match delta {
494            CapturedDelta::ReplaySetResourceRecordById {
495                resource_id,
496                record,
497            } => {
498                let id = parse_id(resource_id)?;
499                let actual = self.output.resource_record(id);
500                let actual = actual.as_ref().map(record_value).transpose()?;
501                let expected = record.as_ref().map(record_value).transpose()?;
502                if actual != expected {
503                    return Err(LegacyMigrationError(
504                        "typed resource record replacement was refused".into(),
505                    ));
506                }
507            },
508            CapturedDelta::ReplaySetShownResourceById {
509                surface_id,
510                resource_id,
511            } => {
512                let surface = self
513                    .output
514                    .get_node_key_by_id(parse_id(surface_id)?)
515                    .ok_or_else(|| {
516                        LegacyMigrationError("typed shown binding has no surface".into())
517                    })?;
518                let expected = resource_id.as_deref().map(parse_id).transpose()?;
519                if self.output.shown_resource_id(surface) != expected {
520                    return Err(LegacyMigrationError(
521                        "typed shown binding was refused".into(),
522                    ));
523                }
524            },
525            _ => {},
526        }
527        Ok(())
528    }
529
530    fn ensure_resource(&mut self, surface: Uuid) -> Result<(Uuid, String), LegacyMigrationError> {
531        let key = self
532            .source
533            .get_node_key_by_id(surface)
534            .ok_or_else(|| LegacyMigrationError("legacy claim endpoint is absent".into()))?;
535        let node = self.source.get_node(key).expect("surface key exists");
536        let url = node.primary_address().as_url_str().to_owned();
537        let resource = ResourceNode::new(&url);
538        if self.output.resource(resource.id()).is_none() {
539            let record = PersistedResourceRecord {
540                canonical_iri: resource.canonical_iri().into(),
541                facets: vec![],
542            };
543            if !self.output.set_resource_record(resource.id(), Some(record)) {
544                return Err(LegacyMigrationError(
545                    "resource identity insertion was refused".into(),
546                ));
547            }
548        }
549        Ok((resource.id(), url))
550    }
551
552    fn first_origin(
553        &mut self,
554        pair: Pair,
555        payload: &EdgePayload,
556        id: &str,
557        baseline: bool,
558    ) -> Result<Origin, LegacyMigrationError> {
559        let statement = payload
560            .assertions()
561            .iter()
562            .find(|statement| statement.statement_id == id)
563            .expect("claim present");
564        let fixed = statement
565            .recognized_sub_kind
566            .map(|kind| super::built_in_relation_stratum(super::RelationKind::Semantic(kind)))
567            .or_else(|| super::built_in_predicate_stratum(&statement.predicate));
568        let nature = if let Some(nature) = fixed {
569            nature
570        } else if !baseline && self.authored_declarations.contains(&statement.predicate) {
571            // A selected authored declaration in this prefix is evidence at mint time.
572            // A conflict does not reinterpret historical raw assertions.
573            self.source
574                .effective_predicate_stratum(&statement.predicate)
575                .unwrap_or(GraphStratum::Resource)
576        } else {
577            GraphStratum::Resource
578        };
579        if nature == GraphStratum::Surface {
580            return Ok(Origin {
581                surface: pair,
582                resource: None,
583                claim: statement.clone(),
584            });
585        }
586        let (current_from, from_url) = self.ensure_resource(pair.0)?;
587        let (current_to, to_url) = self.ensure_resource(pair.1)?;
588        let (from, to) = self
589            .resolutions
590            .get(id)
591            .copied()
592            .unwrap_or((current_from, current_to));
593        if baseline {
594            let edge = persisted_edge_for_ids(pair.0, pair.1, payload);
595            let statement = edge
596                .retained_assertions()
597                .iter()
598                .find(|statement| statement.statement_id == id)
599                .expect("statement serialized")
600                .clone();
601            self.add_note(
602                from,
603                LegacyMigrationNote {
604                    from_surface_id: pair.0.to_string(),
605                    to_surface_id: pair.1.to_string(),
606                    from_resource_id: from.to_string(),
607                    to_resource_id: to.to_string(),
608                    from_url,
609                    to_url,
610                    statement,
611                    uncertainty: "baseline_current_resources_without_mint_event".into(),
612                },
613            )?;
614        }
615        Ok(Origin {
616            surface: pair,
617            resource: Some((from, to)),
618            claim: statement.clone(),
619        })
620    }
621
622    fn add_note(
623        &mut self,
624        resource: Uuid,
625        note: LegacyMigrationNote,
626    ) -> Result<(), LegacyMigrationError> {
627        let mut record = self
628            .output
629            .resource_record(resource)
630            .expect("resource ensured");
631        let mut notes: Vec<LegacyMigrationNote> = record
632            .facets
633            .iter()
634            .find(|facet| facet.facet == LEGACY_RESOURCE_MIGRATION_FACET)
635            .map(|facet| serde_json::from_str(&facet.value_json))
636            .transpose()
637            .map_err(|error| {
638                LegacyMigrationError(format!("invalid prior migration note: {error}"))
639            })?
640            .unwrap_or_default();
641        if !notes.contains(&note) {
642            notes.push(note);
643        }
644        record
645            .facets
646            .retain(|facet| facet.facet != LEGACY_RESOURCE_MIGRATION_FACET);
647        record.facets.push(PersistedResourceFacet {
648            facet: LEGACY_RESOURCE_MIGRATION_FACET.into(),
649            value_json: serde_json::to_string(&notes).expect("migration note serializes"),
650        });
651        self.output.set_resource_record(resource, Some(record));
652        Ok(())
653    }
654
655    fn first_aggregate_origin(
656        &mut self,
657        pair: Pair,
658        kind: super::RelationKind,
659        author: Option<&super::Author>,
660    ) -> Result<Pair, LegacyMigrationError> {
661        let (from, from_url) = self.ensure_resource(pair.0)?;
662        let (to, to_url) = self.ensure_resource(pair.1)?;
663        let note = LegacyAggregateMigrationNote {
664            from_surface_id: pair.0.to_string(),
665            to_surface_id: pair.1.to_string(),
666            from_resource_id: from.to_string(),
667            to_resource_id: to.to_string(),
668            from_url,
669            to_url,
670            kind,
671            author: author.cloned(),
672            uncertainty: if author.is_some() {
673                "legacy_pair_kind_identity_without_assertion_handle_or_time"
674            } else {
675                "baseline_current_resources_without_mint_event_handle_or_time"
676            }
677            .into(),
678        };
679        let mut record = self.output.resource_record(from).expect("resource ensured");
680        let mut notes: Vec<LegacyAggregateMigrationNote> = record
681            .facets
682            .iter()
683            .find(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
684            .map(|facet| serde_json::from_str(&facet.value_json))
685            .transpose()
686            .map_err(|error| {
687                LegacyMigrationError(format!("invalid aggregate migration note: {error}"))
688            })?
689            .unwrap_or_default();
690        if notes.contains(&note) {
691            return Ok((from, to));
692        }
693        notes.push(note);
694        record
695            .facets
696            .retain(|facet| facet.facet != LEGACY_AGGREGATE_MIGRATION_FACET);
697        record.facets.push(PersistedResourceFacet {
698            facet: LEGACY_AGGREGATE_MIGRATION_FACET.into(),
699            value_json: serde_json::to_string(&notes).expect("aggregate note serializes"),
700        });
701        if !self.output.set_resource_record(from, Some(record)) {
702            return Err(LegacyMigrationError(
703                "aggregate migration note insertion was refused".into(),
704            ));
705        }
706        Ok((from, to))
707    }
708
709    fn sync(
710        &mut self,
711        before: &Pairs,
712        baseline: bool,
713        entry: Option<&AttributedDelta>,
714    ) -> Result<(), LegacyMigrationError> {
715        let after = surface_pairs(&self.source)?;
716        let previous = self.active.clone();
717        let aggregate_previous = self.aggregate_active.clone();
718        let present = statement_ids(&after.values().flatten().cloned().collect::<Vec<_>>());
719        self.active.retain(|id, _| present.contains(id));
720        let mut seen = BTreeMap::new();
721        let mut next = BTreeMap::<String, Membership>::new();
722        let mut aggregate_next = BTreeMap::<(Pair, u32), Membership>::new();
723        for (&pair, edges) in &after {
724            let old_ids = statement_ids(before.get(&pair).map(Vec::as_slice).unwrap_or(&[]));
725            let old_kinds: BTreeSet<_> = before
726                .get(&pair)
727                .into_iter()
728                .flatten()
729                .flat_map(|edge| aggregate_kinds(&payload_from_persisted(edge)))
730                .map(super::RelationKind::tag)
731                .collect();
732            for edge in edges {
733                let mut payload = payload_from_persisted(edge);
734                for kind in aggregate_kinds(&payload).into_iter().filter(|kind| {
735                    super::built_in_relation_stratum(*kind) == GraphStratum::Resource
736                }) {
737                    let key = (pair, kind.tag());
738                    if !self.aggregate_origins.contains_key(&key) {
739                        let proven_author = entry
740                            .filter(|entry| delta_introduces_member(&entry.delta, pair, kind))
741                            .map(|entry| &entry.author);
742                        let resource = self.first_aggregate_origin(pair, kind, proven_author)?;
743                        self.aggregate_origins.insert(key, resource);
744                    }
745                    if self.aggregate_active.contains_key(&key) || !old_kinds.contains(&kind.tag())
746                    {
747                        let resource = self.aggregate_origins[&key];
748                        let mut claim = EdgePayload::new();
749                        // The prefix marks the deterministic record created
750                        // when an old family sidecar is decoded. Lift that
751                        // exact record into its Resource owner; minting a new
752                        // membership assertion here loses identity and makes
753                        // two parallel Surface owners indistinguishable.
754                        let statement = payload
755                            .assertions()
756                            .iter()
757                            .find(|statement| {
758                                statement.is_held()
759                                    && statement.relation_kind() == kind
760                                    && statement.statement_id.starts_with(
761                                        super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX,
762                                    )
763                            })
764                            .expect("legacy aggregate kind has its deterministic source record")
765                            .clone();
766                        claim.assertions.statements.push(statement);
767                        claim.assertions.rebuild_compat();
768                        aggregate_next
769                            .entry(key)
770                            .or_insert_with(|| Membership {
771                                surface: pair,
772                                resource,
773                                edges: Vec::new(),
774                            })
775                            .edges
776                            .push(persisted_edge_for_ids(resource.0, resource.1, &claim));
777                    }
778                }
779                {
780                    let semantic = &mut payload.assertions;
781                    for statement in &mut semantic.statements {
782                        statement.normalize_legacy_asserter();
783                    }
784                }
785                let ids: Vec<_> = payload
786                    .assertions()
787                    .iter()
788                    .map(|statement| statement.statement_id.clone())
789                    .collect();
790                for id in ids {
791                    let statement = payload
792                        .assertions()
793                        .iter()
794                        .find(|statement| statement.statement_id == id)
795                        .expect("claim present");
796                    if let Some((old_pair, old_statement)) =
797                        seen.insert(id.clone(), (pair, statement.clone()))
798                        && (old_pair != pair || old_statement != *statement)
799                    {
800                        return Err(LegacyMigrationError(format!(
801                            "conflicting legacy statement handle {id}"
802                        )));
803                    }
804                    if !self.origins.contains_key(&id) {
805                        let origin = self.first_origin(pair, &payload, &id, baseline)?;
806                        self.origins.insert(id.clone(), origin);
807                    }
808                    let origin = &self.origins[&id];
809                    if origin.surface != pair {
810                        return Err(LegacyMigrationError(format!(
811                            "legacy handle {id} changed original endpoints"
812                        )));
813                    }
814                    if !origin.claim.same_claim_as(statement) {
815                        return Err(LegacyMigrationError(format!(
816                            "legacy handle {id} changed its original claim identity"
817                        )));
818                    }
819                    if let Some(resource) = origin.resource
820                        // Exact records minted from canonical input keep their
821                        // carried IDs in the Resource stratum. The only records
822                        // handled by the pair+kind compatibility migration are
823                        // IDs synthesized while decoding pre-canonical family
824                        // sidecars; those have no source-owned assertion handle.
825                        && !(id.starts_with(super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX)
826                            && aggregate_kinds(&payload)
827                                .contains(&statement.relation_kind()))
828                        && (self.active.contains_key(&id) || !old_ids.contains(&id))
829                    {
830                        let mut claim = EdgePayload::new();
831                        claim.assertions = payload.assertions.clone();
832                        let semantic = &mut claim.assertions;
833                        semantic
834                            .statements
835                            .retain(|statement| statement.statement_id == id);
836                        semantic.rebuild_compat();
837                        let edge = persisted_edge_for_ids(resource.0, resource.1, &claim);
838                        let held = next.entry(id).or_insert_with(|| Membership {
839                            surface: pair,
840                            resource,
841                            edges: Vec::new(),
842                        });
843                        if held.edges.contains(&edge) {
844                            self.note_deduped_copy(pair, resource, &edge)?;
845                        } else {
846                            held.edges.push(edge);
847                        }
848                    }
849                }
850            }
851        }
852        self.active = next;
853        self.aggregate_active = aggregate_next;
854        // Staged: the replay arms' edge check waits for the settle. Remove surface
855        // authority first anyway, before the exact resource handle admission check.
856        for pair in before
857            .keys()
858            .chain(after.keys())
859            .copied()
860            .collect::<BTreeSet<_>>()
861        {
862            let edges = after.get(&pair).map(Vec::as_slice).unwrap_or(&[]);
863            let semantic_filtered = filter_edges(pair, edges, |id| {
864                self.origins
865                    .get(id)
866                    .is_some_and(|origin| origin.resource.is_some())
867            });
868            let (filtered, copies) =
869                copies::split_copies(filter_resource_aggregates(pair, &semantic_filtered));
870            let (Some(from), Some(to)) = (
871                self.output.get_node_key_by_id(pair.0),
872                self.output.get_node_key_by_id(pair.1),
873            ) else {
874                continue;
875            };
876            for copy in &copies {
877                self.note_deduped_surface_copy(pair, copy)?;
878            }
879            if self.output.persisted_edges_between(from, to) != filtered {
880                // Surface restore inserts in petgraph order; reverse to retain the read order.
881                self.output.set_edges_between(
882                    from,
883                    to,
884                    &filtered.iter().rev().cloned().collect::<Vec<_>>(),
885                );
886            }
887        }
888        let mut affected: BTreeSet<_> = previous
889            .keys()
890            .chain(self.active.keys())
891            .filter(|id| previous.get(*id) != self.active.get(*id))
892            .flat_map(|id| {
893                previous
894                    .get(id)
895                    .into_iter()
896                    .chain(self.active.get(id))
897                    .map(|member| member.resource)
898            })
899            .collect();
900        affected.extend(
901            aggregate_previous
902                .keys()
903                .chain(self.aggregate_active.keys())
904                .filter(|key| aggregate_previous.get(*key) != self.aggregate_active.get(*key))
905                .flat_map(|key| {
906                    aggregate_previous
907                        .get(key)
908                        .into_iter()
909                        .chain(self.aggregate_active.get(key))
910                        .map(|member| member.resource)
911                }),
912        );
913        for pair in affected {
914            let existing = self.output.persisted_resource_edges_between(pair.0, pair.1);
915            let mut desired = existing.clone();
916            // Remove only copies this migration previously placed. A typed
917            // checkpoint may have replaced the pair since then; preserve its
918            // independently owned records while reconciling the legacy source.
919            for edge in previous
920                .values()
921                .filter(|member| member.resource == pair)
922                .flat_map(|member| &member.edges)
923            {
924                if let Some(index) = desired.iter().position(|held| held == edge) {
925                    desired.remove(index);
926                }
927            }
928            for edge in aggregate_previous
929                .values()
930                .filter(|member| member.resource == pair)
931                .flat_map(|member| &member.edges)
932            {
933                if let Some(index) = desired.iter().position(|held| held == edge) {
934                    desired.remove(index);
935                }
936            }
937            desired.extend(
938                self.active
939                    .values()
940                    .filter(|member| member.resource == pair)
941                    .flat_map(|member| member.edges.iter().cloned()),
942            );
943            desired.extend(
944                self.aggregate_active
945                    .values()
946                    .filter(|member| member.resource == pair)
947                    .flat_map(|member| member.edges.iter().cloned()),
948            );
949            if desired != existing
950                && !self
951                    .output
952                    .set_resource_edges_between(pair.0, pair.1, &desired)
953            {
954                return Err(LegacyMigrationError(format!(
955                    "resource handle collision on {} -> {}",
956                    pair.0, pair.1
957                )));
958            }
959        }
960        self.dedupe_resource_copies()?;
961        // Raw legacy lifecycle has no shown-resource column. Bind its current pages explicitly.
962        let surfaces: Vec<_> = self.source.nodes().map(|(_, node)| node.id).collect();
963        for surface in surfaces {
964            let source_key = self
965                .source
966                .get_node_key_by_id(surface)
967                .expect("surface exists");
968            if self.source.shown_resource_id(source_key).is_some() {
969                continue;
970            }
971            let (resource, _) = self.ensure_resource(surface)?;
972            self.output.set_shown_resource(surface, Some(resource));
973        }
974        Ok(())
975    }
976}
977
978fn parse_id(id: &str) -> Result<Uuid, LegacyMigrationError> {
979    Uuid::parse_str(id).map_err(|error| LegacyMigrationError(error.to_string()))
980}
981
982fn historical_statement_stratum(
983    graph: &Graph,
984    statement: &super::SemanticStatement,
985) -> GraphStratum {
986    statement
987        .recognized_sub_kind
988        .map(|kind| super::built_in_relation_stratum(super::RelationKind::Semantic(kind)))
989        .or_else(|| super::built_in_predicate_stratum(&statement.predicate))
990        .unwrap_or_else(|| {
991            graph
992                .effective_predicate_stratum(&statement.predicate)
993                .unwrap_or(GraphStratum::Resource)
994        })
995}
996
997fn aggregate_kinds(payload: &EdgePayload) -> Vec<super::RelationKind> {
998    let mut kinds: Vec<_> = payload
999        .held_assertions()
1000        .filter(|statement| {
1001            statement
1002                .statement_id
1003                .starts_with(super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX)
1004        })
1005        .map(|statement| statement.relation_kind())
1006        .filter(|kind| {
1007            matches!(
1008                kind,
1009                super::RelationKind::Containment(_)
1010                    | super::RelationKind::Imported(_)
1011                    | super::RelationKind::Provenance(_)
1012            )
1013        })
1014        .collect();
1015    kinds.sort_by_key(|kind| kind.tag());
1016    kinds.dedup();
1017    kinds
1018}
1019
1020fn filter_resource_aggregates(pair: Pair, edges: &[PersistedEdge]) -> Vec<PersistedEdge> {
1021    edges
1022        .iter()
1023        .filter_map(|edge| {
1024            let mut payload = payload_from_persisted(edge);
1025            let kinds: Vec<_> = aggregate_kinds(&payload)
1026                .into_iter()
1027                .filter(|kind| super::built_in_relation_stratum(*kind) == GraphStratum::Resource)
1028                .collect();
1029            if !kinds.is_empty() {
1030                payload.assertions.statements.retain(|statement| {
1031                    !statement.statement_id.starts_with(
1032                        super::legacy_family_attribution::LEGACY_FAMILY_ASSERTION_ID_PREFIX,
1033                    ) || !kinds.contains(&statement.relation_kind())
1034                });
1035                payload.assertions.rebuild_compat();
1036            }
1037            (!payload.is_empty()).then(|| persisted_edge_for_ids(pair.0, pair.1, &payload))
1038        })
1039        .collect()
1040}
1041
1042fn record_value(
1043    record: &PersistedResourceRecord,
1044) -> Result<(String, BTreeMap<String, serde_json::Value>), LegacyMigrationError> {
1045    let mut facets = BTreeMap::new();
1046    for facet in &record.facets {
1047        let value = serde_json::from_str(&facet.value_json)
1048            .map_err(|error| LegacyMigrationError(error.to_string()))?;
1049        if facets.insert(facet.facet.clone(), value).is_some() {
1050            return Err(LegacyMigrationError(
1051                "duplicate typed resource facet".into(),
1052            ));
1053        }
1054    }
1055    Ok((record.canonical_iri.clone(), facets))
1056}
1057fn current_resource_pair(graph: &Graph, pair: Pair) -> Result<Pair, LegacyMigrationError> {
1058    let resource = |surface| {
1059        graph
1060            .get_node_by_id(surface)
1061            .map(|(_, node)| ResourceNode::new(node.primary_address().as_url_str()).id())
1062            .ok_or_else(|| LegacyMigrationError("legacy endpoint is absent".into()))
1063    };
1064    Ok((resource(pair.0)?, resource(pair.1)?))
1065}
1066fn raw_semantic_edit(delta: &CapturedDelta) -> bool {
1067    matches!(
1068        delta,
1069        CapturedDelta::ReplayAssertRelationByIds {
1070            assertion: super::EdgeAssertion::Semantic { .. },
1071            ..
1072        } | CapturedDelta::ReplayAssertSemanticPredicateByIds { .. }
1073            | CapturedDelta::ReplaySetEdgeSemanticPredicateByIds { .. }
1074    )
1075}
1076
1077/// A legacy aggregate can retain an actor only when this exact replay event
1078/// first asserted the directed member. Full-pair snapshots and unrelated
1079/// checkpoint writes do not attribute newly seen sidecar membership.
1080fn delta_introduces_member(delta: &CapturedDelta, pair: Pair, kind: super::RelationKind) -> bool {
1081    match delta {
1082        CapturedDelta::ReplayAssertRelationByIds {
1083            from_id,
1084            to_id,
1085            assertion,
1086        } => {
1087            let asserted_kind = match assertion {
1088                super::EdgeAssertion::Semantic { sub_kind, .. } => {
1089                    super::RelationKind::Semantic(*sub_kind)
1090                },
1091                super::EdgeAssertion::Containment { sub_kind } => {
1092                    super::RelationKind::Containment(*sub_kind)
1093                },
1094                super::EdgeAssertion::Arrangement { sub_kind } => {
1095                    super::RelationKind::Arrangement(*sub_kind)
1096                },
1097                super::EdgeAssertion::Imported { sub_kind } => {
1098                    super::RelationKind::Imported(*sub_kind)
1099                },
1100                super::EdgeAssertion::Provenance { sub_kind } => {
1101                    super::RelationKind::Provenance(*sub_kind)
1102                },
1103            };
1104            (parse_id(from_id).ok(), parse_id(to_id).ok()) == (Some(pair.0), Some(pair.1))
1105                && asserted_kind == kind
1106        },
1107        _ => false,
1108    }
1109}
1110
1111fn surface_pairs(graph: &Graph) -> Result<Pairs, LegacyMigrationError> {
1112    pairs(&graph.to_snapshot().edges)
1113}
1114fn pairs(edges: &[PersistedEdge]) -> Result<Pairs, LegacyMigrationError> {
1115    let mut pairs = Pairs::new();
1116    for edge in edges {
1117        pairs
1118            .entry((parse_id(&edge.from_node_id)?, parse_id(&edge.to_node_id)?))
1119            .or_default()
1120            .push(edge.clone());
1121    }
1122    Ok(pairs)
1123}
1124fn statement_ids(edges: &[PersistedEdge]) -> BTreeSet<String> {
1125    edges
1126        .iter()
1127        .flat_map(|edge| edge.retained_assertions())
1128        .map(|statement| statement.statement_id.clone())
1129        .collect()
1130}
1131fn filter_edges(
1132    pair: Pair,
1133    edges: &[PersistedEdge],
1134    remove: impl Fn(&str) -> bool,
1135) -> Vec<PersistedEdge> {
1136    edges
1137        .iter()
1138        .filter_map(|edge| {
1139            let mut payload = payload_from_persisted(edge);
1140            let ids: Vec<_> = payload
1141                .assertions()
1142                .iter()
1143                .filter(|statement| remove(&statement.statement_id))
1144                .map(|statement| statement.statement_id.clone())
1145                .collect();
1146            for id in ids {
1147                payload.compact_semantic_statement(&id);
1148            }
1149            (!payload.is_empty()).then(|| persisted_edge_for_ids(pair.0, pair.1, &payload))
1150        })
1151        .collect()
1152}
1153fn legacy_edge_edit(delta: &CapturedDelta) -> bool {
1154    matches!(
1155        delta,
1156        CapturedDelta::ReplayAssertRelationByIds { .. }
1157            | CapturedDelta::ReplayRetractRelationsByIds { .. }
1158            | CapturedDelta::ReplayAppendTraversalByIds { .. }
1159            | CapturedDelta::ReplaySetEdgeSemanticPredicateByIds { .. }
1160            | CapturedDelta::ReplayAssertSemanticPredicateByIds { .. }
1161            | CapturedDelta::ReplaySetEdgesByIds { .. }
1162    )
1163}
1164fn typed_resource_pair(delta: &CapturedDelta) -> Result<Option<Pair>, LegacyMigrationError> {
1165    match delta {
1166        CapturedDelta::ReplaySetResourceEdgesByIds {
1167            from_resource_id,
1168            to_resource_id,
1169            ..
1170        } => Ok(Some((
1171            parse_id(from_resource_id)?,
1172            parse_id(to_resource_id)?,
1173        ))),
1174        _ => Ok(None),
1175    }
1176}
1177
1178fn lifecycle_surface(delta: &CapturedDelta) -> Result<Option<Uuid>, LegacyMigrationError> {
1179    match delta {
1180        CapturedDelta::ReplayAddNodeWithIdIfMissing { id: node_id, .. }
1181        | CapturedDelta::ReplaySetNodeUrlById { node_id, .. }
1182        | CapturedDelta::ReplayNavigateNodeById { node_id, .. }
1183        | CapturedDelta::ReplayNodeHistoryBackById { node_id, .. }
1184        | CapturedDelta::ReplayNodeHistoryForwardById { node_id, .. } => {
1185            Ok(Some(parse_id(node_id)?))
1186        },
1187        _ => Ok(None),
1188    }
1189}
1190
1191fn effects_between(
1192    before: &GraphSnapshot,
1193    after: &GraphSnapshot,
1194    after_facets: &super::node_facets::NodeFacetStore,
1195) -> Result<Vec<CapturedDelta>, LegacyMigrationError> {
1196    let mut effects = Vec::new();
1197    let before_nodes: BTreeMap<_, _> = before
1198        .nodes
1199        .iter()
1200        .map(|node| (node.node_id.as_str(), node))
1201        .collect();
1202    // Content migration removes Surface tags; replay must carry that removal.
1203    for node in &after.nodes {
1204        if let Some(previous) = before_nodes.get(node.node_id.as_str()) {
1205            let mut removed = false;
1206            for tag in &previous.tags {
1207                if !node.tags.contains(tag) {
1208                    removed = true;
1209                    effects.push(CapturedDelta::ReplayRemoveNodeTagById {
1210                        node_id: node.node_id.clone(),
1211                        tag: tag.clone(),
1212                    });
1213                }
1214            }
1215            if removed {
1216                // Raw removal prunes presentation. Migration retains it for the
1217                // same labels now shown through the Resource.
1218                let facet = super::node_facets::PRESENTATION_TAGS;
1219                let id = parse_id(&node.node_id)?;
1220                effects.push(
1221                    match after_facets.get(&id, &chartulary::FacetId::new(facet)) {
1222                        Some(value) => CapturedDelta::ReplaySetNodeFacetById {
1223                            node_id: node.node_id.clone(),
1224                            facet: facet.into(),
1225                            value_json: serde_json::to_string(value).expect("facet serializes"),
1226                        },
1227                        None => CapturedDelta::ReplayRemoveNodeFacetById {
1228                            node_id: node.node_id.clone(),
1229                            facet: facet.into(),
1230                        },
1231                    },
1232                );
1233            }
1234        }
1235    }
1236    let before_records: BTreeMap<_, _> = before
1237        .resources
1238        .iter()
1239        .map(|record| (ResourceNode::for_term(&record.canonical_iri).id(), record))
1240        .collect();
1241    let after_records: BTreeMap<_, _> = after
1242        .resources
1243        .iter()
1244        .map(|record| (ResourceNode::for_term(&record.canonical_iri).id(), record))
1245        .collect();
1246    // Preserve materialized resource insertion order in the exact reconstruction.
1247    let mut seen_records = BTreeSet::new();
1248    for id in after
1249        .resources
1250        .iter()
1251        .chain(&before.resources)
1252        .map(|record| ResourceNode::for_term(&record.canonical_iri).id())
1253        .filter(|id| seen_records.insert(*id))
1254    {
1255        if before_records.get(&id) != after_records.get(&id) {
1256            effects.push(CapturedDelta::ReplaySetResourceRecordById {
1257                resource_id: id.to_string(),
1258                record: after_records.get(&id).map(|record| (*record).clone()),
1259            });
1260        }
1261    }
1262    let before_shown: BTreeMap<_, _> = before
1263        .shown_resources
1264        .iter()
1265        .map(|shown| (&shown.surface_id, &shown.resource_id))
1266        .collect();
1267    let after_shown: BTreeMap<_, _> = after
1268        .shown_resources
1269        .iter()
1270        .map(|shown| (&shown.surface_id, &shown.resource_id))
1271        .collect();
1272    for surface in before_shown
1273        .keys()
1274        .chain(after_shown.keys())
1275        .copied()
1276        .collect::<BTreeSet<_>>()
1277    {
1278        if before_shown.get(surface) != after_shown.get(surface) {
1279            effects.push(CapturedDelta::ReplaySetShownResourceById {
1280                surface_id: surface.clone(),
1281                resource_id: after_shown.get(surface).map(|id| (*id).clone()),
1282            });
1283        }
1284    }
1285    for (resource, before, after) in [
1286        (false, &before.edges, &after.edges),
1287        (true, &before.resource_edges, &after.resource_edges),
1288    ] {
1289        let before = pairs(before)?;
1290        let after = pairs(after)?;
1291        for pair in before
1292            .keys()
1293            .chain(after.keys())
1294            .copied()
1295            .collect::<BTreeSet<_>>()
1296        {
1297            if before.get(&pair) != after.get(&pair) {
1298                let edges = after.get(&pair).cloned().unwrap_or_default();
1299                effects.push(if resource {
1300                    CapturedDelta::ReplaySetResourceEdgesByIds {
1301                        from_resource_id: pair.0.to_string(),
1302                        to_resource_id: pair.1.to_string(),
1303                        edges,
1304                    }
1305                } else {
1306                    CapturedDelta::ReplaySetEdgesByIds {
1307                        from_id: pair.0.to_string(),
1308                        to_id: pair.1.to_string(),
1309                        edges: edges.into_iter().rev().collect(),
1310                    }
1311                });
1312            }
1313        }
1314    }
1315    Ok(effects)
1316}
1317
1318fn facet_effects_between(
1319    before: &super::node_facets::NodeFacetStore,
1320    after: &super::node_facets::NodeFacetStore,
1321) -> Vec<CapturedDelta> {
1322    let values = |store: &super::node_facets::NodeFacetStore| -> BTreeMap<_, _> {
1323        store
1324            .iter()
1325            .flat_map(|(node, facets)| {
1326                facets
1327                    .iter()
1328                    .map(move |(facet, value)| ((*node, facet.as_str().to_owned()), value.clone()))
1329            })
1330            .collect()
1331    };
1332    let before = values(before);
1333    let after = values(after);
1334    before
1335        .keys()
1336        .chain(after.keys())
1337        .collect::<BTreeSet<_>>()
1338        .into_iter()
1339        .filter(|key| before.get(*key) != after.get(*key))
1340        .map(|(node, facet)| match after.get(&(*node, facet.clone())) {
1341            Some(value) => CapturedDelta::ReplaySetNodeFacetById {
1342                node_id: node.to_string(),
1343                facet: facet.clone(),
1344                value_json: serde_json::to_string(value).expect("facet value serializes"),
1345            },
1346            None => CapturedDelta::ReplayRemoveNodeFacetById {
1347                node_id: node.to_string(),
1348                facet: facet.clone(),
1349            },
1350        })
1351        .collect()
1352}
1353
1354#[cfg(test)]
1355mod tests {
1356    use super::super::{
1357        Author, EdgeAssertion, GraphJournal, ImportedSubKind, ProvenanceSubKind, SemanticStatement,
1358        SemanticSubKind, Seq, predicate_iri, replay_captured_deltas_onto,
1359    };
1360    use super::*;
1361    use crate::types::GraphScope;
1362    use euclid::default::Point2D;
1363
1364    fn baseline(urls: &[&str]) -> Graph {
1365        let mut graph = Graph::new();
1366        for (index, url) in urls.iter().enumerate() {
1367            graph.add_node_with_id(
1368                Uuid::from_u128(index as u128 + 1),
1369                (*url).into(),
1370                Point2D::zero(),
1371            );
1372        }
1373        graph
1374    }
1375
1376    fn payload(id: &str, predicate: &str, source: Option<&str>) -> EdgePayload {
1377        let mut payload = EdgePayload::new();
1378        payload.push_persisted_semantic_statement(SemanticStatement {
1379            statement_id: id.into(),
1380            predicate: predicate.into(),
1381            recognized_sub_kind: super::super::sub_kind_from_iri(predicate),
1382            label: Some(format!("label-{id}")),
1383            graph_scope: GraphScope::User,
1384            provenance_iri: source.map(str::to_owned),
1385            asserted_at_ms: Some(100),
1386            first_asserted_ms: Some(100),
1387            withdrawn: None,
1388            basis: Default::default(),
1389        });
1390        payload
1391    }
1392
1393    fn exact(from: u128, to: u128, payload: &EdgePayload) -> CapturedDelta {
1394        let pair = (Uuid::from_u128(from), Uuid::from_u128(to));
1395        CapturedDelta::ReplaySetEdgesByIds {
1396            from_id: pair.0.to_string(),
1397            to_id: pair.1.to_string(),
1398            edges: vec![persisted_edge_for_ids(pair.0, pair.1, payload)],
1399        }
1400    }
1401
1402    fn legacy_sidecar(from: Uuid, to: Uuid, kinds: &[super::super::RelationKind]) -> PersistedEdge {
1403        use super::super::RelationKind;
1404        use crate::persistence::{
1405            PersistedContainmentSubKind as C, PersistedImportedSubKind as I,
1406            PersistedProvenanceSubKind as P,
1407        };
1408
1409        let mut containment = Vec::new();
1410        let mut imported = Vec::new();
1411        let mut provenance = Vec::new();
1412        for kind in kinds {
1413            match kind {
1414                RelationKind::Containment(kind) => containment.push(match kind {
1415                    super::super::ContainmentSubKind::UrlPath => C::UrlPath,
1416                    super::super::ContainmentSubKind::Domain => C::Domain,
1417                    super::super::ContainmentSubKind::FileSystem => C::FileSystem,
1418                    super::super::ContainmentSubKind::UserFolder => C::UserFolder,
1419                    super::super::ContainmentSubKind::ClipSource => C::ClipSource,
1420                    super::super::ContainmentSubKind::NotebookSection => C::NotebookSection,
1421                    super::super::ContainmentSubKind::CollectionMember => C::CollectionMember,
1422                }),
1423                RelationKind::Imported(kind) => imported.push(match kind {
1424                    super::super::ImportedSubKind::BookmarkFolder => I::BookmarkFolder,
1425                    super::super::ImportedSubKind::HistoryImport => I::HistoryImport,
1426                    super::super::ImportedSubKind::SessionImport => I::SessionImport,
1427                    super::super::ImportedSubKind::RssMembership => I::RssMembership,
1428                    super::super::ImportedSubKind::FileSystemImport => I::FileSystemImport,
1429                    super::super::ImportedSubKind::ArchiveMembership => I::ArchiveMembership,
1430                    super::super::ImportedSubKind::SharedCollection => I::SharedCollection,
1431                }),
1432                RelationKind::Provenance(kind) => provenance.push(match kind {
1433                    super::super::ProvenanceSubKind::ClippedFrom => P::ClippedFrom,
1434                    super::super::ProvenanceSubKind::ExcerptedFrom => P::ExcerptedFrom,
1435                    super::super::ProvenanceSubKind::SummarizedFrom => P::SummarizedFrom,
1436                    super::super::ProvenanceSubKind::TranslatedFrom => P::TranslatedFrom,
1437                    super::super::ProvenanceSubKind::RewrittenFrom => P::RewrittenFrom,
1438                    super::super::ProvenanceSubKind::GeneratedFrom => P::GeneratedFrom,
1439                    super::super::ProvenanceSubKind::ExtractedFrom => P::ExtractedFrom,
1440                    super::super::ProvenanceSubKind::ImportedFromSource => P::ImportedFromSource,
1441                    super::super::ProvenanceSubKind::CopiedFrom => P::CopiedFrom,
1442                    super::super::ProvenanceSubKind::MergedFrom => P::MergedFrom,
1443                }),
1444                _ => panic!("test legacy fixture only encodes the three old family sidecars"),
1445            }
1446        }
1447        PersistedEdge {
1448            from_node_id: from.to_string(),
1449            to_node_id: to.to_string(),
1450            families: Vec::new(),
1451            semantic: None,
1452            traversal: None,
1453            containment: (!containment.is_empty()).then_some(PersistedContainmentEdgeData {
1454                sub_kinds: containment,
1455            }),
1456            arrangement: None,
1457            imported: (!imported.is_empty()).then_some(PersistedImportedEdgeData {
1458                sub_kinds: imported,
1459            }),
1460            provenance: (!provenance.is_empty()).then_some(PersistedProvenanceEdgeData {
1461                sub_kinds: provenance,
1462            }),
1463            assertions: None,
1464        }
1465    }
1466
1467    fn exact_legacy(from: u128, to: u128, kind: super::super::RelationKind) -> CapturedDelta {
1468        let (from_id, to_id) = (Uuid::from_u128(from), Uuid::from_u128(to));
1469        CapturedDelta::ReplaySetEdgesByIds {
1470            from_id: from_id.to_string(),
1471            to_id: to_id.to_string(),
1472            edges: vec![legacy_sidecar(from_id, to_id, &[kind])],
1473        }
1474    }
1475
1476    fn clear(from: u128, to: u128) -> CapturedDelta {
1477        CapturedDelta::ReplaySetEdgesByIds {
1478            from_id: Uuid::from_u128(from).to_string(),
1479            to_id: Uuid::from_u128(to).to_string(),
1480            edges: vec![],
1481        }
1482    }
1483
1484    fn resource_pair(a: &str, b: &str) -> Pair {
1485        (ResourceNode::new(a).id(), ResourceNode::new(b).id())
1486    }
1487
1488    fn aggregate_assertion(kind: super::super::RelationKind) -> super::super::EdgeAssertion {
1489        match kind {
1490            super::super::RelationKind::Containment(sub_kind) => {
1491                super::super::EdgeAssertion::Containment { sub_kind }
1492            },
1493            super::super::RelationKind::Imported(sub_kind) => {
1494                super::super::EdgeAssertion::Imported { sub_kind }
1495            },
1496            super::super::RelationKind::Provenance(sub_kind) => {
1497                super::super::EdgeAssertion::Provenance { sub_kind }
1498            },
1499            _ => unreachable!("fixture includes the three nonsemantic families"),
1500        }
1501    }
1502
1503    fn persisted_aggregate_tags(edges: &[PersistedEdge]) -> Vec<u32> {
1504        edges
1505            .iter()
1506            .flat_map(|edge| aggregate_kinds(&payload_from_persisted(edge)))
1507            .map(super::super::RelationKind::tag)
1508            .collect()
1509    }
1510
1511    #[test]
1512    fn legacy_resource_migration_exact_facet_effects_freeze_birth_clock_and_unknown_values() {
1513        let baseline = baseline(&["https://a.test/", "https://b.test/"]);
1514        let born = Uuid::from_u128(3);
1515        let mut journal = GraphJournal::new();
1516        let author = Author::person("legacy-author");
1517        journal.record_as(
1518            author.clone(),
1519            CapturedDelta::ReplayAddNodeWithIdIfMissing {
1520                id: born.to_string(),
1521                url: "https://c.test/".into(),
1522                position: [0.0, 0.0],
1523            },
1524        );
1525        journal.record_as(
1526            author.clone(),
1527            CapturedDelta::ReplayAssertRelationByIds {
1528                from_id: Uuid::from_u128(1).to_string(),
1529                to_id: born.to_string(),
1530                assertion: EdgeAssertion::Semantic {
1531                    sub_kind: SemanticSubKind::UserGrouped,
1532                    label: None,
1533                },
1534            },
1535        );
1536        journal.record_as(
1537            author.clone(),
1538            CapturedDelta::ReplaySetNodeFacetById {
1539                node_id: born.to_string(),
1540                facet: "foreign.opaque".into(),
1541                value_json: r#"{"raw":"KeepCase#Exact","nested":[null,17,{"x":true}]}"#.into(),
1542            },
1543        );
1544        journal.record_as(
1545            author.clone(),
1546            CapturedDelta::ReplaySetNodeFacetById {
1547                node_id: born.to_string(),
1548                facet: "foreign.removed".into(),
1549                value_json: "[1,2]".into(),
1550            },
1551        );
1552        journal.record_as(
1553            author,
1554            CapturedDelta::ReplayRemoveNodeFacetById {
1555                node_id: born.to_string(),
1556                facet: "foreign.removed".into(),
1557            },
1558        );
1559        let input = serde_json::to_vec(journal.entries()).unwrap();
1560        let translated = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1561        assert!(translated.entry_effects[0].iter().any(|delta| matches!(delta,
1562            CapturedDelta::ReplaySetNodeFacetById { node_id, facet, .. }
1563                if node_id == &born.to_string() && facet == super::super::node_facets::VISIT_HISTORY)));
1564        assert!(
1565            translated.entry_effects[4]
1566                .iter()
1567                .any(|delta| matches!(delta,
1568            CapturedDelta::ReplayRemoveNodeFacetById { node_id, facet }
1569                if node_id == &born.to_string() && facet == "foreign.removed"))
1570        );
1571        let snapshot_value = |graph: &Graph| {
1572            let mut value = serde_json::to_value(graph.to_snapshot()).unwrap();
1573            value["timestamp_secs"] = serde_json::json!(0);
1574            value
1575        };
1576        let mut recreated = baseline.clone();
1577        replay_captured_deltas_onto(&mut recreated, translated.baseline_effects.clone());
1578        for effects in &translated.entry_effects {
1579            replay_captured_deltas_onto(&mut recreated, effects.iter().cloned());
1580        }
1581        assert_eq!(
1582            snapshot_value(&recreated),
1583            snapshot_value(&translated.graph)
1584        );
1585        assert_eq!(recreated.facets(), translated.graph.facets());
1586        let mut reordered_baseline = translated.baseline_effects.clone();
1587        let records: Vec<_> = reordered_baseline
1588            .iter()
1589            .enumerate()
1590            .filter_map(|(index, delta)| {
1591                matches!(
1592                    delta,
1593                    CapturedDelta::ReplaySetResourceRecordById {
1594                        record: Some(_),
1595                        ..
1596                    }
1597                )
1598                .then_some(index)
1599            })
1600            .collect();
1601        assert_eq!(records.len(), 2);
1602        for (destination, source) in records.iter().zip(records.iter().rev()) {
1603            reordered_baseline[*destination] = translated.baseline_effects[*source].clone();
1604        }
1605        let mut reordered = baseline.clone();
1606        replay_captured_deltas_onto(&mut reordered, reordered_baseline);
1607        for effects in &translated.entry_effects {
1608            replay_captured_deltas_onto(&mut reordered, effects.iter().cloned());
1609        }
1610        assert_eq!(
1611            reordered.to_snapshot().edges,
1612            translated.graph.to_snapshot().edges,
1613            "changing record creation order does not change the carried statement handle"
1614        );
1615        assert_ne!(
1616            reordered.to_snapshot().resources,
1617            translated.graph.to_snapshot().resources,
1618            "exact frozen reconstruction also preserves resource record order"
1619        );
1620        let mut fresh_clock = baseline.clone();
1621        replay_captured_deltas_onto(&mut fresh_clock, translated.baseline_effects.clone());
1622        for effects in &translated.entry_effects {
1623            replay_captured_deltas_onto(&mut fresh_clock, effects.iter().filter(|delta| !matches!(delta,
1624                CapturedDelta::ReplaySetNodeFacetById { node_id, facet, .. }
1625                    if node_id == &born.to_string() && facet == super::super::node_facets::VISIT_HISTORY)).cloned());
1626        }
1627        let key = translated.graph.get_node_key_by_id(born).unwrap();
1628        let frozen_ms = translated
1629            .graph
1630            .node_last_visited(key)
1631            .unwrap()
1632            .duration_since(std::time::UNIX_EPOCH)
1633            .unwrap()
1634            .as_millis() as u64;
1635        // A controlled later replay clock makes the negative independent of clock resolution.
1636        replay_captured_deltas_onto(
1637            &mut fresh_clock,
1638            [CapturedDelta::ReplayTouchNodeLastVisitedById {
1639                node_id: born.to_string(),
1640                timestamp_ms: frozen_ms.saturating_add(1),
1641            }],
1642        );
1643        assert_eq!(
1644            snapshot_value(&fresh_clock),
1645            snapshot_value(&translated.graph),
1646            "the snapshot alone does not include the authoritative visit facet"
1647        );
1648        assert_ne!(
1649            fresh_clock.facets(),
1650            translated.graph.facets(),
1651            "an unfrozen replay clock is observably different"
1652        );
1653        assert_eq!(serde_json::to_vec(journal.entries()).unwrap(), input);
1654        assert_eq!(
1655            statement_ids(&recreated.to_snapshot().edges),
1656            statement_ids(&translated.graph.to_snapshot().edges)
1657        );
1658    }
1659
1660    #[test]
1661    fn legacy_resource_migration_surface_placed_claims_need_no_resource_origin_resolution() {
1662        let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
1663        for predicate in [
1664            predicate_iri(SemanticSubKind::UserGrouped),
1665            "https://vocab.test/custom",
1666        ] {
1667            let mut entries = Vec::new();
1668            let author = Author::person("mint-author");
1669            entries.push(AttributedDelta {
1670                author: author.clone(),
1671                delta: CapturedDelta::ReplayAssertSemanticPredicateByIds {
1672                    from_id: Uuid::from_u128(1).to_string(),
1673                    to_id: Uuid::from_u128(2).to_string(),
1674                    predicate: predicate.into(),
1675                },
1676            });
1677            entries.push(AttributedDelta {
1678                author: author.clone(),
1679                delta: CapturedDelta::ReplaySetNodeUrlById {
1680                    node_id: Uuid::from_u128(1).to_string(),
1681                    new_url: "https://a.test/new".into(),
1682                },
1683            });
1684            if predicate.starts_with("https://vocab.test/") {
1685                let mut declarations = Graph::new();
1686                declarations
1687                    .declare_predicate(predicate, GraphStratum::Surface)
1688                    .unwrap();
1689                let id = ResourceNode::for_term(predicate).id();
1690                entries.push(AttributedDelta {
1691                    author: author.clone(),
1692                    delta: CapturedDelta::ReplaySetResourceRecordById {
1693                        resource_id: id.to_string(),
1694                        record: declarations.resource_record(id),
1695                    },
1696                });
1697            }
1698            let mut carried = payload("surface-carried", predicate, Some(&author.asserter_iri()));
1699            carried.assertions.statements[0].graph_scope = GraphScope::Default;
1700            entries.push(AttributedDelta {
1701                author,
1702                delta: exact(1, 2, &carried),
1703            });
1704            assert!(
1705                probe_legacy_mint_links(&baseline, &entries)
1706                    .unwrap()
1707                    .is_empty()
1708            );
1709            let result = migrate_legacy_prefix(&baseline, &entries).unwrap();
1710            assert_eq!(
1711                statement_ids(&result.graph.to_snapshot().edges),
1712                BTreeSet::from(["surface-carried".into()])
1713            );
1714            assert!(statement_ids(&result.graph.to_snapshot().resource_edges).is_empty());
1715        }
1716    }
1717
1718    #[test]
1719    fn legacy_resource_migration_new_carried_conflicted_placement_refuses_with_known_handle_controls()
1720     {
1721        let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
1722        let predicate = "https://vocab.test/conflicted";
1723        let author = Author::person("mint");
1724        let mut declarations = Graph::new();
1725        let resource_choice = declarations
1726            .declare_predicate(predicate, GraphStratum::Resource)
1727            .unwrap();
1728        let surface_choice = declarations
1729            .declare_predicate(predicate, GraphStratum::Surface)
1730            .unwrap();
1731        let resource_id = ResourceNode::for_term(predicate).id();
1732        let mut conflict = declarations.resource_record(resource_id).unwrap();
1733        let facet = conflict
1734            .facets
1735            .iter_mut()
1736            .find(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
1737            .unwrap();
1738        let mut choices: super::super::PredicateDeclarations =
1739            serde_json::from_str(&facet.value_json).unwrap();
1740        choices.selected = None;
1741        facet.value_json = serde_json::to_string(&choices).unwrap();
1742        let mut journal = GraphJournal::new();
1743        journal.record_as(
1744            author.clone(),
1745            CapturedDelta::ReplayAssertSemanticPredicateByIds {
1746                from_id: Uuid::from_u128(1).to_string(),
1747                to_id: Uuid::from_u128(2).to_string(),
1748                predicate: predicate.into(),
1749            },
1750        );
1751        journal.record(CapturedDelta::ReplaySetNodeUrlById {
1752            node_id: Uuid::from_u128(1).to_string(),
1753            new_url: "https://a.test/new".into(),
1754        });
1755        journal.record(CapturedDelta::ReplaySetResourceRecordById {
1756            resource_id: resource_id.to_string(),
1757            record: Some(conflict.clone()),
1758        });
1759        let mut carried = payload("new-carried", predicate, Some(&author.asserter_iri()));
1760        carried.assertions.statements[0].graph_scope = GraphScope::Default;
1761        journal.record(exact(1, 2, &carried));
1762        let before = serde_json::to_vec(journal.entries()).unwrap();
1763        let error = migrate_legacy_prefix(&baseline, journal.entries())
1764            .err()
1765            .unwrap();
1766        assert!(error.to_string().contains("checkpoint C22"));
1767        let mut checkpoint = baseline.clone();
1768        let revision = checkpoint.revision();
1769        assert!(
1770            journal
1771                .migrated_replay_from_with_baseline(Seq(0), &mut checkpoint, &baseline)
1772                .is_err()
1773        );
1774        assert_eq!(checkpoint.to_snapshot().edges, baseline.to_snapshot().edges);
1775        assert_eq!(checkpoint.revision(), revision);
1776        assert_eq!(serde_json::to_vec(journal.entries()).unwrap(), before);
1777        for (selected, stratum) in [
1778            (resource_choice, GraphStratum::Resource),
1779            (surface_choice, GraphStratum::Surface),
1780        ] {
1781            choices.selected = Some(selected);
1782            let mut record = conflict.clone();
1783            record
1784                .facets
1785                .iter_mut()
1786                .find(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
1787                .unwrap()
1788                .value_json = serde_json::to_string(&choices).unwrap();
1789            let mut entries = journal.entries().to_vec();
1790            entries[2].delta = CapturedDelta::ReplaySetResourceRecordById {
1791                resource_id: resource_id.to_string(),
1792                record: Some(record),
1793            };
1794            let diagnostics = probe_legacy_mint_links(&baseline, &entries).unwrap();
1795            let resolutions = if stratum == GraphStratum::Resource {
1796                assert_eq!(diagnostics.len(), 1);
1797                vec![LegacyResourceOriginResolution {
1798                    statement_id: "new-carried".into(),
1799                    from_resource_id: parse_id(&diagnostics[0].earlier_resource_pair.0).unwrap(),
1800                    to_resource_id: parse_id(&diagnostics[0].earlier_resource_pair.1).unwrap(),
1801                }]
1802            } else {
1803                assert!(diagnostics.is_empty());
1804                vec![]
1805            };
1806            let result =
1807                migrate_legacy_prefix_with_resolutions(&baseline, &entries, &resolutions).unwrap();
1808            assert_eq!(
1809                statement_ids(&result.graph.to_snapshot().resource_edges).contains("new-carried"),
1810                stratum == GraphStratum::Resource
1811            );
1812            assert_eq!(
1813                statement_ids(&result.graph.to_snapshot().edges).contains("new-carried"),
1814                stratum == GraphStratum::Surface
1815            );
1816        }
1817        // An already observed handle keeps its owning Resource store across the conflict.
1818        let mut known = GraphJournal::new();
1819        known.record(exact(1, 2, &carried));
1820        known.record(CapturedDelta::ReplaySetResourceRecordById {
1821            resource_id: resource_id.to_string(),
1822            record: Some(conflict),
1823        });
1824        known.record(exact(1, 2, &carried));
1825        let result = migrate_legacy_prefix(&baseline, known.entries()).unwrap();
1826        assert_eq!(
1827            statement_ids(&result.graph.to_snapshot().resource_edges),
1828            BTreeSet::from(["new-carried".into()])
1829        );
1830        assert!(result.graph.effective_predicate_stratum(predicate).is_err());
1831    }
1832
1833    #[test]
1834    fn legacy_resource_migration_canonical_family_records_keep_exact_ids_without_aggregate_copies()
1835    {
1836        let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
1837        let kinds: Vec<_> = [(2u32, 7), (4, 7), (5, 9)]
1838            .into_iter()
1839            .flat_map(|(family, count)| (0..count).map(move |sub| (family << 24) | sub))
1840            .map(|tag| super::super::RelationKind::from_tag(tag).unwrap())
1841            .collect();
1842        assert_eq!(kinds.len(), 23);
1843        let mut all = EdgePayload::new();
1844        for kind in &kinds {
1845            all.assert_relation(aggregate_assertion(*kind));
1846        }
1847        let exact_ids: BTreeSet<_> = all
1848            .assertions()
1849            .iter()
1850            .map(|statement| statement.statement_id.clone())
1851            .collect();
1852        let mut journal = GraphJournal::new();
1853        journal.record_as(
1854            Author::engine("legacy-import", "v7").via("reader"),
1855            exact(1, 2, &all),
1856        );
1857        let result = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1858        let snapshot = result.graph.to_snapshot();
1859        // These are already canonical assertion records, not anonymous old
1860        // sidecar memberships. Preserve their exact records without emitting
1861        // compatibility aggregate copies alongside them.
1862        let resource_tags = persisted_aggregate_tags(&snapshot.resource_edges);
1863        let surface_tags = persisted_aggregate_tags(&snapshot.edges);
1864        assert!(resource_tags.is_empty());
1865        assert!(surface_tags.is_empty());
1866        let resource_ids = statement_ids(&snapshot.resource_edges);
1867        let surface_ids = statement_ids(&snapshot.edges);
1868        assert_eq!(resource_ids.len(), 16);
1869        assert_eq!(surface_ids.len(), 7);
1870        assert_eq!(
1871            resource_ids
1872                .union(&surface_ids)
1873                .cloned()
1874                .collect::<BTreeSet<_>>(),
1875            exact_ids
1876        );
1877        for edge in &snapshot.resource_edges {
1878            for statement in payload_from_persisted(edge).assertions() {
1879                assert_eq!(
1880                    super::super::built_in_relation_stratum(statement.relation_kind()),
1881                    GraphStratum::Resource
1882                );
1883            }
1884        }
1885        for edge in &snapshot.edges {
1886            for statement in payload_from_persisted(edge).assertions() {
1887                assert_eq!(
1888                    super::super::built_in_relation_stratum(statement.relation_kind()),
1889                    GraphStratum::Surface
1890                );
1891            }
1892        }
1893        let from = ResourceNode::new("https://a.test/old").id();
1894        let record = result.graph.resource_record(from).unwrap();
1895        assert!(
1896            !record
1897                .facets
1898                .iter()
1899                .any(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
1900        );
1901        let mut effective = baseline.clone();
1902        replay_captured_deltas_onto(&mut effective, result.baseline_effects);
1903        for effects in result.entry_effects {
1904            replay_captured_deltas_onto(&mut effective, effects);
1905        }
1906        assert_eq!(
1907            effective.to_snapshot().resource_edges,
1908            result.graph.to_snapshot().resource_edges
1909        );
1910        assert_eq!(
1911            effective.to_snapshot().edges,
1912            result.graph.to_snapshot().edges
1913        );
1914    }
1915
1916    #[test]
1917    fn legacy_resource_migration_aggregate_original_pair_survives_withdrawal_and_typed_takeover() {
1918        let baseline = baseline(&[
1919            "https://a.test/old",
1920            "https://a.test/old",
1921            "https://b.test/",
1922        ]);
1923        let mut claim = EdgePayload::new();
1924        claim.assert_relation(EdgeAssertion::Provenance {
1925            sub_kind: ProvenanceSubKind::ClippedFrom,
1926        });
1927        let legacy_kind = super::super::RelationKind::Provenance(ProvenanceSubKind::ClippedFrom);
1928        let mint = Author::person("mint");
1929        let mut journal = GraphJournal::new();
1930        journal.record_as(mint, exact_legacy(1, 3, legacy_kind));
1931        journal.record_as(Author::person("alias"), exact_legacy(2, 3, legacy_kind));
1932        journal.record(CapturedDelta::ReplaySetNodeUrlById {
1933            node_id: Uuid::from_u128(1).to_string(),
1934            new_url: "https://a.test/new".into(),
1935        });
1936        journal.record(clear(1, 3));
1937        let pair = resource_pair("https://a.test/old", "https://b.test/");
1938        let withdrawn = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1939        assert_eq!(
1940            persisted_aggregate_tags(
1941                &withdrawn
1942                    .graph
1943                    .persisted_resource_edges_between(pair.0, pair.1)
1944            )
1945            .len(),
1946            1,
1947            "withdrawal preserves the other original surface pair"
1948        );
1949        // Restore the old family membership through its legacy sidecar form.
1950        // `exact` carries canonical assertion IDs and belongs to the typed
1951        // takeover path below; it must not be reinterpreted as an aggregate.
1952        journal.record_as(Author::person("restorer"), exact_legacy(1, 3, legacy_kind));
1953        let restored = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
1954        assert_eq!(
1955            persisted_aggregate_tags(
1956                &restored
1957                    .graph
1958                    .persisted_resource_edges_between(pair.0, pair.1)
1959            )
1960            .len(),
1961            2
1962        );
1963        assert!(
1964            restored
1965                .graph
1966                .persisted_resource_edges_between(
1967                    ResourceNode::new("https://a.test/new").id(),
1968                    pair.1
1969                )
1970                .is_empty()
1971        );
1972        let notes: Vec<LegacyAggregateMigrationNote> = serde_json::from_str(
1973            &restored
1974                .graph
1975                .resource_record(pair.0)
1976                .unwrap()
1977                .facets
1978                .iter()
1979                .find(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
1980                .unwrap()
1981                .value_json,
1982        )
1983        .unwrap();
1984        assert_eq!(notes.len(), 2);
1985        assert_eq!(
1986            notes
1987                .iter()
1988                .find(|note| note.from_surface_id == Uuid::from_u128(1).to_string())
1989                .unwrap()
1990                .author,
1991            None,
1992            "an aggregate snapshot has no exact mint event author"
1993        );
1994        let typed = vec![persisted_edge_for_ids(pair.0, pair.1, &claim)];
1995        journal.record(CapturedDelta::ReplaySetResourceEdgesByIds {
1996            from_resource_id: pair.0.to_string(),
1997            to_resource_id: pair.1.to_string(),
1998            edges: typed.clone(),
1999        });
2000        journal.record(CapturedDelta::ReplaySetNodeTitleById {
2001            node_id: Uuid::from_u128(2).to_string(),
2002            title: "unrelated".into(),
2003        });
2004        let taken = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
2005        assert_eq!(
2006            taken.graph.persisted_resource_edges_between(pair.0, pair.1),
2007            typed,
2008            "explicit pair ownership is not repopulated by an unrelated edit"
2009        );
2010        journal.record(clear(1, 3));
2011        journal.record(exact_legacy(1, 3, legacy_kind));
2012        let new_member = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
2013        let new_member_edges = new_member
2014            .graph
2015            .persisted_resource_edges_between(pair.0, pair.1);
2016        assert_eq!(persisted_aggregate_tags(&new_member_edges).len(), 1);
2017        let records: Vec<_> = new_member_edges
2018            .iter()
2019            .flat_map(|edge| edge.retained_assertions())
2020            .collect();
2021        assert_eq!(
2022            records.len(),
2023            2,
2024            "a later legacy reappearance adds its own copy without erasing the typed copy"
2025        );
2026        assert!(
2027            records.contains(&&typed[0].retained_assertions()[0]),
2028            "the explicit typed record remains exact alongside the legacy copy"
2029        );
2030        journal.record(clear(1, 3));
2031        let final_state = migrate_legacy_prefix(&baseline, journal.entries()).unwrap();
2032        assert_eq!(
2033            final_state
2034                .graph
2035                .persisted_resource_edges_between(pair.0, pair.1),
2036            typed
2037        );
2038    }
2039
2040    #[test]
2041    fn legacy_resource_migration_preserves_baseline_handles_and_uncertainty_with_surface_controls()
2042    {
2043        let mut baseline = baseline(&["https://a.test/current", "https://b.test/current"]);
2044        let mut held = payload("unknown", predicate_iri(SemanticSubKind::Cites), None);
2045        held.push_persisted_semantic_statement(SemanticStatement {
2046            statement_id: "group".into(),
2047            predicate: predicate_iri(SemanticSubKind::UserGrouped).into(),
2048            recognized_sub_kind: Some(SemanticSubKind::UserGrouped),
2049            label: Some("surface control".into()),
2050            graph_scope: GraphScope::User,
2051            provenance_iri: Some("https://group-author.test/".into()),
2052            asserted_at_ms: Some(9),
2053            first_asserted_ms: Some(9),
2054            withdrawn: None,
2055            basis: Default::default(),
2056        });
2057        held.assert_relation(EdgeAssertion::Imported {
2058            sub_kind: ImportedSubKind::BookmarkFolder,
2059        });
2060        held.assert_relation(EdgeAssertion::Provenance {
2061            sub_kind: ProvenanceSubKind::ClippedFrom,
2062        });
2063        let a = baseline.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2064        let b = baseline.get_node_key_by_id(Uuid::from_u128(2)).unwrap();
2065        baseline.inner.connect(a, b, held.clone());
2066        let before = baseline.to_snapshot();
2067        let replay = migrate_legacy_prefix(&baseline, &[]).unwrap();
2068        assert_eq!(
2069            baseline.to_snapshot().edges,
2070            before.edges,
2071            "input remains exact"
2072        );
2073        let pair = resource_pair("https://a.test/current", "https://b.test/current");
2074        let claims = replay
2075            .graph
2076            .persisted_resource_edges_between(pair.0, pair.1);
2077        let source_payload = payload_from_persisted(&before.edges[0]);
2078        let expected_resource_ids: BTreeSet<_> = source_payload
2079            .assertions()
2080            .iter()
2081            .filter(|statement| {
2082                historical_statement_stratum(&baseline, statement) == GraphStratum::Resource
2083            })
2084            .map(|statement| statement.statement_id.clone())
2085            .collect();
2086        let expected_surface_ids: BTreeSet<_> = source_payload
2087            .assertions()
2088            .iter()
2089            .filter(|statement| {
2090                historical_statement_stratum(&baseline, statement) == GraphStratum::Surface
2091            })
2092            .map(|statement| statement.statement_id.clone())
2093            .collect();
2094        assert_eq!(statement_ids(&claims), expected_resource_ids);
2095        assert!(statement_ids(&claims).contains("unknown"));
2096        let claim = claims
2097            .iter()
2098            .flat_map(|edge| edge.retained_assertions())
2099            .find(|statement| statement.statement_id == "unknown")
2100            .expect("unknown legacy statement remains available");
2101        assert_eq!(claim.asserted_at_ms, Some(100));
2102        assert_eq!(
2103            claim.provenance_iri.as_deref(),
2104            Some(super::super::edge_data::UNKNOWN_LEGACY_ASSERTER_IRI)
2105        );
2106        let held_surface = replay.graph.persisted_edges_between(a, b);
2107        assert_eq!(
2108            statement_ids(&held_surface),
2109            expected_surface_ids,
2110            "canonical surface-family records remain on the original Surface pair"
2111        );
2112        assert_eq!(held_surface[0].imported, before.edges[0].imported);
2113        assert!(held_surface[0].provenance.is_none());
2114        assert!(
2115            claims
2116                .iter()
2117                .any(|edge| edge.provenance == before.edges[0].provenance)
2118        );
2119        assert_eq!(
2120            held_surface[0]
2121                .retained_assertions()
2122                .iter()
2123                .find(|statement| statement.statement_id == "group")
2124                .expect("the held user-grouped claim remains on Surface")
2125                .provenance_iri
2126                .as_deref(),
2127            Some("https://group-author.test/")
2128        );
2129        let record = replay.graph.resource_record(pair.0).unwrap();
2130        let notes: Vec<LegacyMigrationNote> = serde_json::from_str(
2131            &record
2132                .facets
2133                .iter()
2134                .find(|facet| facet.facet == LEGACY_RESOURCE_MIGRATION_FACET)
2135                .unwrap()
2136                .value_json,
2137        )
2138        .unwrap();
2139        assert_eq!(notes.len(), expected_resource_ids.len());
2140        let claim_note = notes
2141            .iter()
2142            .find(|note| note.statement.statement_id == claim.statement_id)
2143            .expect("each exact carried record keeps its own migration note");
2144        assert_eq!(claim_note.from_surface_id, Uuid::from_u128(1).to_string());
2145        assert_eq!(claim_note.to_surface_id, Uuid::from_u128(2).to_string());
2146        assert_eq!(
2147            claim_note.uncertainty,
2148            "baseline_current_resources_without_mint_event"
2149        );
2150        assert_eq!(replay.graph.shown_resource_id(a), Some(pair.0));
2151        let mut effective = baseline.clone();
2152        replay_captured_deltas_onto(&mut effective, replay.baseline_effects);
2153        assert_eq!(
2154            effective.to_snapshot().resource_edges,
2155            replay.graph.to_snapshot().resource_edges
2156        );
2157        assert_eq!(
2158            effective.to_snapshot().edges,
2159            replay.graph.to_snapshot().edges
2160        );
2161        assert!(
2162            !record
2163                .facets
2164                .iter()
2165                .any(|facet| facet.facet == LEGACY_AGGREGATE_MIGRATION_FACET)
2166        );
2167        let mut noted_baseline = baseline.clone();
2168        for record in &replay.graph.to_snapshot().resources {
2169            assert!(noted_baseline.set_resource_record(
2170                ResourceNode::for_term(&record.canonical_iri).id(),
2171                Some(record.clone())
2172            ));
2173        }
2174        let repeated = migrate_legacy_prefix(&noted_baseline, &[]).unwrap();
2175        assert_eq!(
2176            repeated.graph.resource_record(pair.0),
2177            replay.graph.resource_record(pair.0),
2178            "an existing identical uncertainty note is a valid no-op"
2179        );
2180    }
2181
2182    #[test]
2183    fn legacy_resource_migration_lifetime_and_pair_membership_survive_navigation_and_restore() {
2184        let baseline = baseline(&[
2185            "https://a.test/old",
2186            "https://a.test/old",
2187            "https://b.test/",
2188        ]);
2189        let alice = Author::person("alice");
2190        let bob = Author::person("bob");
2191        let mut journal = GraphJournal::new();
2192        let predicate = predicate_iri(SemanticSubKind::Cites);
2193        journal.record_as(alice.clone(), exact(1, 3, &payload("one", predicate, None)));
2194        journal.record_as(bob.clone(), exact(2, 3, &payload("two", predicate, None)));
2195        journal.record(CapturedDelta::ReplaySetNodeUrlById {
2196            node_id: Uuid::from_u128(1).to_string(),
2197            new_url: "https://a.test/new".into(),
2198        });
2199        journal.record(clear(1, 3));
2200        let pair = resource_pair("https://a.test/old", "https://b.test/");
2201        let withdrawn = journal
2202            .migrated_prefix_at_from(&baseline, journal.live_cursor())
2203            .unwrap()
2204            .unwrap();
2205        assert_eq!(
2206            statement_ids(
2207                &withdrawn
2208                    .graph
2209                    .persisted_resource_edges_between(pair.0, pair.1)
2210            ),
2211            BTreeSet::from(["two".into()]),
2212            "other original surface pair survives withdrawal"
2213        );
2214        let checkpoint_cursor = journal.live_cursor();
2215        let mut checkpoint = journal
2216            .snapshot_at_from(&baseline, checkpoint_cursor)
2217            .unwrap()
2218            .unwrap();
2219        journal.record_as(
2220            Author::person("restorer"),
2221            exact(1, 3, &payload("one", predicate, None)),
2222        );
2223        let replay = journal
2224            .migrated_prefix_at_from(&baseline, journal.live_cursor())
2225            .unwrap()
2226            .unwrap();
2227        let claims = replay
2228            .graph
2229            .persisted_resource_edges_between(pair.0, pair.1);
2230        assert_eq!(
2231            statement_ids(&claims),
2232            BTreeSet::from(["one".into(), "two".into()])
2233        );
2234        for (id, author) in [("one", alice), ("two", bob)] {
2235            let statement = claims
2236                .iter()
2237                .flat_map(|edge| edge.retained_assertions())
2238                .find(|statement| statement.statement_id == id)
2239                .unwrap();
2240            assert_eq!(statement.asserted_at_ms, Some(100));
2241            assert_eq!(statement.provenance_iri, Some(author.asserter_iri()));
2242        }
2243        let new = ResourceNode::new("https://a.test/new").id();
2244        assert!(
2245            replay
2246                .graph
2247                .persisted_resource_edges_between(new, pair.1)
2248                .is_empty(),
2249            "restored handle does not follow navigation"
2250        );
2251        assert_eq!(
2252            replay
2253                .graph
2254                .shown_resource_id(replay.graph.get_node_key_by_id(Uuid::from_u128(1)).unwrap()),
2255            Some(new)
2256        );
2257        assert!(
2258            replay
2259                .graph
2260                .to_snapshot()
2261                .edges
2262                .iter()
2263                .all(|edge| edge.semantic.is_none() && edge.assertions.is_some())
2264        );
2265        journal
2266            .migrated_replay_from_with_baseline(checkpoint_cursor, &mut checkpoint, &baseline)
2267            .unwrap();
2268        assert_eq!(
2269            checkpoint.to_snapshot().resource_edges,
2270            replay.graph.to_snapshot().resource_edges
2271        );
2272        let mut effective = baseline.clone();
2273        replay_captured_deltas_onto(
2274            &mut effective,
2275            replay
2276                .baseline_effects
2277                .into_iter()
2278                .chain(replay.entry_effects.into_iter().flatten()),
2279        );
2280        assert_eq!(
2281            effective.to_snapshot().resource_edges,
2282            replay.graph.to_snapshot().resource_edges
2283        );
2284        assert!(
2285            journal
2286                .migrated_snapshot_at_from(&baseline, Seq(journal.live_cursor().0 + 1))
2287                .unwrap()
2288                .is_none()
2289        );
2290    }
2291
2292    #[test]
2293    fn legacy_resource_migration_typed_pair_owns_only_its_pair_and_is_not_repopulated() {
2294        let baseline = baseline(&[
2295            "https://a.test/",
2296            "https://b.test/",
2297            "https://c.test/",
2298            "https://d.test/",
2299        ]);
2300        let mut journal = GraphJournal::new();
2301        let predicate = predicate_iri(SemanticSubKind::Cites);
2302        journal.record(exact(
2303            1,
2304            2,
2305            &payload("old-a", predicate, Some("https://author.test/")),
2306        ));
2307        journal.record(exact(
2308            3,
2309            4,
2310            &payload("old-c", predicate, Some("https://author.test/")),
2311        ));
2312        let first = resource_pair("https://a.test/", "https://b.test/");
2313        let second = resource_pair("https://c.test/", "https://d.test/");
2314        let typed = persisted_edge_for_ids(
2315            first.0,
2316            first.1,
2317            &payload("typed", predicate, Some("https://typed-author.test/")),
2318        );
2319        journal.record(CapturedDelta::ReplaySetResourceEdgesByIds {
2320            from_resource_id: first.0.to_string(),
2321            to_resource_id: first.1.to_string(),
2322            edges: vec![typed.clone()],
2323        });
2324        let mut update = payload("old-c", predicate, Some("https://author.test/"));
2325        update.assertions.statements[0].label = Some("later unrelated edit".into());
2326        journal.record(exact(3, 4, &update));
2327        let replay = journal
2328            .migrated_prefix_at_from(&baseline, journal.live_cursor())
2329            .unwrap()
2330            .unwrap();
2331        assert_eq!(
2332            replay
2333                .graph
2334                .persisted_resource_edges_between(first.0, first.1),
2335            vec![typed]
2336        );
2337        assert_eq!(
2338            statement_ids(
2339                &replay
2340                    .graph
2341                    .persisted_resource_edges_between(second.0, second.1)
2342            ),
2343            BTreeSet::from(["old-c".into()])
2344        );
2345        assert!(
2346            replay
2347                .graph
2348                .to_snapshot()
2349                .edges
2350                .iter()
2351                .all(|edge| edge.semantic.is_none() && edge.assertions.is_some())
2352        );
2353        journal.record(CapturedDelta::ReplaySetResourceEdgesByIds {
2354            from_resource_id: first.0.to_string(),
2355            to_resource_id: first.1.to_string(),
2356            edges: vec![],
2357        });
2358        journal.record(exact(3, 4, &update));
2359        let cleared = journal
2360            .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2361            .unwrap()
2362            .unwrap();
2363        assert!(
2364            cleared
2365                .persisted_resource_edges_between(first.0, first.1)
2366                .is_empty(),
2367            "unrelated old membership cannot undo explicit typed clear"
2368        );
2369        assert_eq!(
2370            statement_ids(&cleared.persisted_resource_edges_between(second.0, second.1)),
2371            BTreeSet::from(["old-c".into()])
2372        );
2373    }
2374
2375    #[test]
2376    fn legacy_resource_migration_authored_overrides_apply_at_mint_and_conflicts_keep_typed_history()
2377    {
2378        let baseline = baseline(&["https://a.test/", "https://b.test/"]);
2379        let predicate = "https://vocab.test/p#custom";
2380        let mut declarations = Graph::new();
2381        declarations
2382            .declare_predicate(predicate, GraphStratum::Surface)
2383            .unwrap();
2384        let id = ResourceNode::for_term(predicate).id();
2385        let surface = declarations.resource_record(id).unwrap();
2386        declarations
2387            .declare_predicate(predicate, GraphStratum::Resource)
2388            .unwrap();
2389        let resource = declarations.resource_record(id).unwrap();
2390        let mut journal = GraphJournal::new();
2391        journal.record(CapturedDelta::ReplaySetResourceRecordById {
2392            resource_id: id.to_string(),
2393            record: Some(surface),
2394        });
2395        journal.record(exact(
2396            1,
2397            2,
2398            &payload("surface-mint", predicate, Some("https://author.test/")),
2399        ));
2400        journal.record(CapturedDelta::ReplaySetResourceRecordById {
2401            resource_id: id.to_string(),
2402            record: Some(resource),
2403        });
2404        let mut both = payload("surface-mint", predicate, Some("https://author.test/"));
2405        both.push_persisted_semantic_statement(SemanticStatement {
2406            statement_id: "resource-mint".into(),
2407            predicate: predicate.into(),
2408            recognized_sub_kind: None,
2409            label: None,
2410            graph_scope: GraphScope::User,
2411            provenance_iri: Some("https://other.test/".into()),
2412            asserted_at_ms: Some(200),
2413            first_asserted_ms: Some(200),
2414            withdrawn: None,
2415            basis: Default::default(),
2416        });
2417        journal.record(exact(1, 2, &both));
2418        let migrated = journal
2419            .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2420            .unwrap()
2421            .unwrap();
2422        assert_eq!(
2423            statement_ids(&migrated.to_snapshot().edges),
2424            BTreeSet::from(["surface-mint".into()])
2425        );
2426        assert_eq!(
2427            statement_ids(&migrated.to_snapshot().resource_edges),
2428            BTreeSet::from(["resource-mint".into()])
2429        );
2430        let mut conflicted = migrated.clone();
2431        let mut record = conflicted.resource_record(id).unwrap();
2432        let facet = record
2433            .facets
2434            .iter_mut()
2435            .find(|facet| facet.facet == PREDICATE_DECLARATIONS_FACET)
2436            .unwrap();
2437        let mut declarations: super::super::PredicateDeclarations =
2438            serde_json::from_str(&facet.value_json).unwrap();
2439        declarations.selected = None;
2440        facet.value_json = serde_json::to_string(&declarations).unwrap();
2441        assert!(conflicted.set_resource_record(id, Some(record)));
2442        assert!(conflicted.effective_predicate_stratum(predicate).is_err());
2443        // Only caller-qualified raw legacy bytes are adapted; typed claims keep their store.
2444        let mut typed_only = baseline.clone();
2445        for record in &conflicted.to_snapshot().resources {
2446            let resource = ResourceNode::for_term(&record.canonical_iri).id();
2447            typed_only.set_resource_record(resource, Some(record.clone()));
2448        }
2449        let pair = resource_pair("https://a.test/", "https://b.test/");
2450        let typed = conflicted.persisted_resource_edges_between(pair.0, pair.1);
2451        assert!(typed_only.set_resource_edges_between(pair.0, pair.1, &typed));
2452        let replay = migrate_legacy_prefix(&typed_only, &[]).unwrap();
2453        assert_eq!(
2454            replay
2455                .graph
2456                .persisted_resource_edges_between(pair.0, pair.1),
2457            typed
2458        );
2459        assert!(replay.graph.effective_predicate_stratum(predicate).is_err());
2460    }
2461
2462    #[test]
2463    fn legacy_resource_migration_handle_collision_is_atomic_with_distinct_handle_control() {
2464        let mut baseline = baseline(&["https://a.test/", "https://b.test/"]);
2465        let a = baseline.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2466        let b = baseline.get_node_key_by_id(Uuid::from_u128(2)).unwrap();
2467        let predicate = predicate_iri(SemanticSubKind::Cites);
2468        baseline.inner.connect(
2469            a,
2470            b,
2471            payload("collision", predicate, Some("https://legacy.test/")),
2472        );
2473        let resources = [
2474            ResourceNode::for_term("https://other.test/a"),
2475            ResourceNode::for_term("https://other.test/b"),
2476        ];
2477        for resource in &resources {
2478            assert!(baseline.set_resource_record(
2479                resource.id(),
2480                Some(PersistedResourceRecord {
2481                    canonical_iri: resource.canonical_iri().into(),
2482                    facets: vec![]
2483                })
2484            ));
2485        }
2486        let pair = (resources[0].id(), resources[1].id());
2487        // Deliberately malformed in-memory input bypasses the checked setter.
2488        let from = baseline.resources.key_of(&pair.0).unwrap();
2489        let to = baseline.resources.key_of(&pair.1).unwrap();
2490        baseline.resources.connect(
2491            from,
2492            to,
2493            payload("collision", predicate, Some("https://typed.test/")),
2494        );
2495        let before = baseline.to_snapshot();
2496        assert!(migrate_legacy_prefix(&baseline, &[]).is_err());
2497        assert_eq!(baseline.to_snapshot().edges, before.edges);
2498        assert_eq!(baseline.to_snapshot().resource_edges, before.resource_edges);
2499        let keys: Vec<_> = baseline.resources.inner().edge_indices().collect();
2500        for key in keys {
2501            baseline.resources.disconnect(key);
2502        }
2503        assert!(baseline.set_resource_edges_between(
2504            pair.0,
2505            pair.1,
2506            &[persisted_edge_for_ids(
2507                pair.0,
2508                pair.1,
2509                &payload("distinct", predicate, Some("https://typed.test/"))
2510            )]
2511        ));
2512        let valid = migrate_legacy_prefix(&baseline, &[]).unwrap();
2513        assert_eq!(
2514            statement_ids(&valid.graph.to_snapshot().resource_edges),
2515            BTreeSet::from(["collision".into(), "distinct".into()])
2516        );
2517    }
2518
2519    #[test]
2520    fn legacy_resource_migration_claim_identity_survives_absence_and_allows_metadata_updates() {
2521        let baseline = baseline(&["https://a.test/", "https://b.test/"]);
2522        let predicate = predicate_iri(SemanticSubKind::Cites);
2523        let held = payload("held", predicate, Some("https://author.test/"));
2524        let mut journal = GraphJournal::new();
2525        journal.record(exact(1, 2, &held));
2526        journal.record(clear(1, 2));
2527        let mut metadata = held.clone();
2528        let statement = &mut metadata.assertions.statements[0];
2529        statement.label = Some("new label".into());
2530        statement.basis.note = Some("new label".into());
2531        statement.asserted_at_ms = Some(300);
2532        journal.record(exact(1, 2, &metadata));
2533        let valid = journal
2534            .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2535            .unwrap()
2536            .unwrap();
2537        let valid_snapshot = valid.to_snapshot();
2538        let statement = &valid_snapshot.resource_edges[0].retained_assertions()[0];
2539        assert_eq!(statement.statement_id, "held");
2540        assert_eq!(statement.label.as_deref(), Some("new label"));
2541        assert_eq!(statement.asserted_at_ms, Some(300));
2542        for change in 0..4 {
2543            let mut conflict = held.clone();
2544            let statement = &mut conflict.assertions.statements[0];
2545            match change {
2546                0 => statement.predicate = "https://vocab.test/changed".into(),
2547                1 => statement.recognized_sub_kind = Some(SemanticSubKind::Quotes),
2548                2 => statement.graph_scope = GraphScope::Default,
2549                _ => statement.provenance_iri = Some("https://changed-author.test/".into()),
2550            }
2551            let mut divergent = journal.clone();
2552            divergent.record(clear(1, 2));
2553            divergent.record(exact(1, 2, &conflict));
2554            let source_before = serde_json::to_vec(divergent.entries()).unwrap();
2555            let mut checkpoint = valid.clone();
2556            let before = checkpoint.to_snapshot();
2557            assert!(
2558                divergent
2559                    .migrated_replay_from_with_baseline(Seq(0), &mut checkpoint, &baseline)
2560                    .is_err()
2561            );
2562            assert_eq!(
2563                checkpoint.to_snapshot().resource_edges,
2564                before.resource_edges
2565            );
2566            assert_eq!(
2567                serde_json::to_vec(divergent.entries()).unwrap(),
2568                source_before
2569            );
2570            conflict.assertions.statements[0].statement_id = format!("distinct-{change}");
2571            let mut distinct = journal.clone();
2572            distinct.record(exact(1, 2, &conflict));
2573            assert!(
2574                distinct
2575                    .migrated_snapshot_at_from(&baseline, distinct.live_cursor())
2576                    .unwrap()
2577                    .is_some(),
2578                "distinct-handle control"
2579            );
2580        }
2581    }
2582
2583    #[test]
2584    fn legacy_resource_migration_dedupes_identical_parallel_handle_copies_and_says_so() {
2585        let mut baseline = baseline(&["https://a.test/", "https://b.test/"]);
2586        let a = baseline.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2587        let b = baseline.get_node_key_by_id(Uuid::from_u128(2)).unwrap();
2588        let claim = payload(
2589            "copied",
2590            predicate_iri(SemanticSubKind::Cites),
2591            Some("https://author.test/"),
2592        );
2593        baseline.inner.connect(a, b, claim.clone());
2594        baseline.inner.connect(a, b, claim);
2595        let migrated = migrate_legacy_prefix(&baseline, &[]).unwrap();
2596        let pair = resource_pair("https://a.test/", "https://b.test/");
2597        let rows = migrated
2598            .graph
2599            .persisted_resource_edges_between(pair.0, pair.1);
2600        assert_eq!(rows.len(), 1, "the copy is dropped, the first row kept");
2601        assert_eq!(statement_ids(&rows), BTreeSet::from(["copied".into()]));
2602        assert!(migrated.graph.persisted_edges_between(a, b).is_empty());
2603        let record = migrated.graph.resource_record(pair.0).unwrap();
2604        let notes: Vec<LegacyMigrationNote> = serde_json::from_str(
2605            &record
2606                .facets
2607                .iter()
2608                .find(|facet| facet.facet == LEGACY_RESOURCE_MIGRATION_FACET)
2609                .unwrap()
2610                .value_json,
2611        )
2612        .unwrap();
2613        assert!(
2614            notes
2615                .iter()
2616                .any(|note| note.uncertainty == copies::DEDUPED_COPY
2617                    && note.statement.statement_id == "copied")
2618        );
2619        Graph::try_from_snapshot(&migrated.graph.to_snapshot())
2620            .expect("the migrated graph is legal state");
2621        let mut replayed = baseline.clone();
2622        replay_captured_deltas_onto(&mut replayed, migrated.baseline_effects.clone());
2623        assert_eq!(
2624            replayed.to_snapshot().resources,
2625            migrated.graph.to_snapshot().resources
2626        );
2627        assert_eq!(
2628            replayed.to_snapshot().resource_edges,
2629            migrated.graph.to_snapshot().resource_edges
2630        );
2631        let mut invalid = baseline.clone();
2632        let key = invalid.find_edge_key(a, b).unwrap();
2633        invalid.get_edge_mut(key).unwrap().assertions.statements[0].label =
2634            Some("conflicting copy".into());
2635        invalid.get_edge_mut(key).unwrap().assertions.statements[0]
2636            .basis
2637            .note = Some("conflicting copy".into());
2638        assert!(migrate_legacy_prefix(&invalid, &[]).is_err());
2639        assert_eq!(baseline.persisted_edges_between(a, b).len(), 2);
2640    }
2641
2642    #[test]
2643    fn legacy_resource_migration_new_handles_honor_selected_baseline_declarations() {
2644        let mut baseline = baseline(&["https://a.test/", "https://b.test/"]);
2645        let surface_predicate = "https://vocab.test/surface";
2646        baseline
2647            .declare_predicate(surface_predicate, GraphStratum::Surface)
2648            .unwrap();
2649        let mut journal = GraphJournal::new();
2650        journal.record(exact(
2651            1,
2652            2,
2653            &payload(
2654                "new-surface",
2655                surface_predicate,
2656                Some("https://author.test/"),
2657            ),
2658        ));
2659        let mut combined = payload(
2660            "new-surface",
2661            surface_predicate,
2662            Some("https://author.test/"),
2663        );
2664        combined.push_persisted_semantic_statement(SemanticStatement {
2665            statement_id: "resource-control".into(),
2666            predicate: "https://vocab.test/default".into(),
2667            recognized_sub_kind: None,
2668            label: None,
2669            graph_scope: GraphScope::User,
2670            provenance_iri: Some("https://author.test/".into()),
2671            asserted_at_ms: Some(200),
2672            first_asserted_ms: Some(200),
2673            withdrawn: None,
2674            basis: Default::default(),
2675        });
2676        journal.record(exact(1, 2, &combined));
2677        let graph = journal
2678            .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2679            .unwrap()
2680            .unwrap();
2681        assert_eq!(
2682            statement_ids(&graph.to_snapshot().edges),
2683            BTreeSet::from(["new-surface".into()])
2684        );
2685        assert_eq!(
2686            statement_ids(&graph.to_snapshot().resource_edges),
2687            BTreeSet::from(["resource-control".into()])
2688        );
2689        assert_eq!(
2690            graph.effective_predicate_stratum(surface_predicate),
2691            Ok(GraphStratum::Surface)
2692        );
2693    }
2694
2695    #[test]
2696    fn legacy_resource_migration_effective_captures_undo_claim_after_later_navigation() {
2697        let baseline = baseline(&[
2698            "https://a.test/old",
2699            "https://a.test/old",
2700            "https://b.test/",
2701        ]);
2702        let predicate = predicate_iri(SemanticSubKind::Cites);
2703        let mut journal = GraphJournal::new();
2704        journal.record(exact(
2705            2,
2706            3,
2707            &payload("other", predicate, Some("https://other.test/")),
2708        ));
2709        let before = journal
2710            .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2711            .unwrap()
2712            .unwrap();
2713        journal.record(exact(
2714            1,
2715            3,
2716            &payload("mine", predicate, Some("https://author.test/")),
2717        ));
2718        let after = journal
2719            .migrated_prefix_at_from(&baseline, journal.live_cursor())
2720            .unwrap()
2721            .unwrap();
2722        let change = after.entry_effects.last().unwrap().clone();
2723        assert!(
2724            change
2725                .iter()
2726                .any(|delta| matches!(delta, CapturedDelta::ReplaySetResourceEdgesByIds { .. }))
2727        );
2728        journal.record(CapturedDelta::ReplaySetNodeUrlById {
2729            node_id: Uuid::from_u128(1).to_string(),
2730            new_url: "https://a.test/new".into(),
2731        });
2732        let mut live = journal
2733            .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2734            .unwrap()
2735            .unwrap();
2736        let undo = super::super::revert_change(&change, &before, &after.graph, &live);
2737        assert!(undo.kept.is_empty());
2738        replay_captured_deltas_onto(&mut live, undo.edits);
2739        let pair = resource_pair("https://a.test/old", "https://b.test/");
2740        assert_eq!(
2741            statement_ids(&live.persisted_resource_edges_between(pair.0, pair.1)),
2742            BTreeSet::from(["other".into()])
2743        );
2744        let key = live.get_node_key_by_id(Uuid::from_u128(1)).unwrap();
2745        assert_eq!(
2746            live.get_node(key).unwrap().primary_address().as_url_str(),
2747            "https://a.test/new"
2748        );
2749        assert_eq!(
2750            live.shown_resource_id(key),
2751            Some(ResourceNode::new("https://a.test/new").id())
2752        );
2753    }
2754
2755    #[test]
2756    fn legacy_resource_migration_raw_assertion_retains_author_and_historical_endpoints() {
2757        let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
2758        let mut journal = GraphJournal::new();
2759        let author = Author::person("raw-author");
2760        journal.record_as(
2761            author.clone(),
2762            CapturedDelta::ReplayAssertRelationByIds {
2763                from_id: Uuid::from_u128(1).to_string(),
2764                to_id: Uuid::from_u128(2).to_string(),
2765                assertion: EdgeAssertion::Semantic {
2766                    sub_kind: SemanticSubKind::Cites,
2767                    label: None,
2768                },
2769            },
2770        );
2771        journal.record(CapturedDelta::ReplaySetNodeUrlById {
2772            node_id: Uuid::from_u128(1).to_string(),
2773            new_url: "https://a.test/new".into(),
2774        });
2775        for _ in 0..2 {
2776            let graph = journal
2777                .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2778                .unwrap()
2779                .unwrap();
2780            let pair = resource_pair("https://a.test/old", "https://b.test/");
2781            let claims = graph.persisted_resource_edges_between(pair.0, pair.1);
2782            assert_eq!(claims.len(), 1);
2783            assert_eq!(
2784                claims[0].retained_assertions()[0].provenance_iri,
2785                Some(author.asserter_iri())
2786            );
2787            assert!(
2788                graph
2789                    .persisted_resource_edges_between(
2790                        ResourceNode::new("https://a.test/new").id(),
2791                        pair.1
2792                    )
2793                    .is_empty()
2794            );
2795            assert!(
2796                graph
2797                    .to_snapshot()
2798                    .edges
2799                    .iter()
2800                    .all(|edge| edge.semantic.is_none() && edge.assertions.is_some())
2801            );
2802        }
2803        // Raw records did not carry stable handles; repeated replay deliberately
2804        // makes no identity-equality promise absent from the retained history.
2805        assert!(
2806            probe_legacy_mint_links(&baseline, journal.entries())
2807                .unwrap()
2808                .is_empty()
2809        );
2810    }
2811
2812    #[test]
2813    fn legacy_resource_migration_probe_reports_mixed_raw_and_carried_evidence_without_aliasing() {
2814        let baseline = baseline(&["https://a.test/old", "https://b.test/"]);
2815        let mut journal = GraphJournal::new();
2816        let author = Author::person("mint-author");
2817        journal.record_as(
2818            author.clone(),
2819            CapturedDelta::ReplayAssertRelationByIds {
2820                from_id: Uuid::from_u128(1).to_string(),
2821                to_id: Uuid::from_u128(2).to_string(),
2822                assertion: EdgeAssertion::Semantic {
2823                    sub_kind: SemanticSubKind::Cites,
2824                    label: None,
2825                },
2826            },
2827        );
2828        journal.record(CapturedDelta::ReplaySetNodeUrlById {
2829            node_id: Uuid::from_u128(1).to_string(),
2830            new_url: "https://a.test/new".into(),
2831        });
2832        let mut carried = payload(
2833            "carried",
2834            predicate_iri(SemanticSubKind::Cites),
2835            Some(&author.asserter_iri()),
2836        );
2837        carried.assertions.statements[0].graph_scope = GraphScope::Default;
2838        journal.record_as(Author::person("later-author"), exact(1, 2, &carried));
2839        let source_before = serde_json::to_vec(journal.entries()).unwrap();
2840        let diagnostics = probe_legacy_mint_links(&baseline, journal.entries()).unwrap();
2841        assert_eq!(diagnostics.len(), 1);
2842        let diagnostic = &diagnostics[0];
2843        assert_eq!(
2844            (diagnostic.raw_entry_index, diagnostic.carried_entry_index),
2845            (0, 2)
2846        );
2847        assert_eq!(diagnostic.statement_id, "carried");
2848        assert!(diagnostic.explicit_source_matches);
2849        assert_eq!(
2850            diagnostic.earlier_resource_pair.0,
2851            ResourceNode::new("https://a.test/old").id().to_string()
2852        );
2853        assert_eq!(
2854            diagnostic.current_resource_pair.0,
2855            ResourceNode::new("https://a.test/new").id().to_string()
2856        );
2857        assert_eq!(
2858            serde_json::to_vec(journal.entries()).unwrap(),
2859            source_before
2860        );
2861        for candidate in [
2862            &diagnostic.earlier_resource_pair,
2863            &diagnostic.current_resource_pair,
2864        ] {
2865            let choice = LegacyResourceOriginResolution {
2866                statement_id: "carried".into(),
2867                from_resource_id: parse_id(&candidate.0).unwrap(),
2868                to_resource_id: parse_id(&candidate.1).unwrap(),
2869            };
2870            validate_legacy_origin_resolutions(&baseline, journal.entries(), &[choice.clone()])
2871                .unwrap();
2872            let resolved = migrate_legacy_prefix_with_resolutions(
2873                &baseline,
2874                journal.entries(),
2875                &[choice.clone()],
2876            )
2877            .unwrap();
2878            let exact = resolved
2879                .graph
2880                .persisted_resource_edges_between(choice.from_resource_id, choice.to_resource_id);
2881            assert_eq!(statement_ids(&exact), BTreeSet::from(["carried".into()]));
2882            let claim = &exact
2883                .iter()
2884                .find(|edge| !edge.retained_assertions().is_empty())
2885                .unwrap()
2886                .retained_assertions()[0];
2887            assert_eq!(
2888                claim,
2889                &persisted_edge_for_ids(Uuid::from_u128(1), Uuid::from_u128(2), &carried)
2890                    .retained_assertions()[0],
2891                "resolution preserves carried ID, time and source"
2892            );
2893            let prefix = journal
2894                .migrated_prefix_at_from_with_resolutions(&baseline, Seq(1), &[choice.clone()])
2895                .unwrap()
2896                .unwrap();
2897            assert!(
2898                !statement_ids(&prefix.graph.to_snapshot().resource_edges).contains("carried"),
2899                "future resolution does not invent a handle in an earlier prefix"
2900            );
2901            let mut effective = baseline.clone();
2902            replay_captured_deltas_onto(&mut effective, resolved.baseline_effects);
2903            for effects in resolved.entry_effects {
2904                replay_captured_deltas_onto(&mut effective, effects);
2905            }
2906            assert_eq!(
2907                effective.to_snapshot().resource_edges,
2908                resolved.graph.to_snapshot().resource_edges
2909            );
2910            let mut checkpoint = baseline.clone();
2911            journal
2912                .migrated_replay_from_with_baseline_and_resolutions(
2913                    Seq(1),
2914                    &mut checkpoint,
2915                    &baseline,
2916                    &[choice],
2917                )
2918                .unwrap();
2919            assert_eq!(
2920                statement_ids(&checkpoint.to_snapshot().resource_edges),
2921                BTreeSet::from(["carried".into()])
2922            );
2923        }
2924        let invalid = LegacyResourceOriginResolution {
2925            statement_id: "carried".into(),
2926            from_resource_id: ResourceNode::new("https://third.test/").id(),
2927            to_resource_id: parse_id(&diagnostic.current_resource_pair.1).unwrap(),
2928        };
2929        let mut unknown = invalid.clone();
2930        unknown.statement_id = "absent-handle".into();
2931        let earlier = LegacyResourceOriginResolution {
2932            statement_id: "carried".into(),
2933            from_resource_id: parse_id(&diagnostic.earlier_resource_pair.0).unwrap(),
2934            to_resource_id: parse_id(&diagnostic.earlier_resource_pair.1).unwrap(),
2935        };
2936        let later = LegacyResourceOriginResolution {
2937            from_resource_id: parse_id(&diagnostic.current_resource_pair.0).unwrap(),
2938            ..earlier.clone()
2939        };
2940        for choices in [vec![invalid], vec![unknown], vec![earlier, later]] {
2941            assert!(
2942                migrate_legacy_prefix_with_resolutions(&baseline, journal.entries(), &choices)
2943                    .is_err()
2944            );
2945            assert!(
2946                journal
2947                    .migrated_snapshot_at_from_with_resolutions(&baseline, Seq(1), &choices)
2948                    .is_err()
2949            );
2950            let mut checkpoint = baseline.clone();
2951            let original = checkpoint.to_snapshot();
2952            let revision = checkpoint.revision();
2953            assert!(
2954                journal
2955                    .migrated_replay_from_with_baseline_and_resolutions(
2956                        Seq(0),
2957                        &mut checkpoint,
2958                        &baseline,
2959                        &choices
2960                    )
2961                    .is_err()
2962            );
2963            assert_eq!(checkpoint.to_snapshot().edges, original.edges);
2964            assert_eq!(checkpoint.to_snapshot().resources, original.resources);
2965            assert_eq!(checkpoint.revision(), revision);
2966        }
2967        let error = migrate_legacy_prefix(&baseline, journal.entries())
2968            .err()
2969            .expect("direct adapter must hold unresolved linkage");
2970        assert!(error.to_string().contains("checkpoint C28"));
2971        assert!(
2972            journal
2973                .migrated_prefix_at_from(&baseline, journal.live_cursor())
2974                .is_err()
2975        );
2976        assert!(
2977            journal
2978                .migrated_snapshot_at_from(&baseline, journal.live_cursor())
2979                .is_err()
2980        );
2981        let mut checkpoint = baseline.clone();
2982        let checkpoint_author = Author::person("checkpoint-author");
2983        checkpoint.write_author = checkpoint_author.clone();
2984        checkpoint.current_session = 55;
2985        let seen = std::sync::Arc::new(std::sync::Mutex::new(Vec::<CapturedDelta>::new()));
2986        let sink = seen.clone();
2987        checkpoint.set_recorder(Some(std::sync::Arc::new(move |delta| {
2988            sink.lock().unwrap().push(delta.clone())
2989        })));
2990        let before_checkpoint = serde_json::to_value(checkpoint.to_snapshot()).unwrap();
2991        let before_revision = checkpoint.revision();
2992        let before_url_revision = checkpoint.url_grouping_revision();
2993        assert!(
2994            journal
2995                .migrated_replay_from_with_baseline(Seq(0), &mut checkpoint, &baseline)
2996                .is_err()
2997        );
2998        let mut after_checkpoint = serde_json::to_value(checkpoint.to_snapshot()).unwrap();
2999        after_checkpoint["timestamp_secs"] = before_checkpoint["timestamp_secs"].clone();
3000        assert_eq!(
3001            after_checkpoint, before_checkpoint,
3002            "failed checkpoint replay leaves the whole graph unchanged"
3003        );
3004        assert_eq!(checkpoint.revision(), before_revision);
3005        assert_eq!(checkpoint.url_grouping_revision(), before_url_revision);
3006        assert_eq!(checkpoint.write_author, checkpoint_author);
3007        assert_eq!(checkpoint.current_session, 55);
3008        assert!(checkpoint.is_recording());
3009        assert!(seen.lock().unwrap().is_empty());
3010        assert_eq!(
3011            serde_json::to_vec(journal.entries()).unwrap(),
3012            source_before
3013        );
3014        let witness = CapturedDelta::ReplaySetNodeTitleById {
3015            node_id: Uuid::from_u128(1).to_string(),
3016            title: "recorder remains live".into(),
3017        };
3018        super::super::apply::apply_graph_delta(
3019            &mut checkpoint,
3020            witness.replay().into_write().unwrap(),
3021        );
3022        assert_eq!(
3023            *seen.lock().unwrap(),
3024            vec![witness],
3025            "a real edit proves the retained recorder works"
3026        );
3027        let mut marker = carried.clone();
3028        marker.assertions.statements[0].provenance_iri =
3029            Some(super::super::edge_data::UNKNOWN_LEGACY_ASSERTER_IRI.into());
3030        let mut uncertain = journal.entries()[..2].to_vec();
3031        uncertain.push(AttributedDelta {
3032            author: Author::person("later-author"),
3033            delta: exact(1, 2, &marker),
3034        });
3035        let unknown = probe_legacy_mint_links(&baseline, &uncertain).unwrap();
3036        assert_eq!(
3037            unknown.len(),
3038            1,
3039            "unknown legacy attribution cannot suppress earlier mint evidence"
3040        );
3041        assert!(!unknown[0].explicit_source_matches);
3042        assert!(migrate_legacy_prefix(&baseline, &uncertain).is_err());
3043        marker.assertions.statements[0].provenance_iri =
3044            Some(Author::person("different-author").asserter_iri());
3045        uncertain[2].delta = exact(1, 2, &marker);
3046        assert!(
3047            probe_legacy_mint_links(&baseline, &uncertain)
3048                .unwrap()
3049                .is_empty(),
3050            "a concrete different Author is a distinct claim control"
3051        );
3052        let author_control = migrate_legacy_prefix(&baseline, &uncertain).unwrap();
3053        assert_eq!(
3054            statement_ids(&author_control.graph.to_snapshot().resource_edges),
3055            BTreeSet::from(["carried".into()])
3056        );
3057        // A distinct claim key is an unambiguous carried handle control.
3058        carried.assertions.statements[0].predicate = "https://vocab.test/distinct".into();
3059        carried.assertions.statements[0].recognized_sub_kind = None;
3060        let mut independent = journal.entries()[..2].to_vec();
3061        independent.push(AttributedDelta {
3062            author,
3063            delta: exact(1, 2, &carried),
3064        });
3065        assert!(
3066            probe_legacy_mint_links(&baseline, &independent)
3067                .unwrap()
3068                .is_empty()
3069        );
3070        let predicate_control = migrate_legacy_prefix(&baseline, &independent).unwrap();
3071        assert_eq!(
3072            statement_ids(&predicate_control.graph.to_snapshot().resource_edges),
3073            BTreeSet::from(["carried".into()])
3074        );
3075    }
3076}