Pre-push review: T-2316/work-creators

diff --git a/Asterism/Asterism/Layout/AppNavigation.swift b/Asterism/Asterism/Layout/AppNavigation.swiftindex be8e548..3d12d7d 100644--- a/Asterism/Asterism/Layout/AppNavigation.swift+++ b/Asterism/Asterism/Layout/AppNavigation.swift@@ -124,10 +124,21 @@ final class AppNavigation {         switch worksPath.last {         case .work(let workID): workID         case .chapter: selectedWorkID-        case .series, .seriesList, .none: nil+        case .series, .seriesList, .creator, .creatorList, .none: nil         }     } +    /// Whether the route on top of the Works stack has another route under it.+    ///+    /// The wide tree's one question about depth (`work-creators` Q77): a route+    /// drawn over something else gets `ColumnBackButton`, because that column's+    /// navigation bar has no back chevron of its own. Every route but `.work`+    /// answers it by construction — a chapter rides on its work, and the series+    /// and creator routes are appends — so `.work` is the arm that has to ask,+    /// and it is exactly `pushWork` (from a series member row or a creator's+    /// work row) that puts one on top of another route.+    var hasRouteBeneathWorksTop: Bool { worksPath.count > 1 }+     /// What the Works detail column is showing, as one comparable value.     ///     /// Req 8.1's announcement and focus move fire on a change of this, so it has@@ -334,6 +345,26 @@ final class AppNavigation {         worksPath.append(.seriesList)     } +    /// The creator screen, carrying the work it was opened from where there is+    /// one — `work-creators` Req 4.3's "Current work" marker is that field and+    /// nothing else. `showSeries`' shape, for its reason: a creator screen and a+    /// work detail lead to each other without bound, so it appends.+    func showCreator(_ creatorID: UUID, from originWorkID: UUID? = nil) {+        selectedTab = .works+        selectedWorksEntryID = nil+        dropTrailingChapter()+        worksPath.append(.creator(id: creatorID, originWorkID: originWorkID))+    }++    /// The creators list (`work-creators` Req 1.6), from the Works list's own+    /// toolbar beside the series control.+    func showCreatorList() {+        selectedTab = .works+        selectedWorksEntryID = nil+        dropTrailingChapter()+        worksPath.append(.creatorList)+    }+     /// The Works list's own entry route: the unattached-notes group, tapped at     /// the stack root and pushed from it, so nothing may be under it.     func showWorksEntry(_ entryID: UUID) {@@ -508,8 +539,13 @@ nonisolated enum WorksRoute: Hashable, Sendable {     /// A series screen, and the work it was opened from where there is one:     /// Req 3.3's "Current work" marker is that field.     case series(id: UUID, originWorkID: UUID?)+    /// The creators list (`work-creators` Req 1.6).+    case creatorList+    /// A creator screen, and the work it was opened from where there is one:+    /// `work-creators` Req 4.3's "Current work" marker is that field.+    case creator(id: UUID, originWorkID: UUID?) -    /// The work this route *is*, or nil for the three that are not one. Not+    /// The work this route *is*, or nil for the five that are not one. Not     /// "the work this route belongs to": a chapter has one and deliberately     /// answers nil, because the two questions have different answers and only     /// the stack knows the second.

diff --git a/Asterism/Asterism/Layout/AppScreens.swift b/Asterism/Asterism/Layout/AppScreens.swiftindex f6a01ff..007cc43 100644--- a/Asterism/Asterism/Layout/AppScreens.swift+++ b/Asterism/Asterism/Layout/AppScreens.swift@@ -120,6 +120,7 @@ struct AppScreens {             // opened *from* a work, and this one was opened from the list.             onSelectSeries: { navigation.showSeries($0) },             onShowSeriesList: navigation.showSeriesList,+            onShowCreatorList: navigation.showCreatorList,             onResolveDuplicate: resolve,             // Req 5.5: the reader's answer is recorded and the sets are             // re-derived, which is what takes the pill off the row they just@@ -165,6 +166,9 @@ struct AppScreens {                 // Req 5.1, with the origin: the series screen marks the row of                 // the work it was opened from (Req 3.3).                 onSelectSeries: { navigation.showSeries($0, from: workID) },+                // `work-creators` Req 4.3, with the origin: the creator screen+                // marks the row of the work it was opened from.+                onSelectCreator: { navigation.showCreator($0, from: workID) },                 exportModel: model.markdownExportModel(forWork: workID),                 showsSky: showsSky,                 // `character-extraction`: the indicator, the review sheet and@@ -222,6 +226,49 @@ struct AppScreens {         }     } +    // MARK: - Creators++    /// `work-creators` Req 1.6's list, on `seriesList()`'s shape: a row appends+    /// the creator route rather than pushing a screen of its own, which is what+    /// makes Back from a creator return to this list in both trees.+    @ViewBuilder+    func creatorList() -> some View {+        if let listModel = model.creatorListModel() {+            CreatorListView(+                model: listModel,+                // Read here, in the tree's body, so a sync arrival that bumps it+                // reaches the screen's `.task(id:)` (Req 10.2).+                snapshotGeneration: model.snapshotGeneration,+                showsSky: showsSky,+                // No origin: Req 4.3's "Current work" marker belongs to a+                // creator opened *from* a work, and this one was opened from the+                // list.+                onSelectCreator: { navigation.showCreator($0) })+        }+    }++    /// `work-creators` Req 4.1's screen. `origin` is the work the reader came+    /// from, which is where Req 4.3's marker comes from.+    @ViewBuilder+    func creator(_ creatorID: UUID, origin: UUID?) -> some View {+        if let detailModel = model.creatorDetailModel(for: creatorID, originWorkID: origin) {+            CreatorDetailView(+                model: detailModel,+                snapshotGeneration: model.snapshotGeneration,+                showsSky: showsSky,+                // A work row **pushes**, so Back returns to the creator rather+                // than to whatever is under it (Q49 of `ipad-and-mac-layouts`).+                onSelectWork: navigation.pushWork,+                // The deleted creator takes its screen with it, and the route+                // under it is what the reader came from.+                onDeleted: navigation.popWorksRoute)+                // The identity the screen needs (design §Navigation): a second+                // creator opened from the first is the same structural position,+                // and without this SwiftUI would keep the first one's state.+                .id(creatorID)+        }+    }+     // MARK: - Diagnostics      /// Req 4.1's listing, pushed onto Recent's own stack in both trees.

diff --git a/Asterism/Asterism/Layout/CompactRootView.swift b/Asterism/Asterism/Layout/CompactRootView.swiftindex 6ecfa84..2f407e2 100644--- a/Asterism/Asterism/Layout/CompactRootView.swift+++ b/Asterism/Asterism/Layout/CompactRootView.swift@@ -158,6 +158,10 @@ struct CompactRootView: View {             screens.seriesList()         case .series(let seriesID, let originWorkID):             screens.series(seriesID, origin: originWorkID)+        case .creatorList:+            screens.creatorList()+        case .creator(let creatorID, let originWorkID):+            screens.creator(creatorID, origin: originWorkID)         }     } }

diff --git a/Asterism/Asterism/Layout/SettingsScreen.swift b/Asterism/Asterism/Layout/SettingsScreen.swiftindex edcaa3c..c6c234e 100644--- a/Asterism/Asterism/Layout/SettingsScreen.swift+++ b/Asterism/Asterism/Layout/SettingsScreen.swift@@ -82,6 +82,7 @@ struct SettingsScreen: View {                 }             },             workTypesModel: model.workTypesModel(),+            creatorRolesModel: model.creatorRolesModel(),             // The preserved-capture surfaces. The sentences are the model's,             // like every other notice here; what this view owns is where a             // tapped entry goes.

diff --git a/Asterism/Asterism/Layout/WideRootView.swift b/Asterism/Asterism/Layout/WideRootView.swiftindex c93a2d0..4523fee 100644--- a/Asterism/Asterism/Layout/WideRootView.swift+++ b/Asterism/Asterism/Layout/WideRootView.swift@@ -207,8 +207,21 @@ struct WideRootView: View {     private var worksDetail: some View {         switch navigation.worksPath.last {         case .work(let workID):-            screens.workDetail(workID)-                .detailMeasure(WideLayoutPolicy.workMeasure)+            // Q77: a work is a stacked route too, whenever one sits under it.+            // `pushWork` is how a series member row and a creator's work row+            // open a work, so that work has the screen it was opened from+            // beneath it — and without the button there was no way back to it+            // in the wide tree, where the navigation bar has no back chevron of+            // its own. A work at the stack root has nothing under it and draws+            // none, exactly as before.+            if navigation.hasRouteBeneathWorksTop {+                stackedRoute(measure: WideLayoutPolicy.workMeasure) {+                    screens.workDetail(workID)+                }+            } else {+                screens.workDetail(workID)+                    .detailMeasure(WideLayoutPolicy.workMeasure)+            }         case .chapter(let entryID):             stackedRoute(measure: WideLayoutPolicy.entryMeasure) {                 EntryDetailRoute(@@ -222,6 +235,14 @@ struct WideRootView: View {             stackedRoute(measure: WideLayoutPolicy.workMeasure) {                 screens.series(seriesID, origin: originWorkID)             }+        case .creatorList:+            stackedRoute(measure: WideLayoutPolicy.workMeasure) {+                screens.creatorList()+            }+        case .creator(let creatorID, let originWorkID):+            stackedRoute(measure: WideLayoutPolicy.workMeasure) {+                screens.creator(creatorID, origin: originWorkID)+            }         case .none:             if let entryID = navigation.selectedWorksEntryID {                 // The Works list's unattached-entry route lands in this column@@ -260,6 +281,10 @@ struct WideRootView: View {             return model.workTitlesByID[workID] ?? "Work"         case .series, .seriesList:             return "Series"+        case .creatorList:+            return "Creators"+        case .creator:+            return "Creator"         case .chapter, .none:             // A chapter is never underneath anything — it is dropped before a             // route is appended — and nothing underneath at all means the route@@ -295,6 +320,12 @@ struct WideRootView: View {             // Core composed; the route alone carries an identifier and no name,             // and the announcement is derived from the route.             return "Series"+        case .creatorList:+            return "Creators"+        case .creator:+            // The creator screen names itself in its navigation title, from the+            // name the read resolved; the route carries an identifier alone.+            return "Creator"         case .none:             return entryTitle(navigation.selectedWorksEntryID)         }

diff --git a/Asterism/Asterism/Support/ConstellationEditorRecipes.swift b/Asterism/Asterism/Support/ConstellationEditorRecipes.swiftnew file mode 100644index 0000000..c0900cb--- /dev/null+++ b/Asterism/Asterism/Support/ConstellationEditorRecipes.swift@@ -0,0 +1,245 @@+import ConstellationKit+import SwiftUI++/// The edit-screen vocabulary the work editor's four collection cards share:+/// one compact line per record, one bordered footer button per "add another",+/// one non-red destructive control, and one sheet the lines open.+///+/// Written once here rather than four times inside `WorkDetailView`: credits,+/// related works and characters draw the same three shapes, and a copy per+/// section is three chances for them to disagree+/// (`specs/work-creators/decision_log.md`, the edit-screen decision).+///+/// These are app-target recipes rather than `ConstellationKit` ones because the+/// sheet scaffold needs the app's own platform seams — `inlineNavigationTitle()`+/// and `macListChrome()` live in `Support/PlatformModifiers.swift` — and+/// splitting one vocabulary across two modules is what this file exists to+/// avoid.++// MARK: - The compact line++/// "NAME: detail" on one tappable line with a chevron.+///+/// The view-mode credit line's recipe (`work-creators` Q96, style guide §7),+/// lifted so the editor's credits, related works and characters all read alike.+/// Like that line it is **deliberately below `AsterismLayout.minHitTarget`**:+/// four collections of these on one screen is exactly what the 44 pt row per+/// record made too tall, and the line is still a full-width target through+/// `contentShape`.+struct ConstellationLineRow: View {+    /// The record's name — the part in primary text.+    let name: String+    /// Whether the name is a real name. An unresolved record draws the+    /// placeholder glyph in `.caption` secondary text, the unresolved work-type+    /// treatment the rest of the app uses.+    var isNameResolved: Bool = true+    /// What follows the colon: the roles, the link type, the counts. Nil or+    /// empty draws the bare name — no trailing colon announcing nothing.+    let detail: String?+    /// The amber `exclamationmark.circle` a torn record wears, so the tear is+    /// disclosed where the reader meets the record rather than only inside the+    /// sheet it opens.+    var showsAttention: Bool = false+    let action: () -> Void++    var body: some View {+        Button(action: action) {+            HStack(alignment: .top, spacing: 8) {+                Self.line(name: name, isNameResolved: isNameResolved, detail: detail)+                    // Two lines, not one: at the accessibility text sizes a+                    // record with three roles loses all but the first to+                    // truncation.+                    .lineLimit(2)+                Spacer(minLength: 0)+                if showsAttention {+                    Image(systemName: "exclamationmark.circle")+                        .font(.caption)+                        .foregroundStyle(AsterismColors.amberText)+                        .accessibilityHidden(true)+                }+                Image(systemName: "chevron.right")+                    .font(.caption)+                    .foregroundStyle(AsterismColors.secondaryText)+                    .accessibilityHidden(true)+            }+            .frame(maxWidth: .infinity, alignment: .leading)+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+    }++    /// The whole line as **one** `Text`: the name in `.subheadline`, then ": "+    /// and the detail in secondary text at the same size.+    ///+    /// Concatenated rather than laid out as two views so the line wraps as a+    /// single piece of text and the colon can never be orphaned from the name it+    /// belongs to.+    static func line(name: String, isNameResolved: Bool, detail: String?) -> Text {+        let title = Text(name)+            .font(isNameResolved ? .subheadline : .caption)+            .foregroundStyle(+                isNameResolved ? AsterismColors.primaryText : AsterismColors.secondaryText)+        guard let detail, !detail.isEmpty else { return title }+        // Interpolated rather than `+`, which iOS 26 deprecates.+        let trailing = Text(": " + detail)+            .font(.subheadline)+            .foregroundStyle(AsterismColors.secondaryText)+        return Text("\(title)\(trailing)")+    }+}++// MARK: - The footer button++/// The label a bordered full-width control wears: a glyph where it has one, the+/// title, on a hairline in `cardBorder` at the field radius.+///+/// Split from the button so a `Menu` can wear it too — the URL-identity review+/// is a `Menu` on a multi-site work and a `Button` on a single-site one, and+/// both have to look like the row above them.+struct ConstellationFooterLabel: View {+    let title: String+    /// The leading glyph, or nil for the actions that are only words.+    var systemImage: String? = "plus"+    /// Violet for "make one" and for the structural actions; `secondaryText`+    /// for the destructive ones — §11 gives the palette no error hue, so red is+    /// not available to spend here.+    var tint: Color = AsterismColors.violet++    private var shape: RoundedRectangle {+        RoundedRectangle(cornerRadius: AsterismLayout.fieldRadius, style: .continuous)+    }++    var body: some View {+        HStack(spacing: 6) {+            if let systemImage {+                Image(systemName: systemImage)+                    .accessibilityHidden(true)+            }+            Text(title)+        }+        .font(.caption.weight(.semibold))+        .foregroundStyle(tint)+        .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)+        .overlay { shape.strokeBorder(AsterismColors.cardBorder, lineWidth: 1) }+        .contentShape(shape)+    }+}++/// "Add a creator", "Merge into…", "Delete work": a full-width bordered control+/// at the bottom of the card or section it belongs to.+///+/// It replaces the bare `Button` this screen used to add things with — a system+/// row that drew opaque white between two glass cards.+struct ConstellationFooterButton: View {+    let title: String+    var systemImage: String? = "plus"+    var tint: Color = AsterismColors.violet+    let action: () -> Void++    var body: some View {+        Button(action: action) {+            ConstellationFooterLabel(title: title, systemImage: systemImage, tint: tint)+        }+        .buttonStyle(.plain)+    }+}++// MARK: - The non-red destructive row++/// "Remove credit", "Remove link": the way off a record, inside the sheet that+/// edits it.+///+/// `secondaryText` with a `minus.circle` glyph rather than the system's+/// destructive red (§11: the palette has three hues and none of them is an+/// error hue). The sentence that says what survives the removal is the section+/// footer beside it, which is the caller's.+struct ConstellationDestructiveRow: View {+    let title: String+    var systemImage: String = "minus.circle"+    let action: () -> Void++    var body: some View {+        Button(action: action) {+            HStack(spacing: 10) {+                Image(systemName: systemImage)+                    .accessibilityHidden(true)+                Text(title)+                Spacer(minLength: 0)+            }+            .foregroundStyle(AsterismColors.secondaryText)+            .frame(minHeight: AsterismLayout.minHitTarget)+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+    }+}++// MARK: - The caption above a control inside a card++/// `ConstellationCaptionedCard`'s caption without its card, for the controls+/// that share one: the Work card's URL, Type and Genre fields, the Status+/// card's two capsules and its verdict, the series card's position.+///+/// Same caption recipe as the card's, so a field reads the same whether it has+/// a card of its own or shares one.+struct ConstellationCaptionedField: ViewModifier {+    let caption: String++    func body(content: Content) -> some View {+        VStack(alignment: .leading, spacing: 4) {+            Text(caption)+                .font(.caption.weight(.semibold))+                .foregroundStyle(AsterismColors.secondaryText)+            content+        }+        .frame(maxWidth: .infinity, alignment: .leading)+    }+}++extension View {+    /// Puts this control under a small caption, without a card of its own.+    func constellationCaptionedField(_ caption: String) -> some View {+        modifier(ConstellationCaptionedField(caption: caption))+    }+}++// MARK: - The editor sheet++/// The sheet a compact line opens: the record's name as the title, its controls+/// as list sections, and Done.+///+/// `CreatorPickerView` and `LinkTypeEntryView`'s chrome, which is this app's+/// small-editor sheet: a `NavigationStack` around a `List` with the scroll+/// background hidden and an inline title. It carries **no Cancel**, unlike+/// those two: everything inside one of these editors is already written — a+/// role toggle into the work's draft, a link type onto the link itself — so a+/// Cancel would promise an undo the sheet cannot perform. The work's own X+/// still discards the draft the credits and characters ride.+struct ConstellationEditorSheet<Content: View>: View {+    let title: String+    /// The sheet's own identifier, and the one its Done button carries.+    let identifier: String+    let doneIdentifier: String+    @ViewBuilder let content: () -> Content++    @Environment(\.dismiss) private var dismiss++    var body: some View {+        NavigationStack {+            List {+                content()+            }+            .scrollContentBackground(.hidden)+            .macListChrome()+            .navigationTitle(title)+            .inlineNavigationTitle()+            .accessibilityIdentifier(identifier)+            .toolbar {+                ToolbarItem(placement: .confirmationAction) {+                    Button("Done") { dismiss() }+                        .accessibilityIdentifier(doneIdentifier)+                }+            }+        }+    }+}

diff --git a/Asterism/Asterism/Support/PlatformModifiers.swift b/Asterism/Asterism/Support/PlatformModifiers.swiftindex 0c344e0..0f79508 100644--- a/Asterism/Asterism/Support/PlatformModifiers.swift+++ b/Asterism/Asterism/Support/PlatformModifiers.swift@@ -160,6 +160,26 @@ extension View {         return self         #endif     }++    /// The toolbar toggle that puts a reorderable list into edit mode+    /// (`work-creators` Req 2.5).+    ///+    /// `EditButton` is declared unavailable on macOS, and there is nothing to+    /// approximate: a Mac `List` row with `.onMove` is dragged directly, with no+    /// mode to enter first. So this is the toolbar item on iOS and **nothing**+    /// on the Mac — the rows still reorder there, by drag (Q81).+    func listEditToolbarButton(identifier: String) -> some View {+        #if os(iOS)+        return toolbar {+            ToolbarItem(placement: .trailingBar) {+                EditButton()+                    .accessibilityIdentifier(identifier)+            }+        }+        #else+        return self+        #endif+    } }  // MARK: - The window's sky (Req 3.1)

diff --git a/Asterism/Asterism/UITestLaunchSupport.swift b/Asterism/Asterism/UITestLaunchSupport.swiftindex 4eed345..8ee2b5f 100644--- a/Asterism/Asterism/UITestLaunchSupport.swift+++ b/Asterism/Asterism/UITestLaunchSupport.swift@@ -70,6 +70,16 @@ enum UITestFixtureKind: Equatable {     /// row holds and a link to a work no row holds. `seeded-works-options` is     /// left alone: its suites assert exact orders that a sixth work would move.     case series+    /// A small legal library the creators list, the creator screen, the credits+    /// section and editor, the creator filter and the roles settings have+    /// something to say about (`work-creators`): four works, three creators —+    /// one credited on three works, one on one, one on none — the three seeded+    /// roles plus a reader-added "letterer" and a removed "editor" one credit+    /// still holds, and one work carrying both unresolved credit references: a+    /// credit naming a creator id no row holds, and a credit holding a role id+    /// no row holds. `seeded-series` and `seeded-works-options` are left alone:+    /// their suites assert exact orders and counts that a credit would move.+    case creators      /// Whether the seeded shape needs a second open before its diagnoses are     /// complete. `.invalidSiteTuple` is produced only by the full@@ -118,6 +128,9 @@ enum UITestLaunchSupport {     static let seededWorksOptionsScenario = "seeded-works-options"     /// The five works, three series and two links the series journeys run over.     static let seededSeriesScenario = "seeded-series"+    /// The four works, three creators, five roles and six credits the creator+    /// journeys run over.+    static let seededCreatorsScenario = "seeded-creators"     /// One scenario per tolerated state, plus the illegal-tuple state that     /// carries the re-teach route and the empty-library shape Q15 hoists the     /// banner for. Keyed by the fixture's own raw value so a new shape needs no@@ -240,6 +253,8 @@ enum UITestLaunchSupport {             fixture = .worksOptions         case seededSeriesScenario:             fixture = .series+        case seededCreatorsScenario:+            fixture = .creators         case let scenario where scenario.hasPrefix(seededScaleM4ToleratedPrefix):             guard let state = M4ToleratedFixtureState(                 rawValue: String(scenario.dropFirst(seededScaleM4ToleratedPrefix.count)))

diff --git a/Asterism/Asterism/ViewModels/AppLibraryModel.swift b/Asterism/Asterism/ViewModels/AppLibraryModel.swiftindex 6dfc9b5..7348a2f 100644--- a/Asterism/Asterism/ViewModels/AppLibraryModel.swift+++ b/Asterism/Asterism/ViewModels/AppLibraryModel.swift@@ -157,8 +157,8 @@ public final class AppLibraryModel {     /// The resolved configuration after successful bootstrap.     private var resolvedConfiguration: LibraryConfiguration?     private var repository: (any LibraryProviding)?-    /// Retains the concrete repository for backup export (conforms to BackupV10SnapshotProviding).-    private var backupRepository: (any BackupV10SnapshotProviding)?+    /// Retains the concrete repository for backup export (conforms to BackupV11SnapshotProviding).+    private var backupRepository: (any BackupV11SnapshotProviding)?     /// A pre-bootstrap failure used to fail closed on invalid debug launch input.     private let startupFailureMessage: String?     /// Seeds only a fresh, explicit temporary configuration used by UI tests.@@ -1198,6 +1198,20 @@ public final class AppLibraryModel {             onMutation: { [weak self] in await self?.refreshDiagnosesAndSnapshots() })     } +    /// The creator-roles list (`work-creators` Req 2.1).+    ///+    /// The work-types list's mutation hook, and for its reason: a rename changes+    /// the label every credit holding the role displays (Req 2.3), and a removal+    /// takes it out of every credit's display (Req 2.4), so the snapshots behind+    /// Recent, Works and the work detail have to be re-read even though nothing+    /// wrote to a work.+    public func creatorRolesModel() -> CreatorRolesModel? {+        guard let repo = repository else { return nil }+        return CreatorRolesModel(+            library: repo,+            onMutation: { [weak self] in await self?.refreshDiagnosesAndSnapshots() })+    }+     /// The series list (`series-and-related-works` Req 1.6).     ///     /// The mutation hook is the snapshot refresh, as the work-types list's is: a@@ -1234,6 +1248,39 @@ public final class AppLibraryModel {             })     } +    /// The creators list (`work-creators` Req 1.6).+    ///+    /// The mutation hook is the snapshot refresh, as the series list's is: a+    /// created creator joins the works list's filter options and the credits+    /// editor's picker, neither of which reads this screen.+    public func creatorListModel() -> CreatorListModel? {+        guard let repo = repository else { return nil }+        return CreatorListModel(+            library: repo,+            onMutation: { [weak self] in await self?.refreshDiagnosesAndSnapshots() })+    }++    /// One creator's screen (`work-creators` Reqs 4.1–4.5).+    ///+    /// The read-only mutation hook, unlike the series screen's: not one of this+    /// screen's writes touches a `Work` row — a rename reaches every credit+    /// through the identity, and a deletion removes credit rows and creator rows+    /// and leaves every work as it found it (Q44) — so there is no work write to+    /// schedule a duplicate pass for.+    ///+    /// `originWorkID` is the route's, and it is what Req 4.3's "Current work"+    /// marker is read from — nil for a creator opened from the creators list.+    public func creatorDetailModel(+        for creatorID: UUID, originWorkID: UUID?+    ) -> CreatorDetailModel? {+        guard let repo = repository else { return nil }+        return CreatorDetailModel(+            creatorID: creatorID,+            originWorkID: originWorkID,+            library: repo,+            onMutation: { [weak self] in await self?.refreshDiagnosesAndSnapshots() })+    }+     /// The diagnosis surface's model (Req 4.1, 4.2, and Req 9.3's duplicate     /// rows). The caller supplies the re-teach route because navigation is its     /// concern, not the model's.@@ -1340,7 +1387,7 @@ public final class AppLibraryModel {                 return workload.item(for: pending.id, type: pending.recordType) == nil             case .survivorDiverged:                 return false-            case .seriesMissing:+            case .seriesMissing, .creatorMissing, .roleMissing:                 // Not a duplicate at all, so no published set will ever mention                 // it. Like `.survivorDiverged`, it clears when a write lands.                 return false@@ -2005,7 +2052,7 @@ public final class AppLibraryModel {         guard let repo = backupRepository, let config = resolvedConfiguration else { return nil }         let stagingDir = config.rootDirectory             .appending(path: "Library/Caches/BackupExports")-        let exporter = BackupV10Exporter(+        let exporter = BackupV11Exporter(             repository: repo,             stagingDirectory: stagingDir         )@@ -2371,6 +2418,172 @@ public final class AppLibraryModel {         return work.id     } +    /// `work-creators`: the smallest library the creators list, the creator+    /// screen, the credits section and its editor, the creator filter and the+    /// roles settings all have something to say about (the design's UI test+    /// fixture section).+    ///+    /// Four works over two hostnames, seeded in this order — so the date order+    /// is the reverse of it and the works list's opening sort is deterministic:+    ///+    /// | Work | Site | Credits |+    /// |---|---|---|+    /// | Lantern Song | quill.test | Mori Ayane · author; Studio Lantern · artist |+    /// | Nightjar Bay | quill.test | Mori Ayane · author, editor *(removed after)* |+    /// | Salt and Ember | press.test | Mori Ayane · artist + *unresolved role*; *unresolved creator* · author |+    /// | Quiet Tide | press.test | — |+    ///+    /// Three creators: **Mori Ayane**, credited on three works (author on two,+    /// artist on one); **Studio Lantern**, artist on one; and **Quill Wright**,+    /// credited on nothing, which is the creator Req 1.5 keeps and the one the+    /// filter therefore never offers. Five roles: the three seeded defaults, a+    /// reader-added "letterer" at the end that nothing holds, and an "editor"+    /// added, credited on Nightjar Bay and then removed — so Req 2.1's removed+    /// list has a row whose credit count is not zero.+    ///+    /// Salt and Ember carries **both** unresolved references — a credit naming a+    /// creator id no row holds and a credit holding a role id no row holds —+    /// through the Core debug seam, because neither is reachable through a write+    /// path (`CreditStateFixture`). It is also the reason Quiet Tide has no+    /// credit at all: "No creators" then matches exactly one work.+    ///+    /// **`seedSeriesFixture` and `seedWorksOptionsFixture` are untouched**: their+    /// suites assert exact orders and counts that a credit would move.+    private func seedCreatorsFixture(in repo: LibraryRepository) async throws {+        let operation = "seeding the work-creators UI test fixture"++        // The creators first: a work's credits are written with the work, and+        // `updateWork` writes the identifiers it is given through whether or not+        // they resolve — so seeding them first is what makes these three resolve.+        let mori = try Self.creatorID(+            try await repo.createCreator(+                name: "Mori Ayane",+                notes: "Writes the Lantern books and draws the short ones."),+            operation)+        let lantern = try Self.creatorID(+            try await repo.createCreator(name: "Studio Lantern", notes: ""), operation)+        _ = try Self.creatorID(+            try await repo.createCreator(+                name: "Quill Wright", notes: "Nothing of theirs is in the library yet."),+            operation)++        // Req 2.6's three defaults are already in the store — the app seeded+        // them at open — so the fixture only adds the two the journeys need.+        let seeded = try await repo.creatorRoleOptions()+        guard+            let author = seeded.first(where: { $0.name == "author" })?.id,+            let artist = seeded.first(where: { $0.name == "artist" })?.id+        else {+            throw LibraryRepositoryError.invalidInput(+                operation: operation, reason: "the seeded creator roles are missing")+        }+        // "letterer" before "editor", so the two land at positions 3 and 4 and+        // the removed row is the last of them.+        _ = try Self.roleID(try await repo.addCreatorRole(name: "letterer"), operation)+        let editor = try Self.roleID(try await repo.addCreatorRole(name: "editor"), operation)++        _ = try await seedCreatorsWork(+            title: "Lantern Song", hostname: "quill.test", slug: "song",+            credits: [+                CreditDraft(creatorID: mori, roleIDs: [author.uuidString]),+                CreditDraft(creatorID: lantern, roleIDs: [artist.uuidString]),+            ], in: repo)+        _ = try await seedCreatorsWork(+            title: "Nightjar Bay", hostname: "quill.test", slug: "nightjar",+            credits: [+                CreditDraft(creatorID: mori, roleIDs: [author.uuidString, editor.uuidString])+            ], in: repo)+        let ember = try await seedCreatorsWork(+            title: "Salt and Ember", hostname: "press.test", slug: "ember",+            credits: [CreditDraft(creatorID: mori, roleIDs: [artist.uuidString])], in: repo)+        _ = try await seedCreatorsWork(+            title: "Quiet Tide", hostname: "press.test", slug: "tide", credits: [], in: repo)++        // Req 2.4, and it has to be after the credit: removing a role writes no+        // credit, so the row on Nightjar Bay keeps the identifier and the+        // settings list can say one credit holds it.+        try await repo.removeCreatorRole(id: editor)++        #if DEBUG || ASTERISM_PERFORMANCE_TESTING+        _ = try await repo.seedUnresolvedCreditReferences(+            workID: ember, creatorID: mori, roleIDs: [author])+        #else+        throw LibraryRepositoryError.invalidInput(+            operation: operation,+            reason: "the creators fixture requires a debug build")+        #endif+        Self.logger.debug("Seeded the work-creators UI test fixture")+    }++    /// One work of that fixture: a capture, a work on the same site, the move+    /// that puts one under the other, and the credits the work is committed with.+    ///+    /// `seedSeriesWork`'s shape, and for its reason — one whole work at a time+    /// keeps each capture in a later millisecond than the last, which is what+    /// makes the date order deterministic. The credits ride the work's own+    /// `updateWork` because that is the only path that writes them (Req 3.5).+    private func seedCreatorsWork(+        title: String, hostname: String, slug: String, credits: [CreditDraft],+        in repo: LibraryRepository+    ) async throws -> UUID {+        let entry = try await repo.capture(CaptureDraft(+            captureTitle: "Chapter 1 - \(title)",+            captureTitleSource: .host,+            rawURLString: "https://\(hostname)/\(slug)/1"))+        let work = try await repo.createWork(+            NewWorkDraft(displayTitle: title, hostname: hostname))+        let assignment = try await repo.entry(id: entry.id)+        _ = try await repo.moveEntry(+            entry.id,+            basis: EntryAssignmentBasis(entry: assignment),+            to: .existing(work.id))++        let reloaded = try await repo.work(id: work.id)+        _ = try await repo.updateWork(+            id: work.id,+            basis: WorkEditBasis(work: reloaded),+            draft: WorkMetadataDraft(+                displayTitle: title, typeAssignment: reloaded.typeDisplay.assignment,+                genreTags: [], genericNotes: "",+                workStatus: reloaded.workStatus, readingStatus: .reading, verdict: "",+                membership: reloaded.membership,+                // Nil rather than an empty draft for a work with no credits: the+                // two mean the same thing on a work that has none, and nil is+                // what every non-editor caller sends (Q85's other side).+                credits: credits.isEmpty+                    ? nil : CreditsDraft(seenRowIDs: [], credits: credits)))+        return work.id+    }++    /// The identifier a fixture create returned, or a failure naming the refusal+    /// — a rejected seed would otherwise show up as a missing row in whichever+    /// journey happened to run first.+    private static func creatorID(+        _ outcome: CreatorAddOutcome, _ operation: String+    ) throws -> UUID {+        switch outcome {+        case .added(let id):+            return id+        case .rejected(let rejection):+            throw LibraryRepositoryError.invalidInput(+                operation: operation,+                reason: "the creator was refused: \(String(describing: rejection))")+        }+    }++    private static func roleID(+        _ outcome: CreatorRoleAddOutcome, _ operation: String+    ) throws -> UUID {+        switch outcome {+        case .added(let id), .restored(let id):+            return id+        case .rejected(let rejection):+            throw LibraryRepositoryError.invalidInput(+                operation: operation,+                reason: "the creator role was refused: \(String(describing: rejection))")+        }+    }+     /// Preserves two captures in the disposable root's spool, exactly as the     /// share extension would have: one the drain commits, and one it can never     /// commit and therefore sets aside (Req 6.4).@@ -2474,6 +2687,11 @@ public final class AppLibraryModel {             return         } +        if fixture == .creators {+            try await seedCreatorsFixture(in: repository)+            return+        }+         if fixture == .composed {             // Production opens through the app-role opener, so the composed             // fixture seeds through the ordinary bootstrap, which creates and

diff --git a/Asterism/Asterism/ViewModels/CreatorModels.swift b/Asterism/Asterism/ViewModels/CreatorModels.swiftnew file mode 100644index 0000000..5463ea8--- /dev/null+++ b/Asterism/Asterism/ViewModels/CreatorModels.swift@@ -0,0 +1,476 @@+import AsterismCore+import Foundation+import Observation+import OSLog++// The two creator screens' models (Requirements 1 and 4).+//+// `SeriesModels.swift` is the template, minus the membership half of it: a+// credit is edited on the *work* (Non-Goal 1), so this screen has no add-member,+// no reposition and no remove. What is left is a list that creates, a screen+// that renames, re-notes and deletes, and the works that credit it.+//+// The house rule holds: 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.++/// The creators list (Req 1.6): every active creator with its work count, and+/// the field that creates one.+@MainActor @Observable+public final class CreatorListModel {+    private static let logger = Logger(+        subsystem: "me.nore.ig.Asterism", category: "CreatorListModel")++    public enum State: Equatable, Sendable {+        case loading+        case ready+        case error(message: String)+    }++    /// One creator, as the list presents it.+    public struct Row: Identifiable, Equatable, Sendable {+        public let creator: CreatorSnapshot++        public var id: UUID { creator.id }+        /// The stored spelling of the folded identity. Creators have no+        /// qualifier the way series do — two active creators cannot share a+        /// normalized name (Req 1.1), so the name tells them apart on its own.+        public var name: String { creator.name }+        public var workCount: Int { creator.workCount }++        /// What the count pill says out loud. Req 4.4 counts works in the local+        /// library, and one work is one work.+        public var countLabel: String {+            Pluralisation.count(workCount, "work", "works")+        }+    }++    public private(set) var state: State = .loading+    /// In the order the read returned them, which is `CreatorOrdering` — the+    /// repository orders the read 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 creator is for rather than showing an empty box.+    public let emptyMessage =+        "No creators yet. Add one above, then credit them from a work's own editor."++    public var canAdd: Bool {+        !WorkTypeName.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?+    /// Set by one of this screen's own writes, which re-reads at the moment it+    /// commits: `onMutation` then bumps the app's snapshot generation, and the+    /// screen's `.task(id:)` fires `reload(for:)` on that bump with a read this+    /// model has already done. Without it every add paid for `creators()` twice+    /// — a fetch of every creator, every credit and every work.+    private var didReadAfterOwnMutation = false++    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.creators().map(Row.init(creator:))+            state = .ready+        } catch {+            rows = []+            state = .error(message: error.localizedDescription)+            Self.logger.error("Creator read failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// The sync-arrival trigger (Req 10.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 work count without a relaunch.+    public func reload(for generation: Int) async {+        guard loadedGeneration != generation else { return }+        loadedGeneration = generation+        if didReadAfterOwnMutation {+            didReadAfterOwnMutation = false+            return+        }+        await load()+    }++    /// Creates the typed creator (Req 1.1).+    ///+    /// The refusal is the repository's reason, sentenced here: `createCreator`+    /// refuses an empty, multi-line or duplicate name and names the creator it+    /// collided with (Q57), which is the one thing the reader needs to know.+    public func add() async {+        guard canAdd else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        do {+            switch try await library.createCreator(name: draftName, notes: "") {+            case .added:+                draftName = ""+                message = nil+                // The read comes first and the refresh second, so the bump+                // `onMutation` publishes cannot land between them: this read has+                // already answered it (see `reload(for:)`).+                await load()+                didReadAfterOwnMutation = true+                await onMutation()+            case .rejected(let rejection):+                message = CreatorRejectionPresentation.sentence(for: rejection)+            }+        } catch {+            message = error.localizedDescription+            Self.logger.error("Creator add failed: \(String(describing: error), privacy: .public)")+        }+    }+}++/// One creator's screen (Reqs 4.1–4.5): its name, its notes, and every work in+/// the library crediting it.+@MainActor @Observable+public final class CreatorDetailModel {+    private static let logger = Logger(+        subsystem: "me.nore.ig.Asterism", category: "CreatorDetailModel")++    public enum State: Equatable, Sendable {+        case loading+        case ready+        /// The creator 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 credited work, as the screen draws it.+    public struct CreditedWork: Identifiable, Equatable, Sendable {+        public let work: WorkSnapshot+        /// Req 4.2: the active, resolved roles this creator holds on this work,+        /// in list order. A removed, merged-into-shown or unresolved role is not+        /// drawn on this screen (Req 3.8).+        public let roles: [CreatorRoleDisplay]+        /// Req 4.3: the work this screen was opened from, marked. A creator+        /// opened from the creators list marks nothing.+        public let isCurrent: Bool++        public var id: UUID { work.id }++        /// The secondary line: the role names, separated as the work detail's+        /// credit rows separate them. Empty where this creator holds no shown+        /// role on the work, which draws no line at all.+        public var roleText: String {+            roles.compactMap(\.name).joined(separator: " · ")+        }++        /// What the **role line** says out loud (Req 12.1).+        ///+        /// The line only, not the whole row: the row is a `WorkRow`, which+        /// composes its own title, type pill, status glyphs and site labels, and+        /// a label on the button around it would replace all of them with one+        /// sentence. So the roles carry their own, separated as speech separates+        /// a list rather than by the interpunct the line draws. Empty where this+        /// creator holds no shown role, which draws no line to label.+        public var rolesAccessibilityLabel: String {+            roles.compactMap(\.name).joined(separator: ", ")+        }+    }++    /// What the deletion confirmation is offering.+    ///+    /// The count rides **on the presented value**, not beside it in the model,+    /// for the reason `SeriesDetailModel.DeletionPrompt` 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 workCount: Int++        /// Req 1.4: the confirmation states how many works credit the creator,+        /// and what happens to them — which is nothing. The deletion removes the+        /// creator and its credits; no work is deleted or even written (Q44).+        public var message: String {+            guard workCount > 0 else {+                return "No works credit this creator. Deleting it removes the creator itself; "+                    + "nothing else changes."+            }+            // The verb rides *inside* the pluralised subject, as+            // `SeriesDetailModel.DeletionPrompt` puts "is"/"are" inside its own:+            // agreement is one rule, and a verb parked outside the helper reads+            // as "1 work credit this creator".+            let subject = Pluralisation.count(workCount, "work credits", "works credit")+            return "\(subject) this creator. They stay in your library and lose the credit."+        }+    }++    public let creatorID: UUID+    /// The work the reader came from, if any (Req 4.3).+    public let originWorkID: UUID?++    public private(set) var state: State = .loading+    public private(set) var display: CreatorDisplay?+    public private(set) var notes: String = ""+    public private(set) var works: [CreditedWork] = []++    public private(set) var isEditing = false+    public var draftName: String = ""+    public var draftNotes: String = ""++    /// The one line the screen says back for a refusal: a refused name, a write+    /// the repository would not take.+    public private(set) var message: String?++    /// Where the standing refusal is **said**, so the screen can draw it there+    /// and take the reader to it.+    ///+    /// `SeriesDetailModel.RefusalTarget`'s shape, with one field instead of a+    /// row per member: every refusal a *rejection* carries is about the name —+    /// empty, control characters, a duplicate — and Q72 of+    /// `series-and-related-works` says a refusal about a field is said under+    /// that field. A write the repository would not take has no field to sit+    /// under, and keeps the screen's bottom row.+    public enum RefusalTarget: Equatable, Sendable {+        /// The name field's own card, under the field.+        case name+        /// The last section of the list, for a refusal with no field.+        case message+    }++    public private(set) var refusalTarget: RefusalTarget?+    public private(set) var deletionPrompt: DeletionPrompt?+    /// Set once the creator is gone, so the screen can leave the stack.+    public private(set) var didFinish = false+    public private(set) var isSubmitting = false++    /// Req 4.1's title, and the placeholder for the moment before the read+    /// lands. An unresolved creator reads as Core's placeholder rather than as a+    /// name this screen invented.+    public var title: String { display?.label ?? "Creator" }++    public var canSave: Bool {+        !WorkTypeName.trimmed(draftName).isEmpty && !isSubmitting+    }++    /// Req 4.1's empty works list, which is an ordinary state: a creator outlives+    /// its last credit (Req 1.5).+    public let emptyWorksMessage =+        "No works credit this creator yet. Add a credit from a work's own editor."++    private let library: any LibraryProviding+    private let onMutation: @Sendable () async -> Void+    private var loadedGeneration: Int?+    /// See `CreatorListModel.didReadAfterOwnMutation`.+    private var didReadAfterOwnMutation = false++    public init(+        creatorID: UUID,+        originWorkID: UUID?,+        library: any LibraryProviding,+        onMutation: @escaping @Sendable () async -> Void+    ) {+        self.creatorID = creatorID+        self.originWorkID = originWorkID+        self.library = library+        self.onMutation = onMutation+    }++    // MARK: - Reading (Reqs 4.1–4.4)++    public func load() async {+        do {+            guard let detail = try await library.creatorDetail(id: creatorID) else {+                display = nil+                notes = ""+                works = []+                state = .missing+                return+            }+            display = detail.creator+            notes = detail.creator.notes+            works = detail.works.map { credit in+                CreditedWork(+                    work: credit.work, roles: credit.roles,+                    isCurrent: credit.work.id == originWorkID)+            }+            state = .ready+        } catch {+            state = .error(message: error.localizedDescription)+            Self.logger.error(+                "Creator detail read failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// `CreatorListModel.reload(for:)`'s trigger, for the same reason: a work+    /// or a credit arriving through sync joins the list without a relaunch, which+    /// is what heals an unresolved credit (Req 10.2).+    public func reload(for generation: Int) async {+        guard loadedGeneration != generation else { return }+        loadedGeneration = generation+        if didReadAfterOwnMutation {+            didReadAfterOwnMutation = false+            return+        }+        await load()+    }++    // MARK: - Editing the creator (Reqs 1.2, 4.5)++    public func beginEditing() {+        guard state == .ready else { return }+        clearRefusal()+        draftName = display?.name ?? ""+        draftNotes = notes+        isEditing = true+    }++    public func cancelEditing() {+        isEditing = false+        // A refusal belongs to the editing session that earned it.+        clearRefusal()+        draftName = ""+        draftNotes = ""+    }++    /// Says a rejection under the name field it is about (Q72 of+    /// `series-and-related-works`).+    private func refuse(_ rejection: CreatorRejection) {+        message = CreatorRejectionPresentation.sentence(for: rejection)+        refusalTarget = .name+    }++    /// Says a refusal with no field to sit under in the screen's bottom row.+    private func report(_ error: Error) {+        message = error.localizedDescription+        refusalTarget = .message+    }++    /// Q74 of `series-and-related-works`: a refusal belongs to the attempt that+    /// earned it, so it is cleared on every entry to and every exit from the+    /// editor — not only inside `save()`, which a no-op confirm never reaches+    /// far enough to clear on its own.+    private func clearRefusal() {+        message = nil+        refusalTarget = nil+    }++    /// The editor's one way out that writes (Reqs 1.2, 4.5).+    ///+    /// One call, because a creator has exactly two fields and the repository+    /// writes both under one lock, stamping each with its own timestamp.+    public func save() async {+        guard !isSubmitting else { return }+        guard canSave else {+            refuse(.emptyName)+            return+        }+        isSubmitting = true+        defer { isSubmitting = false }+        clearRefusal()++        guard WorkTypeName.trimmed(draftName) != (display?.name ?? "")+            || WorkTypeName.trimmed(draftNotes) != notes+        else {+            isEditing = false+            return+        }++        do {+            switch try await library.updateCreator(+                id: creatorID, name: draftName, notes: draftNotes)+            {+            case .added:+                isEditing = false+                // The read comes first and the refresh second, so the bump+                // `onMutation` publishes cannot land between them: this read has+                // already answered it (see `reload(for:)`).+                await load()+                didReadAfterOwnMutation = true+                await onMutation()+            case .rejected(let rejection):+                refuse(rejection)+            }+        } catch {+            report(error)+            Self.logger.error(+                "Creator update failed: \(String(describing: error), privacy: .public)")+        }+    }++    // MARK: - Deletion (Reqs 1.4, 4.5)++    public func requestDeletion() {+        guard !isSubmitting, let display else { return }+        clearRefusal()+        deletionPrompt = DeletionPrompt(+            id: creatorID, name: display.label, workCount: works.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+    }++    /// `CreatorDeletionOutcome` has one case (Q56): the deletion writes no work,+    /// site or membership row, so no diagnosis can be drawn over what it touches+    /// and there is no invalidation arm to answer. A save that cannot happen+    /// throws, and leaves creator, aliases and credits in place (Req 7.2).+    public func confirmDeletion(_ prompt: DeletionPrompt) async {+        guard !isSubmitting else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        clearRefusal()+        do {+            switch try await library.deleteCreator(id: prompt.id) {+            case .committed:+                deletionPrompt = nil+                await onMutation()+                didFinish = true+            }+        } catch {+            // No field to sit under: the deletion is a button, not a value.+            report(error)+            Self.logger.error(+                "Creator deletion failed: \(String(describing: error), privacy: .public)")+        }+    }+}++/// The one place a refused creator name is turned into words, so the creators+/// list's add field, the creator screen's name field and the credits editor's+/// "New creator" row cannot explain the same refusal differently (Req 1.1).+///+/// `WorkTypeRejectionPresentation`'s shape, minus its fourth case: a creator is+/// deleted rather than removed, so no removed name can be collided with+/// (Decision 4).+enum CreatorRejectionPresentation {+    static func sentence(for rejection: CreatorRejection) -> String {+        switch rejection {+        case .emptyName:+            "Enter a name for the creator."+        case .invalidCharacters:+            "A creator name is a single line of text, without line breaks or control characters."+        case .duplicateActive(let existing):+            "“\(existing)” is already in the list."+        }+    }+}

diff --git a/Asterism/Asterism/ViewModels/CreatorRolesModels.swift b/Asterism/Asterism/ViewModels/CreatorRolesModels.swiftnew file mode 100644index 0000000..e983d4d--- /dev/null+++ b/Asterism/Asterism/ViewModels/CreatorRolesModels.swift@@ -0,0 +1,435 @@+import AsterismCore+import Foundation+import Observation+import OSLog++// The creator-roles settings screen's two models (Requirement 2).+//+// `WorkTypesModels.swift` is the template, and for the reason that file gives:+// every sentence the screen shows is built here, so the views choose rows and+// styling and never wording — which is also what makes the screen's language+// testable.+//+// Two departures from work types, both from the requirement:+//+// - The list is **ordered by the reader** (Req 2.5), so this model has a+//   `move(from:to:)` the work-types model has no use for.+// - A removed role is listed whether or not a credit holds it (Req 2.1): unlike+//   a work type, the removed role is the thing Req 2.2 restores, so there is+//   something for the reader to do about it either way.++/// The configured list as settings presents it: the active roles in the reader's+/// order, and beneath them the roles they removed (Reqs 2.1, 2.7).+@MainActor @Observable+public final class CreatorRolesModel {+    private static let logger = Logger(+        subsystem: "me.nore.ig.Asterism", category: "CreatorRolesModel")++    public enum State: Equatable, Sendable {+        case loading+        case ready+        case error(message: String)+    }++    /// One role, as the list presents it.+    public struct Row: Identifiable, Equatable, Sendable {+        public let role: CreatorRoleSnapshot++        public var id: UUID { role.id }+        public var name: String { role.name }+        /// Req 2.1: the removed roles are shown, visually apart from the active+        /// ones — the work-types screen's dimmed violet.+        public var isRemoved: Bool { role.state == .removed }+        public var creditCount: Int { role.creditCount }++        /// How many credits hold this role, or nil when there is nothing to say.+        ///+        /// An **active** role nothing holds says nothing, as an unused work type+        /// does: the number is only news once it is not zero. A **removed** role+        /// always states it, because Req 2.1 asks the removed list to carry the+        /// count and "nothing holds it" is the fact that decides whether+        /// restoring it would bring anything back (Q80).+        public var creditLine: String? {+            guard creditCount > 0 else {+                return isRemoved ? "No credits hold this role" : nil+            }+            return "Held by \(Pluralisation.count(creditCount, "credit", "credits"))"+        }+    }++    public private(set) var state: State = .loading+    /// The active roles, in the order the read returned them — `CreatorRoleOrdering`,+    /// which is the reader's own list order (Req 2.5).+    public private(set) var rows: [Row] = []+    /// Req 2.1's second list: the roles the reader removed, kept so Req 2.2 can+    /// restore them.+    public private(set) var removedRows: [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 rejection's reason (Req 2.2) or a+    /// restore's confirmation. Nil when there is nothing to report.+    public private(set) var message: String?++    /// Req 2.7: an emptied list is a state the reader put the library in, and+    /// credits stay editable without it — which is the half a bare empty box+    /// would not say.+    public let emptyMessage =+        "No roles. Add one above and it joins every credit's editor; until then, a credit "+        + "records who worked on the work and nothing about what they did."++    /// Why removed roles are still on this screen (Req 2.2).+    public let removedExplanation =+        "These roles were removed from credits. The credits that held them kept them hidden — "+        + "adding the name again restores the role and they show it again."++    public var canAdd: Bool {+        !WorkTypeName.trimmed(draftName).isEmpty && !isSubmitting+    }++    private let library: any LibraryProviding+    private let onMutation: @Sendable () async -> Void+    private var isSubmitting = false++    public init(+        library: any LibraryProviding,+        onMutation: @escaping @Sendable () async -> Void+    ) {+        self.library = library+        self.onMutation = onMutation+    }++    public func load() async {+        state = .loading+        do {+            let roles = try await library.creatorRoles().map(Row.init(role:))+            rows = roles.filter { !$0.isRemoved }+            removedRows = roles.filter(\.isRemoved)+            state = .ready+        } catch {+            rows = []+            removedRows = []+            state = .error(message: error.localizedDescription)+            Self.logger.error(+                "Creator roles read failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Adds the typed name — or restores the removed role that already holds it+    /// (Req 2.2).+    ///+    /// The two outcomes are worded differently on purpose: a restore hands the+    /// credits that kept the role their label back, which "added" would quietly+    /// hide.+    public func add() async {+        guard canAdd else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        let typed = draftName+        do {+            switch try await library.addCreatorRole(name: typed) {+            case .added:+                draftName = ""+                message = nil+                await committed()+            case .restored:+                draftName = ""+                message =+                    "“\(WorkTypeName.trimmed(typed))” was removed earlier. It is back at the "+                    + "end of the list, and the credits that kept it are showing it again."+                await committed()+            case .rejected(let rejection):+                message = CreatorRoleRejectionPresentation.sentence(for: rejection)+            }+        } catch {+            message = error.localizedDescription+            Self.logger.error(+                "Creator role add failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Req 2.5's reorder, from the list's `.onMove`.+    ///+    /// The rows move **locally first** and the write follows: a list that only+    /// re-ordered once the repository answered would snap back under the+    /// reader's finger for the length of a save. The repository is handed the+    /// full active order rather than a pair of indices — it numbers the roles it+    /// is given 0…n and drops any that resolve to a removed or merged row+    /// (Q58), so the list the screen draws is the list that is written.+    public func move(from source: IndexSet, to destination: Int) async {+        guard !isSubmitting else { return }+        let reordered = Self.reordering(rows, from: source, to: destination)+        let ids = reordered.map(\.id)+        // A drag that ended where it started is not a write.+        guard ids != rows.map(\.id) else { return }+        rows = reordered+        isSubmitting = true+        defer { isSubmitting = false }+        do {+            try await library.reorderCreatorRoles(ids: ids)+            await committed()+        } catch {+            message = error.localizedDescription+            Self.logger.error(+                "Creator role reorder failed: \(String(describing: error), privacy: .public)")+            // The order on screen is now a claim the store did not accept, so+            // the read puts back what it holds.+            await load()+        }+    }++    /// `RangeReplaceableCollection.move(fromOffsets:toOffset:)`, restated.+    ///+    /// That method is SwiftUI's, and a view model does not import SwiftUI: the+    /// wording, the ordering and the write are all testable without a screen,+    /// and one framework import here would be the exception that ends that.+    /// `destination` carries the framework's meaning — an index into the list+    /// **as it was**, naming the row the moved ones land in front of.+    static func reordering(_ rows: [Row], from source: IndexSet, to destination: Int) -> [Row] {+        let moved = source.sorted().compactMap { rows.indices.contains($0) ? rows[$0] : nil }+        var remaining: [Row] = []+        var insertion = destination+        for (index, row) in rows.enumerated() {+            if source.contains(index) {+                if index < destination { insertion -= 1 }+            } else {+                remaining.append(row)+            }+        }+        remaining.insert(contentsOf: moved, at: min(max(insertion, 0), remaining.count))+        return remaining+    }++    /// One role's screen. Built here rather than by the host, as the work-types+    /// list builds its own: nothing about it needs navigation, and the list is+    /// what has to re-read itself once the detail has written.+    public func detailModel(for row: Row) -> CreatorRoleDetailModel {+        CreatorRoleDetailModel(+            role: row.role,+            library: library,+            onMutation: onMutation,+            onChanged: { [weak self] in await self?.load() })+    }++    private func committed() async {+        await onMutation()+        await load()+    }+}++/// One role's screen: rename it, or take it out of credits (Reqs 2.3, 2.4).+@MainActor @Observable+public final class CreatorRoleDetailModel {+    private static let logger = Logger(+        subsystem: "me.nore.ig.Asterism", category: "CreatorRoleDetailModel")++    /// What the removal 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 RemovalPrompt: Identifiable, Equatable, Sendable {+        public let id: UUID+        public let name: String+        public let creditCount: Int++        /// Req 2.4: the confirmation states how many credits hold the role, and+        /// what happens to them — which is that they keep it, hidden, until the+        /// name is added again (Req 2.2). It must not imply data loss; there is+        /// none, and no work is written.+        public var message: String {+            guard creditCount > 0 else {+                return "No credits hold this role. Removing it takes it out of the credits "+                    + "editor; adding the name again restores it."+            }+            let subject = Pluralisation.count(creditCount, "credit holds", "credits hold")+            return "\(subject) this role. It disappears from them and from the editor, and "+                + "they keep it — adding the name again restores it."+        }+    }++    /// Where a standing refusal is **said**, so the screen can draw it there+    /// (Q89).+    ///+    /// `CreatorDetailModel.RefusalTarget`, adopted here rather than the+    /// work-types template's single bottom row: every *rejection* this screen+    /// raises is about the name — empty, control characters, a duplicate, a+    /// removed name — and a reader who has just been refused one is looking at+    /// the field. A write the repository would not take has no field to sit+    /// under and keeps the bottom row.+    public enum RefusalTarget: Equatable, Sendable {+        /// Under the name field, in its own section.+        case name+        /// The screen's last section, for a refusal with no field.+        case message+    }++    public let role: CreatorRoleSnapshot+    /// Opens on the stored spelling, because a rename is nearly always a+    /// correction of it.+    public var draftName: String+    public private(set) var removalPrompt: RemovalPrompt?+    public private(set) var errorMessage: String?+    public private(set) var refusalTarget: RefusalTarget?+    public private(set) var isSubmitting = false+    /// Set once a write lands, so the screen can leave: it holds an immutable+    /// snapshot, and after a rename or a removal everything on it describes the+    /// role as it was.+    public private(set) var didFinish = false++    private let library: any LibraryProviding+    private let onMutation: @Sendable () async -> Void+    private let onChanged: @MainActor () async -> Void++    public init(+        role: CreatorRoleSnapshot,+        library: any LibraryProviding,+        onMutation: @escaping @Sendable () async -> Void,+        onChanged: @escaping @MainActor () async -> Void+    ) {+        self.role = role+        self.draftName = role.name+        self.library = library+        self.onMutation = onMutation+        self.onChanged = onChanged+    }++    // MARK: - Wording++    /// Req 2.4's count, stated on the screen that offers the removal — so the+    /// reader knows it before the dialog tells them again.+    public var usageLine: String {+        guard role.creditCount > 0 else { return "No credits hold this role." }+        return "Held by \(Pluralisation.count(role.creditCount, "credit", "credits"))."+    }++    /// Whether this screen is looking at a role the reader already removed+    /// (Req 2.1).+    public var isRemoved: Bool { role.state == .removed }++    /// Req 2.2's way back, said on the screen the reader actually reached+    /// (Q90).+    ///+    /// A removed role's screen used to offer "Remove from credits" — a control+    /// that either does nothing or removes what is already removed — and said+    /// nothing about the one thing the reader can do here. The removal is gone+    /// and this takes its place, so the screen has an answer rather than a dead+    /// end.+    public var restoreExplanation: String {+        "“\(role.name)” was removed from credits. The credits that held it kept it, hidden — "+            + "adding that name in the roles list restores this same role, and they show it again."+    }++    public var canRename: Bool {+        !WorkTypeName.trimmed(draftName).isEmpty && !isSubmitting+    }++    // MARK: - Rename (Req 2.3)++    /// Renames the role. Every credit holding it follows, because a credit cites+    /// the identity and the identity carries the name — nothing here writes to a+    /// work.+    public func rename() async {+        guard canRename else { return }+        isSubmitting = true+        clearRefusal()+        defer { isSubmitting = false }+        do {+            switch try await library.renameCreatorRole(id: role.id, to: draftName) {+            case .added, .restored:+                await onMutation()+                await onChanged()+                didFinish = true+            case .rejected(let rejection):+                // Q89: a rejection is about the name, and is said under the+                // field that holds it.+                errorMessage = CreatorRoleRejectionPresentation.sentence(for: rejection)+                refusalTarget = .name+            }+        } catch {+            report(error)+            Self.logger.error(+                "Creator role rename failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Says a refusal with no field to sit under in the screen's bottom row.+    private func report(_ error: Error) {+        errorMessage = error.localizedDescription+        refusalTarget = .message+    }++    /// A refusal belongs to the attempt that earned it, so every attempt clears+    /// the last one before it runs. The screen itself is built fresh at each+    /// push — the list constructs the model in `detailModel(for:)` — so entry is+    /// clean without a hook of its own, and a successful write dismisses it.+    private func clearRefusal() {+        errorMessage = nil+        refusalTarget = nil+    }++    // MARK: - Removal (Req 2.4)++    public func requestRemoval() {+        guard !isSubmitting else { return }+        clearRefusal()+        removalPrompt = RemovalPrompt(+            id: role.id, name: role.name, creditCount: role.creditCount)+    }++    /// 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 cancelRemoval() {+        removalPrompt = nil+    }++    /// Commits the removal the dialog rendered. Nothing is deleted and no work+    /// is written — the role stays in the store so the credits keep their+    /// identifiers and restoring it is the same identity again (Req 2.4).+    public func confirmRemoval(_ prompt: RemovalPrompt) async {+        guard !isSubmitting else { return }+        isSubmitting = true+        clearRefusal()+        defer { isSubmitting = false }+        do {+            try await library.removeCreatorRole(id: prompt.id)+            removalPrompt = nil+            await onMutation()+            await onChanged()+            didFinish = true+        } catch {+            report(error)+            Self.logger.error(+                "Creator role removal failed: \(String(describing: error), privacy: .public)")+        }+    }+}++/// The one place a refused role name is turned into words, so the settings add+/// field, the rename field and the credits editor's "New role" alert cannot+/// explain the same refusal differently (Reqs 2.2, 2.3).+///+/// `WorkTypeRejectionPresentation`'s four cases, because a role has the+/// work type's three states and the same restore.+enum CreatorRoleRejectionPresentation {+    static func sentence(for rejection: CreatorRoleRejection) -> String {+        switch rejection {+        case .emptyName:+            "Enter a name for the role."+        case .invalidCharacters:+            "A role name is a single line of text, without line breaks or control characters."+        case .duplicateActive(let existing):+            "“\(existing)” is already in the list."+        case .collidesWithRemoved(let existing):+            // Req 2.3: renaming into a removed name would merge two identities,+            // which is out of scope — so the refusal names the way through+            // rather than leaving the reader at a dead end.+            "“\(existing)” was removed earlier. Add that name in the list to restore it, "+                + "instead of renaming this role into it."+        }+    }+}

diff --git a/Asterism/Asterism/ViewModels/EntryDetailModel.swift b/Asterism/Asterism/ViewModels/EntryDetailModel.swiftindex e5bca8e..63bcde5 100644--- a/Asterism/Asterism/ViewModels/EntryDetailModel.swift+++ b/Asterism/Asterism/ViewModels/EntryDetailModel.swift@@ -350,6 +350,10 @@ public final class EntryDetailModel {             "Another copy of this record arrived. Review the copies before deleting."         case .seriesMissing:             "That series no longer exists."+        case .creatorMissing:+            "That creator no longer exists."+        case .roleMissing:+            "That role no longer exists."         }     } 

diff --git a/Asterism/Asterism/ViewModels/MaintenanceViewModels.swift b/Asterism/Asterism/ViewModels/MaintenanceViewModels.swiftindex 476f068..cf36033 100644--- a/Asterism/Asterism/ViewModels/MaintenanceViewModels.swift+++ b/Asterism/Asterism/ViewModels/MaintenanceViewModels.swift@@ -507,6 +507,11 @@ public final class LibraryDiagnosticsModel {             // deleted, here or on another device. Re-opening the work shows the             // list as it now stands.             resolution = "Open the work and choose a series that still exists."+        case .creatorMissing, .roleMissing:+            // The same shape, for the same reason: the creator or role the edit+            // newly named is gone, here or on another device, and the work's+            // credits editor shows what is left.+            resolution = "Open the work and edit its credits again."         }         return Row(             id: "conflict:\(conflict.id.uuidString)",

diff --git a/Asterism/Asterism/ViewModels/SearchFilters.swift b/Asterism/Asterism/ViewModels/SearchFilters.swiftindex 4fb81a6..f8fe10a 100644--- a/Asterism/Asterism/ViewModels/SearchFilters.swift+++ b/Asterism/Asterism/ViewModels/SearchFilters.swift@@ -94,3 +94,52 @@ struct WorksSearchFilter: Equatable {         return WorksSnapshot(works: apply(to: snapshot.works), unattachedEntries: [])     } }++/// The credits editor's creator search (`work-creators` Req 3.2), and the+/// question its "New creator" row is offered by (Req 3.3).+///+/// `WorksSearchFilter`'s sibling, on the same case- and diacritic-insensitive+/// containment rule, so a reader who found a work by typing in one finds a+/// creator by typing in the other. Filtering only, never reordering: the rows+/// arrive in `CreatorOrdering` and leave in it.+///+/// **Matching and uniqueness are two different questions here**, deliberately.+/// The search matches loosely — a substring, ignoring case and accents — so that+/// "mori" finds "Mori Ayane". Whether "New creator" is offered is the *strict*+/// question `createCreator` would answer at the write: an equal normalized name+/// (Req 1.1). Asking the loose question there would hide the row whenever the+/// typed name was a substring of somebody else's.+struct CreatorSearchFilter: Equatable {+    let query: String++    private var needle: String {+        query.trimmingCharacters(in: .whitespacesAndNewlines)+    }++    var isActive: Bool { !needle.isEmpty }++    func apply(to candidates: [CreatorPickerCandidate]) -> [CreatorPickerCandidate] {+        guard isActive else { return candidates }+        let needle = self.needle+        return candidates.filter { contains($0.creator.name, needle) }+    }++    /// Req 3.3: the row is offered only where the trimmed query's normalized+    /// form equals no **active** creator's — which is the whole list the picker+    /// is handed, whatever each row's availability says.+    ///+    /// Availability is a statement about *this work's draft* (Q91), and it+    /// changes as the reader credits and un-credits: a creator taken off the+    /// draft becomes selectable again in the same session. Uniqueness is a+    /// statement about the **library**, and does not. Asking this question+    /// against only the selectable rows would offer "New creator" for a name the+    /// work already credits and let `createCreator` refuse it.+    func offersNewCreator(among candidates: [CreatorPickerCandidate]) -> Bool {+        guard isActive else { return false }+        let normalized = WorkTypeName.normalize(needle)+        guard !normalized.isEmpty else { return false }+        return !candidates.contains {+            WorkTypeName.normalize($0.creator.name ?? "") == normalized+        }+    }+}

diff --git a/Asterism/Asterism/ViewModels/SeriesModels.swift b/Asterism/Asterism/ViewModels/SeriesModels.swiftindex 8de7cc7..1c7ad6e 100644--- a/Asterism/Asterism/ViewModels/SeriesModels.swift+++ b/Asterism/Asterism/ViewModels/SeriesModels.swift@@ -74,6 +74,11 @@ public final class SeriesListModel {     /// 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?+    /// Set by this screen's own add, which re-reads at the moment it commits:+    /// `onMutation` then bumps the app's snapshot generation, and the screen's+    /// `.task(id:)` fires `reload(for:)` on that bump with a read this model has+    /// already done. Without it every add read the whole series list twice.+    private var didReadAfterOwnMutation = false      public init(         library: any LibraryProviding,@@ -101,6 +106,10 @@ public final class SeriesListModel {     public func reload(for generation: Int) async {         guard loadedGeneration != generation else { return }         loadedGeneration = generation+        if didReadAfterOwnMutation {+            didReadAfterOwnMutation = false+            return+        }         await load()     } @@ -123,8 +132,12 @@ public final class SeriesListModel {             _ = try await library.createSeries(name: draftName, notes: "")             draftName = ""             message = nil-            await onMutation()+            // The read comes first and the refresh second, so the bump+            // `onMutation` publishes cannot land between them: this read has+            // already answered it (see `reload(for:)`).             await load()+            didReadAfterOwnMutation = true+            await onMutation()         } catch {             message = SeriesRefusalPresentation.sentence(for: error)             Self.logger.error("Series add failed: \(String(describing: error), privacy: .public)")

diff --git a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift b/Asterism/Asterism/ViewModels/SettingsBackupModel.swiftindex 5c81d80..c599a71 100644--- a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift+++ b/Asterism/Asterism/ViewModels/SettingsBackupModel.swift@@ -5,20 +5,20 @@ import OSLog // MARK: - Backup Exporting Protocol  /// Test seam abstracting the exporter's operations needed by the Settings-/// surface. Conforms `BackupV10Exporter` to this protocol via extension below.+/// surface. Conforms `BackupV11Exporter` to this protocol via extension below. ///-/// Settings exports 10/11 (`series-and-related-works` Req 13.1): the archive+/// Settings exports 11/12 (`work-creators` Req 9.1): the archive /// carries a Work's site memberships, the reader's dismissed pairs, citations /// that name a rule by UUID alone, and the Work's two statuses and verdict. It /// is also the only format the app reads, so there is one exporter and one /// importer. public protocol BackupExporting: Sendable {-    func export(metadata: BackupV10Metadata) async throws -> BackupExportResult+    func export(metadata: BackupV11Metadata) async throws -> BackupExportResult     func cleanup(_ result: BackupExportResult)     func scavengeStaleFiles() } -extension BackupV10Exporter: BackupExporting {}+extension BackupV11Exporter: BackupExporting {}  // MARK: - Settings Backup View Model @@ -79,7 +79,7 @@ public final class SettingsBackupModel {         currentResult = nil          do {-            let metadata = BackupV10Metadata(+            let metadata = BackupV11Metadata(                 appBuild: Self.currentAppBuild(),                 exportedAt: Date()             )@@ -92,7 +92,7 @@ public final class SettingsBackupModel {             state = .failed             // Privacy-safe: log only the error category, never user content             errorMessage = Self.privacySafeMessage(for: error)-            if let exportError = error as? BackupV10ExportError,+            if let exportError = error as? BackupV11ExportError,                case .tornGroups = exportError {                 routesToCheckLibrary = true             }@@ -140,7 +140,7 @@ public final class SettingsBackupModel {         switch error {         case is BackupCodecError:             "Backup export failed due to an encoding error. Please try again."-        case let error as BackupV10ExportError:+        case let error as BackupV11ExportError:             exportMessage(for: error)         default:             "Backup export failed. Please try again."@@ -164,7 +164,7 @@ public final class SettingsBackupModel {     /// (`character-extraction` Req 6.5, Q105). It needs no new sentence: the     /// payload carries a count and a route, not a record kind, and Check Library     /// is where every torn group is resolved.-    private static func exportMessage(for error: BackupV10ExportError) -> String {+    private static func exportMessage(for error: BackupV11ExportError) -> String {         switch error {         case .tornGroups(let payload):             tornGroupsMessage(payload)@@ -204,7 +204,7 @@ public final class SettingsBackupModel {         switch error {         case let e as BackupCodecError:             "codec: \(e)"-        case let e as BackupV10ExportError:+        case let e as BackupV11ExportError:             "export: \(e)"         case let e as LibraryRepositoryError:             "repository: \(e)"

diff --git a/Asterism/Asterism/ViewModels/WorkDetailModel.swift b/Asterism/Asterism/ViewModels/WorkDetailModel.swiftindex 9828f49..8a91fb3 100644--- a/Asterism/Asterism/ViewModels/WorkDetailModel.swift+++ b/Asterism/Asterism/ViewModels/WorkDetailModel.swift@@ -257,6 +257,91 @@ public final class WorkDetailModel {     /// The type each link's edit-mode field holds, keyed by link id.     private var linkTypeDrafts: [UUID: String] = [:] +    // MARK: - Credits (`work-creators` Reqs 3.2–3.5, 3.7, 3.8)++    /// The work's credits as the read folded them: one per canonical creator,+    /// in `CreditOrdering` (Req 3.7). What view mode draws.+    public var credits: [CreditDisplay] { presentation?.credits ?? [] }++    /// One credit as the **editor** holds it (Q52).+    ///+    /// The shown roles are canonical identifiers rather than displays, because+    /// what a chip toggles is a role's identity; the displays are looked up in+    /// `roleOptions` when the chips are drawn, and the ones that have no option+    /// to look up are carried here so the reader can still take them off+    /// (Req 3.8).+    public struct CreditDraftRow: Identifiable, Equatable, Sendable {+        public let creator: CreatorDisplay+        /// Stored identifiers the editor never shows — a removed role's, one+        /// merged into a removed role, an entry that is not a UUID. Written back+        /// untouched, which is the whole of Req 3.2's "preserving each role+        /// identifier the editor did not show".+        public let hiddenRoleIDs: [String]+        /// The identities of the roles the credit holds **and shows**: the+        /// active ones the chips switch, and the unresolved ones below.+        public var shownRoleIDs: Set<UUID>+        /// The unresolved roles still on the credit, in the order the read shows+        /// them, so the dimmed removable chips can be drawn (Req 3.8). Removing+        /// one takes it out of `shownRoleIDs` as well.+        public var unresolvedRoles: [CreatorRoleDisplay]++        public var id: UUID { creator.id }+    }++    /// The credits editor's rows, seeded from the presentation in `load()` and+    /// put back by the cancel that discards the draft (Req 3.2).+    public private(set) var draftCredits: [CreditDraftRow] = []++    /// The credits **as they stood when the draft was seeded**, which is what a+    /// commit is measured against (Req 3.5, Q52).+    ///+    /// Not `presentation?.credits`: a link edit re-reads the presentation from+    /// inside edit mode (`reloadPresentation()`), so a credit another device+    /// added between the seeding and the save would join the live read — and+    /// with it `seenRowIDs`, whose whole job is to say what the editor *saw*.+    /// A row it never saw would then be deleted by a draft that never listed+    /// it, which is precisely the last-writer-wins-per-credit rule Q52 exists+    /// to avoid. Snapshotted beside `draftCredits`, and replaced only when they+    /// are.+    private var creditBaseline: [CreditDisplay] = []++    /// The roles the chips offer: active, in the reader's list order (Req 2.5).+    /// Read with the screen, because the chips are drawn on every credit card.+    public private(set) var roleOptions: [CreatorRoleDisplay] = []++    /// Req 2.7: with no active role the chip row says so and the credit stays+    /// editable — a creator on a work is information without a role.+    public let noRolesCaption = "No roles. Add roles in Settings."++    /// Req 3.2's picker rows, read on demand for `linkCandidates`' reason: a+    /// whole-library read has no business running behind a screen that is not+    /// showing it.+    private var creatorCandidates: [CreatorPickerCandidate] = []++    /// Whether the picker's read is still running, so the sheet says "loading"+    /// rather than "no creators" over a read that has not returned.+    public private(set) var isLoadingCreatorCandidates = false++    /// The picker's rows, availability decided **by the draft**+    /// (`work-creators` Q91).+    ///+    /// The repository answers from the **stored** credits, which is right for+    /// the read and wrong for a session in both directions: a creator added a+    /// moment ago and not yet saved would be offered again, and a creator+    /// *removed* a moment ago would stay unselectable with no way to put it+    /// back. So the reason is re-derived here rather than added to the one the+    /// read gave — unavailable exactly when the draft lists the creator. Q20's+    /// rule holds either way: the row is listed with its reason, never hidden.+    public var creatorPickerCandidates: [CreatorPickerCandidate] {+        let credited = Set(draftCredits.map(\.creator.id))+        return creatorCandidates.map { candidate in+            CreatorPickerCandidate(+                creator: candidate.creator,+                unavailableReason: credited.contains(candidate.creator.id)+                    ? CreatorPickerCandidate.alreadyCredited : nil)+        }+    }+     private let workID: UUID     private let library: any LibraryProviding     /// The locale a position is read and written in (Reqs 2.2, 2.7). Taken at@@ -308,6 +393,8 @@ public final class WorkDetailModel {             autoRevertedReading = false             restoreSeriesDraftFromSnapshot()             seriesOptions = await seriesPickerOptions(carrying: snapshot.series)+            restoreCreditDraftFromPresentation()+            await reloadRoleOptions()             seedLinkTypeDrafts(detail.links)             adoptCharacterDrafts(detail.characters)             // Before the projection below, which is *about* the selected site.@@ -535,6 +622,211 @@ public final class WorkDetailModel {         }     } +    // MARK: - The credits draft (`work-creators` Reqs 3.2–3.5)++    /// Puts the editor's rows back on what the read holds — at load, and at the+    /// cancel that discards the draft (Req 3.2).+    private func restoreCreditDraftFromPresentation() {+        // The baseline is taken with the draft and only with it: everything a+        // commit compares against has to describe the same moment.+        creditBaseline = credits+        draftCredits = creditBaseline.map { credit in+            CreditDraftRow(+                creator: credit.creator,+                hiddenRoleIDs: credit.hiddenRoleIDs,+                shownRoleIDs: Set(credit.roles.map(\.id)),+                unresolvedRoles: credit.roles.filter { !$0.isResolved })+        }+    }++    /// The chips' vocabulary. A failed read is not a failed screen — the credits+    /// stay editable with no role, which is Req 2.7's state arrived at from the+    /// other direction.+    private func reloadRoleOptions() async {+        do {+            roleOptions = try await library.creatorRoleOptions()+        } catch {+            Self.logger.error(+                "Creator role options read failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Raises the picker's loading flag **before** the sheet is presented.+    ///+    /// The read is asynchronous and the presentation is not, so a sheet that+    /// opened on the last rows — or on none — would show "No creators in the+    /// library yet." for as long as the read took. Called by the button that+    /// opens the picker, in the same turn as it sets the presentation flag.+    public func beginLoadingCreatorOptions() {+        isLoadingCreatorCandidates = true+    }++    /// Req 3.2's picker rows, read when the picker is opened.+    ///+    /// A failed read **clears** the rows, as `loadLinkOptions` does: the picker+    /// is a list of what the library holds right now, and leaving the last read's+    /// rows up beside a failure sentence offers the reader a choice this device+    /// could not confirm.+    public func loadCreatorOptions() async {+        isLoadingCreatorCandidates = true+        defer { isLoadingCreatorCandidates = false }+        do {+            creatorCandidates = try await library.creatorCandidates(for: workID)+        } catch {+            creatorCandidates = []+            errorMessage = error.localizedDescription+            Self.logger.error(+                "Creator candidates read failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Whether the credits half of the draft differs from what the read holds.+    ///+    /// Set comparison rather than array: the chip order is `roleOptions`', not+    /// the draft's, so two orderings of the same roles are the same credit.+    public var hasUnsavedCreditChange: Bool {+        let baseline = creditBaseline+        guard draftCredits.count == baseline.count else { return true }+        var shownByCreator: [UUID: Set<UUID>] = [:]+        for credit in baseline { shownByCreator[credit.creator.id] = Set(credit.roles.map(\.id)) }+        for row in draftCredits {+            guard let shown = shownByCreator[row.creator.id] else { return true }+            if shown != row.shownRoleIDs { return true }+        }+        return false+    }++    /// Switches one role on or off for one credit (Req 3.2).+    ///+    /// Switching a role **off** takes only its identity out; the stored+    /// identifiers the editor never showed stay on `hiddenRoleIDs` and are+    /// written back, while an alias of the role being switched off is *not*+    /// among them — it is dropped with its survivor, so the role cannot come+    /// back through it.+    public func toggleCreditRole(_ roleID: UUID, forCreator creatorID: UUID) {+        guard let index = draftCredits.firstIndex(where: { $0.creator.id == creatorID })+        else { return }+        if draftCredits[index].shownRoleIDs.remove(roleID) == nil {+            draftCredits[index].shownRoleIDs.insert(roleID)+        } else {+            // An unresolved role has no chip to switch back on, so taking it off+            // takes its row with it (Req 3.8).+            draftCredits[index].unresolvedRoles.removeAll { $0.id == roleID }+        }+    }++    /// Whether a credit currently holds a role — what fills the chip.+    public func creditHoldsRole(_ roleID: UUID, creatorID: UUID) -> Bool {+        draftCredits.first { $0.creator.id == creatorID }?.shownRoleIDs.contains(roleID) ?? false+    }++    /// Adds a credit for an existing creator (Req 3.2). A creator the draft+    /// already lists is not added twice — the picker marks it unselectable, and+    /// this is the same rule where a race gets past it.+    public func addCredit(for creator: CreatorDisplay) {+        guard !draftCredits.contains(where: { $0.creator.id == creator.id }) else { return }+        draftCredits.append(+            CreditDraftRow(+                creator: creator, hiddenRoleIDs: [], shownRoleIDs: [], unresolvedRoles: []))+    }++    /// Req 3.8: a credit whose creator is unresolved is removable like any+    /// other. Removal is a draft change; the row goes at the commit.+    public func removeCredit(for creatorID: UUID) {+        draftCredits.removeAll { $0.creator.id == creatorID }+    }++    /// Req 3.3's "New creator": the creator exists the moment it is confirmed,+    /// and stays even if the edit is then cancelled.+    ///+    /// A name an active creator already holds is **resolved to that creator**+    /// rather than refused (Decision 2, Q20): the picker offers this row only+    /// when nothing matched, so a duplicate here means the list moved under the+    /// reader, and crediting who they meant is the answer to that — not a+    /// refusal naming a row they were not shown.+    public func createCreator(named name: String) async {+        errorMessage = nil+        do {+            switch try await library.createCreator(name: name, notes: "") {+            case .added(let id):+                await onMutation()+                await loadCreatorOptions()+                addCredit(+                    for: creatorCandidates.first { $0.creator.id == id }?.creator+                        ?? CreatorDisplay(id: id, name: WorkTypeName.trimmed(name), notes: ""))+            case .rejected(.duplicateActive(let existing)):+                await loadCreatorOptions()+                let normalized = WorkTypeName.normalize(existing)+                if let match = creatorCandidates.first(where: {+                    WorkTypeName.normalize($0.creator.name ?? "") == normalized+                }) {+                    addCredit(for: match.creator)+                } else {+                    errorMessage = CreatorRejectionPresentation.sentence(+                        for: .duplicateActive(existing: existing))+                }+            case .rejected(let rejection):+                errorMessage = CreatorRejectionPresentation.sentence(for: rejection)+            }+        } catch {+            errorMessage = error.localizedDescription+            Self.logger.error(+                "Creator create failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Req 3.4's "New role": the role exists the moment it is confirmed, is+    /// switched on for the credit being edited, and stays even if the edit is+    /// then cancelled. A name a removed role holds restores that role, which is+    /// Req 2.2 reached from here.+    public func createRole(named name: String, forCreator creatorID: UUID) async {+        errorMessage = nil+        do {+            switch try await library.addCreatorRole(name: name) {+            case .added(let id), .restored(let id):+                await onMutation()+                await reloadRoleOptions()+                if !creditHoldsRole(id, creatorID: creatorID) {+                    toggleCreditRole(id, forCreator: creatorID)+                }+            case .rejected(let rejection):+                errorMessage = CreatorRoleRejectionPresentation.sentence(for: rejection)+            }+        } catch {+            errorMessage = error.localizedDescription+            Self.logger.error(+                "Creator role add failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// What `save` sends (Q52).+    ///+    /// `seenRowIDs` is every credit row the read loaded, which is what makes a+    /// removal last-writer-wins per credit rather than over the whole set. The+    /// added flags are **derived** from the read rather than tracked as the+    /// reader taps: switching a role off and on again leaves the credit exactly+    /// as the work already had it, and Q21 refuses a commit only for something+    /// the reader newly chose.+    private var creditsDraft: CreditsDraft {+        // The seeded baseline, never the live read: `seenRowIDs` is a statement+        // about what this editing session loaded, and a re-read from inside edit+        // mode must not enrol a row the reader never saw.+        let baseline = creditBaseline+        var shownByCreator: [UUID: Set<UUID>] = [:]+        for credit in baseline { shownByCreator[credit.creator.id] = Set(credit.roles.map(\.id)) }+        return CreditsDraft(+            seenRowIDs: baseline.flatMap(\.rowIDs),+            credits: draftCredits.map { row in+                let held = shownByCreator[row.creator.id]+                return CreditDraft(+                    creatorID: row.creator.id,+                    roleIDs: row.hiddenRoleIDs + row.shownRoleIDs.map(\.uuidString),+                    creatorAddedInDraft: held == nil,+                    roleIDsAddedInDraft: Set(+                        row.shownRoleIDs.subtracting(held ?? []).map(\.uuidString)))+            })+    }+     // MARK: - Related works (Reqs 8.1–8.4, Q24)      private func seedLinkTypeDrafts(_ links: [WorkLinkSnapshot]) {@@ -934,6 +1226,9 @@ public final class WorkDetailModel {             // Req 2.8: the membership is one of the work's authored fields, so             // it makes the checkmark appear like any other.             || hasUnsavedSeriesChange+            // `work-creators` Req 3.5: the credits commit in the same+            // transaction as the rest, so they raise the checkmark with them.+            || hasUnsavedCreditChange     }      // MARK: - View mode and edit mode (Decision 5)@@ -1066,6 +1361,11 @@ public final class WorkDetailModel {         // series the reader created from here is a row in the library and         // stays — `seriesOptions` is deliberately not restored.         restoreSeriesDraftFromSnapshot()+        // Req 3.2's cancel, and Reqs 3.3/3.4's exception to it: the credits go+        // back to what the read holds, while the creator and the role the reader+        // made from inside the editor are rows in the library and stay —+        // `roleOptions` and `creatorCandidates` are deliberately not restored.+        restoreCreditDraftFromPresentation()         // The session that could have auto-reverted is over.         autoRevertedReading = false         finishedReadingPrompt = nil@@ -1426,7 +1726,13 @@ public final class WorkDetailModel {                 // Req 2.3: the picker's selection and the position field, as one                 // value. A save that never touched either sends back what the                 // load put there, so the membership stays where it was.-                membership: draftMembership+                membership: draftMembership,+                // `work-creators` Req 3.5: the credits ride the same+                // transaction. Sent on every save, touched or not — a draft that+                // reproduces the read writes no credit row (the repository only+                // stamps a *changed* role set), and a `nil` here would mean "do+                // not touch the credits", which is a different statement.+                credits: creditsDraft             )             let basis = work.map(WorkEditBasis.init(work:))                 ?? WorkEditBasis(@@ -1482,6 +1788,26 @@ public final class WorkDetailModel {                         draftPositionText = ""                     }                 }+                // `work-creators` Req 3.5, on the `seriesMissing` treatment and+                // for its reason: the creator the reader newly credited is gone,+                // so the picker's rows are wrong and the draft names a creator+                // no row backs. Exactly that is refreshed and exactly that is+                // dropped — never a `load()`, which would take the title, the+                // tags, the verdict and the staged character edits with it.+                if case .creatorMissing(_, let missingCreatorID) = conflict {+                    await loadCreatorOptions()+                    removeCredit(for: missingCreatorID)+                }+                // The same, one level down: the role is gone, so the chips are+                // wrong and every credit that had switched it on loses it. The+                // credits themselves stay — a role is not what a credit is.+                if case .roleMissing(_, let missingRoleID) = conflict {+                    await reloadRoleOptions()+                    for index in draftCredits.indices {+                        draftCredits[index].shownRoleIDs.remove(missingRoleID)+                        draftCredits[index].unresolvedRoles.removeAll { $0.id == missingRoleID }+                    }+                }                 isSubmitting = false                 return             }

diff --git a/Asterism/Asterism/ViewModels/WorksListOptions.swift b/Asterism/Asterism/ViewModels/WorksListOptions.swiftindex 3c58590..abdd947 100644--- a/Asterism/Asterism/ViewModels/WorksListOptions.swift+++ b/Asterism/Asterism/ViewModels/WorksListOptions.swift@@ -192,6 +192,22 @@ nonisolated enum WorksSeriesSelection: Hashable, Sendable {     case series(UUID) } +/// Which creator a creator filter is asking about (`work-creators` Req 5.1).+///+/// `noCreators` rather than `none`, for `WorksSeriesSelection.noSeries`' reason+/// (Q51 of `series-and-related-works`): `.none` on an+/// `Optional<WorksCreatorSelection>` — which is what the filter stores and what+/// the picker binds — resolves to `Optional.none`, so the one value that means+/// "works nothing credits" would be unwritable wherever the type is inferred and+/// would silently read as "Any" wherever it compiled.+nonisolated enum WorksCreatorSelection: Hashable, Sendable {+    /// Req 5.1: a work with no credit, **and** a work whose every credit is+    /// unresolved — both read to the reader as a work no creator they can see is+    /// credited on.+    case noCreators+    case creator(UUID)+}+ /// The Works list's five single-value filters (Req 5, Q3; /// `work-and-reading-status` Req 6.1). ///@@ -210,25 +226,29 @@ nonisolated struct WorksFilter: Equatable, Sendable {     /// Req 4.2 of `series-and-related-works`. In menu order it sits after the     /// site, which is where the pills and the empty state name it too.     var series: WorksSeriesSelection?+    /// `work-creators` Req 5.1. In menu order it sits after the series, which is+    /// where the pills and the empty state name it too.+    var creator: WorksCreatorSelection?     var workStatus: WorkStatus?     var readingStatus: ReadingStatus?      init(         type: WorksTypeSelection? = nil, tag: String? = nil, hostname: String? = nil,-        series: WorksSeriesSelection? = nil,+        series: WorksSeriesSelection? = nil, creator: WorksCreatorSelection? = nil,         workStatus: WorkStatus? = nil, readingStatus: ReadingStatus? = nil     ) {         self.type = type         self.tag = tag         self.hostname = hostname         self.series = series+        self.creator = creator         self.workStatus = workStatus         self.readingStatus = readingStatus     }      var isActive: Bool {-        type != nil || tag != nil || hostname != nil || series != nil || workStatus != nil-            || readingStatus != nil+        type != nil || tag != nil || hostname != nil || series != nil || creator != nil+            || workStatus != nil || readingStatus != nil     }      func apply(to works: [WorkSnapshot]) -> [WorkSnapshot] {@@ -257,6 +277,14 @@ nonisolated struct WorksFilter: Equatable, Sendable {             !options.series.contains(where: { $0.id == seriesID }) {             pruned.series = nil         }+        // Req 5.1: a creator the snapshot no longer offers — deleted, or its+        // last credited work gone — reverts the dimension to "Any". "No+        // creators" is offered whether or not a work has none, so it is never+        // pruned, exactly as "No series" and the two statuses are not.+        if case .creator(let creatorID) = creator,+            !options.creators.contains(where: { $0.id == creatorID }) {+            pruned.creator = nil+        }         return pruned     } @@ -273,6 +301,7 @@ nonisolated struct WorksFilter: Equatable, Sendable {             return false         }         if let series, !Self.matches(series, work) { return false }+        if let creator, !Self.matches(creator, work) { return false }         // Compared against the *resolved* statuses, so a stored spelling this         // build does not know is filtered as the default it reads as         // (Reqs 1.3, 2.7).@@ -298,6 +327,26 @@ nonisolated struct WorksFilter: Equatable, Sendable {         case .series(let seriesID): return resolved == seriesID         }     }++    /// The creator question, asked of the **resolved** credits only+    /// (`work-creators` Req 5.1).+    ///+    /// A credit whose creator row has not arrived names nobody this device can+    /// show, so it counts for no creator and a work holding only such credits+    /// answers "No creators" — the series rule, for its reason. `credits` is+    /// already folded one per canonical creator (Q53), so an alias and its+    /// survivor are one candidate here rather than two.+    ///+    /// `M4CreatorScalePerformanceTests`' `credits-resolve-and-filter` arm times+    /// this shape (Q72 closed at task 26).+    private static func matches(_ selection: WorksCreatorSelection, _ work: WorkSnapshot) -> Bool {+        switch selection {+        case .noCreators:+            return !work.credits.contains { $0.creator.isResolved }+        case .creator(let creatorID):+            return work.credits.contains { $0.creator.isResolved && $0.creator.id == creatorID }+        }+    } }  /// The values the three filter pickers offer, derived from the **full** works@@ -340,6 +389,12 @@ nonisolated struct WorksFilterOptions: Equatable, Sendable {     /// instead. Carried as the display so the menu row, the pill and the section     /// header all spell a same-name pair the same way (Req 1.3).     let series: [SeriesDisplay]+    /// `work-creators` Req 5.1: every active creator with at least one visible+    /// credited work in the full snapshot, in `CreatorOrdering`. **Resolved**+    /// creators only — a credit whose row has not arrived has no name to offer+    /// and answers "No creators" instead. Carried as the display so the menu row+    /// and the pill spell the creator the same way.+    let creators: [CreatorDisplay]      /// What to call a type selection — the option's own spelling where the     /// snapshot still offers it, so a pill and the menu row that set it read the@@ -372,15 +427,38 @@ nonisolated struct WorksFilterOptions: Equatable, Sendable {         }     } -    static let empty = WorksFilterOptions(types: [], tags: [], hostnames: [], series: [])+    /// What the reader sees for a work no creator they can see is credited on —+    /// one row, because "no credit at all" and "every credit unresolved" are the+    /// same answer here (Req 5.1).+    static let noCreatorsLabel = "No creators"++    /// What to call a creator selection: the option's own name where the+    /// snapshot still offers it, so a pill and the menu row that set it read the+    /// same. A creator whose last credited work left the library between the+    /// pick and the redraw falls back to the placeholder the rest of the app+    /// shows for a creator it cannot name.+    func label(for selection: WorksCreatorSelection) -> String {+        switch selection {+        case .noCreators:+            return Self.noCreatorsLabel+        case .creator(let creatorID):+            return creators.first { $0.id == creatorID }?.label+                ?? CreatorDisplay.unresolvedLabel+        }+    }++    static let empty = WorksFilterOptions(+        types: [], tags: [], hostnames: [], series: [], creators: [])      private init(-        types: [TypeOption], tags: [String], hostnames: [String], series: [SeriesDisplay]+        types: [TypeOption], tags: [String], hostnames: [String], series: [SeriesDisplay],+        creators: [CreatorDisplay]     ) {         self.types = types         self.tags = tags         self.hostnames = hostnames         self.series = series+        self.creators = creators     }      /// The vocabularies one snapshot offers, ordered as the menu shows them.@@ -397,6 +475,10 @@ nonisolated struct WorksFilterOptions: Equatable, Sendable {         // Keyed by id, so two works in one series contribute one option and two         // rows of one series contribute the display the directory already folded.         var seriesDisplays: [UUID: SeriesDisplay] = [:]+        // Keyed by canonical creator id, so two works crediting one creator+        // contribute one option and an alias and its survivor are already one+        // (the read folds them, Q53).+        var creatorDisplays: [UUID: CreatorDisplay] = [:]          for work in works {             let selection = WorksTypeSelection.selection(for: work.typeDisplay)@@ -414,9 +496,13 @@ nonisolated struct WorksFilterOptions: Equatable, Sendable {             if work.membership != nil, let display = work.series, display.isResolved {                 seriesDisplays[display.id] = display             }+            for credit in work.credits where credit.creator.isResolved {+                creatorDisplays[credit.creator.id] = credit.creator+            }         }          self.series = seriesDisplays.values.sorted(by: SeriesOrdering.precedes)+        self.creators = creatorDisplays.values.sorted(by: CreatorOrdering.precedes)          self.types = typeRecords             .map { selection, record in@@ -481,6 +567,9 @@ nonisolated enum WorksFilterPresentation {         // Named by the option it came from, for the type's reason: the pill is         // the reader reading back the row they picked, qualifier and all.         if let series = filter.series { labels.append(options.label(for: series)) }+        // After the series, which is where the picker sits and where the empty+        // state names it.+        if let creator = filter.creator { labels.append(options.label(for: creator)) }         if let workStatus = filter.workStatus {             labels.append(WorkStatusPresentation.accessibilityLabel(workStatus))         }@@ -550,6 +639,22 @@ nonisolated enum WorksFilterPresentation {      static let seriesListButtonIdentifier = "works-series-list-button" +    // MARK: - The creator dimension (`work-creators` Reqs 1.6, 5.1)++    static let anyCreatorRowIdentifier = "works-filter-creator-any"+    static let noCreatorsRowIdentifier = "works-filter-creator-none"++    /// Keyed by the creator's identifier rather than its name: the identifier is+    /// what the filter itself stores, and it survives a re-spelling.+    static func creatorRowIdentifier(_ selection: WorksCreatorSelection) -> String {+        switch selection {+        case .noCreators: noCreatorsRowIdentifier+        case .creator(let creatorID): "works-filter-creator-\(creatorID.uuidString)"+        }+    }++    static let creatorsListButtonIdentifier = "works-creators-list-button"+     // MARK: - The two status dimensions (`work-and-reading-status` Req 6.1)      static let anyWorkStatusRowIdentifier = "works-filter-work-status-any"

diff --git a/Asterism/Asterism/Views/CharacterEditorView.swift b/Asterism/Asterism/Views/CharacterEditorView.swiftnew file mode 100644index 0000000..a0df88d--- /dev/null+++ b/Asterism/Asterism/Views/CharacterEditorView.swift@@ -0,0 +1,268 @@+import AsterismCore+import ConstellationKit+import SwiftUI++/// One character's editor (`character-extraction` Req 5.3), opened by tapping+/// its line in the Characters card — or by "Add a character", which mints a+/// draft and opens it for naming.+///+/// Everything the inline editor card drew, unchanged in what it writes: the+/// name and note fields, the aliases, the facts, the torn notice, and the two+/// structural actions. The card is gone from the page because a cast of ten+/// pills with one open editor under them was the section that could not fit.+///+/// The edit session's draft state stays the model's (`characterDraft(for:)`,+/// `updateCharacterDraft`), so nothing here is written until the work's own+/// checkmark commits — the torn read-only gate and the conflict handling are+/// the model's as before.+struct CharacterEditorView: View {+    let model: WorkDetailModel+    let characterID: UUID+    /// Where the reader is taken when a combine finishes: the target's editor,+    /// because the source's name just left the cast and the reader has to see+    /// where everything went.+    let onCombined: (UUID) -> Void++    @Environment(\.dismiss) private var dismiss+    /// Whether the combine picker is up. Owned here rather than by the screen+    /// behind the sheet: a dialog raised back there would be covered by this.+    @State private var isCombining = false++    /// The stored character this draft belongs to, or nil for one created in+    /// this session — which has no stored row yet and so cannot be torn.+    private var character: WorkCharacterPresentation? {+        model.characters.first { $0.id == characterID }+    }++    private var draft: CharacterDraft? { model.characterDraft(for: characterID) }++    /// The per-character read-only gate, which is not the work's: a torn+    /// character is off limits while the rest of the cast is editable.+    private var editable: Bool {+        character.map { model.canEditCharacter(id: $0.id) } ?? !model.isReadOnly+    }++    var body: some View {+        let draft = self.draft+        return ConstellationEditorSheet(+            title: title(draft),+            identifier: "character-editor",+            doneIdentifier: "character-editor-done"+        ) {+            if let draft {+                Section {+                    TextField("Name", text: characterBinding(\.name))+                        .disabled(!editable)+                        .frame(minHeight: AsterismLayout.minHitTarget)+                        .accessibilityIdentifier("work-detail-character-name-field")+                    TextField("Note", text: characterBinding(\.note), axis: .vertical)+                        .disabled(!editable)+                        .lineLimit(1...4)+                        .accessibilityIdentifier("work-detail-character-note-field")+                } footer: {+                    if character?.isTorn == true {+                        Text(+                            "This character exists in differing copies — editing is off until "+                                + "you choose which one to keep.")+                            .foregroundStyle(AsterismColors.amberText)+                            .accessibilityIdentifier("work-detail-character-torn-notice")+                    }+                }++                Section {+                    // The draft has always carried the aliases (combine unions+                    // them, acceptance installs them); the editor just never+                    // showed them until Req 5.3.+                    CharacterAliasEditor(+                        aliases: draft.aliases,+                        editable: editable,+                        onRemove: { alias in+                            model.updateCharacterDraft(id: characterID) { draft in+                                draft.aliases.removeAll { $0 == alias }+                            }+                        },+                        onAdd: { alias in+                            model.updateCharacterDraft(id: characterID) { draft in+                                guard !draft.aliases.contains(alias) else { return }+                                draft.aliases.append(alias)+                            }+                        })+                        .constellationListRow()+                } header: {+                    ConstellationSectionHeader("Aliases", accent: .violet)+                }++                if !draft.facts.isEmpty {+                    Section {+                        ForEach(draft.facts, id: \.identity) { fact in+                            factRow(fact)+                        }+                    } header: {+                        ConstellationSectionHeader("Facts", accent: .violet)+                    }+                }++                Section {+                    structuralActions+                        .constellationListRow()+                }+            }+        }+        // Q49's picker, in the sheet that raises it. `presenting:` is not+        // needed here — the source is the sheet's own subject and cannot change+        // under the dialog.+        .confirmationDialog(+            "Combine into", isPresented: $isCombining, titleVisibility: .visible+        ) {+            ForEach(model.combineTargets(for: characterID)) { target in+                Button(target.name) {+                    model.combineCharacter(source: characterID, into: target.id)+                    isCombining = false+                    onCombined(target.id)+                }+                // The cast lines carry the same character names as labels, so+                // the dialog's choices need their own identity to stay+                // addressable (the dialogButton precedent).+                .accessibilityIdentifier("work-detail-combine-target")+            }+            Button("Cancel", role: .cancel) { isCombining = false }+        } message: {+            Text("Their facts and names move across. Nothing is written until you tap the checkmark.")+        }+    }++    /// What the sheet is called. A draft with no name yet is the one the "Add a+    /// character" button just minted, and it is named by typing into the field+    /// below the title.+    private func title(_ draft: CharacterDraft?) -> String {+        guard let draft, !draft.name.isEmpty else { return "New character" }+        return draft.name+    }++    /// One fact, with the way to drop it. The statement is the reader's own+    /// sentence, so it wraps rather than truncates.+    private func factRow(_ fact: CharacterFact) -> some View {+        HStack(alignment: .top, spacing: 8) {+            Text(fact.statement)+                .font(.footnote)+                .foregroundStyle(AsterismColors.noteText)+                .fixedSize(horizontal: false, vertical: true)+                .frame(maxWidth: .infinity, alignment: .leading)+            Button {+                model.deleteFact(fact.identity, from: characterID)+            } label: {+                Image(systemName: "minus.circle")+                    .foregroundStyle(AsterismColors.secondaryText)+                    .frame(+                        minWidth: AsterismLayout.minHitTarget,+                        minHeight: AsterismLayout.minHitTarget)+                    .contentShape(Rectangle())+            }+            .buttonStyle(.plain)+            .disabled(!editable)+            .accessibilityIdentifier("work-detail-character-fact-delete")+            .accessibilityLabel("Delete the fact \(fact.statement)")+        }+    }++    /// Combine and Delete, side by side on the shared bordered recipe: the one+    /// that keeps everything in violet, the one that ends the record in+    /// `secondaryText` with a trash glyph. Neither is system red — §11 gives the+    /// palette no error hue.+    @ViewBuilder+    private var structuralActions: some View {+        HStack(spacing: 8) {+            if !model.combineTargets(for: characterID).isEmpty {+                ConstellationFooterButton(title: "Combine into…", systemImage: nil) {+                    isCombining = true+                }+                .disabled(!editable)+                .accessibilityIdentifier("work-detail-character-combine")+            }+            ConstellationFooterButton(+                title: "Delete character", systemImage: "trash",+                tint: AsterismColors.secondaryText+            ) {+                model.deleteCharacter(id: characterID)+                dismiss()+            }+            .disabled(!editable)+            .accessibilityIdentifier("work-detail-character-delete")+        }+    }++    private func characterBinding(+        _ keyPath: WritableKeyPath<CharacterDraft, String>+    ) -> Binding<String> {+        Binding(+            get: { model.characterDraft(for: characterID)?[keyPath: keyPath] ?? "" },+            set: { value in+                model.updateCharacterDraft(id: characterID) { $0[keyPath: keyPath] = value }+            })+    }+}++/// Aliases in the character editor: each a removable chip, plus a field to add+/// one. Its own view because the add field needs state of its own.+struct CharacterAliasEditor: View {+    let aliases: [String]+    let editable: Bool+    let onRemove: (String) -> Void+    let onAdd: (String) -> Void+    @State private var newAlias = ""++    private var trimmed: String { newAlias.trimmingCharacters(in: .whitespacesAndNewlines) }++    var body: some View {+        VStack(alignment: .leading, spacing: 6) {+            if !aliases.isEmpty {+                FlowLayout(spacing: 6) {+                    ForEach(aliases, id: \.self) { alias in+                        Button { onRemove(alias) } label: {+                            HStack(spacing: 4) {+                                Text(alias)+                                Image(systemName: "xmark")+                                    .font(.caption2)+                            }+                            // The cyan the view card's "Also" line wears —+                            // aliases are match keys, and cyan is their colour.+                            .constellationPill(.count)+                        }+                        .buttonStyle(.plain)+                        .disabled(!editable)+                        .accessibilityIdentifier("work-detail-character-alias")+                        .accessibilityLabel("Remove alias \(alias)")+                    }+                }+            }+            HStack(spacing: 8) {+                TextField("Add an alias", text: $newAlias)+                    .accessibilityIdentifier("work-detail-character-alias-field")+                    .onSubmit(add)+                // The "+" glyph the series row's "New series" wears, for the+                // same reason: a worded button beside a field is a second+                // sentence where a glyph says it.+                Button(action: add) {+                    Image(systemName: "plus")+                        .foregroundStyle(AsterismColors.violet)+                        .frame(+                            minWidth: AsterismLayout.minHitTarget,+                            minHeight: AsterismLayout.minHitTarget)+                        .contentShape(Rectangle())+                }+                .buttonStyle(.plain)+                .disabled(trimmed.isEmpty)+                .accessibilityIdentifier("work-detail-character-alias-add")+                .accessibilityLabel("Add this alias")+            }+            .disabled(!editable)+        }+        .frame(maxWidth: .infinity, alignment: .leading)+    }++    private func add() {+        guard !trimmed.isEmpty else { return }+        onAdd(trimmed)+        newAlias = ""+    }+}

diff --git a/Asterism/Asterism/Views/CreatorDetailView.swift b/Asterism/Asterism/Views/CreatorDetailView.swiftnew file mode 100644index 0000000..ce538ff--- /dev/null+++ b/Asterism/Asterism/Views/CreatorDetailView.swift@@ -0,0 +1,384 @@+import AsterismCore+import ConstellationKit+import SwiftUI++/// One creator's screen (Reqs 4.1–4.5): the name, the notes, and every work in+/// the library crediting it.+///+/// `SeriesDetailView` minus add-member, reposition and remove: a credit is edited+/// on the *work* (Non-Goal 1), so this screen's editor owns two fields and the+/// deletion and nothing else. The two modes are the work detail's, for its+/// reason: view mode is a screen you read and navigate from — every work row+/// opens its work — and the pencil turns it into the editor.+struct CreatorDetailView: View {+    @State private var model: CreatorDetailModel+    /// `AppLibraryModel.snapshotGeneration`: a credit, a work or a rename+    /// arriving through sync bumps it, and the screen re-reads on the bump, which+    /// is what heals an unresolved credit without a relaunch (Req 10.2).+    let snapshotGeneration: Int+    let showsSky: Bool+    let onSelectWork: (UUID) -> Void+    /// Where the screen goes once its creator is gone. The route is the host's+    /// (Decision 7 of `series-and-related-works`), so leaving is too.+    let onDeleted: () -> Void++    /// Bumped by a save that ended in a refusal, so the screen scrolls to it+    /// even when it is the same refusal, in the same place, as the last one+    /// (Q70 of `series-and-related-works`).+    @State private var refusalScrollRequests = 0++    /// Where `scrollToRefusal` goes for a refusal with no field. The message is+    /// the last section of the list, so with a few credited works it is+    /// off-screen at the moment it is said.+    private static let messageAnchor = "creator-detail-message-anchor"+    /// The name field's card, which is where every *rejection* is said (Q72 of+    /// `series-and-related-works`).+    private static let nameAnchor = "creator-detail-name-anchor"++    init(+        model: CreatorDetailModel,+        snapshotGeneration: Int,+        showsSky: Bool,+        onSelectWork: @escaping (UUID) -> Void,+        onDeleted: @escaping () -> Void+    ) {+        _model = State(initialValue: model)+        self.snapshotGeneration = snapshotGeneration+        self.showsSky = showsSky+        self.onSelectWork = onSelectWork+        self.onDeleted = onDeleted+    }++    var body: some View {+        // The reader has to end up looking at the refusal. Wrapping the whole+        // list means the wide layouts get it too — this list *is* the Mac and+        // iPad detail column.+        ScrollViewReader { proxy in+            content+                // A refusal appearing, or moving between the name field and the+                // message section.+                .onChange(of: model.refusalTarget) { _, target in+                    if target != nil { scrollToRefusal(proxy) }+                }+                // A second field-less refusal with a different sentence leaves+                // the target where it was, so it needs its own trigger.+                .onChange(of: model.message) { _, message in+                    if message != nil { scrollToRefusal(proxy) }+                }+                // The same refusal twice in a row publishes the same values, so+                // neither change above fires a second time; a save that ends in+                // a refusal asks for the scroll itself.+                .onChange(of: refusalScrollRequests) { _, _ in scrollToRefusal(proxy) }+        }+    }++    /// Brings the refusal into view, wherever it is said (Q75 of+    /// `series-and-related-works`).+    ///+    /// One scroll with a target the model chooses (`refusalTarget`), not one+    /// mechanism per place. The hop through a `Task` lets the row the sentence+    /// lives in exist before it is scrolled to; it is inserted by the same+    /// update that publishes the refusal.+    private func scrollToRefusal(_ proxy: ScrollViewProxy) {+        guard let target = model.refusalTarget else { return }+        Task { @MainActor in+            withAnimation(.snappy) {+                switch target {+                case .name: proxy.scrollTo(Self.nameAnchor, anchor: .center)+                case .message: proxy.scrollTo(Self.messageAnchor, anchor: .center)+                }+            }+        }+    }++    /// The refusal said under the name field, where there is one. Placement is+    /// the view's; the wording and the target are the model's.+    private var nameRefusal: String? {+        model.refusalTarget == .name ? model.message : nil+    }++    private var content: some View {+        List {+            switch model.state {+            case .loading:+                ProgressView("Loading…")+                    .accessibilityIdentifier("creator-detail-loading")+            case .missing:+                // A creator deleted on another device while the reader stood+                // here. A tolerated state, not an error to shout about+                // (Req 10.2).+                Text("This creator is no longer in your library.")+                    .font(.callout)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("creator-detail-missing")+            case .error(let message):+                Text(message)+                    .font(.callout)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("creator-detail-error")+            case .ready:+                headerSection+                worksSection+                if model.isEditing { manageSection }+            }++            // Only a refusal with no field to sit under (Q72 of+            // `series-and-related-works`): a rejected name is said on the name+            // field's own card, and what is left here is a write the repository+            // would not take — a failed save, a failed deletion.+            if model.refusalTarget == .message, let message = model.message {+                Section {+                    // Q37 of `work-detail`: a refusal is amber, not system red —+                    // the palette has no error colour.+                    Text(message)+                        .foregroundStyle(AsterismColors.amberText)+                        .frame(maxWidth: .infinity, alignment: .leading)+                        .padding(12)+                        .constellationCard(borderColor: AsterismColors.attentionBorder)+                        .constellationListRow()+                        .accessibilityIdentifier("creator-detail-message")+                        .id(Self.messageAnchor)+                }+            }+        }+        .scrollContentBackground(.hidden)+        .macListChrome()+        .navigationTitle(model.title)+        .inlineNavigationTitle()+        // Edit mode has exactly one way out per direction, and the navigation+        // bar's back chevron is not one of them — it would leave the screen from+        // a mode whose X means "leave the mode".+        //+        // **This holds on iPhone only** (Q78). In the wide tree the way back is+        // `WideRootView`'s `ColumnBackButton`, drawn in the column rather than+        // in the navigation bar, and this modifier does not reach it: a Back tap+        // there pops the route and discards the draft with no confirmation. The+        // series screen has the same shape and the same gap; it is accepted+        // rather than papered over on one screen.+        .hidesBackButton(model.isEditing)+        .screenSky(showsSky)+        .accessibilityIdentifier("creator-detail")+        .toolbar { toolbarItems }+        .task(id: snapshotGeneration) { await model.reload(for: snapshotGeneration) }+        // The creator is gone; so is this screen, and the route under it is what+        // the reader came from.+        .onChange(of: model.didFinish) { _, finished in+            if finished { onDeleted() }+        }+        .confirmationDialog(+            "Delete this creator?",+            isPresented: Binding(+                get: { model.deletionPrompt != nil },+                set: { if !$0 { model.cancelDeletion() } }),+            presenting: model.deletionPrompt+        ) { prompt in+            // The prompt is taken as a parameter, not re-read from the model:+            // SwiftUI runs the dismissal below before this action (see+            // `CreatorDetailModel.DeletionPrompt`).+            Button("Delete", role: .destructive) {+                Task { await model.confirmDeletion(prompt) }+            }+            .accessibilityIdentifier("creator-detail-delete-confirm")+            Button("Cancel", role: .cancel) { model.cancelDeletion() }+                .accessibilityIdentifier("creator-detail-delete-cancel")+        } message: { prompt in+            Text(prompt.message)+        }+    }++    // MARK: - Header (Reqs 1.1, 1.2, 4.1)++    @ViewBuilder+    private var headerSection: some View {+        Section {+            if model.isEditing {+                // The refusal sits **inside this card, under the field**, rather+                // than in the screen's bottom message row: every rejection this+                // screen raises — an empty name, a line break, a name already in+                // the list — is about the name, and a reader who has just been+                // refused one is looking at it (Q72 of+                // `series-and-related-works`). The row grows below the field, so+                // the field does not move under the reader's finger.+                VStack(alignment: .leading, spacing: 8) {+                    TextField("Name", text: $model.draftName)+                        .autocorrectionDisabled()+                        .noAutocapitalization()+                        // Q71: the field a refusal is about wears the amber+                        // attention border while that refusal stands, so the+                        // sentence is never the only mark on the screen.+                        .constellationAttentionField(nameRefusal != nil)+                        // The state joins the label rather than the value: a+                        // field's value is the text the reader typed, and §11+                        // does not let the border carry the state on its own.+                        .accessibilityLabel(+                            nameRefusal == nil ? "Creator name" : "Creator name, not accepted")+                        .accessibilityIdentifier("creator-detail-name-field")++                    if let nameRefusal {+                        Text(nameRefusal)+                            // Q37: amber, as every refusal on these screens is.+                            .font(.footnote)+                            .foregroundStyle(AsterismColors.amberText)+                            .fixedSize(horizontal: false, vertical: true)+                            .frame(maxWidth: .infinity, alignment: .leading)+                            .accessibilityIdentifier("creator-detail-message")+                    }+                }+                // `.snappy` is the curve these screens already use for+                // everything that opens.+                .animation(.snappy, value: nameRefusal)+                .constellationCaptionedCard("Name")+                .id(Self.nameAnchor)+                TextField("Notes", text: $model.draftNotes, axis: .vertical)+                    .lineLimit(3...6)+                    .accessibilityLabel("Creator notes")+                    .accessibilityIdentifier("creator-detail-notes-field")+                    .constellationCaptionedCard("Notes")+            } else {+                VStack(alignment: .leading, spacing: 12) {+                    // No `lineLimit`: this is the one place the whole name is+                    // readable.+                    Text(model.title)+                        .font(AsterismTypography.serifHeading)+                        .foregroundStyle(AsterismColors.primaryText)+                        .fixedSize(horizontal: false, vertical: true)+                        .frame(maxWidth: .infinity, alignment: .leading)+                        .accessibilityIdentifier("creator-detail-title")++                    // Absent when there are none — an empty field on a read+                    // screen invites an edit the screen is not offering.+                    if !model.notes.isEmpty {+                        Text(model.notes)+                            .font(.subheadline)+                            .foregroundStyle(AsterismColors.noteText)+                            .lineSpacing(4)+                            .fixedSize(horizontal: false, vertical: true)+                            .frame(maxWidth: .infinity, alignment: .leading)+                            .accessibilityIdentifier("creator-detail-notes")+                    }+                }+                .padding(12)+                .constellationCard()+                .constellationListRow()+            }+        }+    }++    // MARK: - Works (Reqs 4.1–4.4)++    @ViewBuilder+    private var worksSection: some View {+        Section {+            if model.works.isEmpty {+                Text(model.emptyWorksMessage)+                    .font(.callout)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("creator-detail-empty-works")+            } else {+                ForEach(model.works) { row in+                    workRow(row)+                }+            }+        } header: {+            ConstellationSectionHeader("Works", accent: .violet)+        }+    }++    /// A credited work as the library list draws it — the type pill and the two+    /// status glyphs are `WorkRow`'s, not a second drawing of them — with this+    /// creator's roles on the secondary line beneath (Req 4.2).+    private func workRow(_ row: CreatorDetailModel.CreditedWork) -> some View {+        Button {+            onSelectWork(row.id)+        } label: {+            HStack(alignment: .top, spacing: 10) {+                VStack(alignment: .leading, spacing: 4) {+                    WorkRow(work: row.work)+                    if !row.roleText.isEmpty {+                        Text(row.roleText)+                            .font(.caption)+                            .foregroundStyle(AsterismColors.secondaryText)+                            // Two lines, not one: at the accessibility text+                            // sizes a creator with three roles loses all but the+                            // first to the truncation, and Req 12.2 asks for the+                            // screen to stay readable there.+                            .lineLimit(2)+                            .truncationMode(.tail)+                            // Its own label, spoken after the row's composed one+                            // (Req 12.1) — the interpunct the line draws is not+                            // a separator speech has a word for.+                            .accessibilityLabel(row.rolesAccessibilityLabel)+                    }+                }+                if row.isCurrent {+                    // Req 4.3: the work this screen was opened from, marked the+                    // way the series screen marks it.+                    Image(systemName: "checkmark.circle")+                        .foregroundStyle(AsterismColors.secondaryText)+                        .accessibilityIdentifier("creator-work-current")+                        .accessibilityLabel("Current work")+                }+            }+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+        // Identifier only, no label: `SeriesDetailView.memberRow`'s shape, and+        // for the reason it does not carry one either — a label here replaces+        // everything `WorkRow` composes (the type pill, the two status glyphs,+        // the site labels) with one sentence. The role line carries its own.+        .accessibilityIdentifier("creator-work-\(row.id.uuidString)")+    }++    // MARK: - Deleting the creator (Reqs 1.4, 4.5)++    private var manageSection: some View {+        Section {+            // Not a gradient control: the deletion takes a thing the reader+            // named away, and they should have to mean it.+            Button("Delete creator") { model.requestDeletion() }+                .buttonStyle(.constellationSecondary)+                .disabled(model.isSubmitting)+                .accessibilityIdentifier("creator-detail-delete-button")+        }+    }++    // MARK: - Toolbar++    /// View mode offers the way into the editor; edit mode offers the two ways+    /// out of it — the series screen's shape, and its glyphs.+    @ToolbarContentBuilder+    private var toolbarItems: some ToolbarContent {+        if model.isEditing {+            ToolbarItem(placement: .cancellationAction) {+                Button(role: .close) { model.cancelEditing() }+                    .disabled(model.isSubmitting)+                    .accessibilityIdentifier("creator-detail-cancel-button")+                    .accessibilityLabel("Cancel")+            }+            ToolbarItem(placement: .confirmationAction) {+                Button(role: .confirm) {+                    Task {+                        await model.save()+                        if model.refusalTarget != nil { refusalScrollRequests += 1 }+                    }+                }+                .disabled(model.isSubmitting)+                .accessibilityIdentifier("creator-detail-save-button")+                .accessibilityLabel("Save")+            }+        } else if model.state == .ready {+            ToolbarItem(placement: .trailingBar) {+                Button {+                    model.beginEditing()+                } label: {+                    Image(systemName: "pencil")+                        .frame(+                            minWidth: AsterismLayout.minHitTarget,+                            minHeight: AsterismLayout.minHitTarget)+                }+                .accessibilityIdentifier("creator-detail-edit-button")+                .accessibilityLabel("Edit this creator")+            }+        }+    }+}

diff --git a/Asterism/Asterism/Views/CreatorListView.swift b/Asterism/Asterism/Views/CreatorListView.swiftnew file mode 100644index 0000000..ab1c5e2--- /dev/null+++ b/Asterism/Asterism/Views/CreatorListView.swift@@ -0,0 +1,140 @@+import AsterismCore+import ConstellationKit+import SwiftUI++/// The creators list (Req 1.6): every active creator with its work count, and+/// the field that creates one.+///+/// `SeriesListView`'s shape, and its one difference that matters: a row does not+/// push a `NavigationLink` of its own. The creator screen is a route on the Works+/// stack (Decision 7 of `series-and-related-works`), so the row asks the host to+/// append it — which is what makes list → creator → back return to this list in+/// both layouts.+struct CreatorListView: View {+    @State private var model: CreatorListModel+    /// `AppLibraryModel.snapshotGeneration`. A creator or a credit arriving+    /// through sync bumps it, and this screen re-reads on the bump (Req 10.2).+    let snapshotGeneration: Int+    let showsSky: Bool+    let onSelectCreator: (UUID) -> Void++    init(+        model: CreatorListModel,+        snapshotGeneration: Int,+        showsSky: Bool,+        onSelectCreator: @escaping (UUID) -> Void+    ) {+        _model = State(initialValue: model)+        self.snapshotGeneration = snapshotGeneration+        self.showsSky = showsSky+        self.onSelectCreator = onSelectCreator+    }++    var body: some View {+        List {+            addSection+            listSection+        }+        // Req 8.1 of `ipad-and-mac-layouts`: the Works tab's sky shows through+        // the pushed screen, and the Mac's alternating rows would stripe it.+        .scrollContentBackground(.hidden)+        .macListChrome()+        .navigationTitle("Creators")+        .inlineNavigationTitle()+        .screenSky(showsSky)+        .accessibilityIdentifier("creator-list")+        .task(id: snapshotGeneration) { await model.reload(for: snapshotGeneration) }+    }++    // MARK: - Adding (Req 1.1)++    /// The series list's shape: a field and the button that commits it, on one+    /// row, so the two are read as the single action they are.+    @ViewBuilder+    private var addSection: some View {+        Section {+            HStack {+                // A creator name is data, not prose: the keyboard must not+                // capitalise or correct a name the reader chose deliberately.+                TextField("New creator name", text: $model.draftName)+                    .autocorrectionDisabled()+                    .noAutocapitalization()+                    .accessibilityIdentifier("creator-list-add-field")+                Button {+                    Task { await model.add() }+                } label: {+                    Text("Add")+                        .frame(+                            minWidth: AsterismLayout.minHitTarget,+                            minHeight: AsterismLayout.minHitTarget+                        )+                        .contentShape(Rectangle())+                }+                .disabled(!model.canAdd)+                .accessibilityIdentifier("creator-list-add-button")+            }+            .frame(minHeight: AsterismLayout.minHitTarget)++            // Req 1.1's refusal, in the one line the screen says back. Worded by+            // the model.+            if let message = model.message {+                Text(message)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("creator-list-message")+            }+        }+    }++    // MARK: - The list (Req 1.6)++    @ViewBuilder+    private var listSection: some View {+        switch model.state {+        case .loading:+            ProgressView("Loading…")+                .accessibilityIdentifier("creator-list-loading")+        case .error(let message):+            Text(message)+                .font(.callout)+                .foregroundStyle(.secondary)+                .accessibilityIdentifier("creator-list-error")+        case .ready:+            if model.rows.isEmpty {+                Text(model.emptyMessage)+                    .font(.callout)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("creator-list-empty")+            } else {+                ForEach(model.rows) { row in+                    creatorRow(row)+                }+            }+        }+    }++    private func creatorRow(_ row: CreatorListModel.Row) -> some View {+        Button {+            onSelectCreator(row.id)+        } label: {+            HStack(spacing: 10) {+                Text(row.name)+                    .font(AsterismTypography.serifRowTitle)+                    .foregroundStyle(AsterismColors.primaryText)+                    .lineLimit(1)+                    .truncationMode(.tail)+                Spacer()+                // §7's count pill, as the series rows and the work rows wear it.+                Text("\(row.workCount)")+                    .constellationPill(.count)+            }+            .frame(minHeight: AsterismLayout.minHitTarget)+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+        .accessibilityIdentifier("creator-row-\(row.id.uuidString)")+        // The count is a pill beside the name, so the sentence is where a reader+        // who cannot see it hears the number (Req 12.1).+        .accessibilityLabel("\(row.name), \(row.countLabel)")+    }+}

diff --git a/Asterism/Asterism/Views/CreatorPickerView.swift b/Asterism/Asterism/Views/CreatorPickerView.swiftnew file mode 100644index 0000000..91ef08e--- /dev/null+++ b/Asterism/Asterism/Views/CreatorPickerView.swift@@ -0,0 +1,167 @@+import AsterismCore+import ConstellationKit+import SwiftUI++/// The name search behind "Add a creator" (`work-creators` Reqs 3.2, 3.3).+///+/// `WorkPickerView`'s shape, with its contract: every active creator is listed,+/// including the ones that cannot be chosen, so a reader searching for someone+/// they know is there is told why they are not offered rather than left+/// wondering whether they mistyped (Q20).+///+/// Its one addition is the "New creator" row, offered only where the typed name+/// matches no active creator's normalized name — which is the question+/// `createCreator` would answer at the write, asked before it (Req 3.3).+struct CreatorPickerView: View {+    let candidates: [CreatorPickerCandidate]+    /// Whether the rows are still being read. The sheet is presented before the+    /// read returns, so without this the empty sentence would be shown over a+    /// library that has creators in it.+    let isLoading: Bool+    let onSelect: (CreatorDisplay) -> Void+    /// Creates the typed creator and credits it. The creator exists the moment+    /// this runs and stays even if the edit is then cancelled (Req 3.3).+    let onCreate: (String) -> Void++    @Environment(\.dismiss) private var dismiss+    @State private var query = ""++    private var filter: CreatorSearchFilter { CreatorSearchFilter(query: query) }++    /// Bound once at the top of `body` rather than read where it is needed:+    /// the body asks twice — once for the empty state and once for the rows.+    private var matches: [CreatorPickerCandidate] { filter.apply(to: candidates) }++    var body: some View {+        let matches = self.matches+        // Asked against **every** candidate, not the filtered rows: an+        // already-credited creator is still a creator whose name is taken.+        let offersNew = filter.offersNewCreator(among: candidates)+        return NavigationStack {+            List {+                // A plain field rather than `.searchable` (Q52 of+                // `series-and-related-works`): this is a sheet over a screen that+                // may own a search field of its own, and the journeys have to+                // address *this* one by identifier.+                Section {+                    HStack(spacing: 8) {+                        Image(systemName: "magnifyingglass")+                            .foregroundStyle(AsterismColors.secondaryText)+                        // A creator name is data, not prose. The prompt says+                        // both things the field does: Req 3.3 offers "New+                        // creator" only once something is typed, so a prompt+                        // that said only "Search" left the way in invisible+                        // over an empty library (Q95).+                        TextField("Search or type a new name", text: $query)+                            .autocorrectionDisabled()+                            .noAutocapitalization()+                            .accessibilityIdentifier("creator-picker-search")+                    }+                    .frame(minHeight: AsterismLayout.minHitTarget)+                }++                if offersNew {+                    Section {+                        newCreatorRow+                    }+                }++                if isLoading {+                    // Said instead of the empty sentence, never beside it: "no+                    // creators" is a claim about the library, and until the read+                    // returns this sheet cannot make it.+                    ProgressView("Loading…")+                        .accessibilityIdentifier("creator-picker-loading")+                } else if matches.isEmpty {+                    Text(emptyMessage(offersNew: offersNew))+                        .font(.callout)+                        .foregroundStyle(.secondary)+                        .accessibilityIdentifier("creator-picker-empty")+                } else {+                    ForEach(matches) { candidate in+                        candidateRow(candidate)+                    }+                }+            }+            .scrollContentBackground(.hidden)+            .macListChrome()+            .navigationTitle("Add a creator")+            .inlineNavigationTitle()+            .accessibilityIdentifier("creator-picker")+            .toolbar {+                ToolbarItem(placement: .cancellationAction) {+                    Button("Cancel") { dismiss() }+                        .accessibilityIdentifier("creator-picker-cancel")+                }+            }+        }+    }++    /// The sentence shown where nothing matched.+    ///+    /// An empty library has to say what the field does rather than only what is+    /// missing: Req 3.3 puts "New creator" up only once a name is typed, so a+    /// reader who has never made one is looking at a search field over nothing+    /// (Q95). The no-match sentence points at the row **only where it is+    /// actually up there** — a typed name an already-credited creator holds+    /// filters to nothing and offers no row to tap.+    private func emptyMessage(offersNew: Bool) -> String {+        guard !candidates.isEmpty else { return "No creators yet. Type a name to create one." }+        let missing = "No creators match “\(query)”."+        return offersNew ? missing + " Tap “New creator” above to add it." : missing+    }++    private var newCreatorRow: some View {+        let typed = query.trimmingCharacters(in: .whitespacesAndNewlines)+        return Button {+            onCreate(typed)+        } label: {+            VStack(alignment: .leading, spacing: 4) {+                Text("New creator “\(typed)”")+                    .font(AsterismTypography.serifRowTitle)+                    .foregroundStyle(AsterismColors.primaryText)+                    .lineLimit(2)+                Text("Created straight away, and kept even if you cancel this edit.")+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .fixedSize(horizontal: false, vertical: true)+            }+            .frame(maxWidth: .infinity, alignment: .leading)+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+        .frame(minHeight: AsterismLayout.minHitTarget)+        .accessibilityIdentifier("creator-picker-new")+        .accessibilityLabel("Create the creator \(typed) and credit them")+    }++    private func candidateRow(_ candidate: CreatorPickerCandidate) -> some View {+        Button {+            onSelect(candidate.creator)+        } label: {+            VStack(alignment: .leading, spacing: 4) {+                Text(candidate.creator.label)+                    .font(AsterismTypography.serifRowTitle)+                    .foregroundStyle(AsterismColors.primaryText)+                    .lineLimit(2)+                // Never a greyed-out row on its own: a control that does nothing+                // and says nothing is the dead end this app removes everywhere.+                if let reason = candidate.unavailableReason {+                    Text(reason)+                        .font(.caption)+                        .foregroundStyle(.secondary)+                        .fixedSize(horizontal: false, vertical: true)+                }+            }+            .frame(maxWidth: .infinity, alignment: .leading)+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+        .disabled(candidate.unavailableReason != nil)+        .frame(minHeight: AsterismLayout.minHitTarget)+        .accessibilityIdentifier("creator-picker-\(candidate.id.uuidString)")+        .accessibilityLabel(+            candidate.unavailableReason.map { "\(candidate.creator.label), \($0)" }+                ?? candidate.creator.label)+    }+}

diff --git a/Asterism/Asterism/Views/CreatorRolesView.swift b/Asterism/Asterism/Views/CreatorRolesView.swiftnew file mode 100644index 0000000..e229025--- /dev/null+++ b/Asterism/Asterism/Views/CreatorRolesView.swift@@ -0,0 +1,307 @@+import AsterismCore+import ConstellationKit+import SwiftUI++/// The creator-roles list (Reqs 2.1, 2.5, 2.7): the roles a credit can hold, in+/// the reader's order, the field that adds one, and — beneath them — the roles+/// they removed.+///+/// `WorkTypesListView`'s shape, pushed from Settings like Sites and Check+/// Library. Its one new pattern is the reorder: Req 2.5 makes the list order the+/// reader's, so the active rows carry `.onMove` and the toolbar carries the+/// toggle that turns dragging on.+struct CreatorRolesListView: View {+    @State private var model: CreatorRolesModel++    init(model: CreatorRolesModel) {+        _model = State(initialValue: model)+    }++    var body: some View {+        List {+            addSection+            listSection+            removedSection+        }+        .navigationTitle("Creator roles")+        .accessibilityIdentifier("settings-creator-roles-list")+        // The seam, not an `#if` here (Req 4.5 of `ipad-and-mac-layouts`):+        // `EditButton` does not exist on macOS, where a row with `.onMove` is+        // dragged without entering a mode first.+        .listEditToolbarButton(identifier: "settings-creator-roles-edit-button")+        .task { await model.load() }+    }++    // MARK: - Adding (Req 2.2)++    /// The work-types screen's shape: a field and the button that commits it, on+    /// one row, so the two are read as the single action they are.+    @ViewBuilder+    private var addSection: some View {+        Section {+            HStack {+                // A role name is data, not prose: the keyboard must not+                // capitalise “artist” into “Artist” or correct a word the reader+                // chose deliberately.+                TextField("New role name", text: $model.draftName)+                    .autocorrectionDisabled()+                    .noAutocapitalization()+                    .accessibilityIdentifier("settings-creator-roles-name-field")+                Button {+                    Task { await model.add() }+                } label: {+                    Text("Add")+                        .frame(+                            minWidth: AsterismLayout.minHitTarget,+                            minHeight: AsterismLayout.minHitTarget+                        )+                        .contentShape(Rectangle())+                }+                .disabled(!model.canAdd)+                .accessibilityIdentifier("settings-creator-roles-add-button")+            }+            .frame(minHeight: AsterismLayout.minHitTarget)++            // Req 2.2's refusal, and its restore, in the one line the screen+            // says back. Worded by the model.+            if let message = model.message {+                Text(message)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("settings-creator-roles-message")+            }+        }+    }++    // MARK: - The active list (Reqs 2.1, 2.5, 2.7)++    @ViewBuilder+    private var listSection: some View {+        switch model.state {+        case .loading:+            ProgressView("Loading…")+                .accessibilityIdentifier("settings-creator-roles-loading")+        case .error(let message):+            Text(message)+                .font(.callout)+                .foregroundStyle(.secondary)+                .accessibilityIdentifier("settings-creator-roles-error")+        case .ready:+            if model.rows.isEmpty {+                // Req 2.7: an emptied list is a state the reader put the library+                // in, and credits are still editable without it.+                Text(model.emptyMessage)+                    .font(.callout)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("settings-creator-roles-empty")+            } else {+                ForEach(model.rows) { row in+                    roleRow(row)+                }+                // Req 2.5. The model reorders its rows and sends the whole+                // active order, because the repository numbers what it is given+                // rather than applying a pair of indices (Q58).+                .onMove { source, destination in+                    Task { await model.move(from: source, to: destination) }+                }+            }+        }+    }++    // MARK: - Removed but retained (Reqs 2.1, 2.2)++    @ViewBuilder+    private var removedSection: some View {+        if !model.removedRows.isEmpty {+            Section {+                ForEach(model.removedRows) { row in+                    roleRow(row)+                }+                Text(model.removedExplanation)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("settings-creator-roles-removed-explanation")+            } header: {+                ConstellationSectionHeader("Removed", accent: .violet)+            }+        }+    }++    private func roleRow(_ row: CreatorRolesModel.Row) -> some View {+        NavigationLink {+            CreatorRoleDetailView(model: model.detailModel(for: row))+        } label: {+            HStack(spacing: 10) {+                // A removed role wears the type pill knocked down, which is the+                // same violet at the "ignored" chip's opacity — it is still the+                // role it always was, just no longer offered.+                Text(row.name)+                    .constellationPill(row.isRemoved ? .dimmedTypeTag : .typeTag)+                    .lineLimit(1)+                    .truncationMode(.tail)+                Spacer()+                if let credits = row.creditLine {+                    Text(credits)+                        .font(.caption2)+                        .foregroundStyle(.secondary)+                }+            }+            .frame(minHeight: AsterismLayout.minHitTarget)+        }+        .accessibilityIdentifier("creator-role-row-\(row.id.uuidString)")+        .accessibilityLabel(row.creditLine.map { "\(row.name), \($0)" } ?? row.name)+    }+}++/// One role's screen (Reqs 2.3, 2.4): rename it, or take it out of credits.+struct CreatorRoleDetailView: View {+    @State private var model: CreatorRoleDetailModel+    @Environment(\.dismiss) private var dismiss++    init(model: CreatorRoleDetailModel) {+        _model = State(initialValue: model)+    }++    /// The refusal said under the name field, where there is one (Q89).+    /// Placement is the view's; the wording and the target are the model's.+    private var nameRefusal: String? {+        model.refusalTarget == .name ? model.errorMessage : nil+    }++    var body: some View {+        List {+            nameSection+            usageSection++            // Only a refusal with no field to sit under (Q89): a rejected name+            // is said on the field's own row, and what is left here is a write+            // the repository would not take.+            if model.refusalTarget == .message, let message = model.errorMessage {+                Section {+                    Text(message)+                        .font(.callout)+                        .foregroundStyle(AsterismColors.amberText)+                        .accessibilityIdentifier("creator-role-detail-error")+                }+            }+        }+        .navigationTitle(model.role.name)+        .inlineNavigationTitle()+        .accessibilityIdentifier("creator-role-detail-view")+        // The consequence, then the choice — the shape every confirmation on+        // this side of the app has.+        .confirmationDialog(+            "Remove this role?",+            isPresented: Binding(+                get: { model.removalPrompt != nil },+                set: { if !$0 { model.cancelRemoval() } }),+            presenting: model.removalPrompt+        ) { prompt in+            // The prompt is taken as a parameter, not re-read from the model:+            // SwiftUI runs the dismissal below before this action (see+            // `CreatorRoleDetailModel.RemovalPrompt`).+            Button("Remove", role: .destructive) {+                Task { await model.confirmRemoval(prompt) }+            }+            .accessibilityIdentifier("creator-role-detail-remove-confirm")+            Button("Cancel", role: .cancel) { model.cancelRemoval() }+                .accessibilityIdentifier("creator-role-detail-remove-cancel")+        } message: { prompt in+            Text(prompt.message)+        }+        // The screen holds an immutable snapshot, so once the role has changed+        // everything on it describes the role as it was. Back to the list.+        .onChange(of: model.didFinish) { _, finished in+            if finished { dismiss() }+        }+    }++    // MARK: - The name (Req 2.3)++    /// The field, the refusal it earned, and the rename.+    ///+    /// A rename is offered for a **removed** role too: the repository takes it —+    /// only a merged identity is refused — and the spelling is what Req 2.2's+    /// restore is keyed on, so correcting it here is the difference between the+    /// old role coming back and a new one being made (Q90).+    private var nameSection: some View {+        Section {+            // Q89: the refusal grows **below** the field, inside the same row,+            // so the field does not move under the reader's finger and the+            // sentence is never a section away from what it is about.+            VStack(alignment: .leading, spacing: 8) {+                // A role name is data, not prose.+                TextField("Name", text: $model.draftName)+                    .autocorrectionDisabled()+                    .noAutocapitalization()+                    // The field a refusal is about wears the amber attention+                    // border while it stands, so the sentence is never the only+                    // mark on the screen.+                    .constellationAttentionField(nameRefusal != nil)+                    // The state joins the label rather than the value: a field's+                    // value is the text the reader typed.+                    .accessibilityLabel(+                        nameRefusal == nil ? "Role name" : "Role name, not accepted")+                    .accessibilityIdentifier("creator-role-detail-name-field")+                    .frame(minHeight: AsterismLayout.minHitTarget)++                if let nameRefusal {+                    Text(nameRefusal)+                        // Amber, as every refusal on these screens is: the+                        // palette has no error colour.+                        .font(.footnote)+                        .foregroundStyle(AsterismColors.amberText)+                        .fixedSize(horizontal: false, vertical: true)+                        .frame(maxWidth: .infinity, alignment: .leading)+                        .accessibilityIdentifier("creator-role-detail-error")+                }+            }+            .animation(.snappy, value: nameRefusal)++            // Req 2.3: the rename reaches every credit holding the role,+            // because the credit cites the identity and the identity carries+            // the name.+            Button("Rename") {+                Task { await model.rename() }+            }+            .buttonStyle(.constellationPrimary)+            .disabled(!model.canRename)+            .accessibilityIdentifier("creator-role-detail-rename-button")+        } header: {+            ConstellationSectionHeader(model.role.name)+        }+    }++    // MARK: - Usage, and the way out (Reqs 2.2, 2.4)++    /// The count, and then either the removal or — for a role already removed —+    /// what restoring it takes (Q90).+    ///+    /// A removed role has nothing to remove: offering the control again would be+    /// a button that either does nothing or re-stamps a state, and it would be+    /// the only thing on a screen whose real answer lives in the list above.+    @ViewBuilder+    private var usageSection: some View {+        Section {+            Text(model.usageLine)+                .font(.caption)+                .foregroundStyle(.secondary)+                .accessibilityIdentifier("creator-role-detail-usage")++            if model.isRemoved {+                Text(model.restoreExplanation)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .fixedSize(horizontal: false, vertical: true)+                    .accessibilityIdentifier("creator-role-detail-removed-explanation")+            } else {+                // Not a gradient control: removal takes a label out of every+                // credit that holds it, and the reader should have to mean it.+                Button("Remove from credits") { model.requestRemoval() }+                    .buttonStyle(.constellationSecondary)+                    .disabled(model.isSubmitting)+                    .accessibilityIdentifier("creator-role-detail-remove-button")+            }+        }+    }+}