Every capability, verified against the source code.
Calíope ships as a single application with the capabilities below available on macOS and iPad. Every entry corresponds to code that exists today — this is a catalogue, not a wish list. Use the shortcuts to jump to a category, or scroll through the full list.
This page describes Calíope 1.2, the newest version. The App Store currently serves 1.1 — 1.2 is in review. The changelog says which version each feature landed in.
“Your SSH tunnel, without a terminal or .ssh/config.”
Reach servers behind a bastion from within the macOS sandbox — no local ssh, no ~/.ssh/config, no permission fights.
SwiftNIO + NIOSSH. Password or private-key auth (ed25519, ECDSA P-256/P-384/P-521). OpenSSH parser and in-memory passphrase decrypt. Local proxy on 127.0.0.1 bridged via SSH direct-tcpip.
“Warns you if someone intercepted your tunnel — before you type anything.”
Detects a MITM against your SSH bastion without keeping a known_hosts file on disk.
Fingerprints stored in Keychain. First connection prompts for explicit confirmation; a changed fingerprint fails hard — equivalent to StrictHostKeyChecking=yes.
“SSL that actually protects — not just a toggle.”
Turning “SSL on” means SSL verified. Self-signed certificates require a CA or an explicit opt-out with a visible warning.
Single policy: skip-verification is opt-in; a supplied CA yields no-hostname verification; otherwise full verification.
“Your passwords do not visit iCloud unless you invite them.”
You decide which credentials travel across your devices. By default, none.
Local-only mode pins credentials to WhenUnlockedThisDeviceOnly; enabling sync migrates them to AfterFirstUnlock for iCloud Keychain. Toggle is idempotent.
“Your fingerprint unlocks prod, not just your sleeping Mac.”
Add a Touch ID / Face ID gate before connecting to production servers, configurable per profile.
Built on the LocalAuthentication framework. Enabled per connection profile.
“A connection pool that always closes — even when something fails.”
Connections that do not leak resources or block the UI, even when switching sessions.
SwiftNIO EventLoopGroupConnectionPool, capped at 5 connections per event loop on a single-thread event-loop group. Async teardown with a safety timeout, and a clean SSH close when local binding fails.
“Bindings prepared, not string interpolation — from the root of the stack.”
The values you type never get concatenated into the SQL — they travel through the wire protocol, protocol-separated from the statement.
MySQLNIO native prepared statements: no bindings → simpleQuery fast path; with bindings → conn.query(sql, [MySQLData]). Statements are closed automatically on done(), so the pool never leaks. Identifiers still flow through the centralized escape helper for the residual DCL/DDL cases.
“One server, two addresses — and it tries both.”
The same server is often reached at one address from the Mac and another from the iPad. Give the profile a second address and Calíope tries it when the first does not answer, with the same port and credentials.
The destination is resolved by connectionEndpoints, never by reading the host field: the three places that open a pool receive the endpoint. Fixed order, main then alternate, with no memory of which one won — that state is exactly what cannot travel between devices. Accepts host:port for a route that publishes a different port. Ignored with an SSH tunnel, and the interface says so: there the host is resolved by the bastion, not by your device.
“The editor knows if you are in the FROM, the WHERE, or the column list.”
Write less, and make fewer mistakes, because the suggestion understands where you are inside the statement.
Suggests columns of the active table, database names, schema tokens (tables, views, functions), DML/DDL/control keywords, data types and engine-filtered SQL helper phrases.
“Unbalanced parentheses never make it to the server.”
Catches the obvious mistake before MySQL rejects it.
Detects unclosed comments, unclosed strings, unbalanced parentheses and open backtick identifiers. O(n) scan, no full parser.
“Formats your queries — never rewrites your UPDATE.”
Pretty formatting for SELECT, with no surprises on an UPDATE without a WHERE.
Knows 150+ keywords, types and functions. Safe mode blocks auto-format on destructive statements (ALTER, CREATE, DELETE, DROP, GRANT, TRUNCATE, UPDATE, REPLACE, RENAME) to prevent accidental rewrites.
“Sync your history, not your credentials.”
Your query log does not become a password file on iCloud.
Neutralises IDENTIFIED BY, IDENTIFIED WITH … AS, IDENTIFIED BY PASSWORD, SET PASSWORD FOR and PASSWORD(…). Idempotent redaction, applied before exporting the query log to CloudKit.
“Compose queries with clicks; they come out production-ready.”
A correct SELECT … WHERE … JOIN … without memorising syntax.
Dedicated visual builders for the four most frequent shapes: SELECT, WHERE, UPDATE, and table CREATE.
“Rename id without breaking client_id.”
Refactor identifiers safely, without wrecking similar names.
Regex with \b word boundaries and proper regex escaping. Never matches inside larger identifiers.
“⌘⇧O and you are on the table you were looking for.”
Reach any schema object without walking down the tree.
Incremental fuzzy search across tables, views, routines and objects, with arrow-key navigation and Enter to open.
“Your snippets adapt to the engine, not the other way around.”
Your SQL recipes are always at hand, filtered to the engine you are using.
Local JSON storage. Each snippet declares which engines it applies to (MySQL, MariaDB…). Connecting to a new engine seeds defaults without duplicates. Supports categorisation.
“The docs for GROUP_CONCAT open where you're typing.”
Documentation without leaving the editor or opening a browser.
Shows the signature of the SQL function or the DDL of the schema object under the cursor.
“Edit the cell, see the SQL, and decide.”
Change data quickly and preview the exact SQL that will be executed.
Spreadsheet-like editing on result sets, with a preview of the generated UPDATE or DELETE before it runs.
“Replay your SQL session like a video.”
Debug a batch of queries statement by statement, without rerunning the whole thing.
Timeline-based replay of executed statements, tied to the persistent query history.
“iPad keyboard with SQL superpowers.”
Fast touch suggestions right above the on-screen keyboard.
Contextual bars for the object or function under the cursor, with quick access to “View DDL” and function parameters.
“Your toolbar, in your order.”
Each person has their own ergonomics; DBAs reorder once and forget.
Reorder or hide button groups from a dedicated customiser sheet. Layout is persisted.
“One search across every text column you have.”
Search a string in every text column of every table at once, see the matches per table and column, preview the result computed by the server, and replace in bulk inside a transaction per table.
It shows two counts, not one: collation usually ignores case and REPLACE() never does, so without that warning a bulk edit announces 300 rows and changes 100 without anything failing. The mismatch is measured with CAST(col AS BINARY) rather than a named collation. Generated, primary-key and unique columns are excluded by default — MariaDB accepts an UPDATE on a generated column, reports one affected row and changes nothing. Escaping uses |, because a backslash breaks under NO_BACKSLASH_ESCAPES.
“Your GEOMETRY columns stop being 25 bytes.”
Points, lines and polygons drawn on a map docked in the editor, with satellite and flat styles, clustering and a fit-to-data control. Drag a pin or a vertex and Calíope composes the statement — it shows it to you before writing anything.
The WKB on the wire is always (longitude, latitude); what changes is the text, because MySQL 8 under a geographic SRID prints latitude first and MariaDB never does. The swap lives only at the textual boundary, where the parameter has no default value: getting it wrong does not raise an error, it moves the row to another continent and the server accepts it. The SRID travels with the geometry, editing is blocked without a reliable primary key and it says why, and there is no CoreLocation anywhere.
“Your schema, in a tree that mirrors how you think.”
One view for the whole server catalog.
Databases → tables / views / routines / triggers / events, with lazy loading and contextual actions: DDL, columns, indexes, data import, WHERE builder.
ALTER generation“Diff your schema, generate the ALTER, review before applying.”
Promote a schema from staging to prod without collecting diffs by hand.
Compares two schemas and generates the ALTER TABLE needed to bring one to the other. Column comparison runs concurrently via structured concurrency. Source of truth: INFORMATION_SCHEMA.
“Know what DDL you ran, when, and against which server.”
Traceability of schema changes, without touching the server.
Every CREATE / ALTER / DROP / RENAME is recorded locally with timestamp and target server, in the app's local SQLite store.
“From staging to prod in three clicks — with a preview.”
Clone objects across environments without mysqldump or hand-crafted .sql files.
Dual connection (source + destination), granular selection of tables, views, routines, triggers and events, with options for REPLACE, include data, or skip foreign keys. SQL preview before execution.
“One editor per object type, not a generic .sql for everything.”
Edit routines and events properly, in an editor built for the object.
Dedicated sheets for stored routines, triggers, events, views and indexes. Each emits well-formed DDL.
“OPTIMIZE, ANALYZE and REPAIR, in one button.”
Housekeeping for MyISAM/InnoDB tables without memorising the commands.
Runs OPTIMIZE TABLE, REPAIR TABLE and ANALYZE TABLE with progress feedback.
“GRANTs and REVOKEs — with checkboxes.”
Manage server users without hand-writing every GRANT.
CREATE / ALTER / DROP USER, plus GRANT and REVOKE from a dedicated UI.
“The indexes you have too many of, and the ones you're missing — with evidence.”
Identify redundant or missing indexes using data the server already exposes.
Advisor view that analyses index usage, paired with a dedicated editor for the index catalog.
“Profile the column, don't guess the data.”
Understand the quality of your data before writing the analytical query.
Per-column distributions: histogram, percentiles and cardinality.
“The ER diagram you no longer have to draw.”
Document relationships without drawing boxes in Miro.
Automatic generation from the active schema, with foreign-key visualisation.
“Document databases, with their own vocabulary.”
Browse collections and documents, edit them as JSON, write filters and aggregation pipelines, manage indexes and check the server, its running operations and its users — without leaving the app you already use for MySQL.
Self-contained tool: nothing of MongoDB touches the relational provider layer. Documents are shown as collapsible trees with the type of every value (ObjectId, decimal128, dates, binaries), because a collection has no schema and two neighbouring documents may share no field. Extended JSON in both directions with its own parser, so field order and numeric widths survive a round trip. Reuses the connection profile, the Keychain and the native SSH tunnel. Paginated cursors that are closed when abandoned.
“Two engines, one app: your remote MySQL and your local SQLite.”
Open and edit the .sqlite of an iOS app or a Python script in the same tool where you administer MySQL — with an explicit transaction before anything is written.
Self-contained layer (SQLiteConnection actor over the system C API — it does not use MySQLKit) with Structure · Data · Execute SQL · Pragmas: table, index and view designers, rename, search and filters, pagination and sorting, advanced cell editor, Save/Revert transactions, maintenance (integrity_check, VACUUM, ANALYZE, REINDEX), editable pragmas and CSV · JSON · SQL import/export. Sandbox-safe through security-scoped bookmarks. Unencrypted databases only.
“Reading a file shouldn't require a connection.”
Read the documentation .md, a colleague's .sql, a config .json, an exported .csv, an .rtf someone sent you or a server .log without leaving the app, without connecting, and with no risk of running anything by accident.
Read-only, one file at a time, resolved by extension: own Markdown renderer (ATX and setext, nested lists, checklists, fenced and four-space indented code, quotes, rules, GFM tables), SQL highlighter, JSON formatter, RFC 4180 CSV reader with separator detection, and an RTF reader that keeps structure and emphasis — headings, nested lists, bold, italic, underline, strikethrough, links and alignment — while typeface, sizes and colours stay Calíope's, so the text scales with Dynamic Type and reads in either theme. Everything is parsed off the main thread and reaches the view as inert data. Watches the file path with DispatchSource, so it survives atomic saves. Declared ceilings, stated in the footer: 5 MB read, 500 KB SQL highlighting, 2 MB JSON formatting, 10,000 rows and 64 CSV columns. Never opens the network — remote Markdown images show their alt text.
Bring-Your-Own-Key. The subscription does not include AI credits — you use your own API key. This is disclosed openly on the paywall: “The AI assistant requires your own OpenAI, Google Gemini or Anthropic Claude API key (not included in the subscription).”
“AI that runs on your tokens, not on your subscription bill.”
Use the model you already pay for, and don't depend on Calíope raising prices per token.
OpenAI (GPT-4, GPT-4o, o1, o3) with Bearer token. Google Gemini with API key; filtered to models exposing generateContent. Anthropic Claude (claude-*) with x-api-key and the system prompt kept in its own field (not inside messages). Bilingual system prompt with the active-schema context, keeping the last three exchanges.
“Your key never appears in a stack trace.”
If an error message escapes to a screenshot or a Slack channel, your API key does not travel with it.
Regex-based masking for sk-* (OpenAI), AIza* (Gemini), sk-ant-* (Anthropic Claude, including sk-ant-api03-…), and Bearer … in any provider error message.
Retry-After“If OpenAI says wait, Calíope waits exactly that long.”
Rate-limit spikes don't break your session.
On 429 / 503, retries up to three times (1s / 2s / 4s), honouring the Retry-After header. Timeouts: 30 s for generation, 15 s for listing models.
“Speak the question; run the SQL.”
Dictate a request and have the assistant turn it into SQL — useful on iPad and in hands-busy pair-DBA sessions. Your voice never leaves the device.
Built on Apple's SpeechAnalyzer and DictationTranscriber (macOS 26 / iPadOS 26): recognition runs on the device, no audio is sent to any server, and dictation works offline. The language model is fetched once, with visible progress, in the language you set in Calíope. Only the microphone permission is requested — on-device recognition needs no speech-recognition permission. Live partial results.
“A conversation with your database, not an isolated prompt.”
Ask “now with a LEFT JOIN” and it knows which query you meant.
Keeps context of the active schema plus the last few exchanges, per conversation.
“Backups with native gzip — and no accidentally exported passwords.”
Compact, safe-by-default dumps — nobody exports password hashes by accident.
Generates .sql with options for drop-before, include data, include users, include user credentials (opt-in, default off), and native gzip compression. CREATE USER / ALTER USER / GRANT are neutralised when credentials are excluded. Progress events with ETA.
“Backups that don't rely on you remembering.”
Your Mac takes the backup on time, even if it was asleep, and doesn't fill up your disk.
Daily or weekly schedules. Uses security-scoped destination bookmarks to work inside the sandbox. Handles missed schedules across app restarts, nanosecond-suffixed filenames to avoid collisions, retention purge, and success/error/skip notifications.
“From a spreadsheet to a table in three clicks.”
Import real-world tabular files — not just the happy-path CSV.
RFC 4180-style CSV (escaped quotes, fields with commas), JSON (array of objects) and streaming XLSX. Modes: INSERT, INSERT IGNORE, REPLACE.
“The command you ran on Tuesday, in two seconds.”
Search thousands of past queries by SQL text or date.
Local SQLite store in Application Support with tables for executed queries and the DDL audit log, indexed by query text (asc) and date (desc).
“Your SQL history, in your iCloud, without your credentials.”
Search your Mac's history from your iPad — with credentials stripped out.
CloudKit container iCloud.org.caliope.caliope, batches of 400 records, configurable retention (default 30 days). Applies credential redaction before uploading. Verifies iCloud account status before syncing.
“You decide what goes to iCloud.”
Sync only what you care about — not all or nothing.
Independent toggles for Keychain iCloud sync and query-log iCloud sync, from Preferences.
“722 MB dumped with 68 MB of memory.”
Backup and restore no longer depend on how much RAM the machine has. A 722 MB dump with 4 million rows peaks at 68 MB; restoring it takes 19 seconds using 14 MB. Cancelling actually stops the dump instead of letting it run to the end.
The engine orchestrates and the provider writes SQL: adding an engine to backup means implementing BackupDataSource and nothing else — the test harness implements it in memory with SQLite and Postgres dialects without touching the engine. Restore pulls one statement at a time instead of being pushed, because a buffered stream drops statements in silence and finishes announcing success. Reading uses read(2) and not a mapped file: the same splitting measured +201 MB resident with FileHandle and 1.1 MB this way.
“Before touching iCloud, there is a copy.”
Export and import everything Calíope keeps outside the device — profiles, groups, preferences — with scheduled copies to the iCloud container and local restore points taken automatically before anything risky: enabling or disabling sync, erasing, importing.
It exists because of a measured incident: turning sync on for an iPad replaced a 16 470-byte connections.json with 28 profiles by a 514-byte one holding a sample profile. Secrets are opt-in and always encrypted (AES-GCM, PBKDF2-SHA256 with 210 000 iterations, salt and cost written into the file). Whatever is left out is written into the copy with its reason — a copy that hides its omissions is the one that makes you believe you can restore everything. Restoring merges; a backup never deletes.
“What you need to look up, without the Mac in front of you.”
A separate iPhone app with five tabs — Connections, Snippets, History, AI Assistant and Diagnostics. It carries what Calíope already syncs: your connection profiles, your saved snippets, your query history, your assistant conversations and the error log. Face ID to unlock, five languages, and a demo mode to look around before you connect anything.
It ships no database driver: the Companion never connects to your servers. Everything it shows arrives through iCloud, so without iCloud it has nothing to read — and it says so, instead of showing an empty screen and letting you assume all is well. Connection profiles are the only thing it writes, merged into the shared file so the fields the phone does not know — SSH tunnel, certificates, character set — are preserved untouched. The error log is read-only: pruning and deleting stay on the desktop, because a phone that can wipe the log of an open incident is a quiet way to lose the evidence.
“Metrics of your MySQL, stored in your MySQL.”
Historical monitoring without installing Prometheus.
A dedicated collector writes snapshots to a storage server of your choice, provisioning tables for samples (CPU, memory, connections, QPS) and events (threshold breaches, replication lag). Automatic retention.
“Your query plan as a diagram that breathes.”
Spot the ALL that's killing your query without reading JSON by hand.
Takes EXPLAIN FORMAT=JSON and draws it as a tree. Colour-coded by access type: full scan, range / index merge, optimised, sort, join. Tooltips with access_type, estimated rows and timing. Scroll-wheel zoom and pan.
“See where you're losing the milliseconds.”
Locate which phase of the query is taking the time.
Built on SHOW PROFILE. Table plus bar chart per phase (starting, Sending data, and so on) with millisecond timing.
KILL“A KILL for the query that hung your prod.”
Terminate a runaway query without opening a terminal.
SHOW FULL PROCESSLIST with columns for id, user, host, database, command, time, state and info. Actions for KILL QUERY and KILL CONNECTION.
“MySQL 8 and 5.7 replicas, in the same panel.”
See replica lag without fighting the legacy vs. 8.0 vocabulary.
SHOW REPLICA STATUS (MySQL 8) with automatic fallback to SHOW SLAVE STATUS (MariaDB 10.5 / MySQL 5.7). Metrics: IO/SQL running, seconds behind source, last errors with timestamp, GTID sets, log positions. Configurable auto-refresh.
PURGE“Your binlog, filterable and prunable — from the app.”
Audit which events your statements produced without dropping to mysqlbinlog.
SHOW BINLOG EVENTS with categorisation into DDL / DML / System, text search, and a configurable row limit (default 300). Supports encrypted binlogs (MySQL 8.0.14+). PURGE BINARY LOGS TO with explicit confirmation.
“The pulse of your MySQL, in one view.”
Consolidate server health without opening five clients.
Multi-tab Server Info (global & session variables, global & session status, HDD usage), Server Dashboard with live charts, and a Server Health Monitor.
“Two queries on the scale; one wins.”
Choose between two queries with evidence, not intuition.
Compares execution times of query variants side by side.
“Your Mac tells you when the replica falls behind.”
The system pings you — you don't have to keep staring at the app.
Threshold alerts on CPU, memory, connections and replication lag. Native macOS/iOS notifications.
“What is running no longer disappears when you switch tabs.”
Queries, backups, migrations and scheduled jobs are all registered in one place, with elapsed time, destination and a Stop that actually stops. Visible from the sidebar footer, from the tab that is working and from the server switcher.
Operations enrol themselves — nothing polls anyone else's flags, because a register that guesses ends up lying in both directions. Tasks (which start and end) and modes (which stay on until someone turns them off) are different types, so a mode carries no progress bar or stopwatch. A batch survives its view being destroyed: the controller lives in a store keyed by tab, not in the view's state. Threshold of 0.8 s before anything appears — a 40 ms query is not a process.
“A failure with a cause, a suggestion and a record.”
When something goes wrong, Calíope says what happened, suggests what to check and links to the matching help topic. It all lands in a log with its date and device, which the iPhone companion can read from anywhere.
No error code names an engine: the native code table lives with its provider, so adding one is implementing a protocol. The native number is read from the typed packet, not scraped from the message — MySQLNIO does not print it, so a credentials failure used to be classified as a connection failure and sent you to check the port. The companion is read-only: pruning and deleting stay on the desktop. And «no errors» is an assertion — six different reasons for an empty screen are told apart, because giving the good news when the channel is simply closed is its own kind of lie.
“Server status, glanceable, on your desktop.”
See the pulse of your server without opening Calíope.
Small, Medium and Large families. Snapshots read from a shared app group with file coordination for safe concurrent reads. Payloads larger than a safe threshold are rejected (DoS protection).
“Your MySQL on the iPad Lock Screen.”
Server metrics on your iPad's lock screen — seconds away.
Seven families total: Small, Medium, Large, ExtraLarge, plus accessory Rectangular, Circular and Inline (iOS 16.1+).
“Tap the widget → the right server's dashboard, in one move.”
One tap and you're on the correct server's dashboard.
Widget URL caliope://server/<uuid> when a profile is bound; falls back to caliope:// otherwise.
“One widget per server — edited like a weather widget.”
Pin a different widget to each server — configured in seconds.
Configurable via the system's widget-edit UI through an AppIntentConfiguration. No code required from the user.
“Refreshes when it matters; sleeps when it doesn't.”
The widget doesn't drain your battery and still shows fresh data.
Timeline policy hands control to WidgetKit, respecting the system's refresh budget. Falls back to the latest snapshot when no fresh data is available.
“A SELECT COUNT(*) from Siri, without opening Calíope.”
Run a query or list databases from Shortcuts, without opening the app.
Registered intents: connect to server, execute query (returns TSV with headers), list databases, open workspace tab. Backed by an internal bridge exposing session and database managers to AppIntents.
.sql file handling“Knows how to open from Spotlight with a .sql — like any native app.”
Behaves like a real Mac app — not a Windows or Electron port.
Full menu bar: About, Open SQL file, Recent files, Quick Open, tab navigation, Help, What's New, Privacy Policy, Support. Handles .sql file opens via NotificationCenter.
“A menu-bar icon: you know if you're connected without switching windows.”
Connection context at a glance, without bringing the app to the front.
Menu-bar icon reflecting connection state and active profile.
“Discover what you need, when you need it.”
Learn about features at the moment they're relevant.
Contextual tips for Quick Open, WHERE Builder, Data Import, DDL Audit Log, Binlog Viewer, Replication Monitor, Object Migration, Visual EXPLAIN, Query Profiler and Schema Tree.
“The SQL you write on the Mac is waiting on the iPad — even with the Mac powered off.”
On iPad with a Magic Keyboard, work as you would on the Mac.
Optional iCloud sync carries your connections, editor contents and preferences between devices — no proximity or Bluetooth required. Native pointer and keyboard handling on iPad. Gestures: pinch on the editor to scale the font, swipe on result rows, long press for context menus, pan and zoom in ER diagrams and Visual EXPLAIN, draggable panel dividers. Split View.
“Docs-ready screenshots — not amateur captures.”
Take documentation-ready screenshots with a consistent look.
Cmd+Opt+P on macOS produces PNGs styled for documentation and marketing.
“New things, inside the app — not in a changelog.”
Learn what's new without reading the App Store's release notes.
Per-version highlights, with local “already seen” state.
“Calíope speaks your language — Spanish, English, French, German or Italian.”
An app designed in Spanish first, so it doesn't feel like a machine translation.
Full en, es, fr, de and it resource bundles, with a runtime language manager and localisation helper. English fallback.
“Sandbox on — does what it says, and nothing more.”
Calíope cannot access anything outside its declared entitlements. The system enforces it.
App sandbox enabled with a narrow entitlements set: network client and server (for the SSH proxy), audio input (voice-to-SQL), user-selected files (documents), app groups (for widgets) and iCloud (CloudKit and Cloud Documents).
“One button, and nothing is left behind.”
A button to leave the machine clean before you return or sell it.
On-demand secure deletion of sessions, credentials and the query log.
“Honest subscription — the AI is on your key, and we say so.”
You know exactly what the subscription pays for and what it doesn't.
The paywall displays a BYOK note and an auto-renewal notice, complying with App Store §3.1.2c.
“One free week, no tricks.”
Try Calíope for a week at no cost, and cancel from your Apple ID.
Annual product with a one-week free trial. Verification via StoreKit 2's AppTransaction.shared and Transaction.latest(for:). Restore via AppStore.sync(). Price always presented from product.displayPrice.
“Six places, one report, no silent failures.”
The erase button reaches local files, the iCloud Drive container, the key-value store, CloudKit and the app group — and publishes a tombstone so your other devices erase too instead of re-uploading everything.
A remote erase does not consult the sync switch: the switch says whether things go up from now on, not whether something is already up there, and whoever turned it on, uploaded and turned it off is exactly the case a privacy erase cannot leave out. The propagation is asymmetric so it cannot loop, and the comparison is > rather than != so an old tombstone republished by a sleeping device does not trigger a second erase. The report has one line per channel with its count and its failure — the previous version was written with silent try? and always ended in «everything was deleted successfully», a sentence that could not be false even with CloudKit down.
Every capability on this page ships with the annual subscription. One week free trial, cancel anytime from your Apple ID.