SPB Git

Repository Public

APPLE-APPS.md 28.2 KB

# Apple apps — MacLustr Command Center

State at 2026-11-18. The macOS app and the shared Swift package exist; the iOS / iPadOS app is described in section 11. Everything below is either verified (and says how) or explicitly marked not verified.

# 1. Pieces

Piece Path Role
MCCCore (Swift package, macOS 15 / iOS 18) packages/swift-core generated API client, transport policy, identity (passkeys), session store, event stream, offline cache, repositories, formatting + localization, shared SwiftUI components and feature models
macOS app apps/macos windows, navigation, screens, menu bar extra, notifications, deep links, local lock
Provisioning script infra/apple/provision.py (+ asc.py) bundle ids, capabilities, provisioning profiles through the App Store Connect API

# 2. Bundles and identifiers

macOS Release macOS Debug iOS / iPadOS (section 11)
Bundle id ai.spboucher.clustr ai.spboucher.clustr.debug ai.spboucher.clustr.ios (Debug: ai.spboucher.clustr.ios.debug)
Team 3YM54G49SN same same
Signing Developer ID Application + profile "MCC macOS Developer ID" (MAC_APP_DIRECT) ad-hoc ("sign to run locally"), no restricted entitlement —
Server https://clustr.spboucher.ai (fixed) overridable (MCC_BASE_URL) —
Passkeys system (ASAuthorizationPlatformPublicKeyCredentialProvider, RP clustr.spboucher.ai) system, or the software authenticator with MCC_PASSKEY=software —

The Debug build has its own bundle id on purpose: a second registered copy of the production id makes the system passkey sheet fail (error 1004), as does running from under ~/Desktop — builds go to /tmp/mcc-swift, and the release build must be run from /Applications.

# 3. Entitlements

Release (apps/macos/Support/MCC.entitlements):

Entitlement Value Why
com.apple.security.app-sandbox true App Sandbox
com.apple.security.network.client true HTTPS to the server
com.apple.security.files.user-selected.read-write true save panels (audit export, calendar .ics)
com.apple.developer.associated-domains webcredentials:clustr.spboucher.ai, applinks:clustr.spboucher.ai passkeys of the web RP, universal links
keychain-access-groups 3YM54G49SN.ai.spboucher.clustr data-protection Keychain for the session
com.apple.application-identifier, com.apple.developer.team-identifier 3YM54G49SN.ai.spboucher.clustr, 3YM54G49SN required by the two above
com.apple.developer.aps-environment production remote notifications

Hardened Runtime is on (no exception). Associated Domains, the keychain group and push are restricted entitlements on macOS: they are only honoured when the embedded provisioning profile authorises them, hence the Developer ID profile. Debug (MCC-Debug.entitlements) keeps only the sandbox, the network client and the user-selected files; consequently a Debug build has no system passkeys for the product domain, no data-protection Keychain (it uses the login keychain, or a file store in UI tests) and no remote notifications.

# 4. Associated Domains (AASA)

control-api serves /.well-known/apple-app-site-association from MCC_APPLE_APP_IDS: webcredentials.apps and applinks.details[].appIDs = the configured app ids, with components /setup and /open/*. Production must be started with MCC_APPLE_APP_IDS=3YM54G49SN.ai.spboucher.clustr (add 3YM54G49SN.ai.spboucher.clustr.ios for iOS). Apple's CDN caches the file: publish it before the first launch of the app, otherwise the passkey sheet fails with 1004 until the cache expires. Checked locally only (curl http://localhost:8760/.well-known/apple-app-site-association).

Universal links handled by the app: https://clustr.spboucher.ai/setup#<token> (the token is exchanged at once, kept in memory only, never logged) and /open/<section>, /open/{nodes|actions|alerts|incidents|services|jobs|models|maintenance}/<uuid>.

# 5. Sessions and secrets on the device

  • Access token (10 min) + rotating refresh token + device_id in the Keychain: generic password, kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly, kSecAttrSynchronizable = false, data-protection keychain, access group configurable (KeychainSecureStore(service:accessGroup:dataProtection:)). Never in UserDefaults, never in logs (SessionTokens redacts its own description).
  • Sign-out wipes the tokens; a rejected refresh (expired, revoked session or device, reuse of a rotated token) wipes tokens, device id, in-memory state and the offline cache, and returns to the sign-in screen.
  • The local lock (LocalAuthentication) is a convenience only; step-up always is a passkey ceremony verified by the server.

# 6. Push notifications (APNs)

  • The app registers for remote notifications when the build carries aps-environment and the user accepted notifications, and sends the device token with PUT /me/devices/current/push-token (environment taken from the entitlement).
  • Local notifications for firing / resolved alerts received over the event stream work while the app runs.
  • Not verified: remote delivery. The server has no APNs key (action-orchestrator logs "push notifications inactive … missing MCC_APNS_KEY_FILE"), and a Debug build has no aps-environment. The token upload endpoint itself is verified by an integration test.

# 7. Provisioning (App Store Connect API)

infra/apple/provision.py (idempotent, --check mode) registers ai.spboucher.clustr and ai.spboucher.clustr.debug, enables Associated Domains and Push Notifications, creates and installs the profiles "MCC macOS Developer ID" (MAC_APP_DIRECT) and "MCC macOS Debug Development" (MAC_APP_DEVELOPMENT), and only ever replaces profiles carrying exactly those two names.

sh
ASC_KEY_ID=L379BDKR69 ASC_ISSUER_ID=<issuer uuid> python3 infra/apple/provision.py --check
ASC_KEY_ID=L379BDKR69 ASC_ISSUER_ID=<issuer uuid> python3 infra/apple/provision.py

Status: NOT RUN. ASC_ISSUER_ID was not in the environment and is not where it was expected (ios-release.sh of another project has no ISSUER_ID default); no call was made to the App Store Connect API, so no bundle id, capability, device or profile was created. The script has therefore never been exercised against the real API; its request payloads are untested.

# 8. Release: signing, notarization, verification

sh
apps/macos/Scripts/release.sh            # archive (Release) → Developer ID signature → notarize + staple the app
                                         # → dmg → sign → notarize + staple the dmg → SHA-256 → verify-release.sh
apps/macos/Scripts/verify-release.sh dist/macos/MacLustr-Command-Center-1.0.0-1.dmg

release.sh refuses to start without the "MCC macOS Developer ID" profile. verify-release.sh checks, without installing or launching anything: codesign --verify --deep --strict, spctl -a -vv (app and dmg), stapler validate, Hardened Runtime flag, bundle id, each entitlement, the embedded profile, the absence of Debug-only code (SoftwareAuthenticator, DebugFileSecureStore, MCC_* launch overrides) and of any ATS exception. Notarization uses the keychain profile MacLustr-Notarize.

Status: NOT PRODUCED. Without the provisioning profile (section 7) a Release build cannot be signed in a form that macOS would run (restricted entitlements without a profile are refused at launch), so no dmg was built, no notarization was submitted and dist/macos/ is empty. What was verified instead: the Release configuration compiles (see the test matrix).

# 9. Test matrix

Suite Command What it covers Result (2026-11-18)
MCCCore unit cd packages/swift-core && swift test URLProtocol stub server: error mapping, bearer + single-flight refresh (20 concurrent 401 → 1 refresh), refresh rejected → wipe, GET-only retries, offline guard, cancellation, idempotency keys, dates, WebAuthn JSON mapping, software-authenticator vectors, step-up retry, SSE parser / resume / dedupe / resync / heartbeat / pause, offline cache, Resource states, event patching, formatting, catalogs 52 tests pass
MCCCore integration packages/swift-core/Scripts/integration-test.sh REAL local control-api + throwaway PostgreSQL: invitation setup → session, passkey sign-in, forged signature and wrong origin refused, single-flight refresh, refresh reuse → both holders signed out, revoked device, step-up retry, operator invitation + profile, link flow, passkey add/rename/delete/last-passkey, sign-out, push token, SSE resume without loss or duplicate + resync, live probe of 39 read endpoints (all live, all decode) 14 tests pass (66 with the unit tests, 10 suites)
App unit apps/macos/Scripts/test.sh unit logic and view models of every section, deep links, catalogs complete in fr/en (1 416 keys) 54 tests pass
App UI apps/macos/Scripts/test.sh ui XCUITest against a real local backend + orchestrator (software authenticator): invitation setup, used-link dead end, passkey sign-in; action node.maintenance.set end to end; maintenance window + note; backend stop → offline read-only with timestamps → restart → reconnection; language switch; tour of every section + universal search 6 tests pass
Generated code packages/swift-core/Scripts/generate.sh --check client and tokens are in sync with the contract and tokens.json up to date
Release compile xcodebuild -configuration Release … CODE_SIGNING_ALLOWED=NO build Release configuration compiles; binary free of Debug-only code; no ATS exception build succeeded (unsigned, not distributable)
iOS compile of MCCCore xcodebuild -scheme MCCCore -destination 'generic/platform=iOS' build the package builds for iOS 18 build succeeded

# 10. Results and known limits

Screenshots of a Debug run against the local backend (real server data, empty cluster plus one manually declared node) are in docs/screenshots/macos/. Limits:

  • Real system passkeys: not verified. A native app can only use system passkeys for a domain that serves its AASA over HTTPS; production is not deployed. The ASAuthorization path is covered by construction and by unit tests of the JSON mapping (WebAuthnJSON), and every flow is exercised end to end with the software authenticator, whose attestations and assertions the real server verifies (no server-side test hook).
  • Universal links on the real domain, APNs delivery, Keychain access group in a provisioned build: not verified.
  • Release build, notarization: not produced (section 8).
  • The UI-test runner is sandboxed by Xcode: it drives the backend and saves screenshots through apps/macos/Scripts/ui-test-control.py.
  • The generated client uses closed enums: a NEW enum value sent by a newer server fails the decoding of that response (the screen then shows an error with the correlation id). Event topics are handled leniently: an unknown topic or payload triggers a full reload instead.

# 11. iOS / iPadOS app

State at 2026-11-19. Sources in apps/ios (see apps/ios/README.md for the layout and the commands). SwiftUI only, universal (iPhone + iPad), iOS 18.0+, Swift 6 language mode. It consumes MCCCore like the macOS app; its navigation and layouts are its own (tabs on iPhone, sidebar + side-by-side panes on iPad).

# 11.1 Bundle

Release (TestFlight / App Store) Debug (simulator, Xcode)
Product / display name MacLustr / MacLustr CC same
Bundle id ai.spboucher.clustr.ios (ASC bundle resource DF4Z2ZU7UX) ai.spboucher.clustr.ios.debug (4C4D7R2VU4)
App Store Connect record id 6836652715, name "MacLustr CC", SKU maclustr-cc-ios-001, primary locale fr-CA —
Team 3YM54G49SN same
Server https://clustr.spboucher.ai (fixed) overridable (MCC_BASE_URL)
Passkeys system (ASAuthorizationPlatformPublicKeyCredentialProvider, RP clustr.spboucher.ai) system, or the software authenticator with MCC_PASSKEY=software
Session store Keychain Keychain, or `MCC_SECURE_STORE=file
ATS no exception NSAllowsLocalNetworking (localhost backend)
URL scheme none mcc-ios-debug:// (simulates links on a simulator)
APNs environment sent with the token production development

Info.plist: NSFaceIDUsageDescription, ITSAppUsesNonExemptEncryption = NO (HTTPS and system cryptography only), UIApplicationSupportsMultipleScenes, background mode remote-notification, all orientations on iPad, portrait + landscape on iPhone, LSApplicationCategoryType developer tools. Scripts/release.sh verify checks that the Release binary contains none of the Debug-only code (SoftwareAuthenticator, DebugFileSecureStore, MCC_* overrides, the Debug scheme) and no ATS exception.

# 11.2 Entitlements (apps/ios/Support/MCC.entitlements, MCC-Debug.entitlements)

Entitlement Value Why
com.apple.developer.associated-domains webcredentials:clustr.spboucher.ai, applinks:clustr.spboucher.ai passkeys of the web RP, universal links
aps-environment production (Release) / development (Debug) remote notifications
keychain-access-groups 3YM54G49SN.<bundle id> the app's own group; NOT shared with the macOS app (each device signs in with its own session and device id)
application-identifier, com.apple.developer.team-identifier added by Xcode from the profile —

The session (access token, rotating refresh token, device id) is stored exactly as on macOS (section 5): generic password, kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly, never synchronised to iCloud Keychain. No explicit access group is passed: on iOS an item lands in the app's first keychain group, the one above.

The server must list the iOS app in its AASA: start control-api with MCC_APPLE_APP_IDS=3YM54G49SN.ai.spboucher.clustr,3YM54G49SN.ai.spboucher.clustr.ios (section 4), before the first launch of the app (Apple's CDN caches the file; a missing entry makes the passkey sheet fail with 1004 and the links open Safari). Not verified against production from this work — check with curl https://clustr.spboucher.ai/.well-known/apple-app-site-association.

  • https://clustr.spboucher.ai/setup#<token> → onOpenURL / NSUserActivityTypeBrowsingWeb → AppModel.handle(url:) → the token is exchanged immediately (InvitationSetupModel.begin), lives in memory only, is never logged nor stored; review (who invites, which role) → profile when required → passkey; for an invitation aimed at an existing account: sign-in → explicit confirmation (the server asks for step-up). A used, expired or revoked link is a dead end with the correlation id. The link can also be pasted on the sign-in screen.
  • https://clustr.spboucher.ai/open/<section> and /open/{nodes|alerts|incidents|actions|services|models|jobs|maintenance}/<uuid> → the destination waits until a scene is signed in and unlocked, then opens.
  • On a simulator the same handler is driven through the Debug-only scheme: xcrun simctl openurl <udid> "mcc-ios-debug://setup#<token>" (the UI tests do this; iOS shows an "Open in MacLustr CC?" prompt for custom schemes) or the Debug launch variable MCC_OPEN_URL.

# 11.4 Push notifications — status

  • The app registers for remote notifications once the user accepted them (asked from Settings → Notifications, never at launch) and a session exists, and uploads the token with PUT /me/devices/current/push-token (environment: production for Release builds, development for Debug).
  • One notification category (MCC_ALERT) with one action, "Open" (foreground). No destructive action, no action that changes server state: a tap only opens the alert (alert_id) or the action (action_id), and only in a signed-in, unlocked scene; acknowledging, resolving or running anything goes through the in-app flows (confirmation, justification, step-up).
  • Local notifications for firing, non-suppressed alerts received over the event stream while the app is active (can be turned off in Settings).
  • Not verified: delivery. Nothing was received from APNs in this work: the simulators used for the tests do not obtain a production token, and no physical device is registered. The token upload call is the one covered by the core integration test. Whether the server's APNs key is in place is a server-side matter (section 6).

# 11.5 Background behaviour

  • Scene goes to the background → the event stream is paused (AppSession.setActive(false)), nothing runs in the background (no background fetch). Back to the foreground → the stream resumes with Last-Event-ID; if the app stayed away more than 20 s (AppModel.staleAfter) every read model on screen is reloaded as well, so that all timestamps are recent. A resync from the server reloads everything (core behaviour).
  • Transient inactivity (app switcher, the passkey sheet) does not pause the stream.
  • App lock (optional): locks at launch and when the app goes to the background (immediately, or after a grace period of 1 or 5 minutes); Face ID / Touch ID with the device passcode as fallback (LocalAuthentication). It hides the UI; it never replaces sign-in or step-up, which stay passkey ceremonies verified by the server.
  • Offline: banner "offline since hh:mm", cached data with its timestamp, every mutation disabled (nothing is queued); "reconnecting" banner while the event stream backs off. Reads are retried by the core (GET only).
  • Requests of keyed resources (node detail, metrics, processes, alert detail…) are cancelled when their view disappears (Resource.cancelLoad, added to MCCCore for this).
  • State restoration per scene: selected tab / section and the open item (@SceneStorage). A session end resets it.

# 11.6 Provisioning and signing

sh
ASC_KEY_ID=L379BDKR69 ASC_ISSUER_ID=<issuer> python3 infra/apple/provision.py --ios --check
ASC_KEY_ID=L379BDKR69 ASC_ISSUER_ID=<issuer> python3 infra/apple/provision.py --ios

The --ios mode (added next to the macOS mode, which is unchanged) registers the two bundle ids with Associated Domains and Push Notifications, creates the profile "MCC iOS App Store" (IOS_APP_STORE) only if the keychain holds an Apple / iPhone Distribution identity, the profile "MCC iOS Debug Development" only if the team has registered iOS devices, and reports whether the App Store Connect record exists.

Run on 2026-11-19: both bundle ids registered (DF4Z2ZU7UX, 4C4D7R2VU4; capabilities ASSOCIATED_DOMAINS, PUSH_NOTIFICATIONS, plus Apple's default IN_APP_PURCHASE). No named profile was created: this Mac has no distribution identity in its keychain and the team has no registered iOS device. Signing is therefore Xcode automatic signing authenticated by the API key (-allowProvisioningUpdates -authenticationKeyPath/-ID/-IssuerID): the archive is signed with the Apple Development identity, the export re-signs with the cloud-managed "Apple Distribution: Simon-Pierre Boucher (3YM54G49SN)" certificate and the profile "iOS Team Store Provisioning Profile: ai.spboucher.clustr.ios".

# 11.7 TestFlight procedure

sh
cd apps/ios
ASC_ISSUER_ID=<issuer> Scripts/release.sh archive      # bump CURRENT_PROJECT_VERSION in project.yml (or MCC_BUILD_NUMBER) first
Scripts/release.sh verify                              # 18 checks on the IPA
ASC_ISSUER_ID=<issuer> Scripts/release.sh upload       # checks the app record through the API, then `xcrun altool --upload-app`
ASC_ISSUER_ID=<issuer> python3 ../../infra/apple/testflight.py [--apply]   # processing state, export compliance, internal group

The app record cannot be created through the public API; it was created by hand in App Store Connect (id 6836652715). testflight.py --apply declares usesNonExemptEncryption = false on a build that lacks it, reuses the app's internal beta group (or creates "Interne"), makes sure the account holder is a tester and adds the build when the group does not receive every build automatically. Results of the first upload: see section 11.9.

# 11.8 Test matrix (2026-11-19)

Suite Command What it covers Result
String catalogs apps/ios/Scripts/test.sh unit (first step) every key has fr + en with the same format specifiers; every literal key used in the sources exists 1 054 keys complete in fr and en; 756 literal keys used, all present
App unit (Swift Testing, hosted by the Debug app, iPhone 17 Pro simulator) apps/ios/Scripts/test.sh unit navigation on both layouts, deep links, state restoration, app lock state machine, notification routing, launch configuration, mutation errors, logic of every area (nodes, services, models, jobs, network, storage, alerts, actions, activity, audit, maintenance calendar and notes, settings), keys built at runtime 54 tests in 7 suites pass
App UI, iPhone 17 Pro simulator (iOS 26.5) apps/ios/Scripts/test.sh ui iphone 12 scenarios below 12 tests pass (≈ 14 min)
App UI, iPad Pro 13-inch (M5) simulator (iOS 26.5), landscape apps/ios/Scripts/test.sh ui ipad the same 12 scenarios on the sidebar layout 12 tests pass (≈ 11 min)
MCCCore unit cd packages/swift-core && swift test + Resource.cancelLoad 67 tests in 10 suites pass
macOS after the core changes apps/macos/Scripts/build.sh, apps/macos/Scripts/test.sh unit the macOS app still builds; its unit tests build succeeded; 54 tests pass
Release IPA apps/ios/Scripts/release.sh archive && Scripts/release.sh verify App Store signature, profile, entitlements, version, no Debug-only code, no ATS exception 18 / 18 checks ok

UI scenarios (XCUITest, REAL local control-api + action-orchestrator on 127.0.0.1:8780 / :8782, throwaway PostgreSQL database mcc_ios_test_<random> seeded by apps/ios/Scripts/seed.sql with synthetic nodes ios-test-node-01…04, software authenticator — nothing server-side is bypassed; never run against production):

  1. setup link (simctl openurl, Debug scheme) → review → passkey → signed in; the same link again → dead end
  2. sign-out, passkey sign-in
  3. overview counts by freshness with timestamps, nodes list with the four seeded rows, node detail with the CPU performance levels by their reported names; accessibility audit of overview, nodes, node detail, alerts, actions, maintenance, settings
  4. action node.maintenance.set end to end: catalog-driven form → explicit confirmation → executed by the orchestrator (succeeded) → the node shows its maintenance mode
  5. maintenance window created with a node in scope, then a note on its occurrence
  6. seeded alert acknowledged with a comment
  7. backend stopped → offline banner, cached rows with their timestamp, mutations disabled → backend restarted → banner gone, mutations enabled, data reloaded
  8. background 25 s / foreground: overview refreshed, session kept, event stream connected
  9. language switch fr → en → fr at runtime
  10. largest Dynamic Type size (AccessibilityXXXL): key elements of Overview / Nodes / Alerts exist and are hittable, no visible text clipped (audit), screenshots
  11. screenshots (French, dark) → docs/screenshots/ios/*-iphone.png, *-ipad.png
  12. the owner creates a viewer invitation (one-time link + QR code), signs out; the viewer sets up from the link, admin panes are hidden, and the viewer's action request is refused by the server — the 403 is displayed

Accessibility audit (performAccessibilityAudit: contrast, element detection, hit region, element description, clipped text, traits), policy in UITests/MCCiOSUITests.swift:

  • fixed because of it: primary buttons (the system prominent style put a white label on the light accent — now the token's contrast colour), text buttons of the overview cards (44 pt hit area), one-line freshness and state labels that clipped at large sizes (they wrap now; StatusBadge / StatusLabel of MCCCore no longer limit to one line), card headers at accessibility sizes (the accessory goes under the title);
  • excluded, with the reason next to each rule: system bars; text scrolled under the translucent tab bar / at the scroll edge; the iPad sidebar (system List on the system material); contrast or "potentially inaccessible text" findings that carry no element (decorative, accessibility-hidden glyphs; image analysis); hit-region findings on read-only labels; the dynamicType heuristic (replaced by the real run at the largest size, scenario 10); a finding must also persist on a second pass (live data is still arriving on the first).

# 11.9 Distribution results

  • provision.py --ios: bundle ids ai.spboucher.clustr.ios (DF4Z2ZU7UX) and ai.spboucher.clustr.ios.debug (4C4D7R2VU4) registered with ASSOCIATED_DOMAINS and PUSH_NOTIFICATIONS; no named profile (11.6).
  • release.sh archive: ** ARCHIVE SUCCEEDED **, ** EXPORT SUCCEEDED ** → dist/ios/MacLustr-CC-1.0.0-1.ipa and MacLustr-CC-1.0.0-2.ipa (git-ignored); release.sh verify: 18 / 18.
  • release.sh upload (altool, API key): build 1 — "UPLOAD SUCCEEDED with no errors", delivery 448e3e27-0d56-4087-851e-55d80fdb3e21; build 2 (adjacent-month day numbers of the calendar in the secondary text colour, otherwise identical) — "UPLOAD SUCCEEDED with no errors", delivery fed79d85-a934-4dbf-9fbd-248f3148fe69.
  • testflight.py: both builds processingState = VALID, usesNonExemptEncryption = false (taken from the Info.plist, nothing to declare), internalBuildState = IN_BETA_TESTING. The app already had an internal group, "Test" (60b30f15-fc51-4144-aac9-136e72210239, access to all builds, 1 tester = the account holder): it was reused, so no group "Interne" was created and no change was needed.
  • Not verified: installation from the TestFlight app on a device, and anything listed in 11.10.

# 11.10 To validate on a real device (owner, through TestFlight)

No physical iPhone or iPad is registered on the developer account: everything above ran on simulators with the software authenticator. Remaining checks:

  1. Passkey with iCloud Keychain against clustr.spboucher.ai: sign-in, setup from an invitation, adding a passkey, step-up before a high-criticality action or an audit export. Requires the AASA to list 3YM54G49SN.ai.spboucher.clustr.ios (11.3). The ASAuthorization path is covered by construction and by the unit tests of the JSON mapping only.
  2. Universal link from Mail / Messages: https://clustr.spboucher.ai/setup#<token> opens the app (not Safari) and starts the setup; /open/alerts/<uuid> opens the alert.
  3. Face ID / Touch ID lock: enable in Settings → App lock, background the app, come back; check the grace period and the passcode fallback. (NSFaceIDUsageDescription is present; the lock was only unit-tested.)
  4. Keychain: the session survives a relaunch and a device restart after first unlock; it is gone after sign-out.
  5. Push: accept notifications in Settings → Notifications, check that the device shows push enabled in Settings → Devices, then (once the server sends) that a firing alert arrives and that the tap opens the alert without acting on it.
  6. VoiceOver pass on the main screens (overview, nodes, node detail charts — summary and audio graph —, alerts, action form and confirmation, maintenance calendar cells), plus Reduce Motion, Increase Contrast and Differentiate Without Color.
  7. iPad: Stage Manager / Split View widths (the shell switches between sidebar and tabs), a second window, keyboard shortcuts (⌘1…⌘9, ⌘R, ⌘F, ⇧⌘N), pointer hover.
  8. Poor connectivity on a cellular network (timeouts, reconnection banner).

# 12. macOS 27.0 workarounds in the app (keep until re-tested on a newer system)

  • Root screens are swapped ~150 ms after the state change (RootView), never from inside the click that causes it: an immediate swap left AppKit with a tracking area whose owner was gone (crash in -[NSTrackingArea _dispatchMouseEntered:], seen in the UI tests, intermittent).
  • .inspector is not used: in the detail column of the main NavigationSplitView it put the window in an endless "Update Constraints" pass (NSGenericException). Detail panes use the plain sidePane modifier.
  • openWindow(id: "main") always creates a window: AppModel.show activates the existing main window instead.
Files main
Menu

Theme