3.0.0

[0xLeif]

No description provided.

[gemini-code-assist]

Code Review

This pull request modernizes the AppState library for Swift 6 and Apple's Observation framework, raising platform requirements and introducing first-class SwiftData integration via ModelState and the @ModelState property wrapper. Feedback on these changes highlights a critical performance issue where ModelContainer is eagerly instantiated on every access, a thread-safety and main-thread publication issue in notifyChange(), and opportunities to optimize deletion using SwiftData's batch deletion API.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Critical Performance Issue: Eager Instantiation of ModelContainer

In the current implementation, container is passed as an @autoclosure and evaluated immediately via container() on line 100.

Because modelContainer is defined as a computed property on Application extensions, every access to Application.shared.modelContainer (which happens on every model fetch, insert, delete, or save) evaluates this computed property and eagerly instantiates a new ModelContainer.

Creating a ModelContainer is an extremely heavy operation that sets up SQLite connections, performs migrations, and initializes the schema. Eagerly instantiating it on every access will cause severe performance degradation, high memory usage, and potential database locking or crashes.

Suggestion

Change the parameter to an @escaping closure and pass it lazily to the underlying dependency resolver so that the ModelContainer is only instantiated once when first resolved.

Suggested change

	func modelContainer(
	_ container: @autoclosure () -> ModelContainer,
	_ fileID: StaticString = #fileID,
	_ function: StaticString = #function,
	_ line: Int = #line,
	_ column: Int = #column
	) -> Dependency<ModelContainer> {
	dependency(
	container(),
	id: Application.codeID(
	fileID: fileID,
	function: function,
	line: line,
	column: column
	)
	)
	}
	func modelContainer(
	_ container: @escaping () -> ModelContainer,
	_ fileID: StaticString = #fileID,
	_ function: StaticString = #function,
	_ line: Int = #line,
	_ column: Int = #column
	) -> Dependency<ModelContainer> {
	dependency(
	container,
	id: Application.codeID(
	fileID: fileID,
	function: function,
	line: line,
	column: column
	)
	)
	}

[gemini-code-assist]

Thread-Safety & Main-Thread Publication Issue

The notifyChange() method mutates changeAnchor directly. Since Application is not actor-isolated and notifyChange() can be called from background threads (e.g., when reacting to background iCloud sync notifications or background Combine publishers), this mutation is susceptible to data races.

Furthermore, mutating an @Observable property on a background thread that is currently being tracked by a SwiftUI view will trigger runtime warnings:
Publishing changes from background threads is not supported; make sure to publish values from the Main Thread.

Suggestion

Ensure that changeAnchor is always mutated on the main thread. This guarantees thread-safety and prevents SwiftUI background thread publication warnings.

    public func notifyChange() {
        if Thread.isMainThread {
            changeAnchor &+= 1
        } else {
            DispatchQueue.main.async {
                self.changeAnchor &+= 1
            }
        }
    }

[gemini-code-assist]

Suggestion: Use Lazy Closure for ModelContainer

To align with the recommended lazy instantiation pattern for ModelContainer (preventing eager instantiation on every access), pass the initialization block as a closure.

Suggested change

	var modelContainer: Dependency<ModelContainer> {
	modelContainer(
	try! ModelContainer(
	for: TodoItem.self,
	configurations: ModelConfiguration(isStoredInMemoryOnly: true)
	)
	)
	}
	var modelContainer: Dependency<ModelContainer> {
	modelContainer {
	try! ModelContainer(
	for: TodoItem.self,
	configurations: ModelConfiguration(isStoredInMemoryOnly: true)
	)
	}
	}

[gemini-code-assist]

Performance Improvement: Use Batch Deletion

Currently, deleteAll() fetches all matching models into memory and deletes them one by one. For large datasets, this is highly inefficient, consumes significant memory, and can lead to out-of-memory crashes.

Since the minimum deployment targets for AppState 3.0 are iOS 17 and macOS 14, SwiftData's batch deletion API (context.delete(model:where:)) is unconditionally available. This performs a highly optimized database-level delete without loading any objects into memory.

Suggestion

Use context.delete(model:where:) with the predicate from the FetchDescriptor.

        @MainActor
        public func deleteAll() {
            let context = context

            do {
                try context.delete(model: Model.self, where: fetchDescriptor().predicate)
                save(context: context, action: "Deleting")
            } catch {
                log(
                    error: error,
                    message: "\(ModelState.emoji) ModelState Deleting",
                    fileID: #fileID,
                    function: #function,
                    line: #line,
                    column: #column
                )
            }
        }

[0xLeif]

Absorbed into the new develop branch (origin/develop), which we're using to own this work off main.

develop = main + this PR's commits (fast-forwarded cleanly, since #147 was based on the current main), plus:

Review findings addressed (all four from the automated review):

• Critical — modelContainer(_:) no longer eagerly instantiates the ModelContainer on every \.modelContainer access; the @autoclosure thunk is forwarded to dependency(_:id:) so it's built once on first resolve. Public signature unchanged (non-breaking).
• notifyChange() — asserts main-thread before mutating the @Observable anchor. (Application is non-Sendable, so the change can't be hopped to main on the caller's behalf; the documented invariant is enforced instead of silently raced.)
• ModelState.deleteAll() — switched to batch context.delete(model:where:) (DB-level, no objects loaded).
• SwiftDataExample — dropped try! for a do/catch + fatalError container factory.

Examples — added six standalone SwiftUI example packages (TodoCloud, SettingsKit, DataDashboard, SecureVault, SyncNotes, MultiPlatformTracker) with 69 passing tests, plus an Examples CI workflow.

Library: builds clean, 41 tests pass. Closing in favor of develop.