SwiftData

Used persistent identifiers as the hashable marker identity to sync map selection with the existing photo selection. Avoided adding new model fields or identity schemes. The approach was reasoned from API constraints but not executed.

What worked

Stable identifier type gave a straightforward two-way selection binding.

What got in the way

Could not compile-check identifier conformance without the Swift toolchain.

Relied on existing persisted site and photo models with coordinates and address fields, plus new helpers for filtering geotagged photos and formatting addresses.

What worked

Stored coordinates and address fields needed no migration or geocoding. Filtering and formatting helpers kept view logic simple and testable.

Relied on the existing site and photo models for stored address fields and capture-ordered geotagged filtering, avoiding any lookup or geocoding step.

What worked

Typed model fields made address formatting and geotagged filtering simple to express and test.

Added three optional fields to an existing SwiftData model to cache geocoded coordinates and the address they came from. Relied on lightweight migration for optional properties; not built or run here, so migration behavior is unverified.

What worked

Models are Hashable out of the box, which made binding map selection to a model object straightforward; adding optional properties needs no explicit migration code.

Added three optional properties to an existing @Model to cache the geocoded position and the address it came from. Because the new fields are optional, the existing store should upgrade without a migration step. Neither the build nor the migration was tested.

What worked

Model objects are Hashable and Identifiable, so they could be used directly as map selection tags and as task identifiers.

Photo and site records already stored coordinates and the typed address, so the map read those fields and used each photo's persistent identifier as the marker tag. The model type is not hashable, and the identifier comes from the persistence protocol rather than a declared field. Those types were never confirmed by a compiler.

What worked

Stored coordinates and the address fields were enough for markers and the label, with no geocoding step. Persistent identifiers are hashable, so they can tag a marker and be matched back to the same photo.

What got in the way

The identifier property is implicit, so it was easy to be unsure it had the right type, and the model object itself cannot be the selection tag because it is not hashable. There was no compile to settle that.

Marker tags and the map selection binding used the persistent identifiers already stored on site and photo models, so a marker click could select the same object the grid already highlighted. No new store, migration, or query layer was added. The code was not compiled, so persistence behavior was not observed.

What worked

Stable model identifiers were enough to tag markers and round-trip selection. The map could share the selection value the rest of the site screen already used.

Map selection needed a stable hashable identity for each photo. The model’s persistent identifier provided that, so marker selection could follow the same photo as the grid without making the whole model hashable. The same identifier resets map state when the surveyor switches sites.

What worked

Persistent identifiers were already on stored photos and were hashable, which matched what the map selection binding requires. They also distinguished sites so the camera could reset on a site change.

What got in the way

It was not obvious whether the model type itself could be used as the selection value. I had to reason through identifier identity instead, and I could not confirm that choice with a build.

Map markers are tagged with each photo's persistent model id so a marker click and a thumbnail click resolve to the same photo the grid already compares. The selection binding lives in the view, next to the existing photo state. This was written against the current models and was not run.

What worked

Persistent identifiers are hashable and match the identity the photo grid already uses, so the map and the thumbnails can share one selected photo. The photo type was already identifiable, and the marker list could use those same objects.

What got in the way

A persistent id is only present after the object is inserted into a model context. The selection setter accounts for a missing marker, but that path was never executed, so it is unclear whether the map would clear a selected photo that has no coordinate.

Photos were already stored with optional coordinates. I tagged each marker with the model's persistent identifier and resolved the selected photo from that id, because the model type cannot be hashed. Identifier equality stayed stable across inspector edits in the code I reviewed. The store was not run.

What worked

The persistent identifier is hashable and equatable, so it satisfied map selection and still matched the photo after other fields changed. Optional coordinates made it clear which photos should get a marker.

What got in the way

The model class is not hashable, so it could not be the map selection value and needed an identifier workaround. I also could not check whether lazily loaded relationship arrays omit photos when a marker selection is resolved.

The existing SwiftData photo and site models supplied stored coordinates and persistent identity for marker selection. Documentation was consulted to confirm model identity and hashing behavior, but the integration could not be compiled in the recorded environment.

What worked

Existing persistent models already exposed the location and identity needed by the map feature, avoiding a data-model migration.

What got in the way

Type and protocol assumptions could only be checked statically because the Swift toolchain was unavailable.

Added a derived optional coordinate property to the persisted photo model, alongside an existing boolean that reports whether both halves of a coordinate pair are present. No schema change was needed since the property is computed from stored fields.

What worked

A computed property over stored fields needs no migration and no annotation, so exposing a framework-specific value type to the view layer was a one-line addition with no persistence consequences.

What got in the way

Had to reason carefully about the identifier type the model conformance supplies, because it feeds a view identity and the documentation does not make that concrete type obvious.

The existing SwiftData models exposed the stored site address and optional photo coordinates needed by the new map, so no data migration or new persistence layer was required. Target-platform behavior was not run.

What worked

The existing model shape already contained all map inputs and supported reuse of the current selected-photo flow.

What got in the way

No macOS build or persistence test was executed in the recorded environment.

Relied on the existing SwiftData photo model and its persistent identity to tag map markers and resolve a selected marker back to the photo shown in the grid and inspector. No schema migration or storage changes were needed.

What worked

The existing model already exposed coordinates and stable identity, which kept selection synchronization localized to the view.

What got in the way

The SwiftData-backed interaction was not run because the macOS toolchain was unavailable.

Extended two existing persisted models with computed helpers (a coordinate pair that returns nil for half-missing or out-of-range values, and a formatted address line) and reused the project's existing in-memory container pattern for new unit tests.

What worked

Computed properties on model types are plain Swift and need no schema change, so adding derived values was zero-risk for the store. The persistent identifier is hashable and equatable, which made it usable directly as a view identity key. The in-memory container makes model-layer tests cheap to set up.

What got in the way

Nothing specific surfaced in this task, though none of it was executed, so the test setup is unproven here.

The existing persistent photo identifier provided a convenient stable tag for MapKit marker selection, avoiding a parallel identifier or selection model.

What worked

It fit the existing data model and allowed marker selection to resolve back to the same photo object used by the inspector.

What got in the way

The identifier-based interaction was not runtime-tested because the macOS build toolchain was unavailable.

Used persisted photo identifiers as the map selection type so marker clicks stay in sync with the existing grid and inspector, and instantiated models in tests without a live store.

What worked

Photo identifiers were already Hashable, so marker tags could share the same selection binding the rest of the UI already used.

What got in the way

It was unclear whether a service file needed an explicit SwiftData import for models in the same module, and whether blank-address tests needed an in-memory container. Neither question was settled by a compiler.

The existing SwiftData-backed site and photo models exposed the address, identifiers, and optional EXIF coordinates needed by the new view without requiring a schema change. No runtime persistence behavior was exercised in the recorded environment.

What worked

The existing model shape was sufficient for filtering complete coordinate pairs and binding map selection to the same photo objects already used elsewhere in the UI.

The existing SwiftData photo and site models exposed the optional coordinates and stored address needed by the map feature, avoiding a migration. Model behavior was inspected but not executed in a macOS build.

What worked

Existing persisted properties were sufficient for marker filtering and address display, so the feature did not require schema changes or geocoding.

What got in the way

The environment did not permit exercising persistence or selection behavior in the finished macOS app.

Relied on SwiftData persistent identifiers as stable map marker IDs after the photo model class proved a poor Map selection type. That let marker clicks update the same selected photo the rest of the screen already used. Identifier tagging against Map selection had to be reasoned from API notes rather than a running app.

What worked

Persistent identifiers gave each geotagged photo a stable, Hashable identity the map could bind to without adding another ID scheme.

What got in the way

Map selection did not accept the SwiftData model class as-is. A dedicated marker value wrapping the persistent ID was required, and whether the selection binding needed an explicit identifier cast was never confirmed by a compile.

Drove map markers from existing SwiftData photo records that already stored coordinates. Because the model types are Identifiable but not Hashable, marker tags used persistent identifiers instead of the model objects themselves.

What worked

Latitude and longitude already on the photo model were enough to filter geotagged items and place markers. Persistent identifiers were Hashable and comparable, which fit Map selection tags.

What got in the way

SwiftData models could not be used directly as Map tag values, so a lightweight identifier-based marker type was required before the map builder.

Added three optional properties to an existing persisted model to cache a geocoded coordinate and the address that produced it, and relied on model relationships and identifiers when pairing photos with map annotations.

What worked

Declaring new optional stored properties is a one-line change per field, and the persistent identifier type made a clean, stable key for annotation identity. In-memory containers make model-backed logic easy to exercise from tests.

What got in the way

Migration guarantees are thin in the documentation: adding optionals is widely described as lightweight and automatic, but nothing authoritative confirms it, so I had to flag opening an existing store as something to verify by hand. Inverse relationship population in tests also depends on behaviour that is easier to assume than to confirm from the docs.

Used existing model identifiers as map marker tags so a pin click selects the same photo in the grid and inspector.

What worked

Stable model identifiers worked as map tags and avoided a custom pin type keyed on coordinates.

What got in the way

Wrapping an identifier in an extra optional produced a nested optional that did not match the selection binding. Identifier suitability as tags had to be confirmed before use.