@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftData/ModelActor.swift

@@ -0,0 +1,38 @@
+// Model actors (`@ModelActor`, Macros.swift): an actor that works with a
+// context of its own. Apple's runs on its model executor; here it runs on the
+// main actor's executor, as everything in the browser runs on one thread, so
+// the context (which, like the runtime, lives on the main actor) is used
+// where it expects to be.
+
+/// What runs a model actor's work: here, the holder of its context.
+public protocol ModelExecutor: AnyObject, Sendable {
+    var modelContext: ModelContext { get }
+}
+
+/// The executor `@ModelActor` makes, holding the actor's context.
+public final class DefaultSerialModelExecutor: ModelExecutor, @unchecked Sendable {
+    public let modelContext: ModelContext
+
+    public init(modelContext: ModelContext) {
+        self.modelContext = modelContext
+    }
+}
+
+/// An actor with a model container and a context of its own.
+public protocol ModelActor: Actor {
+    nonisolated var modelContainer: ModelContainer { get }
+    nonisolated var modelExecutor: any ModelExecutor { get }
+}
+
+extension ModelActor {
+    /// The main actor's executor (see the file comment).
+    public nonisolated var unownedExecutor: UnownedSerialExecutor { MainActor.sharedUnownedExecutor }
+
+    /// The actor's context, which its executor holds.
+    public var modelContext: ModelContext { modelExecutor.modelContext }
+
+    /// The model with `id` in the actor's context, if it is there.
+    public subscript<T: PersistentModel>(id: PersistentIdentifier, as type: T.Type) -> T? {
+        modelContext.registeredModel(for: id)
+    }
+}

package/Sources/SwiftData/ModelContainer.swift

@@ -0,0 +1,129 @@
+// Containers and their configurations. A configuration names a store; a
+// persistent store is saved to the page's IndexedDB (one database per app,
+// docs/ops-protocol.md, "Phase 18"), an in-memory one keeps nothing.
+
+import Foundation
+import SwiftUI
+
+/// Where and how a container stores its models.
+public struct ModelConfiguration: Hashable, Identifiable, @unchecked Sendable {
+    public enum CloudKitDatabase: Hashable, Sendable {
+        case automatic
+        case none
+        case `private`(String)
+    }
+
+    public enum GroupContainer: Hashable, Sendable {
+        case automatic
+        case none
+        case identifier(String)
+    }
+
+    public var name: String
+    public var url: URL
+    public var isStoredInMemoryOnly: Bool
+    public var allowsSave: Bool
+    public var schema: Schema?
+    public var cloudKitDatabase: CloudKitDatabase
+    public var groupContainer: GroupContainer
+
+    public var id: String { name }
+
+    public init(
+        _ name: String? = nil,
+        schema: Schema? = nil,
+        isStoredInMemoryOnly: Bool = false,
+        allowsSave: Bool = true,
+        groupContainer: GroupContainer = .automatic,
+        cloudKitDatabase: CloudKitDatabase = .automatic
+    ) {
+        let name = name ?? "default"
+        self.name = name
+        url = URL(fileURLWithPath: "/swiftdata/\(name).store")
+        self.isStoredInMemoryOnly = isStoredInMemoryOnly
+        self.allowsSave = allowsSave
+        self.schema = schema
+        self.cloudKitDatabase = cloudKitDatabase
+        self.groupContainer = groupContainer
+    }
+
+    public init(
+        _ name: String? = nil,
+        schema: Schema? = nil,
+        url: URL,
+        allowsSave: Bool = true,
+        cloudKitDatabase: CloudKitDatabase = .automatic
+    ) {
+        self.name = name ?? url.deletingPathExtension().lastPathComponent
+        self.url = url
+        isStoredInMemoryOnly = false
+        self.allowsSave = allowsSave
+        self.schema = schema
+        self.cloudKitDatabase = cloudKitDatabase
+        groupContainer = .automatic
+    }
+
+    public init(for forTypes: any PersistentModel.Type..., isStoredInMemoryOnly: Bool = false) {
+        self.init(schema: Schema(forTypes), isStoredInMemoryOnly: isStoredInMemoryOnly)
+    }
+
+    public init(isStoredInMemoryOnly: Bool) {
+        self.init(nil, isStoredInMemoryOnly: isStoredInMemoryOnly)
+    }
+
+    /// The name the store goes by in IndexedDB and in `swiftdata` ops.
+    var storeIdentifier: String { url.lastPathComponent }
+
+    public static func == (lhs: ModelConfiguration, rhs: ModelConfiguration) -> Bool {
+        lhs.name == rhs.name && lhs.url == rhs.url && lhs.isStoredInMemoryOnly == rhs.isStoredInMemoryOnly
+            && lhs.allowsSave == rhs.allowsSave
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(name)
+        hasher.combine(url)
+        hasher.combine(isStoredInMemoryOnly)
+    }
+}
+
+/// The models of a schema and the store that keeps them.
+public final class ModelContainer: @unchecked Sendable {
+    public let schema: Schema
+    public let configurations: [ModelConfiguration]
+    let store: _Store
+    private var _mainContext: ModelContext?
+
+    public init(for schema: Schema, migrationPlan: (any SchemaMigrationPlan.Type)? = nil, configurations: [ModelConfiguration] = []) throws {
+        let configuration = configurations.first ?? ModelConfiguration(schema: schema)
+        self.schema = schema
+        self.configurations = configurations.isEmpty ? [configuration] : configurations
+        store = _Store.open(identifier: configuration.storeIdentifier, inMemory: configuration.isStoredInMemoryOnly)
+    }
+
+    public convenience init(for schema: Schema, migrationPlan: (any SchemaMigrationPlan.Type)? = nil, configurations: ModelConfiguration...) throws {
+        try self.init(for: schema, migrationPlan: migrationPlan, configurations: configurations)
+    }
+
+    public convenience init(for forTypes: any PersistentModel.Type..., migrationPlan: (any SchemaMigrationPlan.Type)? = nil, configurations: ModelConfiguration...) throws {
+        try self.init(for: Schema(forTypes), migrationPlan: migrationPlan, configurations: configurations)
+    }
+
+    public convenience init(for forTypes: any PersistentModel.Type..., migrationPlan: (any SchemaMigrationPlan.Type)? = nil, configurations: [ModelConfiguration]) throws {
+        try self.init(for: Schema(forTypes), migrationPlan: migrationPlan, configurations: configurations)
+    }
+
+    /// The context bound to the main actor, which saves on its own after
+    /// every event that changed it (`autosaveEnabled`).
+    @MainActor public var mainContext: ModelContext {
+        if let context = _mainContext { return context }
+        let context = ModelContext(self)
+        context.autosaveEnabled = true
+        _mainContext = context
+        return context
+    }
+
+    /// Deletes every model of the container's store.
+    public func deleteAllData() {
+        store.commit(put: [], delete: [], clear: true, from: nil)
+    }
+}

package/Sources/SwiftData/ModelContext.swift

@@ -0,0 +1,451 @@
+// A context: the live models of a store, and the changes not yet saved.
+//
+// It keeps one object per record (fetching twice returns the same model),
+// tracks inserted, changed and deleted models, keeps the two sides of a
+// relationship in step, and saves into its store. The main context saves on
+// its own at the end of every event that changed it, like SwiftData's
+// autosave; `@Query` re-runs when the context changes.
+
+import Foundation
+import Observation
+import SwiftUI
+
+public struct SwiftDataError: Error, Equatable, CustomStringConvertible, Sendable {
+    public struct Code: Hashable, Sendable {
+        let name: String
+        public static let unsupportedPredicate = Code(name: "unsupportedPredicate")
+        public static let unsupportedSortDescriptor = Code(name: "unsupportedSortDescriptor")
+        public static let modelValidationFailure = Code(name: "modelValidationFailure")
+        public static let loadIssueModelContainer = Code(name: "loadIssueModelContainer")
+        static let _decodeFailed = Code(name: "decodeFailed")
+    }
+
+    public let code: Code
+    let message: String
+
+    init(_ code: Code, _ message: String) {
+        self.code = code
+        self.message = message
+    }
+
+    public static let unsupportedPredicate = SwiftDataError(.unsupportedPredicate, "the predicate is not supported")
+    public static let modelValidationFailure = SwiftDataError(.modelValidationFailure, "a model failed validation")
+    public static let loadIssueModelContainer = SwiftDataError(.loadIssueModelContainer, "the container could not be loaded")
+
+    public static func == (lhs: SwiftDataError, rhs: SwiftDataError) -> Bool { lhs.code == rhs.code }
+
+    public var description: String { "SwiftDataError(\(code.name)): \(message)" }
+}
+
+/// Bumped on every change to a context's models; `@Query` reads it so that
+/// the views showing a query re-run when the context changes.
+@Observable
+final class _ChangeSignal {
+    var generation = 0
+}
+
+public final class ModelContext: Equatable, Hashable {
+    public let container: ModelContainer
+    let store: _Store
+    /// Whether the context saves on its own after each event that changed
+    /// it. On for a container's `mainContext`, off for contexts an app makes.
+    public var autosaveEnabled = false
+
+    /// The context's live models, by identity.
+    private var registered: [PersistentIdentifier: any PersistentModel] = [:]
+    /// Inserted, not yet saved, in order.
+    private var inserted: [PersistentIdentifier] = []
+    private var insertedSet: Set<PersistentIdentifier> = []
+    private var changed: Set<PersistentIdentifier> = []
+    private var deleted: [PersistentIdentifier: any PersistentModel] = [:]
+    private var autosaveScheduled = false
+    let signal = _ChangeSignal()
+
+    public init(_ container: ModelContainer) {
+        self.container = container
+        store = container.store
+        store.register(self)
+    }
+
+    public static func == (lhs: ModelContext, rhs: ModelContext) -> Bool { lhs === rhs }
+    public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+
+    public static let willSave = Notification.Name("SwiftData.ModelContext.willSave")
+    public static let didSave = Notification.Name("SwiftData.ModelContext.didSave")
+
+    // MARK: State
+
+    public var hasChanges: Bool { !inserted.isEmpty || !changed.isEmpty || !deleted.isEmpty }
+
+    public var insertedModelsArray: [any PersistentModel] { inserted.compactMap { registered[$0] } }
+    public var changedModelsArray: [any PersistentModel] { changed.sorted().compactMap { registered[$0] } }
+    public var deletedModelsArray: [any PersistentModel] { deleted.keys.sorted().compactMap { deleted[$0] } }
+
+    func _hasChanges(_ id: PersistentIdentifier) -> Bool {
+        insertedSet.contains(id) || changed.contains(id) || deleted[id] != nil
+    }
+
+    /// Nothing is deferred: changes apply as they are made.
+    public func processPendingChanges() {}
+
+    // MARK: Inserting
+
+    /// Adds a model to the context, with the models its relationships hold.
+    /// It is saved at the next `save()` (or autosave).
+    public func insert<T: PersistentModel>(_ model: T) {
+        _insert(model)
+    }
+
+    private func _insert(_ model: any PersistentModel) {
+        let backing = model.persistentBackingData
+        if backing.context === self {
+            // A deleted model inserted again is no longer deleted.
+            if backing.isDeleted, deleted.removeValue(forKey: backing.identifier) != nil {
+                backing.isDeleted = false
+                registered[backing.identifier] = model
+                noteChange()
+            }
+            return
+        }
+        if backing.context != nil {
+            print("[SwiftData] a \(backing.entity.name) from another context was inserted; it now belongs to this one")
+        }
+        backing.context = self
+        backing.storeIdentifier = store.identifier
+        backing.isDeleted = false
+        if let key = backing.primaryKey, store.record(key) != nil {
+            // The model was identified before its store opened and took a key
+            // a stored record already has.
+            backing.primaryKey = _Store.allocatePrimaryKey()
+        }
+        let id = backing.identifier
+        registered[id] = model
+        if insertedSet.insert(id).inserted { inserted.append(id) }
+        for property in backing.entity.relationships {
+            for target in backing.relatedModels(property) {
+                _insert(target)
+                if let inverse = backing.entity.inverse(of: property) {
+                    link(target, inverse, to: model)
+                }
+            }
+        }
+        noteChange()
+    }
+
+    // MARK: Deleting
+
+    /// Removes a model from the store at the next save, applying its
+    /// relationships' delete rules.
+    public func delete<T: PersistentModel>(_ model: T) {
+        _delete(model)
+    }
+
+    private func _delete(_ model: any PersistentModel) {
+        let backing = model.persistentBackingData
+        guard backing.context === self, !backing.isDeleted else { return }
+        let id = backing.identifier
+        let related = backing.entity.relationships.map { ($0, backing.relatedModels($0)) }
+        backing.isDeleted = true
+        if insertedSet.remove(id) != nil {
+            inserted.removeAll { $0 == id }
+            registered[id] = nil
+        } else {
+            deleted[id] = model
+            changed.remove(id)
+            registered[id] = nil
+        }
+        for (property, targets) in related {
+            switch property.deleteRule {
+            case .cascade:
+                for target in targets { _delete(target) }
+            case .nullify, .deny:
+                guard let inverse = backing.entity.inverse(of: property) else { continue }
+                for target in targets where !target.persistentBackingData.isDeleted {
+                    unlink(target, inverse, from: model)
+                }
+            case .noAction:
+                break
+            }
+        }
+        noteChange()
+    }
+
+    /// Deletes every model of a type that matches the predicate.
+    public func delete<T: PersistentModel>(model: T.Type, where predicate: Predicate<T>? = nil, includeSubclasses: Bool = true) throws {
+        for item in try fetch(FetchDescriptor<T>(predicate: predicate)) { delete(item) }
+    }
+
+    // MARK: Fetching
+
+    public func fetch<T: PersistentModel>(_ descriptor: FetchDescriptor<T>) throws -> [T] {
+        var results = try matches(descriptor)
+        if !descriptor.sortBy.isEmpty { results.sort(using: descriptor.sortBy) }
+        let offset = max(0, descriptor.fetchOffset ?? 0)
+        if offset > 0 { results = Array(results.dropFirst(offset)) }
+        if let limit = descriptor.fetchLimit, limit >= 0, results.count > limit { results = Array(results.prefix(limit)) }
+        return results
+    }
+
+    public func fetch<T: PersistentModel>(_ descriptor: FetchDescriptor<T>, batchSize: Int) throws -> FetchResultsCollection<T> {
+        FetchResultsCollection(models: try fetch(descriptor))
+    }
+
+    public func fetchCount<T: PersistentModel>(_ descriptor: FetchDescriptor<T>) throws -> Int {
+        var count = try matches(descriptor).count
+        count = max(0, count - max(0, descriptor.fetchOffset ?? 0))
+        if let limit = descriptor.fetchLimit, limit >= 0 { count = min(count, limit) }
+        return count
+    }
+
+    public func fetchIdentifiers<T: PersistentModel>(_ descriptor: FetchDescriptor<T>) throws -> [PersistentIdentifier] {
+        try fetch(descriptor).map(\.persistentModelID)
+    }
+
+    public func enumerate<T: PersistentModel>(_ descriptor: FetchDescriptor<T>, batchSize: Int = 5000, allowEscapingMutations: Bool = false, block: (T) throws -> Void) throws {
+        for model in try fetch(descriptor) { try block(model) }
+    }
+
+    /// The models of `T` the context can see (saved and, unless the
+    /// descriptor says otherwise, inserted), filtered by its predicate.
+    private func matches<T: PersistentModel>(_ descriptor: FetchDescriptor<T>) throws -> [T] {
+        let entity = _Entity.of(T.self)
+        var candidates: [T] = []
+        for key in store.keys(of: entity.name) {
+            if let model = _model(primaryKey: key, type: T.self) as? T { candidates.append(model) }
+        }
+        if descriptor.includePendingChanges {
+            for id in inserted where id.entityName == entity.name {
+                if let model = registered[id] as? T, store.record(id.primaryKey) == nil { candidates.append(model) }
+            }
+        }
+        guard let predicate = descriptor.predicate else { return candidates }
+        return try candidates.filter { try predicate.evaluate($0) }
+    }
+
+    /// The live model for a stored record (materialized on first use), or
+    /// nil when the record is gone or deleted in this context.
+    func _model(primaryKey: Int64, type: any PersistentModel.Type) -> (any PersistentModel)? {
+        let entity = _Entity.of(type)
+        let id = PersistentIdentifier(entityName: entity.name, storeIdentifier: store.identifier, primaryKey: primaryKey)
+        if let model = registered[id] { return model }
+        guard deleted[id] == nil, let record = store.record(primaryKey), record.entity == entity.name else { return nil }
+        let backing = _ModelBacking(type: type, primaryKey: primaryKey, storeIdentifier: store.identifier, stored: record.values)
+        backing.context = self
+        let model = type.init(backingData: backing)
+        registered[id] = model
+        return model
+    }
+
+    /// The model with this identifier, if the context has it or its store
+    /// has its record.
+    public func registeredModel<T: PersistentModel>(for id: PersistentIdentifier) -> T? {
+        registered[id] as? T
+    }
+
+    public func model(for id: PersistentIdentifier) -> any PersistentModel {
+        if let model = registered[id] { return model }
+        guard let entity = _Entity.byEntityName[id.entityName], let model = _model(primaryKey: id.primaryKey, type: entity.type) else {
+            fatalError("SwiftData: no \(id.entityName) with identifier \(id) in this context")
+        }
+        return model
+    }
+
+    // MARK: Saving
+
+    /// Writes the context's changes to its store; a persistent store sends
+    /// them to the page, which keeps them in IndexedDB.
+    public func save() throws {
+        guard hasChanges else { return }
+        guard container.configurations.first?.allowsSave ?? true else { return }
+        var put: [(Int64, _Record)] = []
+        var removed: [Int64] = deleted.keys.map(\.primaryKey).sorted()
+        var replaced: [any PersistentModel] = []
+        let ids = inserted + changed.sorted().filter { !insertedSet.contains($0) }
+        for id in ids {
+            guard let model = registered[id] else { continue }
+            let backing = model.persistentBackingData
+            var values: [String: _JSON] = [:]
+            for metadata in backing.entity.properties {
+                values[metadata.name] = backing.json(of: metadata.property)
+            }
+            // `@Attribute(.unique)`: a new model whose value a stored record
+            // already has replaces that record.
+            if insertedSet.contains(id) {
+                for unique in backing.entity.uniqueAttributes {
+                    guard let value = values[unique.name] else { continue }
+                    for key in store.keys(of: backing.entity.name) where key != id.primaryKey && store.record(key)?.values[unique.name] == value {
+                        removed.append(key)
+                        let otherID = PersistentIdentifier(entityName: backing.entity.name, storeIdentifier: store.identifier, primaryKey: key)
+                        if let other = registered[otherID] { replaced.append(other) }
+                    }
+                }
+            }
+            put.append((id.primaryKey, _Record(entity: backing.entity.name, values: values)))
+        }
+        for model in deleted.values { model.persistentBackingData.context = nil }
+        for model in replaced {
+            let backing = model.persistentBackingData
+            backing.isDeleted = true
+            registered[backing.identifier] = nil
+            backing.context = nil
+        }
+        // Saved records are read back from the store: a model keeps its live
+        // values, and the store's JSON is what a later fetch decodes.
+        inserted.removeAll()
+        insertedSet.removeAll()
+        changed.removeAll()
+        deleted.removeAll()
+        store.commit(put: put, delete: removed, from: self)
+        noteChange(autosave: false)
+    }
+
+    /// Discards unsaved changes: inserted models leave the context, deleted
+    /// ones return, and changed ones read their saved values again.
+    public func rollback() {
+        for id in inserted {
+            guard let model = registered.removeValue(forKey: id) else { continue }
+            model.persistentBackingData.context = nil
+        }
+        for (id, model) in deleted where store.record(id.primaryKey) != nil {
+            model.persistentBackingData.isDeleted = false
+            registered[id] = model
+        }
+        for id in changed { reload(id) }
+        for (id, _) in deleted { reload(id) }
+        inserted.removeAll()
+        insertedSet.removeAll()
+        changed.removeAll()
+        deleted.removeAll()
+        noteChange(autosave: false)
+    }
+
+    /// Runs `block` and saves.
+    public func transaction(block: () throws -> Void) throws {
+        try block()
+        try save()
+    }
+
+    /// Resets a registered model to its stored record.
+    private func reload(_ id: PersistentIdentifier) {
+        guard let model = registered[id], let record = store.record(id.primaryKey) else { return }
+        let backing = model.persistentBackingData
+        backing.slots = record.values.mapValues { .stored($0) }
+        for metadata in backing.entity.properties { metadata.property.notify(model) }
+    }
+
+    /// Another context saved to the store: models this context has not
+    /// changed take the saved values, deleted records' models leave.
+    func _storeDidChange(changed saved: Set<Int64>, deleted removed: Set<Int64>, cleared: Bool) {
+        for (id, model) in registered where !insertedSet.contains(id) {
+            if cleared || removed.contains(id.primaryKey) {
+                registered[id] = nil
+                model.persistentBackingData.isDeleted = true
+                model.persistentBackingData.context = nil
+                changed.remove(id)
+            } else if saved.contains(id.primaryKey), !changed.contains(id) {
+                reload(id)
+            }
+        }
+        if cleared {
+            for (_, model) in deleted { model.persistentBackingData.context = nil }
+            deleted.removeAll()
+        }
+        noteChange(autosave: false)
+    }
+
+    // MARK: Changes
+
+    /// A persisted attribute of a registered model was set.
+    func _modelDidChange(_ model: any PersistentModel) {
+        let id = model.persistentModelID
+        if !insertedSet.contains(id) { changed.insert(id) }
+        noteChange()
+    }
+
+    /// A relationship of `model` changed from `old` to `new`: models it now
+    /// holds join the context, and the inverse follows on both sides.
+    func _relationship(_ property: _Property, of model: any PersistentModel, changedFrom old: [any PersistentModel], to new: [any PersistentModel]) {
+        let inverse = model.persistentBackingData.entity.inverse(of: property)
+        for target in new where !old.contains(where: { $0 === target }) {
+            _insert(target)
+            if let inverse { link(target, inverse, to: model) }
+        }
+        guard let inverse else { return }
+        for target in old where !new.contains(where: { $0 === target }) {
+            unlink(target, inverse, from: model)
+        }
+    }
+
+    /// Makes `target`'s `inverse` hold `model`.
+    private func link(_ target: any PersistentModel, _ inverse: _Property, to model: any PersistentModel) {
+        let backing = target.persistentBackingData
+        let current = backing.relatedModels(inverse)
+        if current.contains(where: { $0 === model }) { return }
+        if inverse.kind == .toMany {
+            setRaw(target, inverse, inverse.make(current + [model]))
+        } else {
+            setRaw(target, inverse, inverse.make([model]))
+            // A to-one inverse that held another model: that model's side
+            // of the relationship lets go of `target`.
+            if let previous = current.first, let forward = backing.entity.inverse(of: inverse) {
+                unlink(previous, forward, from: target)
+            }
+        }
+    }
+
+    /// Makes `target`'s `inverse` stop holding `model`.
+    private func unlink(_ target: any PersistentModel, _ inverse: _Property, from model: any PersistentModel) {
+        let backing = target.persistentBackingData
+        let current = backing.relatedModels(inverse)
+        guard current.contains(where: { $0 === model }) else { return }
+        let remaining = current.filter { $0 !== model }
+        if inverse.kind == .toOne, remaining.isEmpty, !inverse.isOptional { return }
+        setRaw(target, inverse, inverse.make(remaining))
+    }
+
+    /// Sets a relationship without running its own inverse bookkeeping, and
+    /// tells its observers.
+    private func setRaw(_ target: any PersistentModel, _ property: _Property, _ value: Any) {
+        let backing = target.persistentBackingData
+        backing.slots[property.name] = .live(value)
+        property.notify(target)
+        if backing.context === self, !backing.isDeleted { _modelDidChange(target) }
+    }
+
+    private func noteChange(autosave: Bool = true) {
+        signal.generation += 1
+        if autosave { scheduleAutosave() }
+    }
+
+    private func scheduleAutosave() {
+        guard autosaveEnabled, !autosaveScheduled else { return }
+        autosaveScheduled = true
+        // Models and contexts belong to the main actor in practice (there is
+        // one thread on wasm); the box only carries the context across.
+        let box = _UncheckedWeakContext(context: self)
+        MainActor.assumeIsolated {
+            _Runtime.shared._afterUpdate { box.context?.autosave() }
+        }
+    }
+
+    private func autosave() {
+        autosaveScheduled = false
+        do {
+            try save()
+        } catch {
+            print("[SwiftData] autosave failed: \(error)")
+        }
+    }
+}
+
+private struct _UncheckedWeakContext: @unchecked Sendable {
+    weak var context: ModelContext?
+}
+
+/// The results of a batched fetch (all of them: the store is in memory).
+public struct FetchResultsCollection<Element: PersistentModel>: RandomAccessCollection {
+    let models: [Element]
+    public var startIndex: Int { models.startIndex }
+    public var endIndex: Int { models.endIndex }
+    public subscript(position: Int) -> Element { models[position] }
+}