Pre-push review: series and related works

diff --git a/Packages/AsterismCore/Tests/AsterismCoreTests/BackupV10ArchiveTests.swift b/Packages/AsterismCore/Tests/AsterismCoreTests/BackupV10ArchiveTests.swiftnew file mode 100644index 0000000..83ddcf2--- /dev/null+++ b/Packages/AsterismCore/Tests/AsterismCoreTests/BackupV10ArchiveTests.swift@@ -0,0 +1,1479 @@+import Foundation+import SwiftData+import Testing++@testable import AsterismCore++// Archive generation 10/11 (T-2308, `series-and-related-works` Req 13): the+// payload carries a series table and a link table, a Work record carries its+// series membership, and the schema number names the store the archive was taken+// from (V11). The records are otherwise 9/10's — a Work carries its two statuses+// and verdict, an Entry citation is the cited rule's UUID alone, a Work's site+// presence is a membership record, the reader's dismissed pairs travel beside+// it, no parent record names its children, and the coverage table is folded onto+// the records that own it. It **replaces** 9/10 outright (Q13).+//+// Three suites, because the generation has three surfaces and they fail+// differently: the codec answers for the wire shape and its refusals, the+// exporter for what the store projects into it, and the importer for what an+// archive does to a live library.++// MARK: - Codec++@Suite("Backup V10 codec")+struct BackupV10CodecTests {++    @Test("V10 encode/decode round-trips 10/11, the multi-site gate, and the twelve arrays")+    func roundTrip() throws {+        let payload = BackupV10Fixtures.payload()++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.backupFormatVersion == 10)+        #expect(decoded.databaseSchemaVersion == 11)+        #expect(decoded.capabilityGate == "multi-site")+        #expect(decoded.payload == payload)+        #expect(decoded.payload.characters == payload.characters)+        #expect(decoded.payload.suppressions == payload.suppressions)+        #expect(decoded.payload.memberships == payload.memberships)+        // Req 9.4: the coverage table is gone and the fingerprints ride on the+        // records whose text they describe.+        #expect(+            decoded.payload.entries.first?.characterExtractionFingerprint+                == BackupV10Fixtures.noteFingerprint)+        #expect(+            decoded.payload.works.first?.genericNotesExtractionFingerprint+                == BackupV10Fixtures.genericNotesFingerprint)+    }++    /// Req 8.1. The two statuses travel as the typed enums, exactly as+    /// `titleProvenance` does, and the verdict as the reader's text — asserted+    /// after a real round-trip over a Work carrying all three off their+    /// defaults, so a dropped field cannot pass as a matching default.+    @Test("A Work's two statuses and verdict survive the round-trip typed")+    func workStatusFieldsRoundTrip() throws {+        let payload = BackupV10Fixtures.composedPayload()++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        let record = try #require(+            decoded.payload.works.first { $0.id == BackupV10Fixtures.composedWorkID })+        #expect(record.workStatus == .finished)+        #expect(record.readingStatus == .abandoned)+        #expect(record.verdict == "Dropped it at the timeskip.")+        #expect(decoded.payload.works == payload.works)+    }++    /// Every field of a character is on the wire, including the fact's citation+    /// and its immutable quote — asserted after a real round-trip rather than+    /// trusted to `Codable`.+    @Test("A character's facts, aliases, note and keys survive the round-trip")+    func characterFieldsRoundTrip() throws {+        let facts = [+            BackupV10Fixtures.fact(),+            BackupV10Fixtures.fact(+                statement: "Knows the way through the pass.",+                quote: "knows the way", source: .genericNotes),+        ]+        let payload = BackupV10Fixtures.payload(+            characters: [+                BackupV10Fixtures.character(aliases: ["Klar", "The Guide"], facts: facts)+            ])++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        let character = try #require(decoded.payload.characters.first)+        #expect(character.name == "Grover")+        #expect(character.nameKey == "grover")+        #expect(character.aliases == ["Klar", "The Guide"])+        #expect(character.note == "The guide.")+        #expect(character.facts.count == 2)+        #expect(character.facts.contains { $0.source == .genericNotes })+        #expect(character.facts.contains { $0.source == .entry(BackupV10Fixtures.entryID) })+        #expect(character.facts.allSatisfy { $0.nameKey == "grover" })+    }++    @Test("Both suppression kinds round-trip with their status and action time")+    func suppressionKindsRoundTrip() throws {+        let rows = [+            BackupV10Fixtures.suppression(),+            BackupV10Fixtures.suppression(+                id: BackupV10Fixtures.factSuppressionID, kind: .fact, nameKey: "grover",+                source: .entry(BackupV10Fixtures.entryID), evidence: "promised to guide",+                status: .cleared),+        ]+        let payload = BackupV10Fixtures.payload(suppressions: rows)++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.payload.suppressions == rows)+    }++    // MARK: The two deliberate exemptions++    /// Q78: the exporter enumerates characters whole, so a character whose work+    /// has not arrived exports with a nil work reference rather than vanishing —+    /// and the validator has to let it through, or the backup refuses over a+    /// tolerated in-flight state (Req 6.7).+    @Test("A character with no work reference validates")+    func orphanCharacterValidates() throws {+        let payload = BackupV10Fixtures.payload(+            characters: [BackupV10Fixtures.character(id: BackupV10Fixtures.orphanID, workID: nil)])++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.payload.characters.first?.workID == nil)+    }++    /// Decision 2, pinned so it survives refactors: a fact's citation is+    /// tolerated when it dangles. The reader deleted the cited entry, or it has+    /// not synced — neither is corruption, and refusing here would fail the+    /// whole backup over routine curation.+    @Test("A fact citing an entry the archive does not carry validates")+    func danglingFactCitationValidates() throws {+        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000001")!+        let payload = BackupV10Fixtures.payload(+            characters: [+                BackupV10Fixtures.character(facts: [BackupV10Fixtures.fact(source: .entry(absent))])+            ],+            suppressions: [+                BackupV10Fixtures.suppression(+                    id: BackupV10Fixtures.factSuppressionID, kind: .fact, nameKey: "grover",+                    source: .entry(absent), evidence: "gone")+            ])++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.payload.characters.first?.facts.first?.source == .entry(absent))+        #expect(decoded.payload.suppressions.first?.sourceEntryID == absent)+    }++    /// The other half of the character rule: optional, but **checked when+    /// present** — the `validateEntry` `workID` pattern.+    @Test("A character naming a work the archive does not carry refuses")+    func characterCitingAnAbsentWorkRefuses() throws {+        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000002")!+        let payload = BackupV10Fixtures.payload(+            characters: [BackupV10Fixtures.character(workID: absent)])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    @Test("A suppression naming a work the archive does not carry refuses")+    func suppressionCitingAnAbsentWorkRefuses() throws {+        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000003")!+        let payload = BackupV10Fixtures.payload(+            suppressions: [BackupV10Fixtures.suppression(workID: absent)])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    // MARK: Payloads that contradict themselves++    @Test("Two records for one character identity refuse")+    func duplicateCharacterIDRefuses() throws {+        let payload = BackupV10Fixtures.payload(+            characters: [BackupV10Fixtures.character(), BackupV10Fixtures.character()])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    @Test("Two records for one suppression identity refuse")+    func duplicateSuppressionIDRefuses() throws {+        let payload = BackupV10Fixtures.payload(+            suppressions: [BackupV10Fixtures.suppression(), BackupV10Fixtures.suppression()])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    // MARK: The two Req 9.5 membership refusals++    /// Req 9.5, first half. An Entry's Work is in the file and holds no+    /// membership on the Entry's hostname: the restored library would start in+    /// exactly the state reconciliation exists to heal, and an archive has to be+    /// wholly legal on arrival (Q50).+    @Test("An Entry whose present Work has no membership on its hostname refuses")+    func entryWithoutAMembershipOnItsHostnameRefuses() throws {+        let base = BackupV10Fixtures.composedPayload()++        // The premise: with the membership present the payload is legal.+        _ = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: base, metadata: BackupV10Fixtures.metadata()))++        let uncovered = BackupV10Payload(+            entries: base.entries, works: base.works, sites: base.sites,+            titlePatterns: base.titlePatterns, urlRules: base.urlRules,+            workTypes: base.workTypes, memberships: [])+        let error = #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(+                    payload: uncovered, metadata: BackupV10Fixtures.metadata()))+        }+        guard case .unresolvedReference(let type, _, let reference) = error else {+            Issue.record("expected an unresolved reference, got \(String(describing: error))")+            return+        }+        #expect(type == "Entry")+        #expect(reference.contains("membership"))+    }++    /// Req 9.5, second half. Two memberships on one `(workID, hostname)` is a+    /// file that cannot say which row the Work is on — a state sync produces and+    /// the reconciler resolves (Req 2.6, 8.2), and one an archive may not carry.+    @Test("Two memberships for one Work and hostname refuse")+    func duplicateMembershipForOneHostnameRefuses() throws {+        let base = BackupV10Fixtures.composedPayload()+        let twin = BackupV10Fixtures.membership(+            id: UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeee2")!,+            workID: BackupV10Fixtures.composedWorkID, hostname: "example.com")+        let payload = BackupV10Payload(+            entries: base.entries, works: base.works, sites: base.sites,+            titlePatterns: base.titlePatterns, urlRules: base.urlRules,+            workTypes: base.workTypes, memberships: base.memberships + [twin])++        let error = #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+        guard case .invalidStateTuple(let type, _, let reason) = error else {+            Issue.record("expected an invalid state tuple, got \(String(describing: error))")+            return+        }+        #expect(type == "WorkSiteMembership")+        #expect(reason.contains("example.com"))+    }++    /// Req 9.5's tolerance, and Q22's: a membership or a pair naming a Work the+    /// archive does not carry is an orphan, not a contradiction. It imports+    /// unattached and re-attaches when the Work arrives.+    @Test("A membership and a pair naming an absent Work are accepted")+    func unattachedMembershipAndPairValidate() throws {+        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000010")!+        let other = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000011")!+        let base = BackupV10Fixtures.composedPayload()+        let orphan = BackupV10Fixtures.membership(+            id: UUID(uuidString: "0adbea00-0000-4000-8000-000000000001")!,+            workID: absent, hostname: "example.com")+        let ids = WorkDistinctPair.sortedIDs(absent, other)+        let payload = BackupV10Payload(+            entries: base.entries, works: base.works, sites: base.sites,+            titlePatterns: base.titlePatterns, urlRules: base.urlRules,+            workTypes: base.workTypes, memberships: base.memberships + [orphan],+            distinctPairs: [+                BackupV10DistinctPair(+                    id: UUID(uuidString: "0adbea00-0000-4000-8000-000000000002")!,+                    lowerWorkID: ids.lower, higherWorkID: ids.higher,+                    recordedAt: BackupV10Fixtures.created)+            ])++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.payload.memberships.contains { $0.workID == absent })+        #expect(decoded.payload.distinctPairs.count == 1)+    }++    /// A membership's own tuple is checked whether or not its Work is here: the+    /// identity arms are the Work arm's, moved to the row that now holds the+    /// value (Req 1.2).+    @Test("A membership whose identity tuple contradicts itself refuses")+    func illegalMembershipTupleRefuses() throws {+        let base = BackupV10Fixtures.composedPayload()+        let illegal = BackupV10Membership(+            id: BackupV10Fixtures.composedMembershipID,+            workID: BackupV10Fixtures.composedWorkID, hostname: "example.com",+            createdAt: BackupV10Fixtures.created, urlIdentity: nil, urlIdentityState: .rule,+            urlIdentityRuleID: nil, workURLString: nil)+        let payload = BackupV10Payload(+            entries: base.entries, works: base.works, sites: base.sites,+            titlePatterns: base.titlePatterns, urlRules: base.urlRules,+            workTypes: base.workTypes, memberships: [illegal])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    /// Q54 retired the membership's `(id, version)` **resolution**, not the+    /// site. A rule the archive carries is one this check can read the hostname+    /// of, and an identity derived on one site by another site's rule is a value+    /// no writer produces — the Entry's identity arm refuses the same shape.+    @Test("A membership citing a rule taught for another site refuses")+    func membershipCitingAnotherSitesRuleRefuses() throws {+        let base = BackupV10Fixtures.composedPayload()+        let otherHost = "other.example"+        let otherRuleID = UUID(uuidString: "dddddddd-dddd-dddd-dddd-ddddddddddd2")!+        let otherSite = BackupV10Site(+            hostname: otherHost, displayName: "Other", mode: .untaught, junkSuffixRule: nil)+        let otherRule = BackupV10URLRule(+            id: otherRuleID, version: 1, isCurrent: false, createdAt: BackupV10Fixtures.created,+            origin: .importedV2,+            definition: .work(locator: .query(name: ExactScalarString("series"))),+            siteHostname: otherHost)+        // The membership is on example.com and cites other.example's rule.+        let crossSite = BackupV10Fixtures.membership(+            id: BackupV10Fixtures.composedMembershipID,+            workID: BackupV10Fixtures.composedWorkID, hostname: "example.com",+            urlIdentity: "serial-9", urlIdentityState: .rule, urlIdentityRuleID: otherRuleID)+        let payload = BackupV10Payload(+            entries: base.entries, works: base.works, sites: base.sites + [otherSite],+            titlePatterns: base.titlePatterns, urlRules: base.urlRules + [otherRule],+            workTypes: base.workTypes, memberships: [crossSite])++        let error = #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+        guard case .invalidStateTuple(let type, _, let reason) = error else {+            Issue.record("expected an invalid state tuple, got \(String(describing: error))")+            return+        }+        #expect(type == "WorkSiteMembership")+        #expect(reason.contains(otherHost))+    }++    /// The other half of Q54, and Q72: a membership whose cited rule the archive+    /// does not carry at all is **accepted**. There is no version to resolve and+    /// no hostname to compare; the row reads as `legacyUnverified` until the rule+    /// arrives, which is a tolerated state rather than a corrupt file.+    @Test("A membership citing a rule the archive does not carry is accepted")+    func membershipCitingAnAbsentRuleValidates() throws {+        let base = BackupV10Fixtures.composedPayload()+        let absentRule = UUID(uuidString: "dddddddd-dddd-dddd-dddd-ddddddddddd3")!+        let dangling = BackupV10Fixtures.membership(+            id: BackupV10Fixtures.composedMembershipID,+            workID: BackupV10Fixtures.composedWorkID, hostname: "example.com",+            urlIdentity: "serial-9", urlIdentityState: .rule, urlIdentityRuleID: absentRule)+        let payload = BackupV10Payload(+            entries: base.entries, works: base.works, sites: base.sites,+            titlePatterns: base.titlePatterns, urlRules: base.urlRules,+            workTypes: base.workTypes, memberships: [dangling])++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.payload.memberships.first?.urlIdentityRuleID == absentRule)+    }++    // MARK: Series and links (`series-and-related-works` Req 13.5)++    /// The whole V11 surface survives a real round trip: the series table, both+    /// works' membership pairs, and the link between them.+    @Test("Series, memberships and links round-trip through the codec")+    func seriesAndLinksRoundTrip() throws {+        let payload = BackupV10Fixtures.seriesPayload()++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.payload.series == payload.series)+        #expect(decoded.payload.links == payload.links)+        let first = try #require(+            decoded.payload.works.first { $0.id == BackupV10Fixtures.composedWorkID })+        #expect(first.seriesID == BackupV10Fixtures.seriesID)+        #expect(first.seriesPosition == 1)+        let second = try #require(+            decoded.payload.works.first { $0.id == BackupV10Fixtures.secondWorkID })+        #expect(second.seriesPosition == 2.5)+    }++    @Test("Two records for one series identity refuse")+    func duplicateSeriesIDRefuses() throws {+        let payload = BackupV10Fixtures.seriesPayload(+            series: [BackupV10Fixtures.seriesRecord(), BackupV10Fixtures.seriesRecord()])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    @Test("Two records for one link identity refuse")+    func duplicateLinkIDRefuses() throws {+        let payload = BackupV10Fixtures.seriesPayload(+            links: [BackupV10Fixtures.linkRecord(), BackupV10Fixtures.linkRecord()])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    /// Req 6.1 forbids a link from a work to itself, so a row saying otherwise+    /// is not a link a reader can have meant. The export filters the shape out+    /// before a file exists; this answers for an archive written elsewhere.+    @Test("A link naming one work twice refuses")+    func selfLinkRefuses() throws {+        let payload = BackupV10Fixtures.seriesPayload(+            links: [+                BackupV10Fixtures.linkRecord(+                    a: BackupV10Fixtures.composedWorkID, b: BackupV10Fixtures.composedWorkID)+            ])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    /// Req 13.2: the archive carries the logical library, so a pair holds one+    /// link. Two would be a file the next reconcile pass would immediately+    /// halve — which is exactly what an archive may not contain.+    @Test("Two links over one pair refuse, whichever order their ids are in")+    func twoLinksForOnePairRefuse() throws {+        let second = UUID(uuidString: "11115E51-0000-4000-8000-000000000002")!+        let payload = BackupV10Fixtures.seriesPayload(+            links: [+                BackupV10Fixtures.linkRecord(),+                // The reversed spelling of the same pair: the payload sorts at+                // the door, so this is the same key rather than a second one.+                BackupV10Fixtures.linkRecord(+                    id: second, a: BackupV10Fixtures.secondWorkID,+                    b: BackupV10Fixtures.composedWorkID, type: "sequel"),+            ])++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    @Test("A series with an empty trimmed name refuses")+    func emptySeriesNameRefuses() throws {+        for name in ["", "   ", "\n\t "] {+            let payload = BackupV10Fixtures.seriesPayload(+                series: [BackupV10Fixtures.seriesRecord(name: name)])+            #expect(throws: BackupCodecError.self) {+                try BackupV10Codec.decode(+                    try BackupV10Codec.encode(+                        payload: payload, metadata: BackupV10Fixtures.metadata()))+            }+        }+    }++    /// Both-or-neither, Req 13.5: a position without a series says where in+    /// nothing, and a series without a position has no place in it. Neither+    /// half-set shape is one a writer produces — both arrive through CloudKit's+    /// per-field merge — and neither may enter through a file.+    @Test("A half-set membership pair refuses, either half")+    func halfSetMembershipRefuses() throws {+        let halves: [(UUID?, Double?)] = [+            (BackupV10Fixtures.seriesID, nil),+            (nil, 2),+        ]+        for (id, position) in halves {+            let payload = BackupV10Fixtures.payloadWithMembership(+                seriesID: id, position: position)+            #expect(throws: BackupCodecError.self) {+                try BackupV10Codec.decode(+                    try BackupV10Codec.encode(+                        payload: payload, metadata: BackupV10Fixtures.metadata()))+            }+        }+    }++    /// Q15's storage rule, refused rather than rounded: rounding here would move+    /// a reader's 2.55 to 2.6 inside their own restore.+    @Test("A position that is not finite or carries a second fraction digit refuses")+    func illegalPositionRefuses() throws {+        for position in [2.55, 1.0 / 3.0, Double.infinity, Double.nan] {+            let payload = BackupV10Fixtures.payloadWithMembership(+                seriesID: BackupV10Fixtures.seriesID, position: position)+            #expect(throws: (any Error).self) {+                try BackupV10Codec.decode(+                    try BackupV10Codec.encode(+                        payload: payload, metadata: BackupV10Fixtures.metadata()))+            }+        }+    }++    /// The tolerated half (Req 13.5, 11.2): neither reference resolves against+    /// the payload. A work naming a series the archive does not carry and a link+    /// naming a work it does not carry are both states sync produces, and+    /// refusing a whole backup over one would fail it for a library that is+    /// merely mid-hydration.+    @Test("A work naming an absent series and a link naming an absent work validate")+    func unresolvedReferencesValidate() throws {+        let absentSeries = UUID(uuidString: "5E81E5A0-0000-4000-8000-000000000009")!+        let absentWork = UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeee99")!+        let payload = BackupV10Fixtures.seriesPayload(+            links: [+                BackupV10Fixtures.linkRecord(+                    a: BackupV10Fixtures.composedWorkID, b: absentWork, type: "spin-off")+            ],+            firstMembership: (absentSeries, 3))++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(+            decoded.payload.works.contains {+                $0.id == BackupV10Fixtures.composedWorkID && $0.seriesID == absentSeries+            })+        #expect(+            decoded.payload.links.contains {+                $0.lowerWorkID == absentWork || $0.higherWorkID == absentWork+            })+    }++    /// A link's pair is unordered, so it has one spelling — and the payload+    /// imposes it at the door rather than trusting the file, exactly as it does+    /// for a dismissed pair. Without it `dedupeLinks`, which groups on the+    /// sorted form, would never match the row.+    @Test("A link's ids are sorted at the door")+    func linkIDsAreSortedAtTheDoor() throws {+        let ids = WorkDistinctPair.sortedIDs(+            BackupV10Fixtures.composedWorkID, BackupV10Fixtures.secondWorkID)+        let reversed = BackupV10Fixtures.linkRecord(a: ids.higher, b: ids.lower)+        #expect(reversed.lowerWorkID == ids.higher)++        let payload = BackupImportPayload(BackupV10Fixtures.seriesPayload(links: [reversed]))+        #expect(payload.links.map(\.lowerWorkID) == [ids.lower])+        #expect(payload.links.map(\.higherWorkID) == [ids.higher])+    }++    // MARK: The citation arms++    /// Q26: the identity *basis version* is a case now, so the arm the reference+    /// checks open on is the case rather than an integer column. A v3 arm with no+    /// name contributor is the shape the old `identityKeyVersion == 3` branch+    /// refused, and it still refuses.+    @Test("A composed identity with no name contributor refuses")+    func composedIdentityWithoutANameContributorRefuses() throws {+        let payload = BackupV10Fixtures.composedPayload(dropNameContributor: true)++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    /// The other side of the same switch: a `.urlRule` basis whose blob says+    /// `.rawURL` is a record that cannot say which key it holds.+    @Test("A URL-rule basis carrying a raw-URL citation arm refuses")+    func urlRuleBasisWithARawURLArmRefuses() throws {+        let base = BackupV10Fixtures.composedPayload()+        let entry = try #require(base.entries.first)+        let stripped = BackupV10Entry(+            id: entry.id, captureTitle: entry.captureTitle,+            captureTitleSource: entry.captureTitleSource, rawURL: entry.rawURL,+            canonicalURL: entry.canonicalURL, hostname: entry.hostname,+            entryIdentityKey: entry.entryIdentityKey,+            conservativeIdentityKey: entry.conservativeIdentityKey,+            identityBasis: .urlRule, urlWorkIdentity: entry.urlWorkIdentity,+            chapterSequence: entry.chapterSequence, chapterTitle: entry.chapterTitle,+            note: entry.note, rating: entry.rating, firstCapturedAt: entry.firstCapturedAt,+            lastSharedAt: entry.lastSharedAt, modifiedAt: entry.modifiedAt,+            workID: entry.workID, intentionallyUnattached: entry.intentionallyUnattached,+            citations: EntryCitations(identity: .rawURL))+        let payload = BackupV10Payload(+            entries: [stripped], works: base.works, sites: base.sites,+            titlePatterns: base.titlePatterns, urlRules: base.urlRules,+            workTypes: base.workTypes, memberships: base.memberships)++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(+                try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))+        }+    }++    @Test("A mismatched version pair around 10/11 is refused by the codec itself")+    func mismatchedPairsRefuse() throws {+        let encoded = try BackupV10Codec.encode(+            payload: BackupV10Fixtures.payload(), metadata: BackupV10Fixtures.metadata())+        var object = try #require(+            try JSONSerialization.jsonObject(with: encoded) as? [String: Any])+        object["databaseSchemaVersion"] = 9++        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(try JSONSerialization.data(withJSONObject: object))+        }+    }++    /// Req 8.2 through the codec: an 8/9 envelope is the pair this generation+    /// replaced, and it is refused at the door rather than half-decoded.+    @Test("An 8/9 envelope is refused by the codec")+    func eightNineEnvelopeRefuses() throws {+        #expect(throws: BackupCodecError.self) {+            try BackupV10Codec.decode(BackupV10Fixtures.retiredGenerationDocument())+        }+    }++    /// A citation is the rule's UUID since 8/9, so `version` is a key the codec+    /// does not write back — and the checksum is taken over the bytes as they+    /// arrived. A 10/11 file carrying one therefore fails the re-encode+    /// comparison, which is the same door every other unrepresentable key meets.+    ///+    /// The paired assertion is what makes this about the key rather than about+    /// the paste: the identical literal with `"version":3` removed decodes.+    @Test("A 10/11 archive whose citation carries a version fails the checksum")+    func citationVersionFailsTheChecksum() throws {+        let document = BackupV10Fixtures.literalDocument(+            payload: BackupV10Fixtures.citationVersionPayloadJSON, entryCount: 1, workCount: 1)++        do {+            _ = try BackupV10Codec.decode(document)+            Issue.record("expected a checksum refusal, but the document decoded")+        } catch let error as BackupCodecError {+            guard case .checksumMismatch = error else {+                Issue.record("expected .checksumMismatch, got \(error)")+                return+            }+        }++        let versionFree = BackupV10Fixtures.literalDocument(+            payload: BackupV10Fixtures.citationVersionFreePayloadJSON, entryCount: 1, workCount: 1)+        let decoded = try BackupV10Codec.decode(versionFree)+        #expect(+            decoded.payload.entries.first?.citations.chapterSequence+                == CitedRule(id: UUID(uuidString: "DDDDDDDD-DDDD-DDDD-DDDD-DDDDDDDDDDDD")!))+    }++    /// Req 8.1 and Q34 from the wire side: the three status fields are declared+    /// without `decodeIfPresent` and without a default, so a 10/11 document whose+    /// Work record omits them is malformed rather than restorable. A default+    /// would put a reader's abandoned work back as one they are still reading.+    ///+    /// The refusal is a decode failure, not a checksum one — the typed decode+    /// gives up on the missing key before the payload is ever re-encoded — and+    /// the paired assertion pins it to the three keys rather than to the paste:+    /// the identical literal carrying them decodes.+    @Test("A 10/11 Work record omitting the three status fields fails to decode")+    func workOmittingTheStatusFieldsRefuses() throws {+        let document = BackupV10Fixtures.literalDocument(+            payload: BackupV10Fixtures.statusFieldsOmittedPayloadJSON, entryCount: 1, workCount: 1)++        do {+            _ = try BackupV10Codec.decode(document)+            Issue.record("expected a decode refusal, but the document decoded")+        } catch let error as BackupCodecError {+            guard case .decodingFailed = error else {+                Issue.record("expected .decodingFailed, got \(error)")+                return+            }+        }++        let complete = BackupV10Fixtures.literalDocument(+            payload: BackupV10Fixtures.citationVersionFreePayloadJSON, entryCount: 1, workCount: 1)+        let record = try #require(try BackupV10Codec.decode(complete).payload.works.first)+        #expect(record.workStatus == .ongoing)+        #expect(record.readingStatus == .reading)+        #expect(record.verdict.isEmpty)+    }++    /// Req 3.2: the version invariants are retired, so an archive whose Site+    /// holds two title patterns at version 1 and a current URL rule below a+    /// retired one is a file the reference checks accept.+    @Test("An archive with duplicate and non-greatest rule versions decodes")+    func duplicateAndNonGreatestVersionsDecode() throws {+        let payload = BackupV10Fixtures.duplicateVersionsPayload()++        let decoded = try BackupV10Codec.decode(+            try BackupV10Codec.encode(payload: payload, metadata: BackupV10Fixtures.metadata()))++        #expect(decoded.payload == payload)+        #expect(decoded.payload.titlePatterns.map(\.version) == [1, 1])+        #expect(decoded.payload.urlRules.first(where: \.isCurrent)?.version == 2)+    }+}++// MARK: - Export++@Suite("Backup V10 export", .serialized)+struct BackupV10ExportTests {+    private static let host = "characters.example"+    private static let workID = UUID(uuidString: "60000000-0000-4000-8000-000000000001")!+    private static let entryID = UUID(uuidString: "60000000-0000-4000-8000-000000000002")!+    private static let characterID = UUID(uuidString: "60000000-0000-4000-8000-000000000003")!+    private static let orphanID = UUID(uuidString: "60000000-0000-4000-8000-000000000004")!+    private static let early = Date(timeIntervalSince1970: 1_000_000)+    private static let note = "Grover promised to guide them home."+    private static let genericNotes = "The guide is not what he seems."++    @Test("Exporter produces a v10 filename and a valid, decodable 10/11 document")+    func exporterProducesValidDocument() async throws {+        let tempDir = FileManager.default.temporaryDirectory.appending(path: UUID().uuidString)+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)+        defer { try? FileManager.default.removeItem(at: tempDir) }++        let payload = BackupV10Fixtures.payload()+        let exporter = BackupV10Exporter(+            repository: MockV10SnapshotProvider(payload: payload), stagingDirectory: tempDir)+        let result = try await exporter.export(metadata: BackupV10Fixtures.metadata())++        #expect(result.fileURL.lastPathComponent.contains("v10"))+        let decoded = try BackupV10Codec.decode(try Data(contentsOf: result.fileURL))+        #expect(decoded.backupFormatVersion == 10)+        #expect(decoded.databaseSchemaVersion == 11)+        #expect(decoded.payload == payload)+        exporter.cleanup(result)+    }++    /// Req 6.1: what the store holds is what the archive carries — the character+    /// with its facts, the suppression row, and both coverage shapes.+    @Test("Characters, suppressions and coverage project out of the store")+    func charactersProject() throws {+        let store = try LibraryStore()+        store.insertCharacter(+            id: Self.characterID, name: "Grover", aliases: ["Klar"], note: "The guide.",+            facts: [+                CharacterFact(+                    statement: "Promised to guide them home.",+                    quote: "promised to guide them home", nameKey: "grover",+                    source: .entry(Self.entryID))+            ])+        store.insertSuppression(nameKey: "the crowned one")+        store.coverEntry()+        store.coverGenericNotes()+        try store.context.save()++        let payload = try LibraryRepository.projectV10Payload(context: store.context)++        let character = try #require(payload.characters.first)+        #expect(character.id == Self.characterID)+        #expect(character.workID == Self.workID)+        #expect(character.nameKey == "grover")+        #expect(character.aliases == ["Klar"])+        #expect(character.facts.map(\.quote) == ["promised to guide them home"])++        let suppression = try #require(payload.suppressions.first)+        #expect(suppression.nameKey == "the crowned one")+        #expect(suppression.workID == Self.workID)+        #expect(suppression.kindRaw == CharacterSuppressionKind.candidate.rawValue)++        // Req 9.4: no coverage table — the fingerprint is on the record whose+        // text it describes.+        #expect(+            payload.entries.first { $0.id == Self.entryID }?.characterExtractionFingerprint+                == CharacterCoverageFingerprint.of(Self.note))+        #expect(+            payload.works.first { $0.id == Self.workID }?.genericNotesExtractionFingerprint+                == CharacterCoverageFingerprint.of(Self.genericNotes))+    }++    /// `wrong-host-work-url-heal` [1.6](../../../../specs/wrong-host-work-url-heal/requirements.md#16),+    /// Q17: the export folds a duplicated `(Work, hostname)` pair to the row+    /// de-duplication would keep, and the discarded row's Work URL comes with+    /// it. A heal-minted row is in identity state `none`, so a later+    /// rule-identity row for the same hostname sorts ahead of it — and without+    /// the carry the address the heal had just preserved would leave the archive+    /// silently, which is what+    /// [4.2](../../../../specs/wrong-host-work-url-heal/requirements.md#42)+    /// depends on.+    ///+    /// The fold is a read (Q54): projecting must leave the context clean.+    @Test("The export fold carries a discarded membership's Work URL")+    func exportFoldCarriesTheWorkURL() throws {+        let store = try LibraryStore()+        let work = try #require(try store.context.fetch(FetchDescriptor<Work>()).first)+        let twin = WorkSiteMembership(+            hostname: Self.host, createdAt: Self.early.addingTimeInterval(60),+            urlIdentityState: .none, workURLString: "https://\(Self.host)/serial",+            workID: work.id, work: work)+        store.context.insert(twin)+        try store.context.save()++        let payload = try LibraryRepository.projectV10Payload(context: store.context)++        // One record for the pair, and it is the survivor's — carrying the+        // address the discarded row held.+        #expect(payload.memberships.count == 1)+        #expect(payload.memberships.first?.id != twin.id)+        #expect(payload.memberships.first?.workURLString == "https://\(Self.host)/serial")+        #expect(!store.context.hasChanges, "the projection must not dirty its context")+    }++    /// Q78: enumerated whole, never works→children. A character that synced+    /// ahead of its work is inert in the app, but dropping it from the backup+    /// would be losing reader data to a timing accident.+    @Test("A character whose work has not arrived exports with a nil work reference")+    func orphanCharacterExports() throws {+        let store = try LibraryStore()+        store.insertCharacter(id: Self.orphanID, name: "Stranger", attachToWork: false)+        try store.context.save()++        let payload = try LibraryRepository.projectV10Payload(context: store.context)++        let orphan = try #require(payload.characters.first { $0.id == Self.orphanID })+        #expect(orphan.workID == nil)+        // And the file it produces is legal: the validator's exemption and the+        // exporter's enumeration have to agree, or the export refuses its own bytes.+        let encoded = try BackupV10Codec.encode(+            payload: payload, metadata: BackupV10Fixtures.metadata())+        #expect(try BackupV10Codec.decode(encoded).payload == payload)+    }++    /// Req 6.5. One character UUID over two rows that disagree about something+    /// the reader wrote is one record with two authored values, and an archive+    /// can hold neither of them honestly.+    @Test("A torn character group refuses the export")+    func tornCharacterRefusesExport() throws {+        let store = try LibraryStore()+        store.insertCharacter(id: Self.characterID, name: "Grover", note: "The guide.")+        store.insertCharacter(id: Self.characterID, name: "Grover", note: "A traitor.")+        try store.context.save()++        #expect(throws: BackupV10ExportError.self) {+            try LibraryRepository.projectV10Payload(context: store.context)+        }+    }++    /// Req 6.2 and Decision 2: the export succeeds while a fact's citation+    /// dangles. Deleting a cited entry is curation, not damage.+    @Test("The export succeeds while a fact's citation dangles")+    func danglingCitationExports() throws {+        let absent = UUID(uuidString: "60000000-0000-4000-8000-0000000000ff")!+        let store = try LibraryStore()+        store.insertCharacter(+            id: Self.characterID, name: "Grover",+            facts: [+                CharacterFact(+                    statement: "Was there.", quote: "was there", nameKey: "grover",+                    source: .entry(absent))+            ])+        try store.context.save()++        let payload = try LibraryRepository.projectV10Payload(context: store.context)++        #expect(payload.characters.first?.facts.first?.source == .entry(absent))+        let encoded = try BackupV10Codec.encode(+            payload: payload, metadata: BackupV10Fixtures.metadata())+        #expect(try BackupV10Codec.decode(encoded).payload == payload)+    }++    // MARK: Series and links (`series-and-related-works` Req 13.1, 13.2)++    /// Req 13.2: the archive carries the **logical** library. One link per pair,+    /// the row `survivorFirstLinks` keeps, and no row naming one work twice —+    /// so an archive never carries a row the next reconcile pass deletes.+    @Test("Links project one per pair by the survivor rule, and no self-link")+    func linksProjectOnePerPair() throws {+        let other = UUID(uuidString: "60000000-0000-4000-8000-00000000000a")!+        let older = UUID(uuidString: "60000000-0000-4000-8000-00000000000b")!+        let newer = UUID(uuidString: "60000000-0000-4000-8000-00000000000c")!+        let selfLink = UUID(uuidString: "60000000-0000-4000-8000-00000000000d")!+        let store = try LibraryStore()+        // Two rows over one pair, and the later modification is the survivor+        // whatever order they sit in the table (Q27).+        store.insertLink(+            id: older, a: Self.workID, b: other, type: "adaptation",+            modifiedAt: Self.early)+        store.insertLink(+            id: newer, a: other, b: Self.workID, type: "sequel",+            modifiedAt: Self.early.addingTimeInterval(60))+        store.insertLink(id: selfLink, a: Self.workID, b: Self.workID, type: "sequel")+        try store.context.save()++        let payload = try LibraryRepository.projectV10Payload(context: store.context)++        #expect(payload.links.map(\.id) == [newer])+        #expect(payload.links.map(\.linkType) == ["sequel"])+        let ids = WorkDistinctPair.sortedIDs(Self.workID, other)+        #expect(payload.links.first?.lowerWorkID == ids.lower)+        #expect(payload.links.first?.higherWorkID == ids.higher)+    }++    /// Req 13.1: the series table travels whole and the membership travels on+    /// the work record, off the carrier's columns.+    @Test("The series table and a work's membership project out of the store")+    func seriesAndMembershipProject() throws {+        let seriesID = UUID(uuidString: "5E81E5A0-0000-4000-8000-000000000001")!+        let store = try LibraryStore()+        store.insertSeries(id: seriesID, name: "Ashfall Cycle", notes: "Read 2.5 after 2.")+        store.placeWork(seriesID: seriesID, position: 2.5)+        try store.context.save()++        let payload = try LibraryRepository.projectV10Payload(context: store.context)++        #expect(payload.series.map(\.id) == [seriesID])+        #expect(payload.series.first?.name == "Ashfall Cycle")+        #expect(payload.series.first?.notes == "Read 2.5 after 2.")+        let work = try #require(payload.works.first)+        #expect(work.seriesID == seriesID)+        #expect(work.seriesPosition == 2.5)+    }++    /// Req 13.5 at the *export* door. The snapshot reads a half-set row as no+    /// membership and an unrounded position as itself, so a backup taken over+    /// one would record "in no series", or a number the format cannot spell,+    /// silently — inside the file that is supposed to be the copy. Named+    /// instead, with the work that holds it.+    @Test("A half-set pair, a non-finite position and an unrounded one refuse the export")+    func illegalMembershipColumnsRefuseTheExport() throws {+        let seriesID = UUID(uuidString: "5E81E5A0-0000-4000-8000-000000000001")!+        let cases: [(UUID?, Double?)] = [+            (seriesID, nil), (nil, 1), (seriesID, 2.55), (seriesID, .infinity),+        ]+        for (id, position) in cases {+            let store = try LibraryStore()+            store.insertSeries(id: seriesID, name: "Ashfall Cycle")+            store.placeWork(seriesID: id, position: position)+            try store.context.save()++            let error = #expect(throws: BackupV10ExportError.self) {+                try LibraryRepository.projectV10Payload(context: store.context)+            }+            guard case .unrepresentableValue(let record, _, _) = error else {+                Issue.record("expected an unrepresentable-value refusal, got \(String(describing: error))")+                continue+            }+            #expect(record.contains(Self.workID.uuidString))+        }+    }++    // MARK: - Fixture++    /// An in-memory V11 store holding one taught-enough Site, one Work with+    /// generic notes and one noted Entry. The container is retained for the+    /// test's lifetime: a `ModelContext` does not keep its container alive.+    private final class LibraryStore {+        let container: ModelContainer+        let context: ModelContext++        init() throws {+            let schema = Schema(versionedSchema: AsterismSchemaV11.self)+            container = try ModelContainer(+                for: schema,+                configurations: [+                    ModelConfiguration(+                        schema: schema, isStoredInMemoryOnly: true, cloudKitDatabase: .none)+                ])+            context = ModelContext(container)+            let site = Site(hostname: BackupV10ExportTests.host, displayName: "Characters")+            site.mode = .untaught+            context.insert(site)++            let work = Work.create(+                in: context, id: BackupV10ExportTests.workID, title: "A Work",+                hostname: BackupV10ExportTests.host, site: site,+                timestamp: BackupV10ExportTests.early)+            work.genericNotes = BackupV10ExportTests.genericNotes++            let rawURL = "https://\(BackupV10ExportTests.host)/read/1"+            let entry = Entry(+                id: BackupV10ExportTests.entryID, captureTitle: "Chapter 1",+                captureTitleSource: .host, rawURLString: rawURL,+                hostname: BackupV10ExportTests.host, entryIdentityKey: rawURL,+                timestamp: BackupV10ExportTests.early, note: BackupV10ExportTests.note)+            entry.conservativeIdentityKey = rawURL+            entry.editCitations { $0.workAssignment = .manual }+            context.insert(entry)+            entry.site = site+            entry.work = work+        }++        private var work: Work? {+            try? context.fetch(FetchDescriptor<Work>()).first+        }++        func insertCharacter(+            id: UUID, name: String, aliases: [String] = [], note: String = "",+            facts: [CharacterFact] = [], attachToWork: Bool = true+        ) {+            let character = CharacterRecord(+                id: id, name: name, nameKey: CharacterNameKey.normalize(name),+                aliases: aliases, note: note, facts: facts,+                timestamp: BackupV10ExportTests.early)+            context.insert(character)+            if attachToWork { character.work = work }+        }++        func insertSuppression(nameKey: String) {+            let row = CharacterSuppression(+                kind: .candidate, nameKey: nameKey, actionAt: BackupV10ExportTests.early)+            context.insert(row)+            row.work = work+        }++        func coverEntry() {+            try? context.fetch(FetchDescriptor<Entry>()).first?+                .characterExtractionFingerprint = CharacterCoverageFingerprint.of(+                    BackupV10ExportTests.note)+        }++        func coverGenericNotes() {+            work?.genericNotesExtractionFingerprint = CharacterCoverageFingerprint.of(+                BackupV10ExportTests.genericNotes)+        }++        // `series-and-related-works` Req 13.++        func insertSeries(+            id: UUID, name: String, notes: String = "",+            createdAt: Date = BackupV10ExportTests.early,+            modifiedAt: Date = BackupV10ExportTests.early+        ) {+            context.insert(+                Series(+                    id: id, name: name, notes: notes, createdAt: createdAt,+                    modifiedAt: modifiedAt))+        }++        /// One link row, ids as given — a caller passing them equal writes the+        /// self-link no writer produces and the projection drops.+        func insertLink(+            id: UUID, a: UUID, b: UUID, type: String,+            modifiedAt: Date = BackupV10ExportTests.early+        ) {+            let sorted = WorkDistinctPair.sortedIDs(a, b)+            context.insert(+                WorkLink(+                    id: id, lowerWorkID: sorted.lower, higherWorkID: sorted.higher,+                    linkType: type, createdAt: BackupV10ExportTests.early,+                    modifiedAt: modifiedAt))+        }++        func placeWork(seriesID: UUID?, position: Double?) {+            work?.seriesID = seriesID+            work?.seriesPosition = position+        }+    }+}++// MARK: - Import++@Suite("Backup 10/11 import", .serialized)+struct BackupV10ImportTests {++    // MARK: One accepted pair (Decision 2)++    @Test("The importer accepts 10/11")+    func acceptedGeneration() throws {+        let data = try BackupV10Codec.encode(+            payload: BackupV10Fixtures.payload(), metadata: BackupV10Fixtures.metadata())++        let plan = try BackupImporter.plan(from: data)+        #expect(plan.metadata.formatVersion == 10)+        #expect(plan.metadata.schemaVersion == 11)+        #expect(plan.payload == BackupImportPayload(BackupV10Fixtures.payload()))+    }++    /// The retired generations refuse **by version**, and the refusal names the+    /// pair the file declares.+    ///+    /// The distinction matters: a 9/10 envelope is well-formed JSON with a+    /// well-formed payload and a valid checksum, so a build that had merely+    /// deleted the 9/10 record types would fail it somewhere inside a decode and+    /// tell the reader their backup is corrupt. It is not corrupt; it is old,+    /// and the message has to say so (Req 13.1, Q13).+    ///+    /// (9, 10) leads the list: it is the generation this one replaced, and the+    /// one a reader upgrading across T-2308 is holding.+    @Test(+        "A retired generation refuses by version, naming the pair",+        arguments: [(9, 10), (8, 9), (7, 8), (6, 7), (4, 4), (5, 6), (3, 3)])+    func retiredGenerationsRefuseByVersion(pair: (format: Int, schema: Int)) throws {+        let data = BackupV10Fixtures.retiredGenerationDocument(+            format: pair.format, schema: pair.schema)+        // The envelope is intact — this is a version refusal, not a decode one.+        #expect((try? JSONSerialization.jsonObject(with: data)) != nil)++        let error = #expect(throws: BackupImportError.self) {+            try BackupImporter.plan(from: data)+        }+        guard case .unsupportedFormat(let reason) = error else {+            Issue.record("expected an unsupported-format refusal, got \(String(describing: error))")+            return+        }+        #expect(reason.contains("format \(pair.format)"))+        #expect(reason.contains("schema \(pair.schema)"))+        // Req 13.1 names both pairs: the archive's and the one this build reads.+        #expect(reason.contains("(\(BackupV10Document.formatVersion)/\(BackupV10Document.schemaVersion))"))+    }++    @Test("A mismatched pair around 10/11 is unsupported")+    func mismatchedPairsReject() throws {+        for (format, schema) in [(10, 10), (10, 12), (9, 11), (11, 11)] {+            let data = try JSONSerialization.data(withJSONObject: [+                "backupFormatVersion": format,+                "databaseSchemaVersion": schema,+            ])+            #expect(throws: BackupImportError.self) {+                try BackupImporter.plan(from: data)+            }+        }+    }++    // MARK: What lands (Req 6.1)++    @Test("A 10/11 archive commits its characters, suppressions and coverage")+    func archiveCommits() async throws {+        let fixture = try await M5Fixture()++        let result = try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(BackupV10Fixtures.payload()))+        guard case .committed = result else {+            Issue.record("expected committed, got \(result)")+            return+        }++        let characters = try await fixture.repository.m5AllCharacters()+        let grover = try #require(characters.first { $0.id == BackupV10Fixtures.groverID })+        #expect(grover.name == "Grover")+        #expect(grover.nameKey == "grover")+        #expect(grover.aliases == ["Klar"])+        #expect(grover.note == "The guide.")+        #expect(grover.facts.map(\.quote) == ["promised to guide them home"])+        #expect(grover.facts.first?.source == .entry(BackupV10Fixtures.entryID))+        #expect(grover.workID == BackupV10Fixtures.workID, "the character joins its work")++        let suppressions = try await fixture.repository.m5SuppressionRows()+        let row = try #require(suppressions.first { $0.id == BackupV10Fixtures.suppressionID })+        #expect(row.nameKey == "the crowned one")+        #expect(row.kind == .candidate)+        #expect(row.status == .active)+        #expect(row.workID == BackupV10Fixtures.workID)++        #expect(+            try await fixture.repository.m5EntryCoverage(BackupV10Fixtures.entryID)+                == BackupV10Fixtures.noteFingerprint)+        #expect(+            try await fixture.repository.m5WorkCoverage(BackupV10Fixtures.workID)+                == BackupV10Fixtures.genericNotesFingerprint)+    }++    /// Req 6.7 through the archive: a character with no work is a tolerated+    /// in-flight state on the way out (Q78) and on the way in.+    @Test("An orphan character imports and stays unattached")+    func orphanCharacterImports() async throws {+        let fixture = try await M5Fixture()++        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.payload(+                    characters: [+                        BackupV10Fixtures.character(id: BackupV10Fixtures.orphanID, workID: nil)+                    ])))++        let characters = try await fixture.repository.m5AllCharacters()+        let orphan = try #require(characters.first { $0.id == BackupV10Fixtures.orphanID })+        #expect(orphan.workID == nil)+    }++    /// Q81: coverage carries no timestamp to value-guard with, and needs none —+    /// a pair is kept exactly where the archived fingerprint still describes the+    /// source's current text, and dropped otherwise.+    @Test("Coverage is self-validating: a stale fingerprint is dropped")+    func coverageIsSelfValidating() async throws {+        let fixture = try await M5Fixture()++        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.payload(entryFingerprint: "not-this-note")))++        #expect(try await fixture.repository.m5EntryCoverage(BackupV10Fixtures.entryID) == nil)+        #expect(+            try await fixture.repository.m5WorkCoverage(BackupV10Fixtures.workID)+                == BackupV10Fixtures.genericNotesFingerprint)+    }++    // MARK: Value guards and idempotence (Req 6.1, 7.7's shape)++    /// Over the four tables an archive can move that are not the Work and Entry+    /// rows: the memberships and the pairs are asserted beside the characters and+    /// suppressions, because they are the two the 7/8 format added and the two a+    /// second import could silently rewrite.+    @Test("Importing the same 10/11 archive twice changes nothing the second time")+    func importingTwiceChangesNothing() async throws {+        let fixture = try await M5Fixture()+        let base = BackupV10Fixtures.payload()+        let stranger = UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeee99")!+        let ids = WorkDistinctPair.sortedIDs(BackupV10Fixtures.workID, stranger)+        let plan = BackupV10Fixtures.plan(+            BackupV10Payload(+                entries: base.entries, works: base.works, sites: base.sites,+                titlePatterns: base.titlePatterns, urlRules: base.urlRules,+                workTypes: base.workTypes, memberships: base.memberships,+                distinctPairs: [+                    BackupV10DistinctPair(+                        id: UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeee98")!,+                        lowerWorkID: ids.lower, higherWorkID: ids.higher,+                        recordedAt: BackupV10Fixtures.created)+                ],+                characters: base.characters, suppressions: base.suppressions))++        try await fixture.repository.confirmImport(plan: plan)+        let charactersAfterFirst = try await fixture.repository.m5AllCharacters()+        let suppressionsAfterFirst = try await fixture.repository.m5SuppressionRows()+        let membershipsAfterFirst = try await fixture.repository.m5MembershipRows()+        let pairsAfterFirst = try await fixture.repository.m5DistinctPairRows()++        try await fixture.repository.confirmImport(plan: plan)++        #expect(try await fixture.repository.m5AllCharacters() == charactersAfterFirst)+        #expect(try await fixture.repository.m5SuppressionRows() == suppressionsAfterFirst)+        #expect(try await fixture.repository.m5MembershipRows() == membershipsAfterFirst)+        #expect(try await fixture.repository.m5DistinctPairRows() == pairsAfterFirst)+        #expect(membershipsAfterFirst.count == 1)+        #expect(pairsAfterFirst.count == 1)+    }++    @Test("An archive older than the stored character writes nothing")+    func olderArchiveDoesNotRegressACharacter() async throws {+        let fixture = try await M5Fixture()+        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(BackupV10Fixtures.payload()))++        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.payload(+                    characters: [+                        BackupV10Fixtures.character(+                            name: "Renamed by an older device", note: "older",+                            modifiedAt: BackupV10Fixtures.created.addingTimeInterval(-1_000))+                    ])))++        let grover = try #require(+            try await fixture.repository.m5AllCharacters()+                .first { $0.id == BackupV10Fixtures.groverID })+        #expect(grover.name == "Grover")+        #expect(grover.note == "The guide.")+    }++    @Test("An archive newer than the stored character updates every row of it")+    func newerArchiveUpdatesACharacter() async throws {+        let fixture = try await M5Fixture()+        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(BackupV10Fixtures.payload()))++        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.payload(+                    characters: [+                        BackupV10Fixtures.character(+                            name: "Grover Underwood", note: "Still the guide.",+                            modifiedAt: BackupV10Fixtures.created.addingTimeInterval(1_000))+                    ])))++        let grover = try #require(+            try await fixture.repository.m5AllCharacters()+                .first { $0.id == BackupV10Fixtures.groverID })+        #expect(grover.name == "Grover Underwood")+        #expect(grover.note == "Still the guide.")+        // The retained key never moves with a rename (Q19/Q46) — including a+        // rename that arrives through an archive.+        #expect(grover.nameKey == "grover")+    }++    /// Req 6.6: suppression convergence is the reader's most recent action, and+    /// an archive is not exempt from it.+    @Test("A suppression older than the stored row does not undo a clear")+    func olderSuppressionDoesNotUndoAClear() async throws {+        let fixture = try await M5Fixture()+        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.payload(+                    suppressions: [+                        BackupV10Fixtures.suppression(+                            status: .cleared,+                            actionAt: BackupV10Fixtures.created.addingTimeInterval(1_000))+                    ])))++        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.payload(suppressions: [BackupV10Fixtures.suppression()])))++        let row = try #require(+            try await fixture.repository.m5SuppressionRows()+                .first { $0.id == BackupV10Fixtures.suppressionID })+        #expect(row.status == .cleared)+    }++    // MARK: An archive carrying no characters (Req 6.1)++    /// The other half of Req 6.1: the three character arrays are legitimately+    /// empty, and an archive of a library that has never run an extraction pass+    /// imports with nothing created.+    ///+    /// It was parameterised over the generations that had nowhere to write a+    /// character. Those read paths are gone (Decision 2), so the state is now+    /// reached the only way it still can be — a 10/11 archive whose arrays are+    /// empty.+    @Test("Importing an archive with no characters creates none")+    func archivesWithoutCharactersCreateNone() async throws {+        let fixture = try await M5Fixture()++        let plan = try BackupImporter.plan(+            from: try BackupV10Codec.encode(+                payload: BackupV10Fixtures.composedPayload(),+                metadata: BackupV10Fixtures.metadata()))+        try await fixture.repository.confirmImport(plan: plan)++        #expect(try await fixture.repository.m5AllCharacters().isEmpty)+        #expect(try await fixture.repository.m5SuppressionRows().isEmpty)+        #expect(try await fixture.repository.m5EntryCoverage(BackupV10Fixtures.entryID) == nil)+    }++    // MARK: Series and links (`series-and-related-works` Req 13.3, 13.4)++    /// Req 13.3: a restore into an empty library reproduces the series, the+    /// memberships and the links exactly, and running it again changes nothing.+    @Test("An import into an empty library reproduces series, memberships and links")+    func seriesAndLinksImportWhole() async throws {+        let fixture = try await M5Fixture()+        let plan = BackupV10Fixtures.plan(BackupV10Fixtures.seriesPayload())++        try await fixture.repository.confirmImport(plan: plan)++        let series = try await fixture.repository.seriesRowValues()+        #expect(series.map(\.id) == [BackupV10Fixtures.seriesID])+        #expect(series.first?.name == "Ashfall Cycle")+        #expect(series.first?.notes == "Read 2.5 after 2.")+        #expect(+            try await fixture.repository.membershipColumns(of: BackupV10Fixtures.composedWorkID)+                == [SeriesColumns(seriesID: BackupV10Fixtures.seriesID, position: 1)])+        #expect(+            try await fixture.repository.membershipColumns(of: BackupV10Fixtures.secondWorkID)+                == [SeriesColumns(seriesID: BackupV10Fixtures.seriesID, position: 2.5)])+        let links = try await fixture.repository.workLinkRowValues()+        #expect(links.map(\.id) == [BackupV10Fixtures.linkID])+        #expect(links.first?.linkType == "adaptation")++        // A repeated import writes the same values back and removes nothing.+        try await fixture.repository.confirmImport(plan: plan)+        #expect(try await fixture.repository.seriesRowValues() == series)+        #expect(try await fixture.repository.workLinkRowValues() == links)+    }++    /// Req 13.4's guard, both halves. A record at least as recent as the row+    /// wins; an older one writes nothing. Neither ever deletes: a series or a+    /// link the library holds and the archive does not is one the reader made on+    /// another device.+    @Test("commitSeries and commitLinks respect the modification guard and delete nothing")+    func seriesAndLinkGuards() async throws {+        let fixture = try await M5Fixture()+        let local = UUID(uuidString: "5E81E5A0-0000-4000-8000-0000000000ff")!+        let localLink = UUID(uuidString: "11115E51-0000-4000-8000-0000000000ff")!+        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(BackupV10Fixtures.seriesPayload()))+        // Two rows only this library holds, and a newer local edit to the+        // series the archive also carries.+        try await fixture.repository.seedSeries([SeedSeries(id: local, name: "Quiet Shelf")])+        try await fixture.repository.seedWorkLinks([+            SeedWorkLink(+                id: localLink, a: BackupV10Fixtures.composedWorkID,+                b: UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeee97")!, type: "prequel")+        ])+        try await fixture.repository.updateSeries(+            id: BackupV10Fixtures.seriesID, name: "Renamed here", notes: "later")+        try await fixture.repository.retypeLink(+            id: BackupV10Fixtures.linkID, type: "retyped here")++        // The same archive again: its records are now older than both rows.+        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(BackupV10Fixtures.seriesPayload()))++        let afterOlder = try await fixture.repository.seriesRowValues()+        #expect(afterOlder.first { $0.id == BackupV10Fixtures.seriesID }?.name == "Renamed here")+        #expect(+            try await fixture.repository.workLinkRowValues()+                .first { $0.id == BackupV10Fixtures.linkID }?.linkType == "retyped here")+        // Nothing the archive does not carry was removed.+        #expect(afterOlder.contains { $0.id == local })+        #expect(try await fixture.repository.workLinkIDs().contains(localLink))++        // A newer archive does win, on both tables.+        // Later than the *local* edits, which the fixture clock stamped at its+        // own epoch — not merely later than the archive's own `created`.+        let later = M5Fixture.epoch.addingTimeInterval(3_600)+        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.seriesPayload(+                    series: [+                        BackupV10Fixtures.seriesRecord(name: "Renamed there", modifiedAt: later)+                    ],+                    links: [BackupV10Fixtures.linkRecord(type: "retyped there", modifiedAt: later)])))++        #expect(+            try await fixture.repository.seriesRowValues()+                .first { $0.id == BackupV10Fixtures.seriesID }?.name == "Renamed there")+        #expect(+            try await fixture.repository.workLinkRowValues()+                .first { $0.id == BackupV10Fixtures.linkID }?.linkType == "retyped there")+    }++    /// Req 13.5's tolerated half, at the store rather than on the wire: a work+    /// naming a series this library does not hold keeps the id, and a link+    /// naming an absent work keeps both ends. Neither is cleared by the+    /// reconcile pass the import fires.+    @Test("An unresolved membership and an unresolved link survive the import")+    func unresolvedReferencesSurviveTheImport() async throws {+        let fixture = try await M5Fixture()+        let absentSeries = UUID(uuidString: "5E81E5A0-0000-4000-8000-000000000009")!+        let absentWork = UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeee99")!+        try await fixture.repository.confirmImport(+            plan: BackupV10Fixtures.plan(+                BackupV10Fixtures.seriesPayload(+                    links: [+                        BackupV10Fixtures.linkRecord(+                            a: BackupV10Fixtures.composedWorkID, b: absentWork, type: "spin-off")+                    ],+                    firstMembership: (absentSeries, 3))))++        #expect(+            try await fixture.repository.membershipColumns(of: BackupV10Fixtures.composedWorkID)+                == [SeriesColumns(seriesID: absentSeries, position: 3)])+        let links = try await fixture.repository.workLinkRowValues()+        #expect(links.count == 1)+        #expect(links.first?.linkType == "spin-off")+    }++    // MARK: The round trip (Req 6.1)++    /// The two halves meeting through the real exporter, the real codec and the+    /// real gate: a library holding characters, suppressions and coverage,+    /// exported and restored into a different one.+    @Test("A 10/11 archive exported from one library imports whole into another")+    func exportedArchivesRoundTrip() async throws {+        let source = try await M5Fixture()+        try await source.repository.confirmImport(+            plan: BackupV10Fixtures.plan(BackupV10Fixtures.payload()))++        let payload = try await source.repository.backupV10Snapshot()+        let plan = try BackupImporter.plan(+            from: try BackupV10Codec.encode(+                payload: payload, metadata: BackupV10Fixtures.metadata()))++        let target = try await M5Fixture()+        try await target.repository.confirmImport(plan: plan)++        let characters = try await target.repository.m5AllCharacters()+        let grover = try #require(characters.first { $0.id == BackupV10Fixtures.groverID })+        #expect(grover.name == "Grover")+        #expect(grover.facts.map(\.quote) == ["promised to guide them home"])+        #expect(grover.workID == BackupV10Fixtures.workID)+        #expect(+            try await target.repository.m5SuppressionRows()+                .contains { $0.id == BackupV10Fixtures.suppressionID })+        #expect(+            try await target.repository.m5EntryCoverage(BackupV10Fixtures.entryID)+                == BackupV10Fixtures.noteFingerprint)+    }+}++// MARK: - Test Doubles++private final class MockV10SnapshotProvider: BackupV10SnapshotProviding, @unchecked Sendable {+    let payload: BackupV10Payload+    init(payload: BackupV10Payload) { self.payload = payload }+    func backupV10Snapshot() async throws -> BackupV10Payload { payload }+}

diff --git a/Packages/AsterismCore/Tests/AsterismCoreTests/BackupV9ArchiveTests.swift b/Packages/AsterismCore/Tests/AsterismCoreTests/BackupV9ArchiveTests.swiftdeleted file mode 100644index 5298478..0000000--- a/Packages/AsterismCore/Tests/AsterismCoreTests/BackupV9ArchiveTests.swift+++ /dev/null@@ -1,1075 +0,0 @@-import Foundation-import SwiftData-import Testing--@testable import AsterismCore--// Archive generation 9/10 (T-2306, Req 8): a Work carries its work status, its-// reading status and the reader's verdict, and the schema number names the store-// the archive was taken from (V10, Q17). The records are otherwise 8/9's — an-// Entry citation is the cited rule's UUID alone, a Work's site presence is a-// membership record, the reader's dismissed pairs travel beside it, no parent-// record names its children, and the coverage table is folded onto the records-// that own it. It **replaces** 8/9 outright (Q34).-//-// Three suites, because the generation has three surfaces and they fail-// differently: the codec answers for the wire shape and its refusals, the-// exporter for what the store projects into it, and the importer for what an-// archive does to a live library.--// MARK: - Codec--@Suite("Backup V9 codec")-struct BackupV9CodecTests {--    @Test("V9 encode/decode round-trips 9/10, the multi-site gate, and the ten arrays")-    func roundTrip() throws {-        let payload = BackupV9Fixtures.payload()--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        #expect(decoded.backupFormatVersion == 9)-        #expect(decoded.databaseSchemaVersion == 10)-        #expect(decoded.capabilityGate == "multi-site")-        #expect(decoded.payload == payload)-        #expect(decoded.payload.characters == payload.characters)-        #expect(decoded.payload.suppressions == payload.suppressions)-        #expect(decoded.payload.memberships == payload.memberships)-        // Req 9.4: the coverage table is gone and the fingerprints ride on the-        // records whose text they describe.-        #expect(-            decoded.payload.entries.first?.characterExtractionFingerprint-                == BackupV9Fixtures.noteFingerprint)-        #expect(-            decoded.payload.works.first?.genericNotesExtractionFingerprint-                == BackupV9Fixtures.genericNotesFingerprint)-    }--    /// Req 8.1. The two statuses travel as the typed enums, exactly as-    /// `titleProvenance` does, and the verdict as the reader's text — asserted-    /// after a real round-trip over a Work carrying all three off their-    /// defaults, so a dropped field cannot pass as a matching default.-    @Test("A Work's two statuses and verdict survive the round-trip typed")-    func workStatusFieldsRoundTrip() throws {-        let payload = BackupV9Fixtures.composedPayload()--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        let record = try #require(-            decoded.payload.works.first { $0.id == BackupV9Fixtures.composedWorkID })-        #expect(record.workStatus == .finished)-        #expect(record.readingStatus == .abandoned)-        #expect(record.verdict == "Dropped it at the timeskip.")-        #expect(decoded.payload.works == payload.works)-    }--    /// Every field of a character is on the wire, including the fact's citation-    /// and its immutable quote — asserted after a real round-trip rather than-    /// trusted to `Codable`.-    @Test("A character's facts, aliases, note and keys survive the round-trip")-    func characterFieldsRoundTrip() throws {-        let facts = [-            BackupV9Fixtures.fact(),-            BackupV9Fixtures.fact(-                statement: "Knows the way through the pass.",-                quote: "knows the way", source: .genericNotes),-        ]-        let payload = BackupV9Fixtures.payload(-            characters: [-                BackupV9Fixtures.character(aliases: ["Klar", "The Guide"], facts: facts)-            ])--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        let character = try #require(decoded.payload.characters.first)-        #expect(character.name == "Grover")-        #expect(character.nameKey == "grover")-        #expect(character.aliases == ["Klar", "The Guide"])-        #expect(character.note == "The guide.")-        #expect(character.facts.count == 2)-        #expect(character.facts.contains { $0.source == .genericNotes })-        #expect(character.facts.contains { $0.source == .entry(BackupV9Fixtures.entryID) })-        #expect(character.facts.allSatisfy { $0.nameKey == "grover" })-    }--    @Test("Both suppression kinds round-trip with their status and action time")-    func suppressionKindsRoundTrip() throws {-        let rows = [-            BackupV9Fixtures.suppression(),-            BackupV9Fixtures.suppression(-                id: BackupV9Fixtures.factSuppressionID, kind: .fact, nameKey: "grover",-                source: .entry(BackupV9Fixtures.entryID), evidence: "promised to guide",-                status: .cleared),-        ]-        let payload = BackupV9Fixtures.payload(suppressions: rows)--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        #expect(decoded.payload.suppressions == rows)-    }--    // MARK: The two deliberate exemptions--    /// Q78: the exporter enumerates characters whole, so a character whose work-    /// has not arrived exports with a nil work reference rather than vanishing —-    /// and the validator has to let it through, or the backup refuses over a-    /// tolerated in-flight state (Req 6.7).-    @Test("A character with no work reference validates")-    func orphanCharacterValidates() throws {-        let payload = BackupV9Fixtures.payload(-            characters: [BackupV9Fixtures.character(id: BackupV9Fixtures.orphanID, workID: nil)])--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        #expect(decoded.payload.characters.first?.workID == nil)-    }--    /// Decision 2, pinned so it survives refactors: a fact's citation is-    /// tolerated when it dangles. The reader deleted the cited entry, or it has-    /// not synced — neither is corruption, and refusing here would fail the-    /// whole backup over routine curation.-    @Test("A fact citing an entry the archive does not carry validates")-    func danglingFactCitationValidates() throws {-        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000001")!-        let payload = BackupV9Fixtures.payload(-            characters: [-                BackupV9Fixtures.character(facts: [BackupV9Fixtures.fact(source: .entry(absent))])-            ],-            suppressions: [-                BackupV9Fixtures.suppression(-                    id: BackupV9Fixtures.factSuppressionID, kind: .fact, nameKey: "grover",-                    source: .entry(absent), evidence: "gone")-            ])--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        #expect(decoded.payload.characters.first?.facts.first?.source == .entry(absent))-        #expect(decoded.payload.suppressions.first?.sourceEntryID == absent)-    }--    /// The other half of the character rule: optional, but **checked when-    /// present** — the `validateEntry` `workID` pattern.-    @Test("A character naming a work the archive does not carry refuses")-    func characterCitingAnAbsentWorkRefuses() throws {-        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000002")!-        let payload = BackupV9Fixtures.payload(-            characters: [BackupV9Fixtures.character(workID: absent)])--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-    }--    @Test("A suppression naming a work the archive does not carry refuses")-    func suppressionCitingAnAbsentWorkRefuses() throws {-        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000003")!-        let payload = BackupV9Fixtures.payload(-            suppressions: [BackupV9Fixtures.suppression(workID: absent)])--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-    }--    // MARK: Payloads that contradict themselves--    @Test("Two records for one character identity refuse")-    func duplicateCharacterIDRefuses() throws {-        let payload = BackupV9Fixtures.payload(-            characters: [BackupV9Fixtures.character(), BackupV9Fixtures.character()])--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-    }--    @Test("Two records for one suppression identity refuse")-    func duplicateSuppressionIDRefuses() throws {-        let payload = BackupV9Fixtures.payload(-            suppressions: [BackupV9Fixtures.suppression(), BackupV9Fixtures.suppression()])--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-    }--    // MARK: The two Req 9.5 membership refusals--    /// Req 9.5, first half. An Entry's Work is in the file and holds no-    /// membership on the Entry's hostname: the restored library would start in-    /// exactly the state reconciliation exists to heal, and an archive has to be-    /// wholly legal on arrival (Q50).-    @Test("An Entry whose present Work has no membership on its hostname refuses")-    func entryWithoutAMembershipOnItsHostnameRefuses() throws {-        let base = BackupV9Fixtures.composedPayload()--        // The premise: with the membership present the payload is legal.-        _ = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: base, metadata: BackupV9Fixtures.metadata()))--        let uncovered = BackupV9Payload(-            entries: base.entries, works: base.works, sites: base.sites,-            titlePatterns: base.titlePatterns, urlRules: base.urlRules,-            workTypes: base.workTypes, memberships: [])-        let error = #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(-                    payload: uncovered, metadata: BackupV9Fixtures.metadata()))-        }-        guard case .unresolvedReference(let type, _, let reference) = error else {-            Issue.record("expected an unresolved reference, got \(String(describing: error))")-            return-        }-        #expect(type == "Entry")-        #expect(reference.contains("membership"))-    }--    /// Req 9.5, second half. Two memberships on one `(workID, hostname)` is a-    /// file that cannot say which row the Work is on — a state sync produces and-    /// the reconciler resolves (Req 2.6, 8.2), and one an archive may not carry.-    @Test("Two memberships for one Work and hostname refuse")-    func duplicateMembershipForOneHostnameRefuses() throws {-        let base = BackupV9Fixtures.composedPayload()-        let twin = BackupV9Fixtures.membership(-            id: UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeee2")!,-            workID: BackupV9Fixtures.composedWorkID, hostname: "example.com")-        let payload = BackupV9Payload(-            entries: base.entries, works: base.works, sites: base.sites,-            titlePatterns: base.titlePatterns, urlRules: base.urlRules,-            workTypes: base.workTypes, memberships: base.memberships + [twin])--        let error = #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-        guard case .invalidStateTuple(let type, _, let reason) = error else {-            Issue.record("expected an invalid state tuple, got \(String(describing: error))")-            return-        }-        #expect(type == "WorkSiteMembership")-        #expect(reason.contains("example.com"))-    }--    /// Req 9.5's tolerance, and Q22's: a membership or a pair naming a Work the-    /// archive does not carry is an orphan, not a contradiction. It imports-    /// unattached and re-attaches when the Work arrives.-    @Test("A membership and a pair naming an absent Work are accepted")-    func unattachedMembershipAndPairValidate() throws {-        let absent = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000010")!-        let other = UUID(uuidString: "DEADBEEF-0000-4000-8000-000000000011")!-        let base = BackupV9Fixtures.composedPayload()-        let orphan = BackupV9Fixtures.membership(-            id: UUID(uuidString: "0adbea00-0000-4000-8000-000000000001")!,-            workID: absent, hostname: "example.com")-        let ids = WorkDistinctPair.sortedIDs(absent, other)-        let payload = BackupV9Payload(-            entries: base.entries, works: base.works, sites: base.sites,-            titlePatterns: base.titlePatterns, urlRules: base.urlRules,-            workTypes: base.workTypes, memberships: base.memberships + [orphan],-            distinctPairs: [-                BackupV9DistinctPair(-                    id: UUID(uuidString: "0adbea00-0000-4000-8000-000000000002")!,-                    lowerWorkID: ids.lower, higherWorkID: ids.higher,-                    recordedAt: BackupV9Fixtures.created)-            ])--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        #expect(decoded.payload.memberships.contains { $0.workID == absent })-        #expect(decoded.payload.distinctPairs.count == 1)-    }--    /// A membership's own tuple is checked whether or not its Work is here: the-    /// identity arms are the Work arm's, moved to the row that now holds the-    /// value (Req 1.2).-    @Test("A membership whose identity tuple contradicts itself refuses")-    func illegalMembershipTupleRefuses() throws {-        let base = BackupV9Fixtures.composedPayload()-        let illegal = BackupV9Membership(-            id: BackupV9Fixtures.composedMembershipID,-            workID: BackupV9Fixtures.composedWorkID, hostname: "example.com",-            createdAt: BackupV9Fixtures.created, urlIdentity: nil, urlIdentityState: .rule,-            urlIdentityRuleID: nil, workURLString: nil)-        let payload = BackupV9Payload(-            entries: base.entries, works: base.works, sites: base.sites,-            titlePatterns: base.titlePatterns, urlRules: base.urlRules,-            workTypes: base.workTypes, memberships: [illegal])--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-    }--    /// Q54 retired the membership's `(id, version)` **resolution**, not the-    /// site. A rule the archive carries is one this check can read the hostname-    /// of, and an identity derived on one site by another site's rule is a value-    /// no writer produces — the Entry's identity arm refuses the same shape.-    @Test("A membership citing a rule taught for another site refuses")-    func membershipCitingAnotherSitesRuleRefuses() throws {-        let base = BackupV9Fixtures.composedPayload()-        let otherHost = "other.example"-        let otherRuleID = UUID(uuidString: "dddddddd-dddd-dddd-dddd-ddddddddddd2")!-        let otherSite = BackupV9Site(-            hostname: otherHost, displayName: "Other", mode: .untaught, junkSuffixRule: nil)-        let otherRule = BackupV9URLRule(-            id: otherRuleID, version: 1, isCurrent: false, createdAt: BackupV9Fixtures.created,-            origin: .importedV2,-            definition: .work(locator: .query(name: ExactScalarString("series"))),-            siteHostname: otherHost)-        // The membership is on example.com and cites other.example's rule.-        let crossSite = BackupV9Fixtures.membership(-            id: BackupV9Fixtures.composedMembershipID,-            workID: BackupV9Fixtures.composedWorkID, hostname: "example.com",-            urlIdentity: "serial-9", urlIdentityState: .rule, urlIdentityRuleID: otherRuleID)-        let payload = BackupV9Payload(-            entries: base.entries, works: base.works, sites: base.sites + [otherSite],-            titlePatterns: base.titlePatterns, urlRules: base.urlRules + [otherRule],-            workTypes: base.workTypes, memberships: [crossSite])--        let error = #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-        guard case .invalidStateTuple(let type, _, let reason) = error else {-            Issue.record("expected an invalid state tuple, got \(String(describing: error))")-            return-        }-        #expect(type == "WorkSiteMembership")-        #expect(reason.contains(otherHost))-    }--    /// The other half of Q54, and Q72: a membership whose cited rule the archive-    /// does not carry at all is **accepted**. There is no version to resolve and-    /// no hostname to compare; the row reads as `legacyUnverified` until the rule-    /// arrives, which is a tolerated state rather than a corrupt file.-    @Test("A membership citing a rule the archive does not carry is accepted")-    func membershipCitingAnAbsentRuleValidates() throws {-        let base = BackupV9Fixtures.composedPayload()-        let absentRule = UUID(uuidString: "dddddddd-dddd-dddd-dddd-ddddddddddd3")!-        let dangling = BackupV9Fixtures.membership(-            id: BackupV9Fixtures.composedMembershipID,-            workID: BackupV9Fixtures.composedWorkID, hostname: "example.com",-            urlIdentity: "serial-9", urlIdentityState: .rule, urlIdentityRuleID: absentRule)-        let payload = BackupV9Payload(-            entries: base.entries, works: base.works, sites: base.sites,-            titlePatterns: base.titlePatterns, urlRules: base.urlRules,-            workTypes: base.workTypes, memberships: [dangling])--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        #expect(decoded.payload.memberships.first?.urlIdentityRuleID == absentRule)-    }--    // MARK: The citation arms--    /// Q26: the identity *basis version* is a case now, so the arm the reference-    /// checks open on is the case rather than an integer column. A v3 arm with no-    /// name contributor is the shape the old `identityKeyVersion == 3` branch-    /// refused, and it still refuses.-    @Test("A composed identity with no name contributor refuses")-    func composedIdentityWithoutANameContributorRefuses() throws {-        let payload = BackupV9Fixtures.composedPayload(dropNameContributor: true)--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-    }--    /// The other side of the same switch: a `.urlRule` basis whose blob says-    /// `.rawURL` is a record that cannot say which key it holds.-    @Test("A URL-rule basis carrying a raw-URL citation arm refuses")-    func urlRuleBasisWithARawURLArmRefuses() throws {-        let base = BackupV9Fixtures.composedPayload()-        let entry = try #require(base.entries.first)-        let stripped = BackupV9Entry(-            id: entry.id, captureTitle: entry.captureTitle,-            captureTitleSource: entry.captureTitleSource, rawURL: entry.rawURL,-            canonicalURL: entry.canonicalURL, hostname: entry.hostname,-            entryIdentityKey: entry.entryIdentityKey,-            conservativeIdentityKey: entry.conservativeIdentityKey,-            identityBasis: .urlRule, urlWorkIdentity: entry.urlWorkIdentity,-            chapterSequence: entry.chapterSequence, chapterTitle: entry.chapterTitle,-            note: entry.note, rating: entry.rating, firstCapturedAt: entry.firstCapturedAt,-            lastSharedAt: entry.lastSharedAt, modifiedAt: entry.modifiedAt,-            workID: entry.workID, intentionallyUnattached: entry.intentionallyUnattached,-            citations: EntryCitations(identity: .rawURL))-        let payload = BackupV9Payload(-            entries: [stripped], works: base.works, sites: base.sites,-            titlePatterns: base.titlePatterns, urlRules: base.urlRules,-            workTypes: base.workTypes, memberships: base.memberships)--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(-                try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))-        }-    }--    @Test("A mismatched version pair around 9/10 is refused by the codec itself")-    func mismatchedPairsRefuse() throws {-        let encoded = try BackupV9Codec.encode(-            payload: BackupV9Fixtures.payload(), metadata: BackupV9Fixtures.metadata())-        var object = try #require(-            try JSONSerialization.jsonObject(with: encoded) as? [String: Any])-        object["databaseSchemaVersion"] = 9--        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(try JSONSerialization.data(withJSONObject: object))-        }-    }--    /// Req 8.2 through the codec: an 8/9 envelope is the pair this generation-    /// replaced, and it is refused at the door rather than half-decoded.-    @Test("An 8/9 envelope is refused by the codec")-    func eightNineEnvelopeRefuses() throws {-        #expect(throws: BackupCodecError.self) {-            try BackupV9Codec.decode(BackupV9Fixtures.retiredGenerationDocument())-        }-    }--    /// A citation is the rule's UUID since 8/9, so `version` is a key the codec-    /// does not write back — and the checksum is taken over the bytes as they-    /// arrived. A 9/10 file carrying one therefore fails the re-encode-    /// comparison, which is the same door every other unrepresentable key meets.-    ///-    /// The paired assertion is what makes this about the key rather than about-    /// the paste: the identical literal with `"version":3` removed decodes.-    @Test("A 9/10 archive whose citation carries a version fails the checksum")-    func citationVersionFailsTheChecksum() throws {-        let document = BackupV9Fixtures.literalDocument(-            payload: BackupV9Fixtures.citationVersionPayloadJSON, entryCount: 1, workCount: 1)--        do {-            _ = try BackupV9Codec.decode(document)-            Issue.record("expected a checksum refusal, but the document decoded")-        } catch let error as BackupCodecError {-            guard case .checksumMismatch = error else {-                Issue.record("expected .checksumMismatch, got \(error)")-                return-            }-        }--        let versionFree = BackupV9Fixtures.literalDocument(-            payload: BackupV9Fixtures.citationVersionFreePayloadJSON, entryCount: 1, workCount: 1)-        let decoded = try BackupV9Codec.decode(versionFree)-        #expect(-            decoded.payload.entries.first?.citations.chapterSequence-                == CitedRule(id: UUID(uuidString: "DDDDDDDD-DDDD-DDDD-DDDD-DDDDDDDDDDDD")!))-    }--    /// Req 8.1 and Q34 from the wire side: the three status fields are declared-    /// without `decodeIfPresent` and without a default, so a 9/10 document whose-    /// Work record omits them is malformed rather than restorable. A default-    /// would put a reader's abandoned work back as one they are still reading.-    ///-    /// The refusal is a decode failure, not a checksum one — the typed decode-    /// gives up on the missing key before the payload is ever re-encoded — and-    /// the paired assertion pins it to the three keys rather than to the paste:-    /// the identical literal carrying them decodes.-    @Test("A 9/10 Work record omitting the three status fields fails to decode")-    func workOmittingTheStatusFieldsRefuses() throws {-        let document = BackupV9Fixtures.literalDocument(-            payload: BackupV9Fixtures.statusFieldsOmittedPayloadJSON, entryCount: 1, workCount: 1)--        do {-            _ = try BackupV9Codec.decode(document)-            Issue.record("expected a decode refusal, but the document decoded")-        } catch let error as BackupCodecError {-            guard case .decodingFailed = error else {-                Issue.record("expected .decodingFailed, got \(error)")-                return-            }-        }--        let complete = BackupV9Fixtures.literalDocument(-            payload: BackupV9Fixtures.citationVersionFreePayloadJSON, entryCount: 1, workCount: 1)-        let record = try #require(try BackupV9Codec.decode(complete).payload.works.first)-        #expect(record.workStatus == .ongoing)-        #expect(record.readingStatus == .reading)-        #expect(record.verdict.isEmpty)-    }--    /// Req 3.2: the version invariants are retired, so an archive whose Site-    /// holds two title patterns at version 1 and a current URL rule below a-    /// retired one is a file the reference checks accept.-    @Test("An archive with duplicate and non-greatest rule versions decodes")-    func duplicateAndNonGreatestVersionsDecode() throws {-        let payload = BackupV9Fixtures.duplicateVersionsPayload()--        let decoded = try BackupV9Codec.decode(-            try BackupV9Codec.encode(payload: payload, metadata: BackupV9Fixtures.metadata()))--        #expect(decoded.payload == payload)-        #expect(decoded.payload.titlePatterns.map(\.version) == [1, 1])-        #expect(decoded.payload.urlRules.first(where: \.isCurrent)?.version == 2)-    }-}--// MARK: - Export--@Suite("Backup V9 export", .serialized)-struct BackupV9ExportTests {-    private static let host = "characters.example"-    private static let workID = UUID(uuidString: "60000000-0000-4000-8000-000000000001")!-    private static let entryID = UUID(uuidString: "60000000-0000-4000-8000-000000000002")!-    private static let characterID = UUID(uuidString: "60000000-0000-4000-8000-000000000003")!-    private static let orphanID = UUID(uuidString: "60000000-0000-4000-8000-000000000004")!-    private static let early = Date(timeIntervalSince1970: 1_000_000)-    private static let note = "Grover promised to guide them home."-    private static let genericNotes = "The guide is not what he seems."--    @Test("Exporter produces a v9 filename and a valid, decodable 9/10 document")-    func exporterProducesValidDocument() async throws {-        let tempDir = FileManager.default.temporaryDirectory.appending(path: UUID().uuidString)-        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)-        defer { try? FileManager.default.removeItem(at: tempDir) }--        let payload = BackupV9Fixtures.payload()-        let exporter = BackupV9Exporter(-            repository: MockV9SnapshotProvider(payload: payload), stagingDirectory: tempDir)-        let result = try await exporter.export(metadata: BackupV9Fixtures.metadata())--        #expect(result.fileURL.lastPathComponent.contains("v9"))-        let decoded = try BackupV9Codec.decode(try Data(contentsOf: result.fileURL))-        #expect(decoded.backupFormatVersion == 9)-        #expect(decoded.databaseSchemaVersion == 10)-        #expect(decoded.payload == payload)-        exporter.cleanup(result)-    }--    /// Req 6.1: what the store holds is what the archive carries — the character-    /// with its facts, the suppression row, and both coverage shapes.-    @Test("Characters, suppressions and coverage project out of the store")-    func charactersProject() throws {-        let store = try LibraryStore()-        store.insertCharacter(-            id: Self.characterID, name: "Grover", aliases: ["Klar"], note: "The guide.",-            facts: [-                CharacterFact(-                    statement: "Promised to guide them home.",-                    quote: "promised to guide them home", nameKey: "grover",-                    source: .entry(Self.entryID))-            ])-        store.insertSuppression(nameKey: "the crowned one")-        store.coverEntry()-        store.coverGenericNotes()-        try store.context.save()--        let payload = try LibraryRepository.projectV9Payload(context: store.context)--        let character = try #require(payload.characters.first)-        #expect(character.id == Self.characterID)-        #expect(character.workID == Self.workID)-        #expect(character.nameKey == "grover")-        #expect(character.aliases == ["Klar"])-        #expect(character.facts.map(\.quote) == ["promised to guide them home"])--        let suppression = try #require(payload.suppressions.first)-        #expect(suppression.nameKey == "the crowned one")-        #expect(suppression.workID == Self.workID)-        #expect(suppression.kindRaw == CharacterSuppressionKind.candidate.rawValue)--        // Req 9.4: no coverage table — the fingerprint is on the record whose-        // text it describes.-        #expect(-            payload.entries.first { $0.id == Self.entryID }?.characterExtractionFingerprint-                == CharacterCoverageFingerprint.of(Self.note))-        #expect(-            payload.works.first { $0.id == Self.workID }?.genericNotesExtractionFingerprint-                == CharacterCoverageFingerprint.of(Self.genericNotes))-    }--    /// `wrong-host-work-url-heal` [1.6](../../../../specs/wrong-host-work-url-heal/requirements.md#16),-    /// Q17: the export folds a duplicated `(Work, hostname)` pair to the row-    /// de-duplication would keep, and the discarded row's Work URL comes with-    /// it. A heal-minted row is in identity state `none`, so a later-    /// rule-identity row for the same hostname sorts ahead of it — and without-    /// the carry the address the heal had just preserved would leave the archive-    /// silently, which is what-    /// [4.2](../../../../specs/wrong-host-work-url-heal/requirements.md#42)-    /// depends on.-    ///-    /// The fold is a read (Q54): projecting must leave the context clean.-    @Test("The export fold carries a discarded membership's Work URL")-    func exportFoldCarriesTheWorkURL() throws {-        let store = try LibraryStore()-        let work = try #require(try store.context.fetch(FetchDescriptor<Work>()).first)-        let twin = WorkSiteMembership(-            hostname: Self.host, createdAt: Self.early.addingTimeInterval(60),-            urlIdentityState: .none, workURLString: "https://\(Self.host)/serial",-            workID: work.id, work: work)-        store.context.insert(twin)-        try store.context.save()--        let payload = try LibraryRepository.projectV9Payload(context: store.context)--        // One record for the pair, and it is the survivor's — carrying the-        // address the discarded row held.-        #expect(payload.memberships.count == 1)-        #expect(payload.memberships.first?.id != twin.id)-        #expect(payload.memberships.first?.workURLString == "https://\(Self.host)/serial")-        #expect(!store.context.hasChanges, "the projection must not dirty its context")-    }--    /// Q78: enumerated whole, never works→children. A character that synced-    /// ahead of its work is inert in the app, but dropping it from the backup-    /// would be losing reader data to a timing accident.-    @Test("A character whose work has not arrived exports with a nil work reference")-    func orphanCharacterExports() throws {-        let store = try LibraryStore()-        store.insertCharacter(id: Self.orphanID, name: "Stranger", attachToWork: false)-        try store.context.save()--        let payload = try LibraryRepository.projectV9Payload(context: store.context)--        let orphan = try #require(payload.characters.first { $0.id == Self.orphanID })-        #expect(orphan.workID == nil)-        // And the file it produces is legal: the validator's exemption and the-        // exporter's enumeration have to agree, or the export refuses its own bytes.-        let encoded = try BackupV9Codec.encode(-            payload: payload, metadata: BackupV9Fixtures.metadata())-        #expect(try BackupV9Codec.decode(encoded).payload == payload)-    }--    /// Req 6.5. One character UUID over two rows that disagree about something-    /// the reader wrote is one record with two authored values, and an archive-    /// can hold neither of them honestly.-    @Test("A torn character group refuses the export")-    func tornCharacterRefusesExport() throws {-        let store = try LibraryStore()-        store.insertCharacter(id: Self.characterID, name: "Grover", note: "The guide.")-        store.insertCharacter(id: Self.characterID, name: "Grover", note: "A traitor.")-        try store.context.save()--        #expect(throws: BackupV9ExportError.self) {-            try LibraryRepository.projectV9Payload(context: store.context)-        }-    }--    /// Req 6.2 and Decision 2: the export succeeds while a fact's citation-    /// dangles. Deleting a cited entry is curation, not damage.-    @Test("The export succeeds while a fact's citation dangles")-    func danglingCitationExports() throws {-        let absent = UUID(uuidString: "60000000-0000-4000-8000-0000000000ff")!-        let store = try LibraryStore()-        store.insertCharacter(-            id: Self.characterID, name: "Grover",-            facts: [-                CharacterFact(-                    statement: "Was there.", quote: "was there", nameKey: "grover",-                    source: .entry(absent))-            ])-        try store.context.save()--        let payload = try LibraryRepository.projectV9Payload(context: store.context)--        #expect(payload.characters.first?.facts.first?.source == .entry(absent))-        let encoded = try BackupV9Codec.encode(-            payload: payload, metadata: BackupV9Fixtures.metadata())-        #expect(try BackupV9Codec.decode(encoded).payload == payload)-    }--    // MARK: - Fixture--    /// An in-memory V9 store holding one taught-enough Site, one Work with-    /// generic notes and one noted Entry. The container is retained for the-    /// test's lifetime: a `ModelContext` does not keep its container alive.-    private final class LibraryStore {-        let container: ModelContainer-        let context: ModelContext--        init() throws {-            let schema = Schema(versionedSchema: AsterismSchemaV10.self)-            container = try ModelContainer(-                for: schema,-                configurations: [-                    ModelConfiguration(-                        schema: schema, isStoredInMemoryOnly: true, cloudKitDatabase: .none)-                ])-            context = ModelContext(container)-            let site = Site(hostname: BackupV9ExportTests.host, displayName: "Characters")-            site.mode = .untaught-            context.insert(site)--            let work = Work.create(-                in: context, id: BackupV9ExportTests.workID, title: "A Work",-                hostname: BackupV9ExportTests.host, site: site,-                timestamp: BackupV9ExportTests.early)-            work.genericNotes = BackupV9ExportTests.genericNotes--            let rawURL = "https://\(BackupV9ExportTests.host)/read/1"-            let entry = Entry(-                id: BackupV9ExportTests.entryID, captureTitle: "Chapter 1",-                captureTitleSource: .host, rawURLString: rawURL,-                hostname: BackupV9ExportTests.host, entryIdentityKey: rawURL,-                timestamp: BackupV9ExportTests.early, note: BackupV9ExportTests.note)-            entry.conservativeIdentityKey = rawURL-            entry.editCitations { $0.workAssignment = .manual }-            context.insert(entry)-            entry.site = site-            entry.work = work-        }--        private var work: Work? {-            try? context.fetch(FetchDescriptor<Work>()).first-        }--        func insertCharacter(-            id: UUID, name: String, aliases: [String] = [], note: String = "",-            facts: [CharacterFact] = [], attachToWork: Bool = true-        ) {-            let character = CharacterRecord(-                id: id, name: name, nameKey: CharacterNameKey.normalize(name),-                aliases: aliases, note: note, facts: facts,-                timestamp: BackupV9ExportTests.early)-            context.insert(character)-            if attachToWork { character.work = work }-        }--        func insertSuppression(nameKey: String) {-            let row = CharacterSuppression(-                kind: .candidate, nameKey: nameKey, actionAt: BackupV9ExportTests.early)-            context.insert(row)-            row.work = work-        }--        func coverEntry() {-            try? context.fetch(FetchDescriptor<Entry>()).first?-                .characterExtractionFingerprint = CharacterCoverageFingerprint.of(-                    BackupV9ExportTests.note)-        }--        func coverGenericNotes() {-            work?.genericNotesExtractionFingerprint = CharacterCoverageFingerprint.of(-                BackupV9ExportTests.genericNotes)-        }-    }-}--// MARK: - Import--@Suite("Backup 9/10 import", .serialized)-struct BackupV9ImportTests {--    // MARK: One accepted pair (Decision 2)--    @Test("The importer accepts 9/10")-    func acceptedGeneration() throws {-        let data = try BackupV9Codec.encode(-            payload: BackupV9Fixtures.payload(), metadata: BackupV9Fixtures.metadata())--        let plan = try BackupImporter.plan(from: data)-        #expect(plan.metadata.formatVersion == 9)-        #expect(plan.metadata.schemaVersion == 10)-        #expect(plan.payload == BackupImportPayload(BackupV9Fixtures.payload()))-    }--    /// The retired generations refuse **by version**, and the refusal names the-    /// pair the file declares.-    ///-    /// The distinction matters: an 8/9 envelope is well-formed JSON with a-    /// well-formed payload and a valid checksum, so a build that had merely-    /// deleted the 8/9 record types would fail it somewhere inside a decode and-    /// tell the reader their backup is corrupt. It is not corrupt; it is old,-    /// and the message has to say so (Req 8.2).-    ///-    /// (8, 9) leads the list: it is the generation this one replaced, and the-    /// one a reader upgrading across T-2306 is holding.-    @Test(-        "A retired generation refuses by version, naming the pair",-        arguments: [(8, 9), (7, 8), (6, 7), (4, 4), (5, 6), (3, 3)])-    func retiredGenerationsRefuseByVersion(pair: (format: Int, schema: Int)) throws {-        let data = BackupV9Fixtures.retiredGenerationDocument(-            format: pair.format, schema: pair.schema)-        // The envelope is intact — this is a version refusal, not a decode one.-        #expect((try? JSONSerialization.jsonObject(with: data)) != nil)--        let error = #expect(throws: BackupImportError.self) {-            try BackupImporter.plan(from: data)-        }-        guard case .unsupportedFormat(let reason) = error else {-            Issue.record("expected an unsupported-format refusal, got \(String(describing: error))")-            return-        }-        #expect(reason.contains("format \(pair.format)"))-        #expect(reason.contains("schema \(pair.schema)"))-        // Req 8.2 names both pairs: the archive's and the one this build reads.-        #expect(reason.contains("(\(BackupV9Document.formatVersion)/\(BackupV9Document.schemaVersion))"))-    }--    @Test("A mismatched pair around 9/10 is unsupported")-    func mismatchedPairsReject() throws {-        for (format, schema) in [(9, 9), (9, 11), (8, 10), (10, 10)] {-            let data = try JSONSerialization.data(withJSONObject: [-                "backupFormatVersion": format,-                "databaseSchemaVersion": schema,-            ])-            #expect(throws: BackupImportError.self) {-                try BackupImporter.plan(from: data)-            }-        }-    }--    // MARK: What lands (Req 6.1)--    @Test("A 9/10 archive commits its characters, suppressions and coverage")-    func archiveCommits() async throws {-        let fixture = try await M5Fixture()--        let result = try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(BackupV9Fixtures.payload()))-        guard case .committed = result else {-            Issue.record("expected committed, got \(result)")-            return-        }--        let characters = try await fixture.repository.m5AllCharacters()-        let grover = try #require(characters.first { $0.id == BackupV9Fixtures.groverID })-        #expect(grover.name == "Grover")-        #expect(grover.nameKey == "grover")-        #expect(grover.aliases == ["Klar"])-        #expect(grover.note == "The guide.")-        #expect(grover.facts.map(\.quote) == ["promised to guide them home"])-        #expect(grover.facts.first?.source == .entry(BackupV9Fixtures.entryID))-        #expect(grover.workID == BackupV9Fixtures.workID, "the character joins its work")--        let suppressions = try await fixture.repository.m5SuppressionRows()-        let row = try #require(suppressions.first { $0.id == BackupV9Fixtures.suppressionID })-        #expect(row.nameKey == "the crowned one")-        #expect(row.kind == .candidate)-        #expect(row.status == .active)-        #expect(row.workID == BackupV9Fixtures.workID)--        #expect(-            try await fixture.repository.m5EntryCoverage(BackupV9Fixtures.entryID)-                == BackupV9Fixtures.noteFingerprint)-        #expect(-            try await fixture.repository.m5WorkCoverage(BackupV9Fixtures.workID)-                == BackupV9Fixtures.genericNotesFingerprint)-    }--    /// Req 6.7 through the archive: a character with no work is a tolerated-    /// in-flight state on the way out (Q78) and on the way in.-    @Test("An orphan character imports and stays unattached")-    func orphanCharacterImports() async throws {-        let fixture = try await M5Fixture()--        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(-                BackupV9Fixtures.payload(-                    characters: [-                        BackupV9Fixtures.character(id: BackupV9Fixtures.orphanID, workID: nil)-                    ])))--        let characters = try await fixture.repository.m5AllCharacters()-        let orphan = try #require(characters.first { $0.id == BackupV9Fixtures.orphanID })-        #expect(orphan.workID == nil)-    }--    /// Q81: coverage carries no timestamp to value-guard with, and needs none —-    /// a pair is kept exactly where the archived fingerprint still describes the-    /// source's current text, and dropped otherwise.-    @Test("Coverage is self-validating: a stale fingerprint is dropped")-    func coverageIsSelfValidating() async throws {-        let fixture = try await M5Fixture()--        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(-                BackupV9Fixtures.payload(entryFingerprint: "not-this-note")))--        #expect(try await fixture.repository.m5EntryCoverage(BackupV9Fixtures.entryID) == nil)-        #expect(-            try await fixture.repository.m5WorkCoverage(BackupV9Fixtures.workID)-                == BackupV9Fixtures.genericNotesFingerprint)-    }--    // MARK: Value guards and idempotence (Req 6.1, 7.7's shape)--    /// Over the four tables an archive can move that are not the Work and Entry-    /// rows: the memberships and the pairs are asserted beside the characters and-    /// suppressions, because they are the two the 7/8 format added and the two a-    /// second import could silently rewrite.-    @Test("Importing the same 9/10 archive twice changes nothing the second time")-    func importingTwiceChangesNothing() async throws {-        let fixture = try await M5Fixture()-        let base = BackupV9Fixtures.payload()-        let stranger = UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeee99")!-        let ids = WorkDistinctPair.sortedIDs(BackupV9Fixtures.workID, stranger)-        let plan = BackupV9Fixtures.plan(-            BackupV9Payload(-                entries: base.entries, works: base.works, sites: base.sites,-                titlePatterns: base.titlePatterns, urlRules: base.urlRules,-                workTypes: base.workTypes, memberships: base.memberships,-                distinctPairs: [-                    BackupV9DistinctPair(-                        id: UUID(uuidString: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeee98")!,-                        lowerWorkID: ids.lower, higherWorkID: ids.higher,-                        recordedAt: BackupV9Fixtures.created)-                ],-                characters: base.characters, suppressions: base.suppressions))--        try await fixture.repository.confirmImport(plan: plan)-        let charactersAfterFirst = try await fixture.repository.m5AllCharacters()-        let suppressionsAfterFirst = try await fixture.repository.m5SuppressionRows()-        let membershipsAfterFirst = try await fixture.repository.m5MembershipRows()-        let pairsAfterFirst = try await fixture.repository.m5DistinctPairRows()--        try await fixture.repository.confirmImport(plan: plan)--        #expect(try await fixture.repository.m5AllCharacters() == charactersAfterFirst)-        #expect(try await fixture.repository.m5SuppressionRows() == suppressionsAfterFirst)-        #expect(try await fixture.repository.m5MembershipRows() == membershipsAfterFirst)-        #expect(try await fixture.repository.m5DistinctPairRows() == pairsAfterFirst)-        #expect(membershipsAfterFirst.count == 1)-        #expect(pairsAfterFirst.count == 1)-    }--    @Test("An archive older than the stored character writes nothing")-    func olderArchiveDoesNotRegressACharacter() async throws {-        let fixture = try await M5Fixture()-        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(BackupV9Fixtures.payload()))--        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(-                BackupV9Fixtures.payload(-                    characters: [-                        BackupV9Fixtures.character(-                            name: "Renamed by an older device", note: "older",-                            modifiedAt: BackupV9Fixtures.created.addingTimeInterval(-1_000))-                    ])))--        let grover = try #require(-            try await fixture.repository.m5AllCharacters()-                .first { $0.id == BackupV9Fixtures.groverID })-        #expect(grover.name == "Grover")-        #expect(grover.note == "The guide.")-    }--    @Test("An archive newer than the stored character updates every row of it")-    func newerArchiveUpdatesACharacter() async throws {-        let fixture = try await M5Fixture()-        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(BackupV9Fixtures.payload()))--        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(-                BackupV9Fixtures.payload(-                    characters: [-                        BackupV9Fixtures.character(-                            name: "Grover Underwood", note: "Still the guide.",-                            modifiedAt: BackupV9Fixtures.created.addingTimeInterval(1_000))-                    ])))--        let grover = try #require(-            try await fixture.repository.m5AllCharacters()-                .first { $0.id == BackupV9Fixtures.groverID })-        #expect(grover.name == "Grover Underwood")-        #expect(grover.note == "Still the guide.")-        // The retained key never moves with a rename (Q19/Q46) — including a-        // rename that arrives through an archive.-        #expect(grover.nameKey == "grover")-    }--    /// Req 6.6: suppression convergence is the reader's most recent action, and-    /// an archive is not exempt from it.-    @Test("A suppression older than the stored row does not undo a clear")-    func olderSuppressionDoesNotUndoAClear() async throws {-        let fixture = try await M5Fixture()-        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(-                BackupV9Fixtures.payload(-                    suppressions: [-                        BackupV9Fixtures.suppression(-                            status: .cleared,-                            actionAt: BackupV9Fixtures.created.addingTimeInterval(1_000))-                    ])))--        try await fixture.repository.confirmImport(-            plan: BackupV9Fixtures.plan(-                BackupV9Fixtures.payload(suppressions: [BackupV9Fixtures.suppression()])))--        let row = try #require(-            try await fixture.repository.m5SuppressionRows()-                .first { $0.id == BackupV9Fixtures.suppressionID })-        #expect(row.status == .cleared)-    }--    // MARK: An archive carrying no characters (Req 6.1)--    /// The other half of Req 6.1: the three character arrays are legitimately-    /// empty, and an archive of a library that has never run an extraction pass-    /// imports with nothing created.-    ///-    /// It was parameterised over the generations that had nowhere to write a-    /// character. Those read paths are gone (Decision 2), so the state is now-    /// reached the only way it still can be — a 9/10 archive whose arrays are-    /// empty.-    @Test("Importing an archive with no characters creates none")-    func archivesWithoutCharactersCreateNone() async throws {-        let fixture = try await M5Fixture()--        let plan = try BackupImporter.plan(-            from: try BackupV9Codec.encode(-                payload: BackupV9Fixtures.composedPayload(),-                metadata: BackupV9Fixtures.metadata()))-        try await fixture.repository.confirmImport(plan: plan)--        #expect(try await fixture.repository.m5AllCharacters().isEmpty)-        #expect(try await fixture.repository.m5SuppressionRows().isEmpty)-        #expect(try await fixture.repository.m5EntryCoverage(BackupV9Fixtures.entryID) == nil)-    }--    // MARK: The round trip (Req 6.1)--    /// The two halves meeting through the real exporter, the real codec and the-    /// real gate: a library holding characters, suppressions and coverage,-    /// exported and restored into a different one.-    @Test("A 9/10 archive exported from one library imports whole into another")-    func exportedArchivesRoundTrip() async throws {-        let source = try await M5Fixture()-        try await source.repository.confirmImport(-            plan: BackupV9Fixtures.plan(BackupV9Fixtures.payload()))--        let payload = try await source.repository.backupV9Snapshot()-        let plan = try BackupImporter.plan(-            from: try BackupV9Codec.encode(-                payload: payload, metadata: BackupV9Fixtures.metadata()))--        let target = try await M5Fixture()-        try await target.repository.confirmImport(plan: plan)--        let characters = try await target.repository.m5AllCharacters()-        let grover = try #require(characters.first { $0.id == BackupV9Fixtures.groverID })-        #expect(grover.name == "Grover")-        #expect(grover.facts.map(\.quote) == ["promised to guide them home"])-        #expect(grover.workID == BackupV9Fixtures.workID)-        #expect(-            try await target.repository.m5SuppressionRows()-                .contains { $0.id == BackupV9Fixtures.suppressionID })-        #expect(-            try await target.repository.m5EntryCoverage(BackupV9Fixtures.entryID)-                == BackupV9Fixtures.noteFingerprint)-    }-}--// MARK: - Test Doubles--private final class MockV9SnapshotProvider: BackupV9SnapshotProviding, @unchecked Sendable {-    let payload: BackupV9Payload-    init(payload: BackupV9Payload) { self.payload = payload }-    func backupV9Snapshot() async throws -> BackupV9Payload { payload }-}

diff --git a/Asterism/Asterism/ViewModels/SeriesModels.swift b/Asterism/Asterism/ViewModels/SeriesModels.swiftnew file mode 100644index 0000000..524a3cd--- /dev/null+++ b/Asterism/Asterism/ViewModels/SeriesModels.swift@@ -0,0 +1,570 @@+import AsterismCore+import Foundation+import Observation+import OSLog++// The two series screens' models (Requirements 1, 2 and 3).+//+// Modelled on `WorkTypesModels.swift`, and for the same reason: every sentence+// the screens show is built here, so the views choose rows and styling and never+// wording — which is also what makes the screens' language testable.+//+// Two rules run through both models. Labels are **Core's** (`SeriesDisplay.label`,+// Q26): the qualifier that tells two same-named series apart is composed once,+// and a screen that rebuilt a label from a name would drop it. And every member+// edit is an `updateWork` built from the member's own snapshot (Q25), so the+// redirect, the torn refusal and the conflict machinery are the work editor's+// rather than a second write path onto the same two columns.++/// The series list (Req 1.6): every series with its member count, and the field+/// that creates one.+@MainActor @Observable+public final class SeriesListModel {+    private static let logger = Logger(subsystem: "me.nore.ig.Asterism", category: "SeriesListModel")++    public enum State: Equatable, Sendable {+        case loading+        case ready+        case error(message: String)+    }++    /// One series, as the list presents it.+    public struct Row: Identifiable, Equatable, Sendable {+        public let series: SeriesSnapshot++        public var id: UUID { series.id }+        /// Req 1.3's label, composed by Core: name, and the qualifier where+        /// another series shares it.+        public var label: String { series.display.label }+        public var memberCount: Int { series.memberCount }++        /// What the count pill says out loud. Req 3.4 counts works in the local+        /// library, and one work is one work.+        public var countLabel: String {+            Pluralisation.count(memberCount, "work", "works")+        }+    }++    public private(set) var state: State = .loading+    /// In the order the read returned them, which is `SeriesOrdering` — the+    /// repository orders the read (`SeriesDirectory.options`) and the screen+    /// shows that order rather than inventing one of its own.+    public private(set) var rows: [Row] = []++    /// The add field. Kept on a rejection so the reader can correct what they+    /// typed rather than type it again.+    public var draftName: String = ""+    /// The one line the screen says back: a refusal's reason (Req 1.1). Nil when+    /// there is nothing to report.+    public private(set) var message: String?++    /// Req 1.6: an empty list is where every library starts, so the screen says+    /// what a series is for rather than showing an empty box.+    public let emptyMessage =+        "No series yet. Add one above, then put works in it from this screen or from a work's "+        + "own editor."++    public var canAdd: Bool {+        !SeriesName.trimmed(draftName).isEmpty && !isSubmitting+    }++    private let library: any LibraryProviding+    private let onMutation: @Sendable () async -> Void+    private var isSubmitting = false+    /// The snapshot generation this screen last read at, so a republication that+    /// moved nothing does not re-read (see `reload(for:)`).+    private var loadedGeneration: Int?++    public init(+        library: any LibraryProviding,+        onMutation: @escaping @Sendable () async -> Void+    ) {+        self.library = library+        self.onMutation = onMutation+    }++    public func load() async {+        state = .loading+        do {+            rows = try await library.seriesList().map(Row.init(series:))+            state = .ready+        } catch {+            rows = []+            state = .error(message: error.localizedDescription)+            Self.logger.error("Series read failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// The sync-arrival trigger (Req 11.2): `AppLibraryModel.snapshotGeneration`+    /// bumps on every arrival and every write, and this re-reads on the bump —+    /// which is what heals a name or a member count without a relaunch.+    public func reload(for generation: Int) async {+        guard loadedGeneration != generation else { return }+        loadedGeneration = generation+        await load()+    }++    /// Creates the typed series (Req 1.1).+    ///+    /// The name is validated here first so the refusal is Core's reason rather+    /// than a repository error's description; the repository validates again,+    /// because it is the one that has to be right.+    public func add() async {+        guard canAdd else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        do {+            try SeriesName.validate(draftName)+        } catch {+            message = SeriesRefusalPresentation.sentence(for: error)+            return+        }+        do {+            _ = try await library.createSeries(name: draftName, notes: "")+            draftName = ""+            message = nil+            await onMutation()+            await load()+        } catch {+            message = SeriesRefusalPresentation.sentence(for: error)+            Self.logger.error("Series add failed: \(String(describing: error), privacy: .public)")+        }+    }+}++/// One series' screen (Reqs 3.1–3.5): its name and notes, its members in order,+/// and the edits the reader makes to both.+@MainActor @Observable+public final class SeriesDetailModel {+    private static let logger = Logger(+        subsystem: "me.nore.ig.Asterism", category: "SeriesDetailModel")++    public enum State: Equatable, Sendable {+        case loading+        case ready+        /// The series is not in this library — deleted here or on another+        /// device while the reader stood on its screen.+        case missing+        case error(message: String)+    }++    /// One member, as the screen draws it.+    public struct MemberRow: Identifiable, Equatable, Sendable {+        public let work: WorkSnapshot+        /// Req 2.7: the position in the viewing locale, with the fewest fraction+        /// digits that represent it.+        public let positionText: String+        /// Req 3.3: the work this screen was opened from, marked. A series+        /// opened from the list or a section header marks nothing.+        public let isCurrent: Bool++        public var id: UUID { work.id }+    }++    /// What the deletion confirmation is offering.+    ///+    /// The count rides **on the presented value**, not beside it in the model,+    /// for the reason `WorkTypeDetailModel.RemovalPrompt` records: SwiftUI runs+    /// a dialog's `isPresented` setter — the dismissal — *before* it runs the+    /// tapped button's action, so a confirm that re-read a model property found+    /// it already cleared and committed nothing, silently.+    public struct DeletionPrompt: Identifiable, Equatable, Sendable {+        public let id: UUID+        public let name: String+        public let memberCount: Int++        /// Req 1.4: the confirmation states how many works the series holds, and+        /// what happens to them — which is nothing. The deletion removes the+        /// series and clears each member's membership; no work is deleted.+        public var message: String {+            guard memberCount > 0 else {+                return "This series holds no works. Deleting it removes the series itself; "+                    + "nothing else changes."+            }+            let subject = Pluralisation.count(memberCount, "work is", "works are")+            return "\(subject) in this series. They stay in your library and leave the series."+        }+    }++    public let seriesID: UUID+    /// The work the reader came from, if any (Req 3.3).+    public let originWorkID: UUID?++    public private(set) var state: State = .loading+    public private(set) var display: SeriesDisplay?+    public private(set) var notes: String = ""+    public private(set) var members: [MemberRow] = []+    /// The add-member search's rows (Req 2.5), read on demand: the picker is a+    /// sheet, and a whole-library read has no business running behind a screen+    /// that is not showing it.+    public private(set) var candidates: [WorkPickerCandidate] = []++    public private(set) var isEditing = false+    public var draftName: String = ""+    public var draftNotes: String = ""++    /// The one line the screen says back: a refused name, a position that is not+    /// a number, or a write the repository would not take.+    public private(set) var message: String?+    public private(set) var deletionPrompt: DeletionPrompt?+    /// Set once the series is gone, so the screen can leave the stack.+    public private(set) var didFinish = false+    public private(set) var isSubmitting = false++    /// Req 3.1's title, and the placeholder for the moment before the read+    /// lands. Never composed from a name (Q26).+    public var title: String { display?.label ?? "Series" }++    public var canSave: Bool {+        !SeriesName.trimmed(draftName).isEmpty && !isSubmitting+    }++    /// Req 3.5's empty members list, which is an ordinary state: a series+    /// outlives its last member (Req 1.5).+    public let emptyMembersMessage =+        "No works in this series yet. Tap the pencil to add one, or set the series from a work's "+        + "own editor."++    /// Req 2.2's refusal, worded once. The rule is `SeriesPosition.parse`'s; this+    /// is the sentence for it.+    static let positionRefusal =+        "A position is a number with at most one decimal place, like 1 or 2.5 — "+        + "no thousands separators."++    private let library: any LibraryProviding+    /// The viewing locale, which is what a position is read and written in+    /// (Req 2.2, 2.7). Taken at construction, as `MarkdownExportModel` takes its+    /// export locale.+    private let locale: Locale+    private let onMutation: @Sendable () async -> Void+    private var positionDrafts: [UUID: String] = [:]+    private var loadedGeneration: Int?++    public init(+        seriesID: UUID,+        originWorkID: UUID?,+        library: any LibraryProviding,+        locale: Locale = .current,+        onMutation: @escaping @Sendable () async -> Void+    ) {+        self.seriesID = seriesID+        self.originWorkID = originWorkID+        self.library = library+        self.locale = locale+        self.onMutation = onMutation+    }++    // MARK: - Reading (Reqs 3.1–3.3)++    public func load() async {+        do {+            guard let detail = try await library.seriesDetail(id: seriesID) else {+                display = nil+                notes = ""+                members = []+                positionDrafts = [:]+                state = .missing+                return+            }+            display = detail.display+            notes = detail.notes+            members = detail.members.map { work in+                MemberRow(+                    work: work,+                    positionText: work.membership+                        .map { SeriesPosition.format($0.position, locale: locale) } ?? "",+                    isCurrent: work.id == originWorkID)+            }+            seedPositionDrafts()+            state = .ready+        } catch {+            state = .error(message: error.localizedDescription)+            Self.logger.error(+                "Series detail read failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// `SeriesListModel.reload(for:)`'s trigger, for the same reason: a member+    /// arriving through sync joins the list without a relaunch (Req 11.2).+    public func reload(for generation: Int) async {+        guard loadedGeneration != generation else { return }+        loadedGeneration = generation+        await load()+    }++    /// Req 2.5's search rows: every work, with the reason it cannot be chosen+    /// where there is one.+    public func loadCandidates() async {+        do {+            candidates = try await library.seriesMemberCandidates()+        } catch {+            candidates = []+            message = error.localizedDescription+            Self.logger.error(+                "Series candidates read failed: \(String(describing: error), privacy: .public)")+        }+    }++    // MARK: - Editing the series (Reqs 1.1, 1.2, 2.6)++    public func beginEditing() {+        guard state == .ready else { return }+        message = nil+        draftName = display?.name ?? ""+        draftNotes = notes+        positionDrafts = Dictionary(uniqueKeysWithValues: members.map { ($0.id, $0.positionText) })+        isEditing = true+    }++    public func cancelEditing() {+        isEditing = false+        message = nil+        draftName = ""+        draftNotes = ""+        positionDrafts = Dictionary(uniqueKeysWithValues: members.map { ($0.id, $0.positionText) })+    }++    /// The drafts a reader has typed survive a reload; only the rows that have+    /// no draft yet take theirs from the store.+    ///+    /// A write on this screen is followed by a re-read, and so is a sync+    /// arrival, so re-seeding unconditionally would clear a half-typed position+    /// under the reader's hands the moment another device wrote anything.+    private func seedPositionDrafts() {+        guard isEditing else {+            positionDrafts = Dictionary(+                uniqueKeysWithValues: members.map { ($0.id, $0.positionText) })+            return+        }+        let present = Set(members.map(\.id))+        positionDrafts = positionDrafts.filter { present.contains($0.key) }+        for row in members where positionDrafts[row.id] == nil {+            positionDrafts[row.id] = row.positionText+        }+    }++    public func positionDraft(for workID: UUID) -> String {+        positionDrafts[workID] ?? ""+    }++    public func setPositionDraft(_ text: String, for workID: UUID) {+        positionDrafts[workID] = text+    }++    /// The editor's one way out that writes (Reqs 1.2, 2.6).+    ///+    /// The name and notes go first, because an invalid name must stop the whole+    /// commit; the positions then commit **one row at a time, in list order**+    /// (Q25). The first refusal stops the sequence: the rows before it stay+    /// committed, the rows after it are never asked, and the screen re-reads so+    /// it shows what actually landed.+    public func save() async {+        guard !isSubmitting else { return }+        guard canSave else {+            message = SeriesRefusalPresentation.sentence(+                for: SeriesError.invalidName(reason: "A series needs a name."))+            return+        }+        isSubmitting = true+        defer { isSubmitting = false }+        message = nil++        var wrote = false+        if SeriesName.trimmed(draftName) != (display?.name ?? "")+            || SeriesName.trimmed(draftNotes) != notes {+            do {+                try SeriesName.validate(draftName)+                try await library.updateSeries(+                    id: seriesID, name: draftName, notes: draftNotes)+                wrote = true+            } catch {+                message = SeriesRefusalPresentation.sentence(for: error)+                Self.logger.error(+                    "Series update failed: \(String(describing: error), privacy: .public)")+                return+            }+        }++        for row in members {+            guard let typed = positionDrafts[row.id] else { continue }+            guard let position = SeriesPosition.parse(typed, locale: locale) else {+                message = Self.positionRefusal+                if wrote { await committed() }+                return+            }+            guard let current = row.work.membership,+                SeriesPosition.rounded(current.position) != position+            else { continue }+            let landed = await write(+                row.work, membership: SeriesMembership(seriesID: seriesID, position: position))+            wrote = wrote || landed+            guard landed else {+                if wrote { await onMutation() }+                await load()+                return+            }+        }++        if wrote { await committed() }+        isEditing = false+    }++    // MARK: - Membership (Reqs 2.5, 2.6, 2.8)++    /// Req 2.6: the work leaves the series and stays in the library. Committed+    /// on the tap rather than folded into the draft — it is a removal, not a+    /// field being typed.+    public func removeMember(_ workID: UUID) async {+        guard let row = members.first(where: { $0.id == workID }) else { return }+        guard !isSubmitting else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        message = nil+        if await write(row.work, membership: nil) {+            await committed()+        } else {+            await load()+        }+    }++    /// Req 2.5: the chosen work takes the position Req 2.3 prefills — the next+    /// whole number above this series' highest, which the repository computes+    /// from the presented memberships.+    public func addMember(_ workID: UUID) async {+        guard let candidate = candidates.first(where: { $0.id == workID }),+            candidate.unavailableReason == nil+        else { return }+        guard !isSubmitting else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        message = nil+        do {+            let position = try await library.nextSeriesPosition(seriesID: seriesID)+            if await write(+                candidate.work,+                membership: SeriesMembership(seriesID: seriesID, position: position))+            {+                await committed()+            } else {+                await load()+            }+        } catch {+            message = error.localizedDescription+            Self.logger.error(+                "Series prefill read failed: \(String(describing: error), privacy: .public)")+        }+    }++    // MARK: - Deletion (Req 1.4)++    public func requestDeletion() {+        guard !isSubmitting, let display else { return }+        message = nil+        deletionPrompt = DeletionPrompt(+            id: seriesID, name: display.label, memberCount: members.count)+    }++    /// The dialog's dismissal. It may clear the prompt freely: the confirm takes+    /// what it needs as a parameter, so nothing here can strand a commit that is+    /// about to run.+    public func cancelDeletion() {+        deletionPrompt = nil+    }++    public func confirmDeletion(_ prompt: DeletionPrompt) async {+        guard !isSubmitting else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        message = nil+        do {+            switch try await library.deleteSeries(id: prompt.id) {+            case .committed:+                deletionPrompt = nil+                await onMutation()+                didFinish = true+            case .invalidated(let reason):+                // Req 2.9 and Req 10.2: refused before any write, or rolled+                // back after one. Either way nothing changed, and the reason is+                // the repository's.+                message = reason+                await load()+            }+        } catch {+            message = error.localizedDescription+            Self.logger.error(+                "Series deletion failed: \(String(describing: error), privacy: .public)")+        }+    }++    // MARK: - Writes++    /// One member edit, as `updateWork` (Q25): the basis and the draft are built+    /// from the member's own snapshot, so every other field goes back unchanged+    /// and a field changed elsewhere is the edit conflict Req 2.4 asks for.+    ///+    /// Returns whether the write landed.+    private func write(_ work: WorkSnapshot, membership: SeriesMembership?) async -> Bool {+        do {+            let outcome = try await library.updateWork(+                id: work.id,+                basis: WorkEditBasis(work: work),+                draft: WorkMetadataDraft(+                    displayTitle: work.displayTitle,+                    typeAssignment: work.typeDisplay.assignment,+                    genreTags: work.genreTags,+                    genericNotes: work.genericNotes,+                    workStatus: work.workStatus,+                    readingStatus: work.readingStatus,+                    verdict: work.verdict,+                    membership: membership))+            if case .conflict(let conflict) = outcome {+                message = EntryDetailModel.conflictMessage(conflict)+                return false+            }+            return true+        } catch {+            message = error.localizedDescription+            Self.logger.error(+                "Series membership write failed: \(String(describing: error), privacy: .public)")+            return false+        }+    }++    private func committed() async {+        await onMutation()+        await load()+    }+}++/// The one place a refused connection is turned into words, so the series+/// list's add field, the series screen's name field and the work detail's+/// series picker and link cards cannot explain the same refusal differently+/// (Reqs 1.1, 6.1, 6.2, 6.4, 6.7).+///+/// Both error types already carry their reason — the rules are+/// `SeriesName.validate`'s and `LinkType.validate`'s and the wording is theirs —+/// so this only unwraps them, and falls back to the error's own description for+/// anything else. The three link refusals that need the store say what happened+/// rather than what to type: they are races and states, not typos.+enum SeriesRefusalPresentation {+    static func sentence(for error: Error) -> String {+        if let seriesError = error as? SeriesError {+            switch seriesError {+            case .invalidName(let reason): return reason+            }+        }+        if let linkError = error as? WorkLinkError {+            switch linkError {+            case .invalidType(let reason):+                return reason+            case .selfLink:+                return "A work cannot be linked to itself."+            case .alreadyLinked(let type):+                return "These works are already linked as “\(type)”."+            case .torn:+                return "This work exists in differing copies. Resolve them before linking it."+            }+        }+        return error.localizedDescription+    }+}

diff --git a/Asterism/AsterismTests/SeriesModelsTests.swift b/Asterism/AsterismTests/SeriesModelsTests.swiftnew file mode 100644index 0000000..a130a53--- /dev/null+++ b/Asterism/AsterismTests/SeriesModelsTests.swift@@ -0,0 +1,552 @@+import AsterismCore+import Foundation+import Testing+@testable import Asterism++// The two series screens' models (Requirements 1, 2 and 3). Wording lives in the+// models, per the house convention, so these tests are where the screens'+// sentences are pinned — the reason a name is refused (1.1), the reason a+// position is (2.2), and the deletion confirmation's count and its promise that+// the works stay (1.4).+//+// Every member edit is an `updateWork` built from the member's own snapshot+// (Q25), so the drafts these tests read back are the second half of the subject:+// a draft that dropped a field would take a reader's status or notes with it.++@Suite("Series list model")+struct SeriesListModelTests {++    private func snapshot(+        _ name: String, id: UUID = UUID(), qualifier: String? = nil, notes: String = "",+        memberCount: Int = 0+    ) -> SeriesSnapshot {+        SeriesSnapshot(+            display: SeriesDisplay(+                id: id, name: name, createdAt: TestFixtures.fixedDate, qualifier: qualifier),+            notes: notes,+            memberCount: memberCount)+    }++    @MainActor private func makeSUT(+        _ series: [SeriesSnapshot] = []+    ) -> (SeriesListModel, MockLibraryProvider, MutationRecorder) {+        let mock = MockLibraryProvider()+        mock.seriesListResult = .success(series)+        let mutations = MutationRecorder()+        let model = SeriesListModel(library: mock, onMutation: { mutations.record() })+        return (model, mock, mutations)+    }++    // MARK: - The list (Req 1.6)++    /// Req 1.3: two series sharing a name are told apart by the qualifier Core+    /// composed, and the row shows the **label** rather than the name — a screen+    /// that re-composed one here would drop it.+    @Test("Rows carry the composed label and the member count, in the read's order")+    @MainActor func rowsCarryLabelsAndCounts() async {+        let (model, _, _) = makeSUT([+            snapshot("Ashfall Cycle", qualifier: "5 Sep 2026 · 1", memberCount: 2),+            snapshot("Ashfall Cycle", qualifier: "5 Sep 2026 · 2"),+            snapshot("Quiet Shelf", memberCount: 1),+        ])++        await model.load()++        #expect(model.state == .ready)+        // The repository orders the read (`SeriesDirectory.options`, in+        // `SeriesOrdering`); the screen shows that order rather than inventing+        // one of its own, exactly as the work-types list does.+        #expect(+            model.rows.map(\.label) == [+                "Ashfall Cycle · 5 Sep 2026 · 1", "Ashfall Cycle · 5 Sep 2026 · 2", "Quiet Shelf",+            ])+        #expect(model.rows.map(\.memberCount) == [2, 0, 1])+        // One work, not "1 works", and an empty series says so rather than+        // wearing a bare zero.+        #expect(model.rows[2].countLabel.contains("1 work"))+        #expect(model.rows[2].countLabel.contains("works") == false)+    }++    @Test("An empty library explains what a series is for rather than showing nothing")+    @MainActor func emptyList() async {+        let (model, _, _) = makeSUT([])++        await model.load()++        #expect(model.state == .ready)+        #expect(model.rows.isEmpty)+        #expect(!model.emptyMessage.isEmpty)+    }++    @Test("A failed read enters the error state")+    @MainActor func failedRead() async {+        let (model, mock, _) = makeSUT()+        mock.seriesListResult = .failure(MockLibraryProvider.MockError.simulatedFailure("nope"))++        await model.load()++        if case .error = model.state {} else { Issue.record("Expected the error state") }+        #expect(model.rows.isEmpty)+    }++    // MARK: - Adding (Req 1.1)++    @Test("Adding a name commits it, clears the field, and re-reads the list")+    @MainActor func addCommits() async {+        let (model, mock, mutations) = makeSUT()+        await model.load()+        model.draftName = "  Ashfall Cycle  "++        await model.add()++        #expect(mock.lastCreatedSeries?.name == "  Ashfall Cycle  ")+        // A new series has no notes: the screen that offers them is the series'+        // own, and the add field is one line.+        #expect(mock.lastCreatedSeries?.notes == "")+        #expect(model.draftName.isEmpty)+        #expect(model.message == nil)+        #expect(mock.seriesListCallCount == 2)+        #expect(mutations.count == 1)+    }++    /// Req 1.1: the refusal states its reason, and it is Core's reason —+    /// `SeriesName.validate` owns the rule, so the screen cannot word it into+    /// something the repository does not enforce.+    @Test("A name with a line break is refused with the reason, keeping the draft")+    @MainActor func addRejectsInvalidName() async {+        let (model, mock, mutations) = makeSUT()+        await model.load()+        model.draftName = "Ashfall\nCycle"++        await model.add()++        #expect(model.draftName == "Ashfall\nCycle")+        #expect(model.message?.isEmpty == false)+        // Refused before the store was asked.+        #expect(mock.lastCreatedSeries == nil)+        #expect(mutations.count == 0)+    }++    @Test("A blank field is not offered as an add")+    @MainActor func blankFieldIsNotAddable() async {+        let (model, mock, _) = makeSUT()+        await model.load()+        model.draftName = "   "++        #expect(!model.canAdd)+        await model.add()++        #expect(mock.lastCreatedSeries == nil)+    }++    @Test("An add that throws is reported without clearing the field")+    @MainActor func addFailure() async {+        let (model, mock, _) = makeSUT()+        mock.createSeriesResult = .failure(MockLibraryProvider.MockError.simulatedFailure("nope"))+        await model.load()+        model.draftName = "Quiet Shelf"++        await model.add()++        #expect(model.draftName == "Quiet Shelf")+        #expect(model.message != nil)+    }++    // MARK: - Reloading (Req 11.2)++    /// A member or a name arriving through sync heals the screen without a+    /// relaunch: `AppLibraryModel.snapshotGeneration` bumps on every arrival and+    /// every write, and the screen re-reads on the bump — but not on a+    /// republication that left the generation where it was.+    @Test("The list re-reads when the snapshot generation moves, and not otherwise")+    @MainActor func reloadsOnGenerationChange() async {+        let (model, mock, _) = makeSUT()++        await model.reload(for: 3)+        await model.reload(for: 3)++        #expect(mock.seriesListCallCount == 1)++        await model.reload(for: 4)++        #expect(mock.seriesListCallCount == 2)+    }+}++@Suite("Series detail model")+struct SeriesDetailModelTests {++    private static let seriesID = UUID()+    private static let locale = Locale(identifier: "en_US")++    private func display(+        _ name: String? = "Ashfall Cycle", id: UUID = SeriesDetailModelTests.seriesID,+        qualifier: String? = nil+    ) -> SeriesDisplay {+        SeriesDisplay(+            id: id, name: name, createdAt: TestFixtures.fixedDate, qualifier: qualifier)+    }++    private func member(+        _ title: String, id: UUID = UUID(), position: Double,+        seriesID: UUID = SeriesDetailModelTests.seriesID+    ) -> WorkSnapshot {+        TestFixtures.makeWork(+            id: id, displayTitle: title,+            genreTags: ["shonen"],+            genericNotes: "kept",+            readingStatus: .abandoned,+            verdict: "put down",+            membership: SeriesMembership(seriesID: seriesID, position: position),+            series: display())+    }++    private func detail(+        notes: String = "", members: [WorkSnapshot] = []+    ) -> SeriesDetail {+        SeriesDetail(display: display(), notes: notes, members: members)+    }++    @MainActor private func makeSUT(+        _ detail: SeriesDetail? = nil,+        origin: UUID? = nil+    ) -> (SeriesDetailModel, MockLibraryProvider, MutationRecorder) {+        let mock = MockLibraryProvider()+        mock.seriesDetailResult = .success(detail)+        let mutations = MutationRecorder()+        let model = SeriesDetailModel(+            seriesID: Self.seriesID, originWorkID: origin, library: mock,+            locale: Self.locale, onMutation: { mutations.record() })+        return (model, mock, mutations)+    }++    // MARK: - The screen (Reqs 3.1–3.3)++    @Test("Load presents the name, the notes and the members the read returned")+    @MainActor func loadPresentsTheSeries() async {+        let first = member("Ashfall", position: 1)+        let second = member("Emberfall", position: 2.5)+        let (model, mock, _) = makeSUT(detail(notes: "Read 2.5 last", members: [first, second]))++        await model.load()++        #expect(model.state == .ready)+        #expect(mock.lastSeriesDetailID == Self.seriesID)+        #expect(model.title == "Ashfall Cycle")+        #expect(model.notes == "Read 2.5 last")+        // The read's order, which is `SeriesMemberOrdering`'s.+        #expect(model.members.map(\.work.id) == [first.id, second.id])+        // Req 2.7: the fewest fraction digits that represent the value, in the+        // viewing locale.+        #expect(model.members.map(\.positionText) == ["1", "2.5"])+    }++    /// Req 3.3: the marker belongs to a series screen opened **from a work**.+    @Test("The origin work's row carries the current marker, and only it")+    @MainActor func currentMemberMarker() async {+        let first = member("Ashfall", position: 1)+        let second = member("Emberfall", position: 2)+        let (model, _, _) = makeSUT(+            detail(members: [first, second]), origin: second.id)++        await model.load()++        #expect(model.members.map(\.isCurrent) == [false, true])+    }++    @Test("A series screen opened from the list carries no marker")+    @MainActor func noMarkerWithoutAnOrigin() async {+        let (model, _, _) = makeSUT(detail(members: [member("Ashfall", position: 1)]))++        await model.load()++        #expect(model.members.allSatisfy { !$0.isCurrent })+    }++    /// A series deleted on another device is a state the reader can reach by+    /// standing on the screen; it says so rather than showing an empty series.+    @Test("A series the library no longer holds says so")+    @MainActor func missingSeries() async {+        let (model, _, _) = makeSUT(nil)++        await model.load()++        #expect(model.state == .missing)+        #expect(model.members.isEmpty)+    }++    @Test("The screen re-reads when the snapshot generation moves, and not otherwise")+    @MainActor func reloadsOnGenerationChange() async {+        let (model, mock, _) = makeSUT(detail())++        await model.reload(for: 1)+        await model.reload(for: 1)+        #expect(mock.seriesDetailCallCount == 1)++        await model.reload(for: 2)+        #expect(mock.seriesDetailCallCount == 2)+    }++    // MARK: - Name and notes (Reqs 1.1, 1.2)++    @Test("Editing opens on the stored name and notes and commits both")+    @MainActor func editCommitsNameAndNotes() async {+        let (model, mock, mutations) = makeSUT(detail(notes: "Read 2.5 last"))+        await model.load()++        model.beginEditing()+        #expect(model.draftName == "Ashfall Cycle")+        #expect(model.draftNotes == "Read 2.5 last")++        model.draftName = "Ashfall Saga"+        model.draftNotes = "Read 2.5 first"+        await model.save()++        #expect(mock.lastUpdatedSeries?.id == Self.seriesID)+        #expect(mock.lastUpdatedSeries?.name == "Ashfall Saga")+        #expect(mock.lastUpdatedSeries?.notes == "Read 2.5 first")+        #expect(!model.isEditing)+        #expect(mutations.count == 1)+    }++    @Test("An invalid name is refused with its reason and keeps the editor open")+    @MainActor func editRejectsInvalidName() async {+        let (model, mock, mutations) = makeSUT(detail())+        await model.load()+        model.beginEditing()+        model.draftName = "   "++        await model.save()++        #expect(model.message?.isEmpty == false)+        #expect(model.isEditing)+        #expect(mock.lastUpdatedSeries == nil)+        #expect(mutations.count == 0)+    }++    @Test("Cancelling an edit writes nothing and drops the drafts")+    @MainActor func cancelEditing() async {+        let (model, mock, _) = makeSUT(detail(notes: "Read 2.5 last"))+        await model.load()+        model.beginEditing()+        model.draftName = "Something else"++        model.cancelEditing()++        #expect(!model.isEditing)+        #expect(mock.lastUpdatedSeries == nil)+        model.beginEditing()+        #expect(model.draftName == "Ashfall Cycle")+    }++    // MARK: - Positions (Reqs 2.2, 2.6, 2.8)++    /// Q25: a member's position is an edit **of the work**, so the draft carries+    /// every one of the work's other fields back unchanged. A draft that dropped+    /// the reading status or the notes would reset them with no error.+    @Test("A changed position writes a draft carrying the member's other fields")+    @MainActor func positionCommitCarriesTheWholeDraft() async throws {+        let work = member("Ashfall", position: 1)+        let (model, mock, mutations) = makeSUT(detail(members: [work]))+        await model.load()+        model.beginEditing()++        model.setPositionDraft("2.5", for: work.id)+        await model.save()++        let call = try #require(mock.updateWorkCalls.first)+        #expect(call.id == work.id)+        #expect(call.draft.membership == SeriesMembership(seriesID: Self.seriesID, position: 2.5))+        #expect(call.draft.displayTitle == "Ashfall")+        #expect(call.draft.genreTags == ["shonen"])+        #expect(call.draft.genericNotes == "kept")+        #expect(call.draft.readingStatus == .abandoned)+        #expect(call.draft.verdict == "put down")+        // The basis is the member's own, so a membership changed elsewhere+        // between the read and this write is the edit conflict Req 2.4 asks for.+        #expect(call.basis.membership == SeriesMembership(seriesID: Self.seriesID, position: 1))+        #expect(mutations.count == 1)+    }++    @Test("An unchanged position writes nothing")+    @MainActor func unchangedPositionWritesNothing() async {+        let work = member("Ashfall", position: 2.5)+        let (model, mock, _) = makeSUT(detail(members: [work]))+        await model.load()+        model.beginEditing()++        model.setPositionDraft("2.5", for: work.id)+        await model.save()++        #expect(mock.updateWorkCalls.isEmpty)+    }++    /// Req 2.2: the refusal is the model's, before any repository call, and the+    /// editor stays open on what the reader typed.+    @Test("A position that is not a number is refused before any write")+    @MainActor func invalidPositionRefused() async {+        let work = member("Ashfall", position: 1)+        let (model, mock, _) = makeSUT(detail(members: [work]))+        await model.load()+        model.beginEditing()++        model.setPositionDraft("1,000.5", for: work.id)+        await model.save()++        #expect(model.message?.isEmpty == false)+        #expect(model.isEditing)+        #expect(model.positionDraft(for: work.id) == "1,000.5")+        #expect(mock.updateWorkCalls.isEmpty)+    }++    /// Req 2.6 and Q25: the rows commit one at a time, in list order. The first+    /// refusal stops the sequence — the rows before it stay committed, the ones+    /// after it are never asked — and the screen re-reads so it shows what+    /// actually landed.+    @Test("Position commits stop at the first conflict, keeping what landed")+    @MainActor func positionCommitsStopAtTheFirstConflict() async {+        let first = member("Ashfall", position: 1)+        let second = member("Emberfall", position: 2)+        let third = member("Duskfall", position: 3)+        let (model, mock, _) = makeSUT(detail(members: [first, second, third]))+        await model.load()+        model.beginEditing()+        mock.updateWorkResultsByWorkID[second.id] = .success(+            .conflict(.torn(recordID: second.id, variants: [])))++        model.setPositionDraft("1.5", for: first.id)+        model.setPositionDraft("2.5", for: second.id)+        model.setPositionDraft("3.5", for: third.id)+        await model.save()++        #expect(mock.updateWorkCalls.map(\.id) == [first.id, second.id])+        #expect(model.message == EntryDetailModel.conflictMessage(+            .torn(recordID: second.id, variants: [])))+        // The re-read that shows what landed: one load, and one more here.+        #expect(mock.seriesDetailCallCount == 2)+        #expect(model.isEditing)+    }++    // MARK: - Membership (Reqs 2.5, 2.6)++    @Test("Removing a member sends a draft with no membership and leaves the work alone")+    @MainActor func removeMember() async throws {+        let work = member("Ashfall", position: 1)+        let (model, mock, mutations) = makeSUT(detail(members: [work]))+        await model.load()++        await model.removeMember(work.id)++        let call = try #require(mock.updateWorkCalls.first)+        #expect(call.id == work.id)+        #expect(call.draft.membership == nil)+        #expect(call.draft.displayTitle == "Ashfall")+        #expect(mutations.count == 1)+        // The screen re-reads: the row it removed has to leave the list.+        #expect(mock.seriesDetailCallCount == 2)+    }++    /// Req 2.5: an added work takes the position Req 2.3 prefills — the next+    /// whole number above the series' highest, which the repository computes.+    @Test("Adding a member writes the prefilled position for this series")+    @MainActor func addMemberTakesThePrefill() async throws {+        let candidate = TestFixtures.makeWork(displayTitle: "Duskfall")+        let (model, mock, mutations) = makeSUT(detail())+        mock.seriesMemberCandidatesResult = .success([+            WorkPickerCandidate(work: candidate, unavailableReason: nil)+        ])+        mock.nextSeriesPositionResult = .success(3)+        await model.load()+        await model.loadCandidates()++        #expect(model.candidates.map(\.id) == [candidate.id])+        await model.addMember(candidate.id)++        let call = try #require(mock.updateWorkCalls.first)+        #expect(mock.lastNextSeriesPositionID == Self.seriesID)+        #expect(call.id == candidate.id)+        #expect(call.draft.membership == SeriesMembership(seriesID: Self.seriesID, position: 3))+        #expect(mutations.count == 1)+    }++    @Test("A refused membership write is reported and nothing is claimed")+    @MainActor func refusedMembershipWrite() async {+        let work = member("Ashfall", position: 1)+        let (model, mock, mutations) = makeSUT(detail(members: [work]))+        mock.updateWorkResult = .success(.conflict(.torn(recordID: work.id, variants: [])))+        await model.load()++        await model.removeMember(work.id)++        #expect(model.message?.isEmpty == false)+        #expect(mutations.count == 0)+    }++    // MARK: - Deletion (Req 1.4)++    /// Req 1.4: the confirmation states how many works the series holds, and+    /// promises they stay — the deletion removes the series, never a work.+    @Test("The deletion prompt names the count and promises the works stay")+    @MainActor func deletionPromptWording() async {+        let (model, _, _) = makeSUT(+            detail(members: [member("Ashfall", position: 1), member("Emberfall", position: 2)]))+        await model.load()++        model.requestDeletion()++        let message = model.deletionPrompt?.message+        #expect(model.deletionPrompt?.memberCount == 2)+        #expect(message?.contains("2 works are") == true)+        #expect(message?.lowercased().contains("stay") == true)+    }++    @Test("An empty series' prompt claims no works")+    @MainActor func deletionPromptZeroForm() async {+        let (model, _, _) = makeSUT(detail())+        await model.load()++        model.requestDeletion()++        let message = model.deletionPrompt?.message+        #expect(model.deletionPrompt?.memberCount == 0)+        #expect(message?.isEmpty == false)+        #expect(message?.contains("0 works") == false)+    }++    /// The `RemovalPrompt` hazard, restated: SwiftUI runs a confirmation+    /// dialog's dismissal *before* the tapped button's action, so the confirm+    /// takes the rendered prompt as a parameter and never re-reads the model.+    @Test("A dismissal running before the confirm action still deletes the series")+    @MainActor func confirmSurvivesTheDismissalRunningFirst() async throws {+        let (model, mock, mutations) = makeSUT(detail())+        await model.load()+        model.requestDeletion()+        let prompt = try #require(model.deletionPrompt)++        model.cancelDeletion()+        await model.confirmDeletion(prompt)++        #expect(mock.lastDeletedSeriesID == Self.seriesID)+        #expect(model.didFinish)+        #expect(mutations.count == 1)+    }++    /// Req 2.9: a torn member refuses the deletion before any write, and the+    /// reason is the repository's — the screen shows it and stays put.+    @Test("A refused deletion keeps the screen and states the reason")+    @MainActor func refusedDeletion() async throws {+        let (model, mock, mutations) = makeSUT(detail())+        mock.deleteSeriesResult = .success(+            .invalidated(reason: "A work in this series has copies that differ."))+        await model.load()+        model.requestDeletion()+        let prompt = try #require(model.deletionPrompt)++        await model.confirmDeletion(prompt)++        #expect(model.message?.contains("copies that differ") == true)+        #expect(!model.didFinish)+        #expect(mutations.count == 0)+    }++}

diff --git a/Asterism/Asterism/Views/WorkDetailView.swift b/Asterism/Asterism/Views/WorkDetailView.swiftindex 5109409..a04f078 100644--- a/Asterism/Asterism/Views/WorkDetailView.swift+++ b/Asterism/Asterism/Views/WorkDetailView.swift@@ -76,12 +76,29 @@ struct WorkDetailView: View {     /// Which order the spine is read in. `@State` and not stored (Q3): Newest is     /// the reading default and every open of the screen starts there.     @State private var sortOrder: WorkDetailModel.ChapterSortOrder = .newest+    /// Where a related work goes, or nil where the host has no route — the+    /// Merge sheet's embedded copy of this screen (Req 8.1).+    let onSelectWork: ((UUID) -> Void)?+    /// Where the series row goes (Req 5.1), on the same terms.+    let onSelectSeries: ((UUID) -> Void)?+    /// Whether the "New series" alert is up, and what has been typed into it+    /// (Req 2.3). `@State` because the alert is the view's, and the name only+    /// becomes the model's business when it is confirmed.+    @State private var isNamingSeries = false+    @State private var newSeriesName = ""+    /// The add-link flow's two steps (Req 8.2). The picker is a flag; the type+    /// step carries the work it is about, so nothing is read out of a+    /// presentation closure.+    @State private var isPresentingLinkPicker = false+    @State private var pendingLinkTarget: PendingLinkTarget?      init(         model: WorkDetailModel,         onResolveDuplicate: (() -> Void)? = nil,         onSelectEntry: ((UUID) -> Void)? = nil,         onMergeCommitted: ((UUID) -> Void)? = nil,+        onSelectWork: ((UUID) -> Void)? = nil,+        onSelectSeries: ((UUID) -> Void)? = nil,         exportModel: MarkdownExportModel? = nil,         showsSky: Bool = true,         extraction: CharacterExtractionCoordinator? = nil@@ -91,6 +108,8 @@ struct WorkDetailView: View {         self.onResolveDuplicate = onResolveDuplicate         self.onSelectEntry = onSelectEntry         self.onMergeCommitted = onMergeCommitted+        self.onSelectWork = onSelectWork+        self.onSelectSeries = onSelectSeries         self.showsSky = showsSky         self.extraction = extraction     }@@ -158,6 +177,52 @@ struct WorkDetailView: View {      // MARK: - The §6 layout +    /// The editor's sections, in the order the reader meets them: what the work+    /// is, what they wrote about it, who is in it, what it is related to, and+    /// where it lives.+    ///+    /// Named rather than written inline in `workContent` because the two mode+    /// branches together defeated the type checker once the series and link+    /// sections joined them.+    @ViewBuilder+    private var editSections: some View {+        editHeaderSection+        editNotesSection+        editCharactersSection+        editRelatedWorksSection+        workURLSection+        urlIdentitySection+        manageSection+    }++    /// The last row of either mode: what the last refused write said.+    @ViewBuilder+    private var errorSection: some View {+        if let errorMessage = model.errorMessage {+            Section {+                // Q37: a save failure is amber, not system red — the palette+                // has no error colour and §11 forbids a fourth hue.+                Text(errorMessage)+                    .foregroundStyle(AsterismColors.amberText)+                    .frame(maxWidth: .infinity, alignment: .leading)+                    .padding(12)+                    .constellationCard(borderColor: AsterismColors.attentionBorder)+                    .constellationListRow()+                    .accessibilityIdentifier("work-detail-error")+            }+        }+    }++    @ViewBuilder+    private func readingSections(_ work: WorkSnapshot) -> some View {+        viewHeaderSection(work)+        seriesSection+        openLastNotedSection+        charactersSection+        relatedWorksSection+        chapterSection+    }+     @ViewBuilder     private func workContent(_ work: WorkSnapshot) -> some View {         List {@@ -166,32 +231,12 @@ struct WorkDetailView: View {             proposalsIndicatorSection              if model.isEditing {-                editHeaderSection-                editNotesSection-                editCharactersSection-                workURLSection-                urlIdentitySection-                manageSection+                editSections             } else {-                viewHeaderSection(work)-                openLastNotedSection-                charactersSection-                chapterSection+                readingSections(work)             } -            if let errorMessage = model.errorMessage {-                Section {-                    // Q37: a save failure is amber, not system red — the-                    // palette has no error colour and §11 forbids a fourth hue.-                    Text(errorMessage)-                        .foregroundStyle(AsterismColors.amberText)-                        .frame(maxWidth: .infinity, alignment: .leading)-                        .padding(12)-                        .constellationCard(borderColor: AsterismColors.attentionBorder)-                        .constellationListRow()-                        .accessibilityIdentifier("work-detail-error")-                }-            }+            errorSection         }         // Req 8.1: the Works tab's sky shows through the pushed screen too.         .scrollContentBackground(.hidden)@@ -222,6 +267,13 @@ struct WorkDetailView: View {                 ComposedTeachingContainerView(model: reteachModel)             }         }+        .modifier(+            WorkConnectionPresentations(+                model: model,+                isPresentingLinkPicker: $isPresentingLinkPicker,+                pendingLinkTarget: $pendingLinkTarget,+                isNamingSeries: $isNamingSeries,+                newSeriesName: $newSeriesName))         .markdownExportShare(             model: exportModel, sheetIdentifier: "work-detail-export-share-sheet")         // Attached to the List, not to the row that triggers it: a presentation@@ -587,50 +639,51 @@ struct WorkDetailView: View {             .constellationCard()             .constellationListRow() +            seriesPicker+            newSeriesButton+            seriesPositionField+             // Reqs 1.2 and 2.2, in the order they are named. Both capsules             // contain a segment called "Finished" and nothing else on the screen             // says which is which, so each carries a visible caption rather than             // relying on position (Q26 chose the capsule over a `Picker`: three             // short labels are a state to see, not a menu to open).-            captionedCard("Work status") {-                ConstellationSegmentedControl(-                    values: WorkStatus.allCases,-                    selection: Binding(-                        get: { model.draftWorkStatus },-                        set: { model.setDraftWorkStatus($0) }),-                    containerLabel: "Work status",-                    title: WorkStatusPresentation.name,-                    identifier: WorkStatusPresentation.controlIdentifier)-            }--            captionedCard("Reading status") {-                ConstellationSegmentedControl(-                    values: ReadingStatus.allCases,-                    selection: Binding(-                        get: { model.draftReadingStatus },-                        // Req 3.1: the setter is the transition, not an-                        // assignment — choosing `finished` on an unfinished work-                        // raises the dialog and leaves the capsule where it was.-                        set: { model.setDraftReadingStatus($0) }),-                    containerLabel: "Reading status",-                    title: ReadingStatusPresentation.name,-                    identifier: ReadingStatusPresentation.controlIdentifier)-            }+            ConstellationSegmentedControl(+                values: WorkStatus.allCases,+                selection: Binding(+                    get: { model.draftWorkStatus },+                    set: { model.setDraftWorkStatus($0) }),+                containerLabel: "Work status",+                title: WorkStatusPresentation.name,+                identifier: WorkStatusPresentation.controlIdentifier)+                .constellationCaptionedCard("Work status")++            ConstellationSegmentedControl(+                values: ReadingStatus.allCases,+                selection: Binding(+                    get: { model.draftReadingStatus },+                    // Req 3.1: the setter is the transition, not an+                    // assignment — choosing `finished` on an unfinished work+                    // raises the dialog and leaves the capsule where it was.+                    set: { model.setDraftReadingStatus($0) }),+                containerLabel: "Reading status",+                title: ReadingStatusPresentation.name,+                identifier: ReadingStatusPresentation.controlIdentifier)+                .constellationCaptionedCard("Reading status")              // Req 2.3: present exactly while the draft reading status is done             // reading, under the prompt that tells the two verdicts apart. The             // table returns nil for `reading`, which *is* the absence.             if let prompt = ReadingStatusPresentation.verdictPrompt(model.draftReadingStatus) {-                captionedCard(prompt) {-                    TextField(prompt, text: $model.draftVerdict, axis: .vertical)-                        .lineLimit(3...6)-                        // Req 10.1: the caption is a sibling `Text`, so the-                        // field carries the same prompt as its placeholder and-                        // its spoken label, and the reader hears which verdict-                        // is being asked for.-                        .accessibilityLabel(prompt)-                        .accessibilityIdentifier("work-detail-verdict-field")-                }+                TextField(prompt, text: $model.draftVerdict, axis: .vertical)+                    .lineLimit(3...6)+                    // Req 10.1: the caption is a sibling `Text`, so the field+                    // carries the same prompt as its placeholder and its spoken+                    // label, and the reader hears which verdict is being asked+                    // for.+                    .accessibilityLabel(prompt)+                    .accessibilityIdentifier("work-detail-verdict-field")+                    .constellationCaptionedCard(prompt)             }              TextField(@@ -653,27 +706,122 @@ struct WorkDetailView: View {         }     } -    /// One edit-mode card under a visible caption — the recipe the two status-    /// capsules and the verdict field share.+    // MARK: - The series picker and its position (Req 2.3)++    /// The type picker's recipe exactly: an em-dash row for "in no series", then+    /// every series the library offers.     ///-    /// The caption is a label rather than a placeholder for the verdict's reason-    /// (Q16): a placeholder vanishes the moment the reader types, and here it is-    /// the caption that says what the control is for.-    private func captionedCard(-        _ caption: String, @ViewBuilder content: () -> some View-    ) -> some View {-        VStack(alignment: .leading, spacing: 8) {-            Text(caption)-                .font(.caption.weight(.semibold))-                .foregroundStyle(AsterismColors.secondaryText)-            content()+    /// A series the list cannot name — a membership whose row has not arrived —+    /// is carried last, knocked down by `menuRowStyle(for: .unresolved)`, and+    /// stays selected until the reader chooses something else (Req 5.2). The+    /// selection goes through the model's setter rather than a raw binding+    /// because choosing a series prefills the position.+    private var seriesPicker: some View {+        Picker("Series", selection: seriesBinding) {+            Text(verbatim: "\u{2014}").tag(UUID?.none)+            ForEach(model.seriesOptions) { option in+                // Req 1.3's qualifier belongs to *every* picker, not only the+                // lists: two series sharing a name are two identical rows+                // without it. The unresolved row keeps its horizontal ellipsis+                // — the type picker's recipe for "a value with no name" — rather+                // than spelling out the placeholder in a menu (Q57).+                Text(option.isResolved ? option.label : "\u{2026}")+                    .foregroundStyle(+                        WorkTypePresentation.menuRowStyle(+                            for: option.isResolved ? .active : .unresolved))+                    .tag(UUID?.some(option.id))+            }         }-        .frame(maxWidth: .infinity, alignment: .leading)-        .padding(12)+        .accessibilityIdentifier("work-detail-series-picker")+        .padding(.horizontal, 12)+        .frame(minHeight: AsterismLayout.minHitTarget)         .constellationCard()         .constellationListRow()     } +    /// The picker's selection. A binding rather than `$model.draftSeriesID`+    /// because the prefill is asynchronous and the choice is the model's rule,+    /// not the control's — the same shape `workURLHostnameBinding` takes.+    private var seriesBinding: Binding<UUID?> {+        Binding(+            get: { model.draftSeriesID },+            set: { selection in Task { await model.selectSeries(selection) } })+    }++    private var newSeriesButton: some View {+        Button("New series") {+            newSeriesName = ""+            isNamingSeries = true+        }+        .disabled(model.isReadOnly)+        .frame(minHeight: AsterismLayout.minHitTarget)+        .accessibilityIdentifier("work-detail-new-series")+    }++    /// Shown exactly while a series is selected (Req 2.3): a position with no+    /// series is not a value the draft can hold.+    @ViewBuilder+    private var seriesPositionField: some View {+        if model.draftSeriesID != nil {+            TextField("Position", text: $model.draftPositionText)+                .decimalKeyboard()+                // Req 10.1's rule from `work-and-reading-status`: the caption is+                // a sibling `Text`, so the field says out loud what the card+                // says in print.+                .accessibilityLabel("Position in the series")+                .accessibilityIdentifier("work-detail-series-position")+                .constellationCaptionedCard("Position")+        }+    }++    // MARK: - Series (`series-and-related-works` Reqs 5.1–5.3)++    /// The series row, above the reading actions because it says what this work+    /// *is part of* rather than what to do with it.+    ///+    /// Absent for a work in no series (Req 5.3) — an empty row would invite an+    /// edit view mode is not offering. An unresolved membership draws the+    /// placeholder and opens nothing (Req 5.2): there is no screen to show for a+    /// series this device does not hold.+    @ViewBuilder+    private var seriesSection: some View {+        if let text = model.seriesRowText {+            Section {+                Button {+                    guard let seriesID = model.work?.membership?.seriesID else { return }+                    onSelectSeries?(seriesID)+                } label: {+                    HStack(spacing: 8) {+                        Text("Series")+                            .font(.caption.weight(.semibold))+                            .foregroundStyle(AsterismColors.secondaryText)+                        Text(text)+                            .font(.subheadline)+                            .foregroundStyle(+                                model.isSeriesResolved+                                    ? AsterismColors.primaryText+                                    : AsterismColors.secondaryText)+                            .fixedSize(horizontal: false, vertical: true)+                        Spacer(minLength: 0)+                        if model.isSeriesResolved {+                            Image(systemName: "chevron.right")+                                .font(.caption)+                                .foregroundStyle(AsterismColors.secondaryText)+                                .accessibilityHidden(true)+                        }+                    }+                    .contentShape(Rectangle())+                }+                .buttonStyle(.plain)+                .disabled(!model.isSeriesResolved || onSelectSeries == nil)+                .frame(minHeight: AsterismLayout.minHitTarget)+                .accessibilityIdentifier("work-detail-series-row")+                .accessibilityLabel("Series, \(text)")+                .constellationListRow()+            }+        }+    }+     /// Req 5.3. Hidden entirely where the work has no entries — the repository     /// decides that by returning no URL, so the screen never has to guess.     @ViewBuilder@@ -867,6 +1015,10 @@ struct WorkDetailView: View {                     // not this session's intent.                     expandedEditCharacterID = nil                     model.beginEditing()+                    // Req 7.1's vocabulary, for the chips on each link card.+                    // Read on entering the editor rather than on every open of+                    // the page: view mode has nowhere to show them.+                    Task { await model.loadLinkOptions() }                 } label: {                     Image(systemName: "pencil")                         .frame(@@ -1106,6 +1258,132 @@ struct WorkDetailView: View {         }     } +    // MARK: - Related works (`series-and-related-works` Reqs 8.1–8.4)++    /// The links, and the way to add one.+    ///+    /// Present even with no links (Req 8.4): unlike the cast, which is+    /// discovered, a link is something the reader makes — so the affordance is+    /// the section's whole content until there is one.+    private var relatedWorksSection: some View {+        Section {+            ForEach(model.links) { link in+                linkRow(link)+            }+            addLinkButton+        } header: {+            ConstellationSectionHeader("Related works", accent: .violet)+        }+    }++    /// "adaptation · The Other Work", opening that work.+    ///+    /// An unresolved end reads as the placeholder and opens nothing (Req 8.3) —+    /// this device has no detail to show for a work it does not hold — but the+    /// row stays, because the link is still the reader's to retype or remove.+    private func linkRow(_ link: WorkLinkSnapshot) -> some View {+        Button {+            onSelectWork?(link.otherWorkID)+        } label: {+            HStack(spacing: 8) {+                Text(link.linkType)+                    .constellationPill(.genreTag)+                Text(link.displayTitle)+                    .font(AsterismTypography.serifRowTitle)+                    .foregroundStyle(+                        link.isResolved+                            ? AsterismColors.primaryText : AsterismColors.secondaryText)+                    .lineLimit(2)+                Spacer(minLength: 0)+                if link.isResolved {+                    Image(systemName: "chevron.right")+                        .font(.caption)+                        .foregroundStyle(AsterismColors.secondaryText)+                        .accessibilityHidden(true)+                }+            }+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+        .disabled(!link.isResolved || onSelectWork == nil)+        .frame(minHeight: AsterismLayout.minHitTarget)+        .accessibilityIdentifier("work-detail-link-\(link.id.uuidString)")+        .accessibilityLabel(+            "\(link.linkType), \(link.displayTitle)")+    }++    /// Req 8.2's affordance, on "Add a character"'s shape. The two reads it+    /// needs run when it is tapped, not behind the screen.+    private var addLinkButton: some View {+        Button("Add a related work") {+            isPresentingLinkPicker = true+            Task { await model.loadLinkOptions() }+        }+        .disabled(model.isReadOnly)+        .frame(minHeight: AsterismLayout.minHitTarget)+        .accessibilityIdentifier("work-detail-add-link")+    }++    /// The same section in edit mode: one card per link with the type field, the+    /// suggestions and the way out.+    ///+    /// Every control here commits on the spot (Q24). A link is its own row with+    /// its own timestamps, so folding it into the work's draft would make a+    /// retype wait on — and conflict with — a title being typed beside it.+    private var editRelatedWorksSection: some View {+        Section {+            ForEach(model.links) { link in+                editLinkRow(link)+            }+            addLinkButton+        } header: {+            ConstellationSectionHeader("Related works", accent: .violet)+        }+    }++    private func editLinkRow(_ link: WorkLinkSnapshot) -> some View {+        VStack(alignment: .leading, spacing: 8) {+            Text(link.displayTitle)+                .font(AsterismTypography.serifRowTitle)+                .foregroundStyle(+                    link.isResolved ? AsterismColors.primaryText : AsterismColors.secondaryText)+                .lineLimit(1)+                .truncationMode(.tail)++            TextField(+                "Link type",+                text: Binding(+                    get: { model.linkTypeDraft(for: link.id) },+                    set: { model.setLinkTypeDraft($0, for: link.id) })+            )+            .autocorrectionDisabled()+            .noAutocapitalization()+            .accessibilityLabel("Link type for \(link.displayTitle)")+            .accessibilityIdentifier("work-detail-link-type-\(link.id.uuidString)")+            // The field commits what it holds when the reader is done with it,+            // rather than on every keystroke: a retype stamps the link's+            // modification time, which is the survivor key (Q27).+            .onSubmit { Task { await model.commitLinkType(for: link.id) } }++            LinkTypeSuggestionChips(suggestions: model.linkTypeSuggestions) { suggestion in+                model.setLinkTypeDraft(suggestion, for: link.id)+                Task { await model.commitLinkType(for: link.id) }+            }++            Button("Remove link", role: .destructive) {+                Task { await model.removeLink(id: link.id) }+            }+            .font(.caption)+            .disabled(model.isReadOnly)+            .accessibilityIdentifier("work-detail-link-remove-\(link.id.uuidString)")+        }+        .buttonStyle(.borderless)+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .constellationCard()+        .constellationListRow()+    }+     /// One name in the cast. The identifier sits on the button — a leaf     /// element, so nothing inside is masked and the pill count is the cast     /// count.@@ -1699,6 +1977,72 @@ enum WorkDetailSitePresentation {     } } +/// The work the add-link flow's second step is about (Req 8.2). Carried on the+/// presented value for `PresentedHostname`'s reason: state read inside a+/// presentation closure is the family of bug Q101 records.+private struct PendingLinkTarget: Identifiable, Equatable {+    let id: UUID+    let title: String+}++/// The add-link flow's two sheets and the "New series" alert, lifted off+/// `workContent`'s modifier chain (`series-and-related-works` Reqs 2.3, 8.2).+///+/// Not a tidiness choice. Written inline, the three pushed that chain past the+/// point where the type checker would finish it — "unable to type-check this+/// expression in reasonable time". One modifier is one expression.+private struct WorkConnectionPresentations: ViewModifier {+    let model: WorkDetailModel+    @Binding var isPresentingLinkPicker: Bool+    @Binding var pendingLinkTarget: PendingLinkTarget?+    @Binding var isNamingSeries: Bool+    @Binding var newSeriesName: String++    func body(content: Content) -> some View {+        content+            // Req 8.2's first step: which work. The second step is chained+            // through `pendingLinkTarget` rather than nested inside this+            // sheet — a sheet presented from inside another sheet's closure is+            // the presentation bug `duplicate-reconciliation` Q101 records.+            .sheet(isPresented: $isPresentingLinkPicker) {+                WorkPickerView(+                    title: "Add a related work",+                    candidates: model.linkCandidates,+                    onSelect: { workID in+                        isPresentingLinkPicker = false+                        pendingLinkTarget = model.linkCandidates+                            .first { $0.id == workID }+                            .map { PendingLinkTarget(id: $0.id, title: $0.work.displayTitle) }+                    })+            }+            // The second step: what the link is called (Req 7).+            .sheet(item: $pendingLinkTarget) { target in+                LinkTypeEntryView(+                    workTitle: target.title,+                    suggestions: model.linkTypeSuggestions,+                    onSubmit: { type in+                        pendingLinkTarget = nil+                        Task { await model.addLink(to: target.id, type: type) }+                    })+            }+            // Req 2.3's "New series": one field, and the series exists the+            // moment it is confirmed (Q16).+            .alert("New series", isPresented: $isNamingSeries) {+                TextField("Name", text: $newSeriesName)+                    .accessibilityIdentifier("work-detail-new-series-field")+                Button("Create") {+                    let name = newSeriesName+                    newSeriesName = ""+                    Task { await model.createSeries(named: name) }+                }+                .accessibilityIdentifier("work-detail-new-series-create")+                Button("Cancel", role: .cancel) { newSeriesName = "" }+            } message: {+                Text("The series is created straight away and stays even if you cancel this edit.")+            }+    }+}+ /// `.sheet(item:)` needs an `Identifiable`, and what the URL-identity review is /// keyed by is a hostname. The wrapper exists only for that — the `ContentView` /// precedent.

diff --git a/Packages/AsterismCore/Sources/AsterismCore/SeriesSupport.swift b/Packages/AsterismCore/Sources/AsterismCore/SeriesSupport.swiftnew file mode 100644index 0000000..dbf09f8--- /dev/null+++ b/Packages/AsterismCore/Sources/AsterismCore/SeriesSupport.swift@@ -0,0 +1,461 @@+import Foundation++// The value layer under series membership: what a membership is, what a series+// is called, how a position is read and written, and the four orderings every+// surface that lists series or members shares.+//+// Nothing here touches a store. `SeriesDirectory` is built from rows the caller+// already fetched, exactly as `WorkTypeDirectory` is (Decision 8 of+// `configurable-work-types`), so ordering, grouping, export and the snapshot+// mapper take a value rather than a context.++// MARK: - Membership++/// A work's place in a series: **both** halves or neither (design, "Work+/// columns: choke-point parity audit").+///+/// The store keeps two optional columns, because the lightweight stage needs no+/// default and nil means "no series". At the repository boundary they are one+/// value, so both-or-neither is a type rather than a check every reader has to+/// remember. A half-set row that arrives through sync reads as *no* membership+/// in every snapshot and is normalised to nil-nil by the next `updateWork` on+/// it.+public struct SeriesMembership: Equatable, Hashable, Sendable {+    public let seriesID: UUID+    /// Finite, and rounded to one fraction digit (Q15). Ties and gaps are+    /// allowed (Req 2.2).+    public let position: Double++    public init(seriesID: UUID, position: Double) {+        self.seriesID = seriesID+        self.position = position+    }+}++// MARK: - Display++/// A series as a reader sees it, composed by Core so no surface builds a label+/// from a name (Q26).+///+/// `name` is nil exactly where the series row has not arrived — the unresolved+/// state [11.2](../../../../specs/series-and-related-works/requirements.md#11.2)+/// tolerates indefinitely — and the label is then the placeholder.+public struct SeriesDisplay: Equatable, Hashable, Sendable, Identifiable {+    public let id: UUID+    /// The stored spelling, nil when unresolved.+    public let name: String?+    public let createdAt: Date?+    /// What tells two series sharing a name apart (Req 1.3): the creation date,+    /// and an ordinal after it where the day collides too. Nil where the name is+    /// unique in the directory, so an ordinary library shows plain names.+    public let qualifier: String?++    public init(id: UUID, name: String?, createdAt: Date?, qualifier: String? = nil) {+        self.id = id+        self.name = name+        self.createdAt = createdAt+        self.qualifier = qualifier+    }++    /// The placeholder an unresolved membership renders as, everywhere: the row,+    /// the work detail, the works list and the Markdown export (Q19).+    public static let unresolvedLabel = "Unavailable series"++    public var isResolved: Bool { name != nil }++    /// "Name", "Name · 5 Sep 2026", "Name · 5 Sep 2026 · 2", or the placeholder.+    public var label: String {+        guard let name else { return Self.unresolvedLabel }+        guard let qualifier else { return name }+        return name + " · " + qualifier+    }+}++/// The series table, folded and resolvable, as of one fetch — `WorkTypeDirectory`'s+/// role for series, and deliberately far simpler: series names need not be+/// unique (Q11), so there is no election and no canonical chase. Two rows with+/// one id would be duplicate rows of one series, and the first by creation date+/// then id answers for it.+public struct SeriesDirectory: Sendable, Equatable {+    private let displays: [UUID: SeriesDisplay]+    /// Kept beside the displays rather than on `SeriesDisplay`, which is the+    /// **label** value every list, picker and section header carries: notes are+    /// read by exactly two surfaces (the series screen and the Markdown export)+    /// and would otherwise ride along on every work row in the works list.+    private let notesByID: [UUID: String]++    public static let empty = SeriesDirectory(entities: [], locale: .current)++    public init(entities: [Series], locale: Locale) {+        // One row per id, chosen the way every other duplicate-row fold chooses:+        // earliest creation, then lowest identifier, so two devices holding the+        // same rows compose the same label.+        var rowsByID: [UUID: Series] = [:]+        for entity in entities {+            guard let held = rowsByID[entity.id] else {+                rowsByID[entity.id] = entity+                continue+            }+            if entity.createdAt < held.createdAt+                || (entity.createdAt == held.createdAt+                    && entity.id.uuidString.lowercased() < held.id.uuidString.lowercased())+            {+                rowsByID[entity.id] = entity+            }+        }++        // Q26: the qualifier exists only inside a collision, so the ordinary+        // library shows plain names and pays for no formatter at all.+        var byFoldedName: [String: [(id: UUID, name: String, createdAt: Date)]] = [:]+        for (id, row) in rowsByID {+            byFoldedName[SeriesName.fold(row.name), default: []]+                .append((id: id, name: row.name, createdAt: row.createdAt))+        }++        var formatter: DateFormatter?+        var qualifiers: [UUID: String] = [:]+        for (_, group) in byFoldedName where group.count > 1 {+            let dateFormatter: DateFormatter+            if let formatter { dateFormatter = formatter } else {+                let made = DateFormatter()+                made.locale = locale+                made.dateStyle = .medium+                made.timeStyle = .none+                formatter = made+                dateFormatter = made+            }+            var byDay: [String: [(id: UUID, name: String, createdAt: Date)]] = [:]+            for member in group {+                byDay[dateFormatter.string(from: member.createdAt), default: []].append(member)+            }+            for (day, sameDay) in byDay {+                guard sameDay.count > 1 else {+                    qualifiers[sameDay[0].id] = day+                    continue+                }+                // The ordinal is by identifier, which is the only key every+                // device agrees on for two series created the same day.+                let ordered = sameDay.sorted {+                    $0.id.uuidString.lowercased() < $1.id.uuidString.lowercased()+                }+                for (index, member) in ordered.enumerated() {+                    qualifiers[member.id] = day + " · \(index + 1)"+                }+            }+        }++        displays = rowsByID.mapValues {+            SeriesDisplay(+                id: $0.id, name: $0.name, createdAt: $0.createdAt,+                qualifier: qualifiers[$0.id])+        }+        notesByID = rowsByID.mapValues(\.notes)+    }++    /// The stored notes of a series this device holds, or nil where it does+    /// not — an unresolved membership has no notes to show.+    public func notes(of id: UUID) -> String? { notesByID[id] }++    /// What a stored `seriesID` shows as. `nil` in, `nil` out — a work in no+    /// series has no row to show. An id no row carries resolves to the+    /// unresolved display rather than to nothing, because the reader is told+    /// "Unavailable series" rather than shown a work that looks unattached.+    public func display(of id: UUID?) -> SeriesDisplay? {+        guard let id else { return nil }+        return displays[id]+            ?? SeriesDisplay(id: id, name: nil, createdAt: nil, qualifier: nil)+    }++    /// Every series this device holds, in `SeriesOrdering` — the picker's rows,+    /// the filter's options and the section order, all from one place.+    public var options: [SeriesDisplay] {+        displays.values.sorted(by: SeriesOrdering.precedes)+    }++    public var isEmpty: Bool { displays.isEmpty }++    public subscript(id: UUID) -> SeriesDisplay? { displays[id] }+}++// MARK: - Names and link types++public enum SeriesError: Error, Equatable, Sendable {+    /// The reason, already worded: the models show it inline and the repository+    /// carries no reader-facing text of its own beyond it.+    case invalidName(reason: String)+}++/// Every refusal the link operations raise (Reqs 6.1, 6.2, 6.4, 6.7).+///+/// Declared here rather than in `LibraryRepository+WorkLinks.swift` because+/// `LinkType.validate` throws the first case and lives here: a validator and its+/// error in two files is one place too many for the rule to drift.+public enum WorkLinkError: Error, Equatable, Sendable {+    /// The reason, already worded: the models show it inline and the repository+    /// carries no reader-facing text of its own beyond it.+    case invalidType(reason: String)+    /// Req 6.1: a link joins two **distinct** works.+    case selfLink+    /// Req 6.2, naming the type the pair already carries so the reader can tell+    /// "already linked" from "linked as something else".+    case alreadyLinked(type: String)+    /// Req 6.7 and Q22: a torn group refuses every editor, and the refusal names+    /// the work whose copies differ — which may be either end.+    case torn(workID: UUID)+}++/// The `WorkTypeName` rule, restated for a vocabulary that is **not** unique.+///+/// `fold` is not `WorkTypeName.normalize`: nothing here decides identity, so+/// there is no convergence rule to protect. It answers one question — do these+/// two spellings collide for the reader — and `precomposedStringWithCanonicalMapping`+/// then `lowercased()` is that question.+public enum SeriesName {++    public static func trimmed(_ raw: String) -> String {+        raw.trimmingCharacters(in: .whitespacesAndNewlines)+    }++    public static func fold(_ raw: String) -> String {+        trimmed(raw).precomposedStringWithCanonicalMapping.lowercased()+    }++    /// The trimmed name, or the reason it was refused (Req 1.1).+    @discardableResult+    public static func validate(_ raw: String) throws -> String {+        let name = trimmed(raw)+        guard !name.isEmpty else {+            throw SeriesError.invalidName(reason: "A series needs a name.")+        }+        guard !name.unicodeScalars.contains(where: WorkTypeName.forbidden.contains) else {+            throw SeriesError.invalidName(+                reason: "A series name cannot contain line breaks or control characters.")+        }+        return name+    }+}++/// `SeriesName`'s rule over a link's type (Req 6.4), with its own error so the+/// two surfaces word their refusals for what the reader was editing.+public enum LinkType {++    /// The five the app offers before the library has taught it any (Q12).+    public static let seeded = ["adaptation", "spin-off", "prequel", "sequel", "alternate version"]++    public static func trimmed(_ raw: String) -> String { SeriesName.trimmed(raw) }++    public static func fold(_ raw: String) -> String { SeriesName.fold(raw) }++    @discardableResult+    public static func validate(_ raw: String) throws -> String {+        let type = trimmed(raw)+        guard !type.isEmpty else {+            throw WorkLinkError.invalidType(reason: "A link needs a type.")+        }+        guard !type.unicodeScalars.contains(where: WorkTypeName.forbidden.contains) else {+            throw WorkLinkError.invalidType(+                reason: "A link type cannot contain line breaks or control characters.")+        }+        return type+    }+}++// MARK: - Orderings++/// Req 1.3: total, and the same in every list, picker, filter option and section+/// header. Locale-aware on the name, identifier as the tie-break — `WorkTypeSnapshot.displayOrder`'s+/// rule, which is also `sites()`'.+public enum SeriesOrdering {+    public static func precedes(_ left: SeriesDisplay, _ right: SeriesDisplay) -> Bool {+        let byName = (left.name ?? "").localizedStandardCompare(right.name ?? "")+        if byName != .orderedSame { return byName == .orderedAscending }+        return left.id.uuidString.lowercased() < right.id.uuidString.lowercased()+    }+}++/// Req 3.1: position ascending, ties broken by display title and then by work+/// identifier. A work with no membership sorts last, which only happens to a+/// caller that handed this a non-member.+public enum SeriesMemberOrdering {+    public static func precedes(_ left: WorkSnapshot, _ right: WorkSnapshot) -> Bool {+        let leftPosition = left.membership?.position ?? .greatestFiniteMagnitude+        let rightPosition = right.membership?.position ?? .greatestFiniteMagnitude+        if leftPosition != rightPosition { return leftPosition < rightPosition }+        let byTitle = left.displayTitle.localizedStandardCompare(right.displayTitle)+        if byTitle != .orderedSame { return byTitle == .orderedAscending }+        return left.id.uuidString.lowercased() < right.id.uuidString.lowercased()+    }+}++/// Reqs 2.5 and 8.2: the add-member and add-link searches are one list in one+/// order — title by the reader's locale, identifier as the tie-break, exactly as+/// `SeriesMemberOrdering` breaks its own ties.+///+/// Beside the other orderings rather than inside either repository file, for+/// their reason: the two pickers held a verbatim copy of it each, and two+/// spellings of an ordering are two answers to what order a list is in.+public enum WorkPickerOrdering {+    public static func precedes(+        _ left: WorkPickerCandidate, _ right: WorkPickerCandidate+    ) -> Bool {+        let byTitle = left.work.displayTitle.localizedStandardCompare(+            right.work.displayTitle)+        if byTitle != .orderedSame { return byTitle == .orderedAscending }+        return left.id.uuidString.lowercased() < right.id.uuidString.lowercased()+    }+}++// MARK: - Positions++/// The one place a position is read from or written for a reader (Q15).+///+/// Three spellings, deliberately: `parse`/`format` are the reader's locale,+/// `canonicalText` is nobody's — it is what ordering keys and the Markdown+/// export use, so a device in another locale sorts and exports the same+/// document (Q28).+public enum SeriesPosition {++    /// One fraction digit, which is the whole of Q15's storage rule.+    public static func rounded(_ value: Double) -> Double {+        guard value.isFinite else { return value }+        return (value * 10).rounded() / 10+    }++    /// `nil` for anything that is not a finite decimal with at most one fraction+    /// digit and no grouping separator (Req 2.2). The refusal is the model's to+    /// word; this only answers whether the text is a position.+    public static func parse(_ text: String, locale: Locale) -> Double? {+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)+        guard !trimmed.isEmpty else { return nil }+        let formatter = formatter(for: locale)+        let separator = formatter.decimalSeparator ?? "."++        var body = trimmed+        var negative = false+        for sign in [formatter.minusSign ?? "-", "-"] where !sign.isEmpty && !negative {+            guard body.hasPrefix(sign) else { continue }+            negative = true+            body.removeFirst(sign.count)+        }++        let parts = body.components(separatedBy: separator)+        guard parts.count <= 2, let whole = parts.first, !whole.isEmpty else { return nil }+        // Digits only, in whatever numbering system the locale writes: this is+        // what rejects a grouping separator, an embedded space, and a stray+        // second sign, whichever character the locale spells them with.+        guard whole.allSatisfy(\.isWholeNumber) else { return nil }+        if parts.count == 2 {+            guard parts[1].count == 1, parts[1].allSatisfy(\.isWholeNumber) else { return nil }+        }++        let signed = negative ? (formatter.minusSign ?? "-") + body : body+        guard let number = formatter.number(from: signed) else { return nil }+        let value = number.doubleValue+        guard value.isFinite else { return nil }+        return rounded(value)+    }++    /// The fewest fraction digits that represent the stored value (Req 2.7).+    public static func format(_ value: Double, locale: Locale) -> String {+        let rounded = rounded(value)+        guard rounded.isFinite else { return canonicalText(rounded) }+        return formatter(for: locale).string(from: NSNumber(value: rounded))+            ?? canonicalText(rounded)+    }++    /// Locale-free, for ordering keys, the archive and the Markdown export+    /// (Q28). "2", "2.5", "-1".+    public static func canonicalText(_ value: Double) -> String {+        let rounded = rounded(value)+        guard rounded.isFinite else { return String(rounded) }+        // `-0.0` and `0.0` are one position, and their canonical text is "0".+        if rounded == rounded.rounded(.towardZero), abs(rounded) < 1e15 {+            return String(Int64(rounded))+        }+        return String(format: "%.1f", rounded)+    }++    /// The prefill (Req 2.3): the next whole number above the highest position,+    /// `1` for an empty series, and `1` where every position is negative.+    public static func next(after positions: [Double]) -> Double {+        guard let highest = positions.filter(\.isFinite).max() else { return 1 }+        return Swift.max(highest.rounded(.down) + 1, 1)+    }++    private static func formatter(for locale: Locale) -> NumberFormatter {+        let formatter = NumberFormatter()+        formatter.locale = locale+        formatter.numberStyle = .decimal+        formatter.usesGroupingSeparator = false+        formatter.minimumFractionDigits = 0+        formatter.maximumFractionDigits = 1+        return formatter+    }+}++// MARK: - Grouping++/// The works list's group-by-series partition (Req 4.3), in Core so the package+/// performance suite can time it (Req 14.6) and so the section order and the+/// member order are the two orderings above rather than a second spelling of+/// them.+public enum SeriesGrouping {++    public struct Bucket: Equatable, Sendable {+        public let series: SeriesDisplay+        public let works: [WorkSnapshot]++        public init(series: SeriesDisplay, works: [WorkSnapshot]) {+            self.series = series+            self.works = works+        }+    }++    /// Buckets by **resolved** series, in `SeriesOrdering`, members in+    /// `SeriesMemberOrdering`. Everything else — no membership, or one whose+    /// series has not arrived — comes back in `rest` in the order it was given,+    /// for the caller to partition under the selected sort.+    public static func buckets(+        _ works: [WorkSnapshot]+    ) -> (buckets: [Bucket], rest: [WorkSnapshot]) {+        var members: [UUID: [WorkSnapshot]] = [:]+        var displays: [UUID: SeriesDisplay] = [:]+        var rest: [WorkSnapshot] = []+        for work in works {+            guard let series = work.series, series.isResolved, work.membership != nil else {+                rest.append(work)+                continue+            }+            displays[series.id] = series+            members[series.id, default: []].append(work)+        }+        let buckets = displays.values+            .sorted(by: SeriesOrdering.precedes)+            .map {+                Bucket(+                    series: $0,+                    works: (members[$0.id] ?? []).sorted(by: SeriesMemberOrdering.precedes))+            }+        return (buckets, rest)+    }+}++// MARK: - Pickers++/// One row of the add-member and add-link searches (Req 2.5, 8.2): every work,+/// with the reason it cannot be chosen where there is one.+///+/// Listing the unavailable ones rather than hiding them is deliberate — a reader+/// searching for a work they know is there should be told why it is not offered.+public struct WorkPickerCandidate: Identifiable, Sendable, Equatable {+    public let work: WorkSnapshot+    /// nil where the work is selectable.+    public let unavailableReason: String?++    public var id: UUID { work.id }++    public init(work: WorkSnapshot, unavailableReason: String?) {+        self.work = work+        self.unavailableReason = unavailableReason+    }+}

diff --git a/Asterism/AsterismTests/WorkDetailModelTests.swift b/Asterism/AsterismTests/WorkDetailModelTests.swiftindex 5c9b0cc..9a9443a 100644--- a/Asterism/AsterismTests/WorkDetailModelTests.swift+++ b/Asterism/AsterismTests/WorkDetailModelTests.swift@@ -1549,3 +1549,457 @@ final class ConflictSink: @unchecked Sendable {     private(set) var count = 0     func record(_ conflict: WriteConflict) { count += 1 } }++/// The work detail's series draft and its related-work links+/// (`series-and-related-works` Reqs 2.2–2.4, 5.1–5.3, 7.2, 8.1–8.4).+///+/// Two rules run through the whole suite. The membership is part of the work's+/// **draft**: it is picked and positioned in edit mode and lands with the+/// title, the tags and the statuses on one `updateWork` (Req 2.3, Req 2.8). The+/// links are not: each add, retype and removal is its own row with its own+/// timestamps, so it commits on the spot and only the section re-reads (Q24).+@Suite("Work detail series and links")+struct WorkDetailConnectionsTests {++    private static let ashfallID = UUID(uuidString: "5E71E500-0000-4000-8000-000000000001")!+    private static let quietShelfID = UUID(uuidString: "5E71E500-0000-4000-8000-000000000002")!++    private static func display(_ id: UUID, _ name: String?) -> SeriesDisplay {+        SeriesDisplay(id: id, name: name, createdAt: TestFixtures.fixedDate)+    }++    private static func snapshot(_ display: SeriesDisplay, members: Int = 1) -> SeriesSnapshot {+        SeriesSnapshot(display: display, notes: "", memberCount: members)+    }++    /// What the library offers the picker, in `SeriesOrdering`.+    private static let options = [+        snapshot(display(ashfallID, "Ashfall Cycle"), members: 2),+        snapshot(display(quietShelfID, "Quiet Shelf"), members: 0),+    ]++    @MainActor private func makeSUT(+        work: WorkSnapshot,+        links: [WorkLinkSnapshot] = [],+        locale: Locale = Locale(identifier: "en_US")+    ) -> (WorkDetailModel, MockLibraryProvider, CallbackTracker) {+        let mock = MockLibraryProvider()+        mock.workResult = .success(work)+        mock.workDetailResult = .success(TestFixtures.makeWorkDetail(work: work, links: links))+        mock.seriesListResult = .success(Self.options)+        let tracker = CallbackTracker()+        let model = WorkDetailModel(+            workID: work.id,+            library: mock,+            locale: locale,+            onMutation: { tracker.mutationCount += 1 })+        return (model, mock, tracker)+    }++    /// A work in "Ashfall Cycle" at 2.5.+    private func member(+        id: UUID = UUID(),+        position: Double = 2.5, seriesID: UUID = ashfallID, name: String? = "Ashfall Cycle"+    ) -> WorkSnapshot {+        TestFixtures.makeWork(+            id: id,+            displayTitle: "Ashfall",+            membership: SeriesMembership(seriesID: seriesID, position: position),+            series: Self.display(seriesID, name))+    }++    // MARK: - Loading the draft (Reqs 5.1–5.3)++    @Test("The series draft and the position field load from the snapshot")+    @MainActor func theDraftLoadsFromTheSnapshot() async {+        let (model, mock, _) = makeSUT(work: member())++        await model.load()++        #expect(model.draftSeriesID == Self.ashfallID)+        #expect(model.draftPositionText == "2.5")+        #expect(model.seriesOptions.map(\.id) == [Self.ashfallID, Self.quietShelfID])+        #expect(mock.seriesOptionsCallCount == 1)+        // Req 5.1: what the view-mode row says, worded by the model.+        #expect(model.seriesRowText == "Ashfall Cycle · 2.5")+        #expect(model.isSeriesResolved)+    }++    @Test("A work in no series loads an empty draft and shows no row")+    @MainActor func aWorkInNoSeriesHasNoRow() async {+        let (model, _, _) = makeSUT(work: TestFixtures.makeWork())++        await model.load()++        #expect(model.draftSeriesID == nil)+        #expect(model.draftPositionText.isEmpty)+        #expect(model.seriesRowText == nil)+    }++    /// Req 5.2: the row reads as the placeholder, the picker keeps the series+    /// selected, and the option list carries it so the selection has a row.+    @Test("An unresolved membership stays selected and reads as the placeholder")+    @MainActor func anUnresolvedMembershipStaysSelected() async {+        let missing = UUID(uuidString: "5E71E500-0000-4000-8000-0000000000FF")!+        let (model, _, _) = makeSUT(work: member(position: 1, seriesID: missing, name: nil))++        await model.load()++        #expect(model.draftSeriesID == missing)+        #expect(model.seriesRowText == SeriesDisplay.unresolvedLabel)+        #expect(!model.isSeriesResolved)+        #expect(model.seriesOptions.last?.id == missing)+        #expect(model.seriesOptions.last?.isResolved == false)+    }++    // MARK: - Choosing a series (Req 2.3)++    @Test("Picking a different series prefills the position from the repository")+    @MainActor func pickingASeriesPrefillsTheNextPosition() async {+        let (model, mock, _) = makeSUT(work: member())+        mock.nextSeriesPositionResult = .success(4)+        await model.load()++        await model.selectSeries(Self.quietShelfID)++        #expect(model.draftSeriesID == Self.quietShelfID)+        #expect(mock.lastNextSeriesPositionID == Self.quietShelfID)+        #expect(model.draftPositionText == "4")+    }++    /// The prefill is for a series the work is *moving to*. Coming back to the+    /// one it is already in restores the position it already has, which is what+    /// makes an accidental detour through the picker a no-op.+    @Test("Returning to the work's own series restores its stored position")+    @MainActor func returningToTheOwnSeriesRestoresThePosition() async {+        let (model, mock, _) = makeSUT(work: member())+        mock.nextSeriesPositionResult = .success(4)+        await model.load()++        await model.selectSeries(Self.quietShelfID)+        await model.selectSeries(Self.ashfallID)++        #expect(model.draftPositionText == "2.5")+        #expect(mock.callLog.filter { $0 == "nextSeriesPosition" }.count == 1)+    }++    @Test("Choosing None clears the position field")+    @MainActor func choosingNoneClearsThePosition() async {+        let (model, _, _) = makeSUT(work: member())+        await model.load()++        await model.selectSeries(nil)++        #expect(model.draftSeriesID == nil)+        #expect(model.draftPositionText.isEmpty)+        #expect(model.hasUnsavedChanges)+    }++    // MARK: - Committing the draft (Reqs 2.2, 2.4, 2.8)++    @Test("Save parses the position in the viewing locale into the draft membership")+    @MainActor func saveParsesThePositionInTheLocale() async {+        let (model, mock, _) = makeSUT(work: member(), locale: Locale(identifier: "nl_NL"))+        await model.load()+        #expect(model.draftPositionText == "2,5")+        model.draftPositionText = "3,5"++        await model.save()++        #expect(+            mock.lastUpdateWorkDraft?.membership+                == SeriesMembership(seriesID: Self.ashfallID, position: 3.5))+        // Req 2.8: the membership rides the work's own edit, so the basis is the+        // snapshot's — a membership changed elsewhere is the conflict Req 2.4+        // asks for.+        #expect(+            mock.lastUpdateWorkBasis?.membership+                == SeriesMembership(seriesID: Self.ashfallID, position: 2.5))+    }++    /// Req 2.2's refusal is the model's, before any repository call: the editor+    /// stays open with the text the reader typed.+    @Test("A position that is not a number is refused before the write")+    @MainActor func anUnparseablePositionIsRefusedBeforeTheWrite() async {+        let (model, mock, tracker) = makeSUT(work: member())+        await model.load()+        model.beginEditing()+        model.draftPositionText = "1.25"++        await model.save()++        #expect(mock.updateWorkCallCount == 0)+        #expect(tracker.mutationCount == 0)+        #expect(model.errorMessage == SeriesDetailModel.positionRefusal)+        #expect(model.draftPositionText == "1.25")+        #expect(model.isEditing)+    }++    /// The fallback basis (Q47 of `work-and-reading-status`) states every field+    /// from what the screen holds rather than taking the parameter defaults. A+    /// model that never loaded has no membership to forward, so it sends none —+    /// not the one the draft is about to write.+    @Test("The fallback basis forwards the snapshot membership rather than the draft")+    @MainActor func theFallbackBasisForwardsTheSnapshotMembership() async {+        let (model, mock, _) = makeSUT(work: member())+        mock.nextSeriesPositionResult = .success(1)+        await model.selectSeries(Self.quietShelfID)+        #expect(model.work == nil)++        await model.save()++        #expect(mock.lastUpdateWorkBasis?.membership == nil)+        #expect(+            mock.lastUpdateWorkDraft?.membership+                == SeriesMembership(seriesID: Self.quietShelfID, position: 1))+    }++    /// Req 2.4: the series the picker still offers was deleted elsewhere. The+    /// message is `EntryDetailModel`'s, and the option list — the one thing on+    /// the screen that is now wrong — is re-read. The record is **not**.+    @Test("A missing series reports its message and re-reads only the options")+    @MainActor func aMissingSeriesRefreshesOnlyTheOptions() async {+        let work = member()+        let (model, mock, _) = makeSUT(work: work)+        await model.load()+        let readsAfterLoad = mock.workDetailCallCount+        let optionReadsAfterLoad = mock.seriesOptionsCallCount+        mock.updateWorkResult = .success(+            .conflict(.seriesMissing(recordID: work.id, seriesID: Self.ashfallID)))+        // What the store now reports: the row is gone and the list no longer+        // offers it.+        mock.seriesListResult = .success(+            [Self.snapshot(Self.display(Self.quietShelfID, "Quiet Shelf"))])++        await model.save()++        #expect(model.errorMessage == "That series no longer exists.")+        #expect(mock.workDetailCallCount == readsAfterLoad)+        #expect(mock.seriesOptionsCallCount == optionReadsAfterLoad + 1)+        // The vanished series is gone from the picker rather than carried onto+        // it: nothing selects it any more, and offering it would offer the+        // reader the series the write just refused.+        #expect(model.seriesOptions.map(\.id) == [Self.quietShelfID])+        #expect(model.draftSeriesID == nil)+        #expect(model.draftPositionText.isEmpty)+    }++    /// Req 2.4 is the one requirement that asks for **nothing** to change. A+    /// reload here would reassign every draft from the record, so a reader who+    /// had retitled the work, retagged it and written a verdict before picking a+    /// series another device had just deleted would lose all of it.+    @Test("A missing series keeps every other draft and clears only the series")+    @MainActor func aMissingSeriesKeepsTheOtherDrafts() async {+        let work = member()+        let (model, mock, _) = makeSUT(work: work)+        mock.nextSeriesPositionResult = .success(4)+        await model.load()+        model.beginEditing()+        model.draftTitle = "Ashfall, retitled"+        model.draftTags = ["epic", "slow burn"]+        model.draftNotes = "Reread from book two."+        model.draftVerdict = "Worth the wait."+        model.setDraftWorkStatus(.hiatus)+        // The series the other device deleted between the read and the save.+        await model.selectSeries(Self.quietShelfID)+        #expect(model.draftPositionText == "4")+        mock.updateWorkResult = .success(+            .conflict(.seriesMissing(recordID: work.id, seriesID: Self.quietShelfID)))+        mock.seriesListResult = .success(+            [Self.snapshot(Self.display(Self.ashfallID, "Ashfall Cycle"))])++        await model.save()++        #expect(model.errorMessage == "That series no longer exists.")+        // Every typed field survives, character drafts included: nothing was+        // written, and the edit is the only copy of itself.+        #expect(model.draftTitle == "Ashfall, retitled")+        #expect(model.draftTags == ["epic", "slow burn"])+        #expect(model.draftNotes == "Reread from book two.")+        #expect(model.draftVerdict == "Worth the wait.")+        #expect(model.draftWorkStatus == .hiatus)+        // Only the half the conflict is about is cleared.+        #expect(model.draftSeriesID == nil)+        #expect(model.draftPositionText.isEmpty)+        // The work's own series is still offered — it was not the one that went.+        #expect(model.seriesOptions.map(\.id) == [Self.ashfallID])+    }++    /// Every other conflict keeps the drafts and does **not** re-read: the edit+    /// is the only copy of itself until the reader resolves it.+    @Test("A torn conflict keeps the drafts and does not reload")+    @MainActor func aTornConflictDoesNotReload() async {+        let work = member()+        let (model, mock, _) = makeSUT(work: work)+        await model.load()+        let readsAfterLoad = mock.workDetailCallCount+        mock.updateWorkResult = .success(.conflict(.torn(recordID: work.id, variants: [])))+        model.draftPositionText = "9"++        await model.save()++        #expect(mock.workDetailCallCount == readsAfterLoad)+        #expect(model.draftPositionText == "9")+    }++    // MARK: - "New series" (Req 2.3, Q16)++    @Test("New series creates immediately, is selected, and survives a cancel")+    @MainActor func newSeriesCommitsImmediately() async {+        let created = UUID(uuidString: "5E71E500-0000-4000-8000-000000000003")!+        let (model, mock, tracker) = makeSUT(work: TestFixtures.makeWork())+        mock.createSeriesResult = .success(created)+        mock.nextSeriesPositionResult = .success(1)+        await model.load()+        model.beginEditing()+        mock.seriesListResult = .success(+            Self.options + [Self.snapshot(Self.display(created, "Winter Court"), members: 0)])++        await model.createSeries(named: "Winter Court")++        #expect(mock.lastCreatedSeries?.name == "Winter Court")+        #expect(model.draftSeriesID == created)+        #expect(model.draftPositionText == "1")+        #expect(model.seriesOptions.map(\.id).contains(created))+        #expect(tracker.mutationCount == 1)++        model.cancelEditing()++        // Q16: the assignment is a draft and goes; the series itself is a row in+        // the library and stays, offered by the picker on the next visit.+        #expect(model.draftSeriesID == nil)+        #expect(model.seriesOptions.map(\.id).contains(created))+    }++    @Test("A series name the validator refuses is reported and nothing is created")+    @MainActor func anInvalidNewSeriesNameIsRefused() async {+        let (model, mock, _) = makeSUT(work: TestFixtures.makeWork())+        await model.load()++        await model.createSeries(named: "   ")++        #expect(mock.lastCreatedSeries == nil)+        #expect(model.errorMessage == "A series needs a name.")+    }++    // MARK: - Related works (Reqs 8.1–8.4, Q24)++    @Test("The links come off the presentation the load read")+    @MainActor func theLinksComeOffThePresentation() async {+        let link = TestFixtures.makeLink(otherTitle: "The Toon", linkType: "adaptation")+        let (model, _, _) = makeSUT(work: TestFixtures.makeWork(), links: [link])++        await model.load()++        #expect(model.links == [link])+    }++    @Test("Adding a link commits it and re-reads the section")+    @MainActor func addingALinkReloadsTheSection() async {+        let other = UUID()+        let work = TestFixtures.makeWork()+        let (model, mock, tracker) = makeSUT(work: work)+        await model.load()+        let readsAfterLoad = mock.workDetailCallCount++        await model.addLink(to: other, type: "adaptation")++        #expect(mock.lastAddedLink?.a == work.id)+        #expect(mock.lastAddedLink?.b == other)+        #expect(mock.lastAddedLink?.type == "adaptation")+        #expect(mock.workDetailCallCount == readsAfterLoad + 1)+        #expect(tracker.mutationCount == 1)+    }++    @Test("A link type the validator refuses is reported and nothing is written")+    @MainActor func anInvalidLinkTypeIsRefused() async {+        let (model, mock, _) = makeSUT(work: TestFixtures.makeWork())+        await model.load()++        await model.addLink(to: UUID(), type: " ")++        #expect(mock.addLinkCallCount == 0)+        #expect(model.errorMessage == "A link needs a type.")+    }++    @Test("Retyping a link commits it and re-reads the section")+    @MainActor func retypingALinkReloadsTheSection() async {+        let link = TestFixtures.makeLink(linkType: "adaptation")+        let (model, mock, tracker) = makeSUT(work: TestFixtures.makeWork(), links: [link])+        await model.load()+        let readsAfterLoad = mock.workDetailCallCount+        #expect(model.linkTypeDraft(for: link.id) == "adaptation")++        model.setLinkTypeDraft("spin-off", for: link.id)+        await model.commitLinkType(for: link.id)++        #expect(mock.lastRetypedLink?.id == link.id)+        #expect(mock.lastRetypedLink?.type == "spin-off")+        #expect(mock.workDetailCallCount == readsAfterLoad + 1)+        #expect(tracker.mutationCount == 1)+    }++    @Test("Committing an unchanged link type writes nothing")+    @MainActor func anUnchangedLinkTypeWritesNothing() async {+        let link = TestFixtures.makeLink(linkType: "adaptation")+        let (model, mock, _) = makeSUT(work: TestFixtures.makeWork(), links: [link])+        await model.load()++        model.setLinkTypeDraft("  adaptation  ", for: link.id)+        await model.commitLinkType(for: link.id)++        #expect(mock.retypeLinkCallCount == 0)+    }++    @Test("Removing a link commits it and re-reads the section")+    @MainActor func removingALinkReloadsTheSection() async {+        let link = TestFixtures.makeLink()+        let (model, mock, tracker) = makeSUT(work: TestFixtures.makeWork(), links: [link])+        await model.load()+        let readsAfterLoad = mock.workDetailCallCount++        await model.removeLink(id: link.id)++        #expect(mock.lastRemovedLinkID == link.id)+        #expect(mock.workDetailCallCount == readsAfterLoad + 1)+        #expect(tracker.mutationCount == 1)+    }++    /// Q24 in one assertion: a link edit lands outside the work's draft, so the+    /// re-read behind it must not put the reader's half-typed fields back.+    @Test("A link edit leaves the metadata drafts where the reader left them")+    @MainActor func aLinkEditLeavesTheDraftsAlone() async {+        let link = TestFixtures.makeLink()+        let (model, _, _) = makeSUT(work: member(), links: [link])+        await model.load()+        model.beginEditing()+        model.draftTitle = "Half typed"+        model.draftPositionText = "7"++        await model.removeLink(id: link.id)++        #expect(model.draftTitle == "Half typed")+        #expect(model.draftPositionText == "7")+        #expect(model.isEditing)+    }++    /// Req 8.2: the picker is read on demand, over works other than this one,+    /// and the type step is offered the vocabulary Req 7.1 defines.+    @Test("The add-link flow reads its candidates and its suggestions on demand")+    @MainActor func theAddFlowReadsItsOptionsOnDemand() async {+        let work = TestFixtures.makeWork()+        let candidate = WorkPickerCandidate(+            work: TestFixtures.makeWork(displayTitle: "Other"), unavailableReason: nil)+        let (model, mock, _) = makeSUT(work: work)+        mock.linkCandidatesResult = .success([candidate])+        mock.linkTypeSuggestionsResult = .success(["adaptation", "sequel"])+        await model.load()+        #expect(mock.linkCandidatesCallCount == 0)++        await model.loadLinkOptions()++        #expect(mock.lastLinkCandidatesWorkID == work.id)+        #expect(model.linkCandidates.map(\.id) == [candidate.id])+        #expect(model.linkTypeSuggestions == ["adaptation", "sequel"])+    }+}