gedcomkit 0.1.18__tar.gz → 0.1.19__tar.gz

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/CHANGELOG.md

@@ -7,6 +7,91 @@ rules.
 
 ## [Unreleased]
 
+## [0.1.19] - 2026-10-17
+
+### Added
+
+- `view::EventView::date_phrase` (`datePhrase` in the serialized view, so
+  in both bindings and the TypeScript definitions): the `PHRASE` beneath an
+  event's `DATE`, exactly as written. A GEDCOM 7 date with an empty payload
+  and a `PHRASE`, or a date with a phrase beside it, showed nothing of the
+  phrase before. A 5.5.1 phrase is written inside the payload, which `date`
+  already holds. The Python stub gains an `EventView` typed dict naming
+  every key of an event.
+- The date reader reads ISO 8601's year and month: `1834-02` is February
+  1834, as `1834-02-10` was already 10 February 1834. Only four digits, a
+  hyphen and two digits are read, and only when the month is no more than
+  the year's last two digits: `1808-10`, `1711-12` and `2010-11` are as
+  often a span of years or a dual year as a month, and stay unparsed. So
+  does every month of a year ending in 00 (`1800-01` to `1800-12`), and
+  the later months of a year ending in 01 to 11 (`2005-06` to `2005-12`).
+
+### Changed
+
+- `validate::inspect` no longer reports two events out of order when an
+  approximate date's leeway could put them in order, which is how
+  `conflicting-vitals` already read them. A birth `ABT 1854` with a
+  christening in 1853 was a `christened-before-born` question; it is now
+  no finding. The same holds for `died-before-born`, `buried-before-died`,
+  `event-after-death`, `event-before-birth`, `married-before-born`,
+  `married-after-died` and `child-born-after-mother-died`, each of which
+  now reports only what is out of order beyond the leeway, as a
+  contradiction (a question for an `EVEN` or `FACT`, as before). Within the
+  leeway no other check fires in its place: a marriage in 1849 for somebody
+  born about 1850 is not `married-as-a-child`. Bounds (`BEF`, `AFT`, `BET`)
+  are read as the ranges they admit, unchanged.
+- `convert::to_version_5_5_1` turns a name type back into 5.5.1's
+  spelling: `OTHER` with a one-line `PHRASE` becomes the phrase's words,
+  and an enumerated value is written in lower case (`BIRTH` becomes
+  `birth`). `OTHER` whose words are themselves an enumerated value (the
+  phrase `birth`) stays `other`, its `PHRASE` kept and reported, since the
+  words alone would convert back up as `BIRTH`. A `PHRASE` beside any other
+  value is kept and reported.
+- `DatePoint::from_ymd` refuses a day its month never has (30 February,
+  31 April, day 0). The point is written with no calendar escape, which
+  makes it Gregorian, so 29 February is taken only in a Gregorian leap
+  year: 2000, not 1900.
+
+### Fixed
+
+- A range with an end the date reader cannot read is no longer read in
+  part. `FROM ABT 1924 TO 1959` was read as `TO 1959`, dropping the start
+  without a word, and `BET 1950 AND JULIAN DEC 302` as a range with only
+  its first end; `FROM Infant` was a period with neither end. Each is now
+  `DateKind::Unparsed`, keeps its text as the phrase, and still offers its
+  year to sort by; `to_version_7` keeps it whole as an empty `DATE` with a
+  `PHRASE`. A range whose ends are both dates reads as before.
+- The date reader no longer accepts a day its month does not have.
+  `1834-02-30` and `30 FEB 1834` were read as 30 February 1834; they are
+  now unparsed, as is `29 FEB 1834`. Leap years follow the payload's
+  calendar: `@#DJULIAN@ 29 FEB 1900` is read and `@#DGREGORIAN@ 29 FEB
+  1900` is not. A payload with no calendar escape keeps the Julian leap
+  day, since files often leave the escape off a Julian date, so
+  `29 FEB 1900` is still read; ISO 8601's `1900-02-29` is not, since ISO
+  8601 is Gregorian by definition. A dual year's leap day is its second
+  year's, so `29 FEB 1711/12` and `@#DJULIAN@ 29 FEB 1711/12` are read. A
+  Roman or unrecognized calendar is held to the Julian month lengths, and
+  no Hebrew or French Republican month has more than 30 days. A numeric
+  date with a month or day out of range (`1834-13-05`, `13/05/1834`) is
+  unparsed too; before, the piece out of range was dropped and the rest
+  read (`1834-13-05` as the year 1834).
+- `convert::to_version_5_5_1` no longer writes `INT  (…)`, an interpreted
+  date with no date, for a version 7 `DATE` that is empty beside its
+  `PHRASE`; 5.5.1 does not allow it. The phrase is written as 5.5.1's date
+  phrase, `(FROM ABT 1924 TO 1959)`, or as the date itself when it is
+  already one in 5.5.1's grammar that version 7 cannot spell, so a dual
+  year (`1740/41`) comes back as the date it was.
+- `convert::to_version_7` / `to_version_7_with` convert a personal name's
+  type (`INDI`.`NAME`.`TYPE`), which 5.5.1 writes as free text and version
+  7 as an enumeration. A value that is one of version 7's words in any case
+  (`aka`, `birth`, `immigrant`, `maiden`, `married`, `professional`,
+  `other`) becomes that word in upper case; any other becomes `OTHER`, with
+  the text kept verbatim as a `PHRASE`, the way a role has been converted
+  since 0.1.13. Before, `TYPE aka` was carried into the 7.0 document as it
+  stood, where it is not valid. A type that already has a `PHRASE`, is
+  empty, or has a continuation line with substructures is kept and
+  reported.
+
 ## [0.1.18] - 2026-10-16
 
 ### Added

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/Cargo.lock

@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit"
-version = "0.1.18"
+version = "0.1.19"
 dependencies = [
  "flate2",
  "serde",

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/Cargo.toml

@@ -3,7 +3,7 @@
 # was checked on crates.io, npm, and PyPI before the initial release.
 [package]
 name = "gedcomkit"
-version = "0.1.18"
+version = "0.1.19"
 description = "A byte-preserving GEDCOM document model: decoding, parsing, readings, version conversion, plausibility checks, and the GEDZIP container, for GEDCOM 5.5 through 7.x."
 edition = "2024"
 # The true minimum, not the workspace's toolchain: a parser library is a leaf

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gedcomkit
-Version: 0.1.18
+Version: 0.1.19
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/bindings/gedcomkit-py/Cargo.lock

@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit"
-version = "0.1.18"
+version = "0.1.19"
 dependencies = [
  "flate2",
  "serde",
@@ -43,7 +43,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit-py"
-version = "0.1.18"
+version = "0.1.19"
 dependencies = [
  "gedcomkit",
  "pyo3",

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/bindings/gedcomkit-py/Cargo.toml

@@ -2,7 +2,7 @@
 # abi3 keeps it to one wheel per platform across Python versions.
 [package]
 name = "gedcomkit-py"
-version = "0.1.18"
+version = "0.1.19"
 description = "Python bindings for gedcomkit: an archival-grade GEDCOM library — byte-preserving round-trip, encoding detection, GEDCOM 5.5 through 7.x, GEDZIP."
 edition = "2024"
 rust-version = "1.88"

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/bindings/gedcomkit-py/gedcomkit.pyi

@@ -19,6 +19,29 @@ class RecordSpec(TypedDict):
     value: NotRequired[str | None]
     children: NotRequired[list[RecordSpec]]
 
+class EventView(TypedDict):
+    """One entry of an individual's or a family's ``events``.
+
+    ``date`` is the DATE payload exactly as written. ``datePhrase`` is the
+    GEDCOM 7 PHRASE beneath that DATE, or ``None``: beside a date, or the
+    only text an empty 7.0 DATE has. A 5.5.1 phrase is part of ``date``.
+    """
+
+    tag: str
+    label: str
+    date: str | None
+    datePhrase: str | None
+    dateDisplay: str | None
+    year: int | None
+    sortKey: int | None
+    place: str | None
+    age: str | None
+    cause: str | None
+    attribute: bool
+    value: str | None
+    citations: list[str]
+    path: list[int]
+
 class WrappedLine(TypedDict):
     record: str
     path: list[int]
@@ -42,8 +65,10 @@ class Gedcom:
     def content_records(self) -> int: ...
     def records(self) -> list[dict[str, Any]]: ...
     def record(self, xref: str) -> dict[str, Any]: ...
-    def individuals(self) -> list[dict[str, Any]]: ...
-    def families(self) -> list[dict[str, Any]]: ...
+    def individuals(self) -> list[dict[str, Any]]:
+        """Every individual's view; each of its ``events`` is an ``EventView``."""
+    def families(self) -> list[dict[str, Any]]:
+        """Every family's view; each of its ``events`` is an ``EventView``."""
     def validate(self) -> list[dict[str, Any]]:
         """Plausibility findings, each with ``record``, ``check``, ``severity``
         and ``message``. ``check`` is the core's stable rule name, such as

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/bindings/gedcomkit-py/src/lib.rs

@@ -224,6 +224,8 @@ impl Gedcom {
     }
 
     /// Every individual, read for display: names, events, families, IDs.
+    /// Each event has its `date` payload as written and, beside it,
+    /// `datePhrase`: the GEDCOM 7 `PHRASE` under the date, or `None`.
     fn individuals(&self, py: Python<'_>) -> PyResult<Vec<Py<PyAny>>> {
         self.document
             .records_of("INDI")
@@ -231,7 +233,7 @@ impl Gedcom {
             .collect()
     }
 
-    /// Every family record's view.
+    /// Every family record's view, its events shaped as `individuals`' are.
     fn families(&self, py: Python<'_>) -> PyResult<Vec<Py<PyAny>>> {
         self.document
             .records_of("FAM")

{gedcomkit-0.1.18 → gedcomkit-0.1.19}/src/convert.rs

@@ -336,6 +336,16 @@ fn structures_to_7_node(node: &mut Node, shared: &[String], pass: &mut Pass) ->
         }
     }
 
+    // A personal name's type, free text in 5.5.1, is version 7's enumerated
+    // name type, the words as written kept in a `PHRASE` — as a role is.
+    if node.tag == "INDI" {
+        for name in node.children.iter_mut().filter(|child| child.tag == "NAME") {
+            for kind in name.children.iter_mut().filter(|child| child.tag == "TYPE") {
+                changed |= name_type_to_7(kind, pass);
+            }
+        }
+    }
+
     // A multimedia record's files: `FORM` moves from the object to each
     // `FILE` (5.5), and each file's path, format and medium take version 7's
     // shape (5.5.1 already nests `FORM` under `FILE`, with `TYPE` beneath).
@@ -977,6 +987,148 @@ fn role_to_7(role: &mut Node, pass: &mut Pass) -> bool {
     true
 }
 
+/// Version 7's enumerated name types (`enumset-NAME-TYPE`).
+const NAME_TYPES_7: &[&str] = &[
+    "AKA",
+    "BIRTH",
+    "IMMIGRANT",
+    "MAIDEN",
+    "MARRIED",
+    "PROFESSIONAL",
+    "OTHER",
+];
+
+/// A personal name's `TYPE` (`INDI`.`NAME`.`TYPE`) in version 7's shape.
+/// 5.5.1's values are free text, its own five (`aka`, `birth`, `immigrant`,
+/// `maiden`, `married`) written in lower case; version 7's are an upper-case
+/// enumeration. A value that is one of version 7's words in any case
+/// becomes that word; any other becomes `OTHER`, with the text kept verbatim
+/// as a `PHRASE`. A type that already has a `PHRASE`, is empty, or has a
+/// continuation line with substructures is kept and reported.
+fn name_type_to_7(kind: &mut Node, pass: &mut Pass) -> bool {
+    const LABEL: &str = "NAME.TYPE";
+    let original = kind.logical_value();
+    let trimmed = original.trim();
+    let upper = trimmed.to_ascii_uppercase();
+    if NAME_TYPES_7.contains(&upper.as_str()) && upper == original {
+        return false;
+    }
+    if continuation_has_children(kind) {
+        refuse_for_continuation_children(LABEL, "name type", pass);
+        return false;
+    }
+    if NAME_TYPES_7.contains(&upper.as_str()) {
+        kind.set_logical_value(&upper);
+        pass.note(
+            LABEL,
+            ConversionKind::Converted,
+            format!("the name type {original:?} is version 7's enumerated value {upper}"),
+        );
+        return true;
+    }
+    if trimmed.is_empty() {
+        pass.note(
+            LABEL,
+            ConversionKind::Kept,
+            "an empty name type has no version 7 reading; it is left as it is",
+        );
+        return false;
+    }
+    if kind.first("PHRASE").is_some() {
+        pass.note(
+            LABEL,
+            ConversionKind::Kept,
+            format!(
+                "the name type {original:?} is not version 7's enumeration, but it already has a PHRASE to keep the words in; it is left as it is"
+            ),
+        );
+        return false;
+    }
+    kind.set_logical_value("OTHER");
+    // The text moves as written, as a role's does: a leading `@` that 5.5.1
+    // escaped as `@@` is version 7's escape too.
+    kind.push(Node::with_value("PHRASE", trimmed));
+    pass.note(
+        LABEL,
+        ConversionKind::Converted,
+        format!(
+            "the name type {original:?} is none of version 7's enumerated values; it became OTHER, with the words kept as a PHRASE"
+        ),
+    );
+    true
+}
+
+/// A version 7 name type in 5.5.1's spelling. `OTHER` with a one-line
+/// `PHRASE` becomes the phrase's words, which is how 5.5.1 holds a type it
+/// does not list — unless the words are themselves one of the enumerated
+/// values (`OTHER` with the phrase `birth`), which would come back as that
+/// value, not as `OTHER`. Any other enumerated value, and `OTHER` then, is
+/// written in lower case, as 5.5.1 writes its own five; a `PHRASE` beside
+/// one of those, or one that spans lines or has substructures, has no place
+/// in 5.5.1 and is kept as written and reported.
+fn name_type_to_5(kind: &mut Node, level: usize, pass: &mut Pass) -> bool {
+    const LABEL: &str = "NAME.TYPE";
+    let original = kind.logical_value();
+    let enumerated = original.trim().to_ascii_uppercase();
+    if !NAME_TYPES_7.contains(&enumerated.as_str()) {
+        return false;
+    }
+    if continuation_has_children(kind) {
+        refuse_for_continuation_children(LABEL, "name type", pass);
+        return false;
+    }
+    let phrase = kind
+        .first("PHRASE")
+        .filter(|phrase| phrase.substructures().next().is_none())
+        .map(Node::logical_value)
+        .filter(|phrase| !phrase.contains('\n') && !phrase.trim().is_empty());
+    let reads_as_enumerated = phrase
+        .as_deref()
+        .is_some_and(|words| NAME_TYPES_7.contains(&words.trim().to_ascii_uppercase().as_str()));
+    let changed = match phrase {
+        Some(words)
+            if enumerated == "OTHER" && kind.all("PHRASE").count() == 1 && !reads_as_enumerated =>
+        {
+            remove_child(kind, "PHRASE");
+            kind.set_logical_value(words.trim());
+            pass.note(
+                LABEL,
+                ConversionKind::Converted,
+                "version 7's OTHER name type with a PHRASE is 5.5.1's name type in words",
+            );
+            true
+        }
+        _ => {
+            let lower = enumerated.to_ascii_lowercase();
+            let changed = lower != original;
+            if changed {
+                kind.set_logical_value(&lower);
+                pass.note(
+                    LABEL,
+                    ConversionKind::Converted,
+                    format!("the name type {original:?} is {lower:?} in 5.5.1's spelling"),
+                );
+            }
+            if kind.first("PHRASE").is_some() {
+                pass.note(
+                    "PHRASE",
+                    ConversionKind::Kept,
+                    if enumerated == "OTHER" && reads_as_enumerated {
+                        "5.5.1 has no phrase beside a name type, and this OTHER type's words are themselves an enumerated value, which they would be read as; the PHRASE is kept as written, which 5.5.1 does not define"
+                    } else {
+                        "5.5.1 has no phrase beside a name type; the PHRASE is kept as written, which 5.5.1 does not define"
+                    },
+                );
+            }
+            changed
+        }
+    };
+    if changed {
+        crate::build::fit_own_lines(kind, level, crate::build::MAX_LINE_LENGTH);
+    }
+    changed
+}
+
 /// The roles 5.5.1 enumerates under a cited event.
 const ROLES_5: &[&str] = &["CHIL", "HUSB", "WIFE", "MOTH", "FATH", "SPOU"];
 
@@ -1204,7 +1356,10 @@ fn structures_to_5_node(node: &mut Node, level: usize, pass: &mut Pass) -> bool
     }
 
     // `DATE` with a `PHRASE` folds back into 5.5.1's interpreted form, which
-    // is the same information in the older spelling.
+    // is the same information in the older spelling. An empty date has no
+    // `INT` form, which needs a date: its phrase is 5.5.1's date phrase
+    // `(…)`, or the date itself when the words are already a date in 5.5.1's
+    // grammar that version 7 cannot spell, such as a dual year.
     if node.tag == "DATE"
         && let Some(phrase_node) = node.first("PHRASE")
     {
@@ -1226,15 +1381,28 @@ fn structures_to_5_node(node: &mut Node, level: usize, pass: &mut Pass) -> bool
                 "5.5.1's interpreted date holds one line and nothing beneath it, and this date or phrase spans lines or has substructures; the PHRASE is kept as written, which 5.5.1 does not define",
             );
         } else {
+            let words = phrase.trim();
+            let (written, detail) = if !payload.trim().is_empty() {
+                (
+                    format!("INT {payload} ({phrase})"),
+                    "a dated phrase became 5.5.1's interpreted form",
+                )
+            } else if GedcomDate::parse(words).to_gedcom_5_5_1().as_deref() == Some(words) {
+                (
+                    words.to_owned(),
+                    "a phrase with no date beside it is a date in 5.5.1's own grammar, which version 7 cannot spell; it became the date",
+                )
+            } else {
+                (
+                    format!("({words})"),
+                    "a phrase with no date beside it became 5.5.1's date phrase",
+                )
+            };
             remove_child(node, "PHRASE");
-            node.set_logical_value(&format!("INT {payload} ({phrase})"));
+            node.set_logical_value(&written);
             changed = true;
             own = true;
-            pass.note(
-                "PHRASE",
-                ConversionKind::Converted,
-                "a dated phrase became 5.5.1's interpreted form",
-            );
+            pass.note("PHRASE", ConversionKind::Converted, detail);
         }
     }
 
@@ -1250,6 +1418,15 @@ fn structures_to_5_node(node: &mut Node, level: usize, pass: &mut Pass) -> bool
         }
     }
 
+    // Version 7's enumerated name type goes back to 5.5.1's free text.
+    if node.tag == "INDI" {
+        for name in node.children.iter_mut().filter(|child| child.tag == "NAME") {
+            for kind in name.children.iter_mut().filter(|child| child.tag == "TYPE") {
+                changed |= name_type_to_5(kind, level + 2, pass);
+            }
+        }
+    }
+
     // Everything else version 7 added and 5.5.1 does not define is kept and
     // named. Deleting a translation or a creation date to satisfy a version
     // number would be the worst trade this application could make.
@@ -1478,6 +1655,8 @@ mod tests {
             ("ABT Oct 1803", "ABT OCT 1803"),
             ("44 B.C.", "44 BCE"),
             ("@#DJULIAN@ 10 MAR 1700", "JULIAN 10 MAR 1700"),
+            ("1834-02", "FEB 1834"),
+            ("1834-02-10", "10 FEB 1834"),
         ];
         for (original, rendered) in cases {
             let document = parse(&format!(
@@ -1504,6 +1683,232 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_date_the_reader_once_read_in_part_is_kept_whole_as_a_phrase() {
+        // `FROM ABT 1924 TO 1959` was written as `TO 1959`, and `30 FEB 1834`
+        // passed through as a date: neither is version 7's grammar, and the
+        // first lost its start.
+        for original in [
+            "FROM ABT 1924 TO 1959",
+            "BET ABT 1900 AND 1910",
+            "30 FEB 1834",
+            "1834-02-30",
+        ] {
+            let document = parse(&format!(
+                "0 HEAD\n1 GEDC\n2 VERS 5.5.1\n0 @I1@ INDI\n1 RESI\n2 DATE {original}\n0 TRLR\n"
+            ));
+            let outcome = to_version_7(&document);
+            let text = outcome.document.to_text();
+            assert!(
+                text.contains(&format!("2 DATE\n3 PHRASE {original}\n")),
+                "{original:?} -> {text}"
+            );
+            let note = outcome
+                .notes
+                .iter()
+                .find(|note| note.tag == "DATE")
+                .unwrap_or_else(|| panic!("a note about {original:?}"));
+            assert!(note.detail.contains("cannot hold"), "{}", note.detail);
+        }
+    }
+
+    #[test]
+    fn a_name_type_in_words_becomes_version_7s_enumeration_with_its_phrase() {
+        let document = parse(
+            "0 HEAD\n1 GEDC\n2 VERS 5.5.1\n0 @I1@ INDI\n\
+1 NAME Wren /Testwright/\n2 TYPE aka\n\
+1 NAME Wren /Elder/\n2 TYPE Birth\n\
+1 NAME Wren /Stage/\n2 TYPE professional\n\
+1 NAME Wren /Quill/\n2 TYPE MARRIED\n\
+1 NAME Wren /Nick/\n2 TYPE Nickname\n\
+1 NAME Wren /Shelf/\n2 TYPE also known as\n\
+0 @R1@ REPO\n1 NAME Example Archive\n2 TYPE county office\n0 TRLR\n",
+        );
+        let outcome = to_version_7(&document);
+        let text = outcome.document.to_text();
+        for expected in [
+            "1 NAME Wren /Testwright/\n2 TYPE AKA\n1 NAME",
+            "1 NAME Wren /Elder/\n2 TYPE BIRTH\n1 NAME",
+            "1 NAME Wren /Stage/\n2 TYPE PROFESSIONAL\n1 NAME",
+            "1 NAME Wren /Quill/\n2 TYPE MARRIED\n1 NAME",
+            "1 NAME Wren /Nick/\n2 TYPE OTHER\n3 PHRASE Nickname\n1 NAME",
+            "1 NAME Wren /Shelf/\n2 TYPE OTHER\n3 PHRASE also known as\n0 @R1@",
+            // Only a person's name has a type in either version.
+            "1 NAME Example Archive\n2 TYPE county office\n",
+        ] {
+            assert!(text.contains(expected), "{expected:?} in {text}");
+        }
+        let notes: Vec<&ConversionNote> = outcome
+            .notes
+            .iter()
+            .filter(|note| note.tag == "NAME.TYPE")
+            .collect();
+        assert_eq!(
+            notes.len(),
+            5,
+            "an enumerated value is untouched: {notes:?}"
+        );
+        assert!(
+            notes
+                .iter()
+                .all(|note| note.kind == ConversionKind::Converted)
+        );
+        assert!(
+            notes
+                .iter()
+                .any(|note| note.detail.contains("\"Nickname\"")),
+            "{notes:?}"
+        );
+        // A second conversion has nothing left to do.
+        assert_eq!(to_version_7(&outcome.document).document.to_text(), text);
+
+        // And back: the words return as 5.5.1's free text, and the
+        // enumerated values in 5.5.1's lower case.
+        let back = to_version_5_5_1(&outcome.document);
+        let back_text = back.document.to_text();
+        for expected in [
+            "2 TYPE aka\n",
+            "2 TYPE birth\n",
+            "2 TYPE professional\n",
+            "2 TYPE married\n",
+            "2 TYPE Nickname\n",
+            "2 TYPE also known as\n",
+            "2 TYPE county office\n",
+        ] {
+            assert!(back_text.contains(expected), "{expected:?} in {back_text}");
+        }
+        assert!(!back_text.contains("PHRASE"), "{back_text}");
+        assert!(
+            back.notes
+                .iter()
+                .all(|note| note.kind != ConversionKind::Kept),
+            "{:?}",
+            back.notes
+        );
+    }
+
+    #[test]
+    fn a_name_type_that_cannot_be_converted_is_kept_and_reported() {
+        let document = parse(
+            "0 HEAD\n1 GEDC\n2 VERS 5.5.1\n0 @I1@ INDI\n\
+1 NAME Wren /Testwright/\n2 TYPE Nickname\n3 PHRASE already here\n\
+1 NAME Wren /Blank/\n2 TYPE\n0 TRLR\n",
+        );
+        let outcome = to_version_7(&document);
+        let text = outcome.document.to_text();
+        assert!(
+            text.contains("2 TYPE Nickname\n3 PHRASE already here\n"),
+            "{text}"
+        );
+        assert!(text.contains("1 NAME Wren /Blank/\n2 TYPE\n"), "{text}");
+        let kept: Vec<&ConversionNote> = outcome
+            .notes
+            .iter()
+            .filter(|note| note.tag == "NAME.TYPE")
+            .collect();
+        assert_eq!(kept.len(), 2, "{kept:?}");
+        assert!(kept.iter().all(|note| note.kind == ConversionKind::Kept));
+
+        // Going down, an enumerated value with a phrase beside it keeps the
+        // phrase rather than losing either.
+        let seven = parse(
+            "0 HEAD\n1 GEDC\n2 VERS 7.0\n0 @I1@ INDI\n1 NAME Wren /Testwright/\n2 TYPE BIRTH\n3 PHRASE name at baptism\n0 TRLR\n",
+        );
+        let back = to_version_5_5_1(&seven);
+        let back_text = back.document.to_text();
+        assert!(
+            back_text.contains("2 TYPE birth\n3 PHRASE name at baptism\n"),
+            "{back_text}"
+        );
+        assert!(
+            back.notes
+                .iter()
+                .any(|note| note.tag == "PHRASE" && note.kind == ConversionKind::Kept),
+            "{:?}",
+            back.notes
+        );
+    }
+
+    #[test]
+    fn a_name_type_round_trips_without_growing_or_changing_its_meaning() {
+        // A leading `@` is escaped as `@@` in both versions, so it moves as
+        // written; it once gained an `@` on every conversion up.
+        let five = parse(
+            "0 HEAD\n1 GEDC\n2 VERS 5.5.1\n0 @I1@ INDI\n1 NAME Wren /Testwright/\n2 TYPE @@home\n0 TRLR\n",
+        );
+        let seven = to_version_7(&five).document;
+        let text = seven.to_text();
+        assert!(text.contains("2 TYPE OTHER\n3 PHRASE @@home\n"), "{text}");
+        let back = to_version_5_5_1(&seven).document;
+        let back_text = back.to_text();
+        assert!(back_text.contains("2 TYPE @@home\n"), "{back_text}");
+        assert_eq!(to_version_7(&back).document.to_text(), text);
+
+        // `OTHER` whose words are an enumerated value would come back up as
+        // that value, so it stays `other` beside its phrase.
+        let seven = parse(
+            "0 HEAD\n1 GEDC\n2 VERS 7.0\n0 @I1@ INDI\n1 NAME Wren /Testwright/\n2 TYPE OTHER\n3 PHRASE birth\n0 TRLR\n",
+        );
+        let down = to_version_5_5_1(&seven);
+        let down_text = down.document.to_text();
+        assert!(
+            down_text.contains("2 TYPE other\n3 PHRASE birth\n"),
+            "{down_text}"
+        );
+        assert!(
+            down.notes
+                .iter()
+                .any(|note| note.tag == "PHRASE" && note.kind == ConversionKind::Kept),
+            "{:?}",
+            down.notes
+        );
+        let up = to_version_7(&down.document).document.to_text();
+        assert!(up.contains("2 TYPE OTHER\n3 PHRASE birth\n"), "{up}");
+    }
+
+    #[test]
+    fn an_empty_date_with_a_phrase_goes_down_as_a_valid_5_5_1_date() {
+        // `INT` needs a date beside its phrase, so an empty one was written
+        // `INT  (…)`, which 5.5.1 does not allow.
+        for (original, down) in [
+            ("FROM ABT 1924 TO 1959", "(FROM ABT 1924 TO 1959)"),
+            ("Infant", "(Infant)"),
+            // A dual year is a 5.5.1 date that version 7 cannot spell.
+            ("1740/41", "1740/41"),
+            ("10 JAN 1699/00", "10 JAN 1699/00"),
+        ] {
+            let five = parse(&format!(
+                "0 HEAD\n1 GEDC\n2 VERS 5.5.1\n0 @I1@ INDI\n1 BIRT\n2 DATE {original}\n0 TRLR\n"
+            ));
+            let seven = to_version_7(&five).document;
+            assert!(
+                seven
+                    .to_text()
+                    .contains(&format!("2 DATE\n3 PHRASE {original}\n")),
+                "{original:?}"
+            );
+            let outcome = to_version_5_5_1(&seven);
+            let text = outcome.document.to_text();
+            assert!(
+                text.contains(&format!("1 BIRT\n2 DATE {down}\n")),
+                "{original:?} -> {text}"
+            );
+            assert!(!text.contains("INT") && !text.contains("PHRASE"), "{text}");
+            let note = outcome
+                .notes
+                .iter()
+                .find(|note| note.tag == "PHRASE")
+                .expect("a note about the phrase");
+            assert_eq!(note.kind, ConversionKind::Converted);
+        }
+        // A version 7 phrase of its own goes down the same way.
+        let seven = parse(
+            "0 HEAD\n1 GEDC\n2 VERS 7.0\n0 @I1@ INDI\n1 BIRT\n2 DATE\n3 PHRASE in his youth\n0 TRLR\n",
+        );
+        let text = to_version_5_5_1(&seven).document.to_text();
+        assert!(text.contains("2 DATE (in his youth)\n"), "{text}");
+    }
+
     #[test]
     fn a_dual_year_has_no_version_7_reading_and_becomes_an_empty_date_with_a_phrase() {
         let document =