Native iCloud apps for Windows and Linux, built in Rust. Notes, Reminders, Calendar, Contacts, Drive and Photos, offline and in sync with your iPhone.
Rust apple-notesapple-reminderscloudkitcrdtdesktop-appicloudicloud-calendaricloud-driveicloud-notesicloud-photosiphonelinuxlinux-desktoplocal-firstoffline-firstprivacyrusttauritauri-appwindows
Backend: faster first sync, offline edits, data safety, security, new app ID
Yashwanth Kamireddi35fdd56912c9
diff --git a/.github/workflows/release.yml b/.github/workflows/release.ymlnew file mode 100644index 0000000..8d734ea--- /dev/null+++ b/.github/workflows/release.yml@@ -0,0 +1,82 @@+# A release, from one tag: `git tag v0.2.0 && git push origin v0.2.0`.+# linux — .deb, .rpm and .AppImage, built on Ubuntu 24.04 (its libheif is new enough), and+# each one installed or started on a clean machine before it is kept;+# windows — the Windows pipeline (windows.yml): its tests, the .msi and .exe, the smoke test;+# publish — every file in one draft release with its checksums, for a person to read over+# and publish. Nothing is published by itself.+name: Release++on:+ push:+ tags: ["v*"]++permissions:+ contents: read++jobs:+ linux:+ runs-on: ubuntu-24.04+ timeout-minutes: 60+ steps:+ - uses: actions/checkout@v4+ - name: Build dependencies+ run: |+ sudo apt-get update+ sudo apt-get install -y --no-install-recommends \+ libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev \+ libsecret-1-dev libheif-dev libfuse3-dev pkg-config patchelf rpm file+ - uses: actions/setup-node@v4+ with:+ node-version: 22+ cache: npm+ - uses: dtolnay/rust-toolchain@stable+ - uses: Swatinem/rust-cache@v2+ - run: npm ci+ - name: Build the packages+ # The build machine's paths are never written into the program.+ env:+ RUSTFLAGS: --remap-path-prefix=${{ github.workspace }}=pomander+ run: npx tauri build+ - name: The .deb installs and its program starts+ run: |+ sudo apt-get install -y ./target/release/bundle/deb/*.deb+ prog=$(dpkg -L $(dpkg-deb -f target/release/bundle/deb/*.deb Package) | grep -m1 '/usr/bin/')+ echo "installed: $prog"+ # Started headless just long enough to show it loads every library it links.+ ldd "$prog" | grep -q "not found" && { ldd "$prog" | grep "not found"; exit 1; } || true+ - name: Checksums+ run: |+ cd target/release/bundle+ sha256sum deb/*.deb rpm/*.rpm appimage/*.AppImage | sed 's# [a-z]*/# #' > SHA256SUMS-linux.txt+ cat SHA256SUMS-linux.txt+ - uses: actions/upload-artifact@v4+ with:+ name: pomander-linux+ path: |+ target/release/bundle/deb/*.deb+ target/release/bundle/rpm/*.rpm+ target/release/bundle/appimage/*.AppImage+ target/release/bundle/SHA256SUMS-linux.txt+ if-no-files-found: error++ windows:+ uses: ./.github/workflows/windows.yml+ with:+ test_first: true++ publish:+ needs: [linux, windows]+ runs-on: ubuntu-24.04+ permissions:+ contents: write+ steps:+ - uses: actions/download-artifact@v4+ with:+ path: dist+ - name: A draft release with every file+ env:+ GH_TOKEN: ${{ github.token }}+ run: |+ find dist -type f \( -name '*.deb' -o -name '*.rpm' -o -name '*.AppImage' -o -name '*.msi' -o -name '*-setup.exe' -o -name 'SHA256SUMS*' \) -print0 \+ | xargs -0 gh release create "$GITHUB_REF_NAME" --repo "$GITHUB_REPOSITORY" \+ --draft --verify-tag --title "Pomander ${GITHUB_REF_NAME#v}" --generate-notesdiff --git a/.github/workflows/windows.yml b/.github/workflows/windows.ymlindex 7edd3cf..4e251ed 100644--- a/.github/workflows/windows.yml+++ b/.github/workflows/windows.yml@@ -1,9 +1,11 @@# Pomander for Windows, proven on Windows before anyone downloads it:# 1. test — the whole test suite on a Windows machine, the real Credential Manager included;+# ui — every interface suite in Edge (WebView2's engine), each screen photographed;# 2. build — the .msi and the per-user .exe installer, only if every test passed;# 3. smoke — the .exe installed silently, Pomander launched, its window seen on screen, and a# screenshot kept, so an installer that cannot even start is never handed over.-# Run by hand (Actions → Windows build → Run workflow) or by a release tag; never on every push.+# Run by hand (Actions → Windows build → Run workflow) or by a release (release.yml); never on+# every push.name: Windows buildon:@@ -13,8 +15,12 @@ on:description: "Run the whole test suite on Windows before building"type: booleandefault: true- push:- tags: ["v*"]+ # A release (release.yml) builds Windows through this same, proven pipeline.+ workflow_call:+ inputs:+ test_first:+ type: boolean+ default: truepermissions:contents: read@@ -32,12 +38,67 @@ jobs:cache: npm- uses: dtolnay/rust-toolchain@stable- uses: Swatinem/rust-cache@v2+ # HEIC decoding: libheif with libde265, decoding only, linked in statically.+ - uses: actions/cache@v4+ with:+ path: C:\vcpkg\installed+ key: vcpkg-libheif-libde265-x64-windows-static-md-v1+ - name: HEIC decoder+ shell: pwsh+ run: |+ & "$env:VCPKG_INSTALLATION_ROOT\vcpkg.exe" install "libheif[core,libde265]:x64-windows-static-md"+ "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" >> $env:GITHUB_ENV+ "VCPKGRS_TRIPLET=x64-windows-static-md" >> $env:GITHUB_ENV- run: npm ci# The window's files must exist for the app crate to compile.- run: npm run build- name: Tests, on Windowsrun: cargo test --workspace --no-fail-fast+ # Every interface suite in Microsoft Edge — the engine WebView2 is — with Windows' own fonts,+ # and every screen photographed light and dark, to be looked at.+ ui:+ if: ${{ github.event_name != 'workflow_dispatch' || inputs.test_first }}+ runs-on: windows-latest+ timeout-minutes: 45+ steps:+ - uses: actions/checkout@v4+ - uses: actions/setup-node@v4+ with:+ node-version: 22+ cache: npm+ - run: npm ci+ - run: npx vite build+ - name: Interface suites, in Edge+ shell: pwsh+ env:+ ENGINE: msedge+ run: |+ $shots = "$PWD\shots"; New-Item -ItemType Directory -Force $shots | Out-Null+ $env:TMPDIR = $shots+ $preview = Start-Process npx -ArgumentList "vite","preview","--port","4173","--strictPort" -PassThru -WindowStyle Hidden+ for ($i = 0; $i -lt 30; $i++) { try { Invoke-WebRequest http://localhost:4173 -UseBasicParsing | Out-Null; break } catch { Start-Sleep 1 } }+ node .uiverify/look-all.mjs $shots 1400 850 dark+ node .uiverify/look-all.mjs "$shots" 1400 850 light+ Get-ChildItem $shots -Filter "all-*.png" | ForEach-Object { Rename-Item $_.FullName ($_.Name -replace "^all-", "screen-") -ErrorAction SilentlyContinue }+ $failed = @()+ $suites = Get-ChildItem .uiverify -Filter *.mjs | Where-Object {+ $_.Name -notmatch '^(look|dbg|engine|stub|assert)' -and $_.Name -notmatch '\.test\.mjs$' -and (Select-String -Path $_.FullName -Pattern 'engine.mjs' -Quiet)+ }+ foreach ($t in $suites) {+ node $t.FullName *> "$shots\$($t.BaseName).log"+ if ($LASTEXITCODE -ne 0) { $failed += $t.Name; "FAIL $($t.Name)" } else { "ok $($t.Name)" }+ }+ Stop-Process -Id $preview.Id -ErrorAction SilentlyContinue+ "$($suites.Count - $failed.Count) of $($suites.Count) suites passed in Edge"+ if ($failed.Count) { $failed | Set-Content "$shots\FAILED.txt"; exit 1 }+ - uses: actions/upload-artifact@v4+ if: always()+ with:+ name: pomander-ui-in-edge+ path: shots+ if-no-files-found: ignore+build:needs: test# After the tests pass — or straight away when a build was asked for without them.@@ -54,6 +115,17 @@ jobs:- uses: Swatinem/rust-cache@v2with:workspaces: ". -> target"+ # HEIC decoding: libheif with libde265, decoding only, linked in statically.+ - uses: actions/cache@v4+ with:+ path: C:\vcpkg\installed+ key: vcpkg-libheif-libde265-x64-windows-static-md-v1+ - name: HEIC decoder+ shell: pwsh+ run: |+ & "$env:VCPKG_INSTALLATION_ROOT\vcpkg.exe" install "libheif[core,libde265]:x64-windows-static-md"+ "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" >> $env:GITHUB_ENV+ "VCPKGRS_TRIPLET=x64-windows-static-md" >> $env:GITHUB_ENV- run: npm ci- name: Build the installers# The build machine's paths are never written into the program.@@ -65,14 +137,14 @@ jobs:run: |$files = Get-ChildItem target/release/bundle -Recurse -Include *.msi,*.exe$files | ForEach-Object { "{0} {1}" -f (Get-FileHash $_ -Algorithm SHA256).Hash.ToLower(), $_.Name } |- Set-Content target/release/bundle/SHA256SUMS.txt+ Set-Content target/release/bundle/SHA256SUMS-windows.txt- uses: actions/upload-artifact@v4with:name: pomander-windowspath: |target/release/bundle/msi/*.msitarget/release/bundle/nsis/*.exe- target/release/bundle/SHA256SUMS.txt+ target/release/bundle/SHA256SUMS-windows.txtif-no-files-found: errorsmoke:@@ -95,6 +167,11 @@ jobs:if (-not $exe) { $exe = Get-ChildItem "$env:LOCALAPPDATA" -Recurse -Filter pomander.exe -ErrorAction SilentlyContinue | Select-Object -First 1 }if (-not $exe) { throw "Pomander was not installed" }"installed at $($exe.FullName)"+ # Alerts are sent as the app the Start menu knows; without that ID on its entry they+ # came from "Windows PowerShell".+ $entry = Get-StartApps | Where-Object { $_.Name -eq "Pomander" } | Select-Object -First 1+ if (-not $entry -or $entry.AppID -ne "io.github.yashwanthkamireddi.Pomander") { throw "Start menu entry has app ID '$($entry.AppID)', not io.github.yashwanthkamireddi.Pomander" }+ "start menu app ID: $($entry.AppID)"$p = Start-Process $exe.FullName -PassThru$title = ""for ($i = 0; $i -lt 30 -and -not $title; $i++) {diff --git a/Cargo.lock b/Cargo.lockindex edf0392..d024d62 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -8,6 +8,16 @@ version = "2.0.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"+[[package]]+name = "aead"+version = "0.5.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"+dependencies = [+ "crypto-common",+ "generic-array",+]+[[package]]name = "aes"version = "0.8.4"@@ -19,6 +29,29 @@ dependencies = ["cpufeatures 0.2.17",]+[[package]]+name = "aes-gcm"+version = "0.10.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"+dependencies = [+ "aead",+ "aes",+ "cipher",+ "ctr",+ "ghash",+ "subtle",+]++[[package]]+name = "aes-kw"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "69fa2b352dcefb5f7f3a5fb840e02665d311d878955380515e4fd50095dd3d8c"+dependencies = [+ "aes",+]+[[package]]name = "ahash"version = "0.8.12"@@ -798,6 +831,15 @@ version = "1.0.13"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "914a755b7c2d4af2bdcff7ce1739e2db9a1b81a9b07123d8015786ae03c0980d"+[[package]]+name = "ctr"+version = "0.9.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"+dependencies = [+ "cipher",+]+[[package]]name = "darling"version = "0.24.1"@@ -1578,6 +1620,16 @@ dependencies = ["wasm-bindgen",]+[[package]]+name = "ghash"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"+dependencies = [+ "opaque-debug",+ "polyval",+]+[[package]]name = "gio"version = "0.18.4"@@ -3216,6 +3268,12 @@ version = "1.21.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"+[[package]]+name = "opaque-debug"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"+[[package]]name = "open"version = "5.4.4"@@ -3329,6 +3387,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"dependencies = ["digest",+ "hmac",][[package]]@@ -3466,6 +3525,18 @@ dependencies = ["windows-sys 0.61.2",]+[[package]]+name = "polyval"+version = "0.6.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"+dependencies = [+ "cfg-if",+ "cpufeatures 0.2.17",+ "opaque-debug",+ "universal-hash",+]+[[package]]name = "portable-atomic"version = "1.15.0"@@ -3637,6 +3708,7 @@ dependencies = ["tauri-plugin-opener","tauri-plugin-single-instance","tauri-plugin-window-state",+ "tauri-winrt-notification","tempfile","tokio","uuid",@@ -3684,16 +3756,21 @@ dependencies = [name = "quince-icloud"version = "0.1.0"dependencies = [+ "aes",+ "aes-gcm",+ "aes-kw","base64 0.22.1","flate2","futures-util","jiff",+ "pbkdf2","plist","quince-core","reqwest 0.12.28","serde","serde_json","sha1",+ "sha2","thiserror 2.0.20","tokio","uuid",@@ -3775,9 +3852,9 @@ dependencies = [[[package]]name = "quinn-proto"-version = "0.11.17"+version = "0.11.19"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "04759210543be93709136e28212294a659ef5001836ff4eab4d663e4529bba83"+checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe"dependencies = ["bytes","getrandom 0.4.3",@@ -4183,9 +4260,9 @@ dependencies = [[[package]]name = "rustls"-version = "0.23.44"+version = "0.23.46"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "6725596c3f2c3a0aef021139e145d4eafe314a6623e4680ca83852b2c67ab2ba"+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"dependencies = ["once_cell","ring",@@ -4207,9 +4284,9 @@ dependencies = [[[package]]name = "rustls-webpki"-version = "0.103.15"+version = "0.103.16"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"dependencies = ["ring","rustls-pki-types",@@ -5639,6 +5716,16 @@ version = "1.13.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"+[[package]]+name = "universal-hash"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"+dependencies = [+ "crypto-common",+ "subtle",+]+[[package]]name = "untrusted"version = "0.9.0"@@ -5919,9 +6006,9 @@ dependencies = [[[package]]name = "webpki-roots"-version = "1.0.9"+version = "1.0.10"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"+checksum = "1c1c8e20c8a38fc7d65abfe74eb7280e4aa667e8eec8bc84996d2874810748d9"dependencies = ["rustls-pki-types",]diff --git a/SECURITY.md b/SECURITY.mdindex 807997f..6612745 100644--- a/SECURITY.md+++ b/SECURITY.md@@ -19,8 +19,10 @@ Apple, and nothing else:This is enforced, not only promised: every network client Pomander makes is built by`quince_auth::apple_only()`, whose resolver refuses to look up any host outside `apple.com`,`icloud.com` and `icloud-content.com` (and their `.com.cn` twins) — a request anywhere else-fails before a connection exists. The test `crates/quince-auth/tests/apple_only.rs` holds it-to that.+fails before a connection exists. A URL that names an address instead of a host+(`https://1.2.3.4/`) is never looked up, so each request's URL is checked too, a redirect's+included: anything that is not Apple's by name (or this computer, `127.0.0.1`) is refused the+same way. The test `crates/quince-auth/tests/apple_only.rs` holds it to that.There are no Pomander servers. There is no telemetry, analytics, crash reporting or updatecheck. Nothing is sent anywhere but Apple, and only what is needed to show and change your@@ -33,7 +35,7 @@ place opens in this computer's own map app (a `geo:` link), never a website.## What Pomander keeps, and where-Everything is in your user's data folder (`~/.local/share/dev.quince.client` on Linux),+Everything is in your user's data folder (`~/.local/share/io.github.yashwanthkamireddi.Pomander` on Linux),which is readable by you alone (mode 700):- **Your password, Apple Account and session tokens:** in the system keyring (GNOME@@ -50,6 +52,28 @@ its caches and Pomander's file-manager thumbnails. Another Apple Account signingthe last one's data: each account's library is set aside whole and brought back only forthat account.+## What runs on this computer++- **Videos** are played from a server on `127.0.0.1` only (WebKitGTK's player reads only+ http). It answers only a request that carries a secret made fresh at every start and given+ to Pomander's window alone, is addressed to `127.0.0.1:<its port>` (so a web page that+ rebinds its own name to this computer is refused), and carries no web page's `Origin`. It+ sends no CORS headers. Another program or user on this computer, or a page in your browser,+ cannot read your videos from it.+- **Pictures** reach the window through Pomander's own `quince://` scheme, which only+ Pomander's windows can load. Every id in it is checked to be an id — letters, digits,+ dashes — before it names a file, so no request reads anything outside Pomander's caches.+- **The window** loads only Pomander's own bundled page, never a website, and may ask+ Tauri for no more than it uses: events, its version, a window title, and the open and save+ dialogs.+- **A note's attachment** you open is saved under a cleaned-up name (never a path, a hidden+ file, or a name that reverses itself to hide its type) in your private data folder, not+ executable, and handed to the app this computer uses for it. A program, script, launcher or+ installer — by its name or its first bytes — is shown in its folder instead of opened, since+ opening it would run it, and a shared note can carry one from anyone.+- **The iCloud Drive and Photos folders** (FUSE) are mounted for you alone (no+ `allow_other`), with no set-user-id or device files, and nothing in them is executable.+## Advanced Data ProtectionWith Advanced Data Protection on and "Access iCloud Data on the Web" off, Apple does notdiff --git a/check.sh b/check.shindex 8308a37..65686f3 100755--- a/check.sh+++ b/check.sh@@ -54,6 +54,7 @@ step "calendar calendars" node .uiverify/calendar-collections.mjsstep "drive names" node .uiverify/drive-names.mjsstep "notes autoformat" node .uiverify/notes-autoformat.mjsstep "reminder ticks" node .uiverify/reminders-tick.mjs+step "waiting to sync" node .uiverify/outbox-pending.mjsstep "photos" node .uiverify/photos.mjsstep "photo albums" node .uiverify/photos-albums.mjsstep "photos at scale" node .uiverify/photos-scale.mjs@@ -109,6 +110,7 @@ step "webkit: calendars" env ENGINE=webkit node .uiverify/calendar-collections.step "webkit: drive names" env ENGINE=webkit node .uiverify/drive-names.mjsstep "webkit: autoformat" env ENGINE=webkit node .uiverify/notes-autoformat.mjsstep "webkit: ticks" env ENGINE=webkit node .uiverify/reminders-tick.mjs+step "webkit: unsent" env ENGINE=webkit node .uiverify/outbox-pending.mjsstep "webkit: photos" env ENGINE=webkit node .uiverify/photos.mjsstep "webkit: albums" env ENGINE=webkit node .uiverify/photos-albums.mjsstep "webkit: at scale" env ENGINE=webkit node .uiverify/photos-scale.mjsdiff --git a/crates/quince-auth/src/lib.rs b/crates/quince-auth/src/lib.rsindex 600f548..4bc791d 100644--- a/crates/quince-auth/src/lib.rs+++ b/crates/quince-auth/src/lib.rs@@ -101,9 +101,9 @@ const UA: &str = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/53#[derive(Debug, thiserror::Error)]pub enum Error {- #[error("that Apple ID or password wasn't accepted")]+ #[error("That Apple ID or password wasn't accepted.")]BadCredentials,- #[error("that code didn't match. Check your iPhone and try again")]+ #[error("That code didn't match. Check your iPhone and try again.")]BadCode,#[error("Apple didn't return a trust token, so this session wouldn't survive a restart")]NoTrustToken,@@ -114,7 +114,7 @@ pub enum Error {Network(#[from] reqwest::Error),#[error("Apple sent back something unexpected: {0}")]Protocol(String),- #[error("too many attempts just now — try again in {seconds}s")]+ #[error("Too many attempts. Try again in {seconds} seconds.")]CoolingDown { seconds: u64 },#[error("this needs a fresh sign-in — Apple won't accept a resumed session for it")]ReauthRequired,@@ -572,8 +572,16 @@ impl Client {self.session.consecutive_failures = 0;self.session.retry_after = None;}- // Not reaching Apple is not a failed attempt: no cooldown for being offline.- Err(Error::CoolingDown { .. } | Error::Network(_)) => {}+ // Only Apple turning the attempt down counts. Not reaching Apple, or this computer+ // failing afterwards (a keyring that would not take the session), is no wrong+ // password: counted, it held a person back from trying again once it was fixed.+ Err(+ Error::CoolingDown { .. }+ | Error::Network(_)+ | Error::Keyring(_)+ | Error::Io(_)+ | Error::Json(_),+ ) => {}Err(e) => {self.session.consecutive_failures =self.session.consecutive_failures.saturating_add(1);@@ -1060,7 +1068,58 @@ pub fn is_apple_host(host: &str) -> bool {/// Every HTTP client Pomander makes starts here: Apple's servers, and nothing else, can be/// reached at all (see [`AppleOnly`]).pub fn apple_only() -> reqwest::ClientBuilder {- HttpClient::builder().dns_resolver(Arc::new(AppleOnly))+ let mut builder = HttpClient::builder()+ .dns_resolver(Arc::new(AppleOnly))+ // The resolver alone is not enough: a URL with an address in it (`https://1.2.3.4/`)+ // is never looked up, and through a proxy the proxy looks the name up, not us. So+ // every request's own URL is checked first, a redirect's included; one that is not+ // Apple's is sent to a "proxy" that cannot be found — by the resolver above, so the+ // refusal reads the same — and never leaves the machine.+ .proxy(reqwest::Proxy::custom(|url| {+ (!url_is_apples(url)).then(|| REFUSED.to_string())+ }));+ // Setting a proxy turns off the system's own (`HTTPS_PROXY` and the rest), which Apple's+ // hosts still go through when one is set, as they did before.+ for (scheme, names) in [+ (+ "https",+ ["HTTPS_PROXY", "https_proxy", "ALL_PROXY", "all_proxy"],+ ),+ (+ "http",+ ["HTTP_PROXY", "http_proxy", "ALL_PROXY", "all_proxy"],+ ),+ ] {+ let Some(via) = names+ .iter()+ .find_map(|n| std::env::var(n).ok().filter(|v| !v.trim().is_empty()))+ else {+ continue;+ };+ let proxy =+ reqwest::Proxy::custom(move |url| (url.scheme() == scheme).then(|| via.clone()))+ .no_proxy(reqwest::NoProxy::from_env());+ builder = builder.proxy(proxy);+ }+ builder+}++/// Where a request that is not Apple's is pointed: a name the resolver refuses.+const REFUSED: &str = "http://refused.pomander.invalid";++/// Whether a request's URL may be sent: an Apple host by name, or this computer.+fn url_is_apples(url: &reqwest::Url) -> bool {+ let Some(host) = url.host_str() else {+ return false;+ };+ match host+ .trim_start_matches('[')+ .trim_end_matches(']')+ .parse::<std::net::IpAddr>()+ {+ Ok(ip) => ip.is_loopback(),+ Err(_) => is_apple_host(host),+ }}/// The one way Pomander's client finds a server: a host that is not Apple's is never lookeddiff --git a/crates/quince-auth/src/session.rs b/crates/quince-auth/src/session.rsindex 5a50ae8..ab790a9 100644--- a/crates/quince-auth/src/session.rs+++ b/crates/quince-auth/src/session.rs@@ -8,9 +8,44 @@use serde::{Deserialize, Serialize};use std::path::{Path, PathBuf};-const KEYRING_SERVICE: &str = "dev.quince.client";const KEYRING_ENTRY: &str = "session";+/// Identifiers the app was published under before, newest first: the keyring services its+/// session may still be under, and the folders `src-tauri/src/migrate.rs` moves. The current+/// identifier is never written here — it is tauri.conf.json's. Renaming the app means adding+/// the identifier being replaced to the front of this list.+pub const PREVIOUS_IDENTIFIERS: &[&str] = &["dev.quince.client"];++/// The keyring services: the one the session is kept under (the app's identifier), and the+/// ones it was kept under before — read when the current one holds nothing, moved across+/// (written, read back, only then deleted there), never written.+struct Services {+ current: String,+ previous: Vec<&'static str>,+}++/// The app's identifier, from tauri.conf.json itself, so every client — the app, a probe, a+/// test — uses the same service without being told, and a rename is one edit there.+fn configured_identifier() -> Option<String> {+ let conf: serde_json::Value =+ serde_json::from_str(include_str!("../../../src-tauri/tauri.conf.json")).ok()?;+ Some(conf.get("identifier")?.as_str()?.to_string())+}++fn services() -> Result<&'static Services, String> {+ static SERVICES: std::sync::OnceLock<Services> = std::sync::OnceLock::new();+ Ok(SERVICES.get_or_init(|| {+ let current =+ configured_identifier().unwrap_or_else(|| PREVIOUS_IDENTIFIERS[0].to_string());+ let previous = PREVIOUS_IDENTIFIERS+ .iter()+ .copied()+ .filter(|p| *p != current)+ .collect();+ Services { current, previous }+ }))+}+/// Headers Apple rotates across responses. Any of them can appear on any call, so we capture/// after every request rather than only at the end of sign-in.pub const CAPTURED_HEADERS: &[(&str, Field)] = &[@@ -204,7 +239,14 @@ pub fn account_fingerprint(apple_id: &str) -> String {/// itself signed out. The app's own directory keeps the name it always had, so nobody is/// signed out by this change; any other directory gets an entry of its own.fn entry_name(state_dir: &Path) -> String {- if state_dir.ends_with(KEYRING_SERVICE) {+ // The app's directory under either identifier: the data directory moves with the+ // identifier, and a launch that could not move it still runs from the old one.+ let ours = services().is_ok_and(|s| {+ std::iter::once(s.current.as_str())+ .chain(s.previous.iter().copied())+ .any(|id| state_dir.ends_with(id))+ });+ if ours {return KEYRING_ENTRY.to_string();}use sha2::{Digest, Sha256};@@ -227,24 +269,38 @@ trait Secrets {fn delete(&self, name: &str) -> Result<(), String>;}-/// The system keyring, under this app's service name.-struct SystemKeyring;+/// The system keyring, under one service name.+struct SystemKeyring(&'static str);++/// Where the session is kept now.+fn current() -> Result<SystemKeyring, String> {+ Ok(SystemKeyring(services()?.current.as_str()))+}++/// Where it was kept under earlier identifiers: read, and moved, newest first.+fn previous() -> Result<Vec<SystemKeyring>, String> {+ Ok(services()?+ .previous+ .iter()+ .map(|p| SystemKeyring(p))+ .collect())+}impl Secrets for SystemKeyring {fn get(&self, name: &str) -> Result<Option<String>, String> {- match keyring::Entry::new(KEYRING_SERVICE, name).and_then(|e| e.get_password()) {+ match keyring::Entry::new(self.0, name).and_then(|e| e.get_password()) {Ok(v) => Ok(Some(v)),Err(keyring::Error::NoEntry) => Ok(None),Err(e) => Err(e.to_string()),}}fn set(&self, name: &str, value: &str) -> Result<(), String> {- keyring::Entry::new(KEYRING_SERVICE, name)+ keyring::Entry::new(self.0, name).and_then(|e| e.set_password(value)).map_err(|e| e.to_string())}fn delete(&self, name: &str) -> Result<(), String> {- match keyring::Entry::new(KEYRING_SERVICE, name).and_then(|e| e.delete_credential()) {+ match keyring::Entry::new(self.0, name).and_then(|e| e.delete_credential()) {Ok(()) | Err(keyring::Error::NoEntry) => Ok(()),Err(e) => Err(e.to_string()),}@@ -342,6 +398,48 @@ fn delete_secret(k: &dyn Secrets, name: &str) -> Result<(), String> {Ok(())}+/// The secret under `name`, from `current`; or, where that holds nothing, from the first of+/// `earlier` that has it (`legacy`) — moved across on the way.+///+/// The move is a copy first: written to `current`, read back and compared, and only then+/// deleted from `legacy`. Any step failing leaves `legacy` as it was and answers its value, so+/// the session is never lost to a keyring that refuses a write, and the move is tried again on+/// the next read. A `current` that will not answer at all (locked) is an error, as it always+/// was: never read as "nothing there", which would fall through to a stale legacy entry.+fn read_moving(+ current: &dyn Secrets,+ earlier: &[&dyn Secrets],+ name: &str,+ size: Option<usize>,+) -> Result<Option<String>, String> {+ if let Some(found) = read_secret(current, name)? {+ return Ok(Some(found));+ }+ // An earlier service not answering is no reason to fail a read that found nothing.+ let Some((legacy, old)) = earlier+ .iter()+ .find_map(|k| read_secret(*k, name).ok().flatten().map(|v| (*k, v)))+ else {+ return Ok(None);+ };+ let landed = write_secret(current, name, &old, size)+ .and_then(|()| read_secret(current, name))+ .is_ok_and(|back| back.as_deref() == Some(old.as_str()));+ if landed {+ if let Err(e) = delete_secret(legacy, name) {+ // Harmless: `current` answers from now on, and save and clear delete it again.+ quiet!("quince: keyring: the old entry stayed after the move: {e}");+ }+ } else {+ quiet!(+ "quince: keyring: could not move the session to the new name; still read from the old"+ );+ // Nothing half-written left under the new name to be read in place of the old.+ let _ = delete_secret(current, name);+ }+ Ok(Some(old))+}+impl Store {/// Production: secrets in the OS keyring.pub fn keyring(state_dir: &Path) -> std::io::Result<Self> {@@ -412,7 +510,11 @@ impl Store {/// the sign-in screen, and signing in then replaced the entry and its trust token.pub fn try_load(&self) -> Result<Session, crate::Error> {let json = match &self.backend {- Backend::Keyring(_) => match read_secret(&SystemKeyring, self.name()) {+ Backend::Keyring(_) => match current().and_then(|now| {+ let before = previous()?;+ let before: Vec<&dyn Secrets> = before.iter().map(|k| k as &dyn Secrets).collect();+ read_moving(&now, &before, self.name(), part_size())+ }) {Ok(Some(j)) => j,Ok(None) => return Ok(Session::default()),Err(e) => return Err(crate::Error::Keyring(e)),@@ -429,14 +531,20 @@ impl Store {let json = serde_json::to_string(session)?;match &self.backend {Backend::Keyring(_) => {- write_secret(&SystemKeyring, self.name(), &json, part_size())+ let now = current().map_err(crate::Error::Keyring)?;+ write_secret(&now, self.name(), &json, part_size()).map_err(crate::Error::Keyring)?;+ // Anything still under an earlier name is older than this: gone, so a later+ // sign-out cannot bring it back.+ for before in previous().unwrap_or_default() {+ let _ = delete_secret(&before, self.name());+ }// Storing the trust token is the whole reason sign-in survives a restart, so// prove it landed rather than assume. A keyring that accepts a write and// loses it looks identical to working until the user reopens the app.if session.trust_token.is_some() {- let stored = read_secret(&SystemKeyring, self.name()).ok().flatten();+ let stored = read_secret(&now, self.name()).ok().flatten();if stored.as_deref() != Some(json.as_str()) {return Err(crate::Error::Keyring("the system keyring accepted the sign-in but did not keep it. \@@ -456,7 +564,12 @@ impl Store {pub fn clear(&self) -> Result<(), crate::Error> {match &self.backend {Backend::Keyring(_) => {- delete_secret(&SystemKeyring, self.name()).map_err(crate::Error::Keyring)?;+ let now = current().map_err(crate::Error::Keyring)?;+ delete_secret(&now, self.name()).map_err(crate::Error::Keyring)?;+ // And under every earlier name, or the next read would move it back.+ for before in previous().map_err(crate::Error::Keyring)? {+ delete_secret(&before, self.name()).map_err(crate::Error::Keyring)?;+ }}Backend::File(path) => {if path.exists() {@@ -661,9 +774,24 @@ mod per_account_tests {mod entry_tests {use super::*;+ #[test]+ fn the_service_is_the_identifier_in_tauri_conf() {+ let s = services().unwrap();+ assert_eq!(Some(s.current.clone()), configured_identifier());+ assert!(!s.previous.contains(&s.current.as_str()));+ assert_eq!(s.previous, PREVIOUS_IDENTIFIERS);+ }+#[test]fn each_library_keeps_its_own_session_and_the_app_keeps_its_old_one() {- let app = Path::new("/home/someone/.local/share/dev.quince.client");+ let share = Path::new("/home/someone/.local/share");+ let app = &share.join(&services().unwrap().current);+ let before = &share.join(PREVIOUS_IDENTIFIERS[0]);+ assert_eq!(+ entry_name(before),+ "session",+ "nor by the identifier changing"+ );let probe = Path::new("/home/someone/.local/share/quince-probe");assert_eq!(entry_name(app),@@ -752,3 +880,223 @@ mod parts_tests {assert!(read_secret(&k, "s").is_err());}}++/// The session moving from the old identifier's keyring service to the new one.+#[cfg(test)]+mod move_tests {+ use super::*;+ use std::cell::RefCell;+ use std::collections::BTreeMap;++ /// A keyring in memory. `refuse`: every write fails. `forget`: writes are accepted and+ /// dropped — the keyring that says yes and keeps nothing. `locked`: nothing answers.+ #[derive(Default)]+ struct Mock {+ held: RefCell<BTreeMap<String, String>>,+ refuse: bool,+ forget: bool,+ locked: bool,+ }+ impl Secrets for Mock {+ fn get(&self, name: &str) -> Result<Option<String>, String> {+ if self.locked {+ return Err("locked".into());+ }+ Ok(self.held.borrow().get(name).cloned())+ }+ fn set(&self, name: &str, value: &str) -> Result<(), String> {+ if self.refuse || self.locked {+ return Err("refused".into());+ }+ if !self.forget {+ self.held.borrow_mut().insert(name.into(), value.into());+ }+ Ok(())+ }+ fn delete(&self, name: &str) -> Result<(), String> {+ if self.locked {+ return Err("locked".into());+ }+ self.held.borrow_mut().remove(name);+ Ok(())+ }+ }++ fn holding(name: &str, value: &str, size: Option<usize>) -> Mock {+ let k = Mock::default();+ write_secret(&k, name, value, size).unwrap();+ k+ }++ #[test]+ fn the_session_moves_and_the_old_entry_goes_only_after() {+ let old = holding("session", "{\"trust\":\"t\"}", None);+ let new = Mock::default();+ let read = read_moving(&new, &[&old], "session", None).unwrap();+ assert_eq!(read.as_deref(), Some("{\"trust\":\"t\"}"));+ assert_eq!(+ new.held.borrow().get("session").map(String::as_str),+ Some("{\"trust\":\"t\"}")+ );+ assert!(old.held.borrow().is_empty(), "moved, not copied");+ // Read again: from the new name, the old one is not needed.+ assert_eq!(read_moving(&new, &[&old], "session", None).unwrap(), read);+ }++ #[test]+ fn a_session_in_parts_moves_whole_with_every_part() {+ // Windows: the Credential Manager's targets are `session` and `session#1..n`.+ let big = "w".repeat(3500);+ let old = holding("session", &big, Some(1000));+ assert_eq!(old.held.borrow().len(), 5);+ let new = Mock::default();+ assert_eq!(+ read_moving(&new, &[&old], "session", Some(1000)).unwrap(),+ Some(big.clone())+ );+ assert_eq!(+ new.held.borrow().get("session").map(String::as_str),+ Some("pomander-parts:4")+ );+ assert_eq!(read_secret(&new, "session").unwrap(), Some(big));+ assert!(+ old.held.borrow().is_empty(),+ "every part gone from the old name"+ );+ }++ #[test]+ fn a_new_keyring_that_refuses_keeps_the_old_entry_and_reads_it() {+ let old = holding("session", "s", None);+ let new = Mock {+ refuse: true,+ ..Mock::default()+ };+ assert_eq!(+ read_moving(&new, &[&old], "session", None)+ .unwrap()+ .as_deref(),+ Some("s")+ );+ assert_eq!(+ old.held.borrow().get("session").map(String::as_str),+ Some("s")+ );+ }++ #[test]+ fn a_new_keyring_that_drops_the_write_keeps_the_old_entry() {+ let old = holding("session", "s", None);+ let new = Mock {+ forget: true,+ ..Mock::default()+ };+ assert_eq!(+ read_moving(&new, &[&old], "session", None)+ .unwrap()+ .as_deref(),+ Some("s")+ );+ assert_eq!(+ old.held.borrow().get("session").map(String::as_str),+ Some("s")+ );+ }++ #[test]+ fn a_locked_keyring_is_an_error_not_a_fall_back_to_the_old_entry() {+ let old = holding("session", "stale", None);+ let new = Mock {+ locked: true,+ ..Mock::default()+ };+ assert!(read_moving(&new, &[&old], "session", None).is_err());+ assert_eq!(old.held.borrow().len(), 1, "untouched");+ }++ #[test]+ fn the_new_entry_wins_over_a_leftover_old_one() {+ let old = holding("session", "older", None);+ let new = holding("session", "newer", None);+ assert_eq!(+ read_moving(&new, &[&old], "session", None)+ .unwrap()+ .as_deref(),+ Some("newer")+ );+ }++ #[test]+ fn the_first_earlier_name_holding_it_is_moved_and_the_rest_left() {+ let older = holding("session", "oldest", None);+ let old = holding("session", "old", None);+ let empty = Mock::default();+ let new = Mock::default();+ assert_eq!(+ read_moving(&new, &[&empty, &old, &older], "session", None)+ .unwrap()+ .as_deref(),+ Some("old")+ );+ assert!(old.held.borrow().is_empty());+ }++ #[test]+ fn nothing_under_either_name_is_nothing() {+ assert_eq!(+ read_moving(&Mock::default(), &[&Mock::default()], "session", None).unwrap(),+ None+ );+ }++ /// The real Secret Service, isolated: run only by the script that starts a private session+ /// bus and a throwaway gnome-keyring (QUINCE_ISOLATED_KEYRING names its bus), never+ /// against the person's own keyring.+ #[test]+ #[ignore = "needs an isolated Secret Service; see the comment"]+ fn the_move_through_a_real_secret_service() {+ let Ok(bus) = std::env::var("QUINCE_ISOLATED_KEYRING") else {+ return;+ };+ assert_eq!(+ std::env::var("DBUS_SESSION_BUS_ADDRESS").ok().as_deref(),+ Some(bus.as_str()),+ "refusing: not on the isolated bus"+ );+ let name = "session";+ let (now, before) = (+ SystemKeyring("org.example.Renamed"),+ SystemKeyring("dev.quince.client"),+ );+ before.set(name, "{\"trust\":\"isolated\"}").unwrap();+ assert_eq!(now.get(name).unwrap(), None);+ let read = read_moving(&now, &[&before], name, None).unwrap();+ assert_eq!(read.as_deref(), Some("{\"trust\":\"isolated\"}"));+ assert_eq!(+ now.get(name).unwrap().as_deref(),+ Some("{\"trust\":\"isolated\"}")+ );+ assert_eq!(before.get(name).unwrap(), None);+ now.delete(name).unwrap();++ // A client nobody configured (a probe's own library): through Store, as it reads it.+ let dir = std::env::temp_dir().join(format!("quince-probe-{}", std::process::id()));+ let store = Store::keyring(&dir).unwrap();+ let entry = entry_name(&dir);+ assert_ne!(entry, KEYRING_ENTRY, "a probe has its own entry");+ let (now, before) = (current().unwrap(), SystemKeyring(PREVIOUS_IDENTIFIERS[0]));+ before.set(&entry, "{}").unwrap();+ assert!(store.try_load().is_ok(), "read, never failed");+ assert_eq!(+ now.get(&entry).unwrap().as_deref(),+ Some("{}"),+ "moved in place"+ );+ assert_eq!(before.get(&entry).unwrap(), None);+ // A second run: read from the current service, nothing lost.+ assert!(store.try_load().is_ok());+ assert_eq!(now.get(&entry).unwrap().as_deref(), Some("{}"));+ now.delete(&entry).unwrap();+ let _ = std::fs::remove_dir_all(&dir);+ }+}diff --git a/crates/quince-auth/tests/apple_only.rs b/crates/quince-auth/tests/apple_only.rsindex c53804d..47b9d16 100644--- a/crates/quince-auth/tests/apple_only.rs+++ b/crates/quince-auth/tests/apple_only.rs@@ -42,3 +42,38 @@ async fn a_client_refuses_anything_but_apple_before_connecting() {"refused by the resolver, not the network: {said}");}++/// An address in the URL is never looked up, so the resolver alone let it through: the URL+/// itself is checked, a redirect's included, and only this computer's addresses pass.+#[tokio::test(flavor = "multi_thread")]+async fn an_address_is_refused_as_a_name_is() {+ use wiremock::{matchers::path, Mock, MockServer, ResponseTemplate};+ let client = quince_auth::apple_only().build().unwrap();+ for url in [+ "https://93.184.215.14/",+ "http://1.1.1.1:80/x",+ "https://[2606:4700:4700::1111]/",+ "https://0x5db8d70e/",+ ] {+ let err = client.get(url).send().await.expect_err(url);+ assert!(+ format!("{err:?}").contains("Pomander talks only to Apple"),+ "{url}: {err:?}"+ );+ }+ // This computer still answers (the tests' mock servers), and a redirect away is refused.+ let server = MockServer::start().await;+ Mock::given(path("/ok"))+ .respond_with(ResponseTemplate::new(200))+ .mount(&server)+ .await;+ Mock::given(path("/away"))+ .respond_with(ResponseTemplate::new(302).insert_header("location", "http://1.1.1.1/"))+ .mount(&server)+ .await;+ let ok = client.get(format!("{}/ok", server.uri())).send().await;+ assert_eq!(ok.unwrap().status(), 200);+ let away = client.get(format!("{}/away", server.uri())).send().await;+ assert!(format!("{:?}", away.expect_err("redirected away"))+ .contains("Pomander talks only to Apple"));+}diff --git a/crates/quince-core/src/alarms.rs b/crates/quince-core/src/alarms.rsindex 45721b3..537990c 100644--- a/crates/quince-core/src/alarms.rs+++ b/crates/quince-core/src/alarms.rs@@ -74,7 +74,7 @@ impl Library {gone: &[String],whole: bool,) -> Result<()> {- let tx = self.conn_mut().transaction()?;+ let tx = self.conn_mut().savepoint()?;if whole {tx.execute("DELETE FROM reminder_alarms", [])?;tx.execute("DELETE FROM alarm_triggers", [])?;diff --git a/crates/quince-core/src/calendar.rs b/crates/quince-core/src/calendar.rsindex dd75f80..3c9df20 100644--- a/crates/quince-core/src/calendar.rs+++ b/crates/quince-core/src/calendar.rs@@ -59,7 +59,7 @@ impl Library {/// Removal cascades to their events, which is what should happen when a calendar is/// deleted on another device.pub fn put_calendars(&mut self, calendars: &[Calendar]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO calendars (guid, title, colour, ctag, sort_order, enabled,@@ -108,7 +108,7 @@ impl Library {/// Upsert events. Existing rows for the same guid are updated in place.pub fn put_events(&mut self, events: &[Event]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO events (guid, calendar_guid, title, location, starts_at, ends_at,@@ -269,7 +269,7 @@ impl Library {/// Drop events Apple no longer has.pub fn forget_events(&mut self, guids: &[String]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("DELETE FROM events WHERE guid = ?1")?;for guid in guids {diff --git a/crates/quince-core/src/contacts.rs b/crates/quince-core/src/contacts.rsindex 3d11158..704380b 100644--- a/crates/quince-core/src/contacts.rs+++ b/crates/quince-core/src/contacts.rs@@ -13,6 +13,213 @@ pub struct ContactMethod {pub value: String,}+/// A postal address as Apple keeps it: each part on its own, so one can be changed without+/// retyping the rest. Field names match Apple's `streetAddresses[].field` keys when+/// serialised, which is also what an edit names a field by.+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct PostalAddress {+ pub label: Option<String>,+ /// Every line before the town, newlines and all.+ pub street: Option<String>,+ pub sub_locality: Option<String>,+ pub city: Option<String>,+ pub sub_administrative_area: Option<String>,+ pub state: Option<String>,+ pub postal_code: Option<String>,+ pub country: Option<String>,+ /// Apple's two-letter code, lower case on the cards it writes.+ pub country_code: Option<String>,+}++/// The parts of an address, by the names Apple's service uses for them.+pub const ADDRESS_FIELDS: [&str; 8] = [+ "street",+ "subLocality",+ "city",+ "subAdministrativeArea",+ "state",+ "postalCode",+ "country",+ "countryCode",+];++impl PostalAddress {+ /// One part by Apple's name for it; `None` for a name that is not a part.+ #[must_use]+ pub fn field(&self, name: &str) -> Option<&Option<String>> {+ Some(match name {+ "street" => &self.street,+ "subLocality" => &self.sub_locality,+ "city" => &self.city,+ "subAdministrativeArea" => &self.sub_administrative_area,+ "state" => &self.state,+ "postalCode" => &self.postal_code,+ "country" => &self.country,+ "countryCode" => &self.country_code,+ _ => return None,+ })+ }++ /// Set one part by Apple's name for it, blank meaning cleared. False for a name that is+ /// not a part.+ pub fn set_field(&mut self, name: &str, value: Option<&str>) -> bool {+ let slot = match name {+ "street" => &mut self.street,+ "subLocality" => &mut self.sub_locality,+ "city" => &mut self.city,+ "subAdministrativeArea" => &mut self.sub_administrative_area,+ "state" => &mut self.state,+ "postalCode" => &mut self.postal_code,+ "country" => &mut self.country,+ "countryCode" => &mut self.country_code,+ _ => return false,+ };+ *slot = clean(value);+ true+ }++ /// No part holds anything (the label alone is not an address).+ #[must_use]+ pub fn is_empty(&self) -> bool {+ ADDRESS_FIELDS+ .iter()+ .all(|f| self.field(f).is_none_or(Option::is_none))+ }++ /// The lines a person would write on an envelope, in the order the address's country+ /// writes them: a postcode before the town in Germany and France, the town and postcode+ /// on lines of their own in the UK, largest to smallest in Japan.+ #[must_use]+ pub fn formatted(&self) -> String {+ let template = match self.country_key() {+ Some("us") => US,+ Some("gb") => GB,+ Some("in") => IN,+ Some("de" | "fr") => DE_FR,+ Some("jp") => JP,+ _ => DEFAULT,+ };+ let mut lines: Vec<String> = Vec::new();+ for line in template {+ let mut text = String::new();+ for (name, separator) in *line {+ let Some(part) = self.field(name).and_then(Option::as_deref) else {+ continue;+ };+ if !text.is_empty() {+ text.push_str(separator);+ }+ text.push_str(part);+ }+ // A street keeps its own line breaks, each trimmed.+ lines.extend(+ text.lines()+ .map(str::trim)+ .filter(|l| !l.is_empty())+ .map(ToString::to_string),+ );+ }+ lines.join("\n")+ }++ /// Which country's layout applies: Apple's code when the card has one, else the name.+ #[must_use]+ pub fn country_key(&self) -> Option<&'static str> {+ self.country_code+ .as_deref()+ .and_then(country_from_code)+ .or_else(|| self.country.as_deref().and_then(country_code_for))+ }+}++fn clean(value: Option<&str>) -> Option<String> {+ value+ .map(str::trim)+ .filter(|s| !s.is_empty())+ .map(ToString::to_string)+}++/// One line of an address layout: each part with what goes before it when a part already+/// sits on the line. A missing part leaves no gap.+type Line = &'static [(&'static str, &'static str)];++const US: &[Line] = &[+ &[("street", "")],+ &[("subLocality", "")],+ &[("city", ""), ("state", ", "), ("postalCode", " ")],+ &[("country", "")],+];+const GB: &[Line] = &[+ &[("street", "")],+ &[("subLocality", "")],+ &[("city", "")],+ &[("subAdministrativeArea", "")],+ &[("postalCode", "")],+ &[("country", "")],+];+const IN: &[Line] = &[+ &[("street", "")],+ &[("subLocality", "")],+ &[("city", ""), ("postalCode", " ")],+ &[("state", "")],+ &[("country", "")],+];+const DE_FR: &[Line] = &[+ &[("street", "")],+ &[("postalCode", ""), ("city", " ")],+ &[("country", "")],+];+const JP: &[Line] = &[+ &[("postalCode", "")],+ &[("state", ""), ("city", " "), ("subLocality", " ")],+ &[("street", "")],+ &[("country", "")],+];+const DEFAULT: &[Line] = &[+ &[("street", "")],+ &[("subLocality", "")],+ &[("city", ""), ("state", " "), ("postalCode", " ")],+ &[("country", "")],+];++/// The countries with a layout of their own, by Apple's code.+fn country_from_code(code: &str) -> Option<&'static str> {+ match code.trim().to_ascii_lowercase().as_str() {+ "us" => Some("us"),+ "gb" | "uk" => Some("gb"),+ "in" => Some("in"),+ "de" => Some("de"),+ "fr" => Some("fr"),+ "jp" => Some("jp"),+ _ => None,+ }+}++/// Apple's two-letter code for a country typed by name, for the countries this app lays out+/// by their own rules. `None` for any other.+#[must_use]+pub fn country_code_for(name: &str) -> Option<&'static str> {+ let name = crate::fold::fold(name.trim());+ let name = name.trim_end_matches('.');+ Some(match name {+ "united states"+ | "united states of america"+ | "usa"+ | "us"+ | "u.s.a"+ | "u.s"+ | "america" => "us",+ "united kingdom" | "uk" | "u.k" | "great britain" | "britain" | "england" | "scotland"+ | "wales" | "northern ireland" | "gb" => "gb",+ "india" | "bharat" | "in" => "in",+ "germany" | "deutschland" | "de" => "de",+ "france" | "fr" => "fr",+ "japan" | "nippon" | "日本" | "jp" => "jp",+ _ => return None,+ })+}+/// Everything needed to put one person's picture on screen.#[derive(Debug, Clone, PartialEq, Eq)]pub struct ContactPhoto {@@ -103,7 +310,17 @@ fn now() -> i64 {impl Library {/// Replace the address book, dropping anyone Apple no longer reports.pub fn put_contacts(&mut self, contacts: &[Contact]) -> Result<()> {- let tx = self.conn.transaction()?;+ self.store_contacts(contacts, true)+ }++ /// Store one card as it now stands — made or edited here, before Apple has it — leaving+ /// everyone else as they are.+ pub fn put_contact(&mut self, contact: &Contact) -> Result<()> {+ self.store_contacts(std::slice::from_ref(contact), false)+ }++ fn store_contacts(&mut self, contacts: &[Contact], whole_book: bool) -> Result<()> {+ let tx = self.conn.savepoint()?;{let mut upsert = tx.prepare("INSERT INTO contacts (guid, first_name, middle_name, last_name, company, is_company,@@ -160,7 +377,9 @@ impl Library {}let keep: Vec<&str> = contacts.iter().map(|c| c.guid.as_str()).collect();- if keep.is_empty() {+ if !whole_book {+ // One card: no one else is touched.+ } else if keep.is_empty() {tx.execute("DELETE FROM contacts", [])?;} else {let placeholders = vec!["?"; keep.len()].join(",");@@ -174,6 +393,125 @@ impl Library {Ok(())}+ /// Store the structured addresses a read of the address book found, by card. A whole+ /// book replaces every stored address; otherwise only the cards named are touched.+ ///+ /// Every card named must already be stored (its addresses hang off it), which holds when+ /// they come from the same read as [`Library::put_contacts`].+ pub fn put_addresses(+ &mut self,+ book: &[(String, Vec<PostalAddress>)],+ whole_book: bool,+ ) -> Result<()> {+ let tx = self.conn.savepoint()?;+ if whole_book {+ tx.execute("DELETE FROM contact_addresses", [])?;+ }+ {+ let mut clear = tx.prepare("DELETE FROM contact_addresses WHERE contact_guid = ?1")?;+ let mut add = tx.prepare(ADD_ADDRESS)?;+ for (guid, addresses) in book {+ clear.execute(params![guid])?;+ insert_addresses(&mut add, guid, addresses)?;+ }+ }+ tx.commit()?;+ Ok(())+ }++ /// One card's addresses as just edited here: the structured parts, and the flattened+ /// lines kept with its other methods (which search and older views read), in the place+ /// its addresses already held among them.+ pub fn set_contact_addresses(&mut self, guid: &str, addresses: &[PostalAddress]) -> Result<()> {+ let tx = self.conn.savepoint()?;+ {+ let mut methods: Vec<ContactMethod> = {+ let mut stmt = tx.prepare(+ "SELECT kind, label, value FROM contact_methods+ WHERE contact_guid = ?1 ORDER BY position",+ )?;+ let rows = stmt.query_map(params![guid], |row| {+ Ok(ContactMethod {+ kind: row.get(0)?,+ label: row.get(1)?,+ value: row.get(2)?,+ })+ })?;+ rows.collect::<rusqlite::Result<_>>()?+ };+ let at = methods+ .iter()+ .position(|m| m.kind == "address")+ .unwrap_or_else(|| {+ // Where a read puts them: after phones, emails and links.+ methods+ .iter()+ .rposition(|m| matches!(m.kind.as_str(), "phone" | "email" | "url"))+ .map_or(0, |i| i + 1)+ });+ methods.retain(|m| m.kind != "address");+ let lines = addresses+ .iter()+ .filter(|a| !a.is_empty())+ .map(|a| ContactMethod {+ kind: "address".into(),+ label: a.label.clone(),+ value: a.formatted(),+ });+ let at = at.min(methods.len());+ methods.splice(at..at, lines);++ tx.execute(+ "DELETE FROM contact_methods WHERE contact_guid = ?1",+ params![guid],+ )?;+ let mut add = tx.prepare(+ "INSERT INTO contact_methods (contact_guid, kind, label, value, position)+ VALUES (?1, ?2, ?3, ?4, ?5)",+ )?;+ for (i, m) in methods.iter().enumerate() {+ add.execute(params![+ guid,+ m.kind,+ m.label,+ m.value,+ i64::try_from(i).unwrap_or(0)+ ])?;+ }+ tx.execute(+ "DELETE FROM contact_addresses WHERE contact_guid = ?1",+ params![guid],+ )?;+ let mut add = tx.prepare(ADD_ADDRESS)?;+ insert_addresses(&mut add, guid, addresses)?;+ }+ tx.commit()?;+ Ok(())+ }++ /// One card's addresses, part by part, in Apple's order.+ pub fn contact_addresses(&self, guid: &str) -> Result<Vec<PostalAddress>> {+ let mut stmt = self.conn.prepare(+ "SELECT label, street, sub_locality, city, sub_administrative_area, state,+ postal_code, country, country_code+ FROM contact_addresses WHERE contact_guid = ?1 ORDER BY position",+ )?;+ let rows = stmt.query_map(params![guid], |row| {+ Ok(PostalAddress {+ label: row.get(0)?,+ street: row.get(1)?,+ sub_locality: row.get(2)?,+ city: row.get(3)?,+ sub_administrative_area: row.get(4)?,+ state: row.get(5)?,+ postal_code: row.get(6)?,+ country: row.get(7)?,+ country_code: row.get(8)?,+ })+ })?;+ Ok(rows.collect::<rusqlite::Result<_>>()?)+ }+/// Where one person's picture lives, without reading the rest of the address book.////// The picture is served per row as a list scrolls, so this stays a single-row lookup@@ -269,6 +607,34 @@ impl Library {}}+const ADD_ADDRESS: &str = "INSERT INTO contact_addresses+ (contact_guid, position, label, street, sub_locality, city, sub_administrative_area, state,+ postal_code, country, country_code)+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)";++fn insert_addresses(+ add: &mut rusqlite::Statement<'_>,+ guid: &str,+ addresses: &[PostalAddress],+) -> Result<()> {+ for (i, a) in addresses.iter().filter(|a| !a.is_empty()).enumerate() {+ add.execute(params![+ guid,+ i64::try_from(i).unwrap_or(0),+ a.label,+ a.street,+ a.sub_locality,+ a.city,+ a.sub_administrative_area,+ a.state,+ a.postal_code,+ a.country,+ a.country_code+ ])?;+ }+ Ok(())+}+/// Only the digits of a number, so its formatting stops mattering.fn digits(text: &str) -> String {text.chars().filter(char::is_ascii_digit).collect()@@ -468,4 +834,148 @@ mod tests {lib.put_contacts(&[contact("1", Some("A"), None)]).unwrap();assert_eq!(lib.contacts(None).unwrap().len(), 1);}++ fn address(+ street: &str,+ city: &str,+ state: &str,+ postcode: &str,+ country: &str,+ ) -> PostalAddress {+ let part = |v: &str| (!v.is_empty()).then(|| v.to_string());+ PostalAddress {+ label: Some("HOME".into()),+ street: part(street),+ city: part(city),+ state: part(state),+ postal_code: part(postcode),+ country: part(country),+ ..PostalAddress::default()+ }+ }++ #[test]+ fn an_address_is_laid_out_the_way_its_country_writes_it() {+ let us = address("1 Main St", "Springfield", "IL", "62701", "United States");+ assert_eq!(+ us.formatted(),+ "1 Main St\nSpringfield, IL 62701\nUnited States"+ );+ let de = address("Hauptstraße 5", "Berlin", "", "10115", "Germany");+ assert_eq!(de.formatted(), "Hauptstraße 5\n10115 Berlin\nGermany");+ let mut fr = address("5 Rue de la Paix", "Paris", "", "75002", "");+ fr.country_code = Some("FR".into());+ assert_eq!(fr.formatted(), "5 Rue de la Paix\n75002 Paris");+ let uk = address("10 Downing St", "London", "", "SW1A 2AA", "UK");+ assert_eq!(uk.formatted(), "10 Downing St\nLondon\nSW1A 2AA\nUK");+ let india = address(+ "12 MG Road\nIndiranagar",+ "Bengaluru",+ "Karnataka",+ "560038",+ "India",+ );+ assert_eq!(+ india.formatted(),+ "12 MG Road\nIndiranagar\nBengaluru 560038\nKarnataka\nIndia"+ );+ let jp = address("1-1 Chiyoda", "Chiyoda-ku", "Tokyo", "100-0001", "Japan");+ assert_eq!(+ jp.formatted(),+ "100-0001\nTokyo Chiyoda-ku\n1-1 Chiyoda\nJapan"+ );+ // Anywhere else: town, region and postcode on one line, and no gaps.+ let other = address("", "Lagos", "", "100001", "Nigeria");+ assert_eq!(other.formatted(), "Lagos 100001\nNigeria");+ }++ #[test]+ fn a_country_typed_by_name_finds_its_code() {+ assert_eq!(country_code_for("United States of America"), Some("us"));+ assert_eq!(country_code_for(" Deutschland "), Some("de"));+ assert_eq!(country_code_for("U.K."), Some("gb"));+ assert_eq!(country_code_for("Narnia"), None);+ // Apple's code outranks a name that disagrees with it.+ let mut a = address("", "Paris", "", "75002", "Germany");+ a.country_code = Some("fr".into());+ assert_eq!(a.country_key(), Some("fr"));+ }++ #[test]+ fn a_part_is_set_by_apples_name_for_it() {+ let mut a = PostalAddress::default();+ assert!(a.is_empty());+ assert!(a.set_field("postalCode", Some(" 560038 ")));+ assert_eq!(a.postal_code.as_deref(), Some("560038"));+ assert!(a.set_field("postalCode", Some(" ")));+ assert_eq!(a.postal_code, None, "blank clears");+ assert!(!a.set_field("planet", Some("Earth")));+ }++ #[test]+ fn addresses_are_kept_part_by_part_and_go_with_their_card() {+ let mut lib = Library::in_memory().unwrap();+ lib.put_contacts(&[contact("1", Some("A"), None), contact("2", Some("B"), None)])+ .unwrap();+ let home = address("1 Main St", "Springfield", "IL", "62701", "USA");+ lib.put_addresses(+ &[+ ("1".into(), vec![home.clone(), PostalAddress::default()]),+ ("2".into(), vec![home.clone()]),+ ],+ true,+ )+ .unwrap();+ assert_eq!(+ lib.contact_addresses("1").unwrap(),+ std::slice::from_ref(&home),+ "blanks dropped"+ );++ // A whole book replaces every address; a card Apple stopped reporting takes its own.+ lib.put_contacts(&[contact("1", Some("A"), None)]).unwrap();+ assert!(lib.contact_addresses("2").unwrap().is_empty());+ lib.put_addresses(&[], true).unwrap();+ assert!(lib.contact_addresses("1").unwrap().is_empty());+ }++ #[test]+ fn an_edited_address_replaces_its_flattened_lines_in_place() {+ let mut lib = Library::in_memory().unwrap();+ let mut c = contact("1", Some("A"), None);+ c.methods.push(ContactMethod {+ kind: "address".into(),+ label: Some("HOME".into()),+ value: "old".into(),+ });+ c.methods.push(ContactMethod {+ kind: "profile".into(),+ label: None,+ value: "@a".into(),+ });+ lib.put_contacts(&[c]).unwrap();+ let moved = address("2 New Rd", "Pune", "MH", "411001", "India");+ lib.set_contact_addresses("1", std::slice::from_ref(&moved))+ .unwrap();++ assert_eq!(lib.contact_addresses("1").unwrap(), [moved]);+ let kinds: Vec<(String, String)> = lib.contacts(None).unwrap()[0]+ .methods+ .iter()+ .map(|m| (m.kind.clone(), m.value.clone()))+ .collect();+ assert_eq!(+ kinds,+ [+ ("phone".into(), "+911".into()),+ ("address".into(), "2 New Rd\nPune 411001\nMH\nIndia".into()),+ ("profile".into(), "@a".into()),+ ]+ );+ assert_eq!(+ lib.contacts(Some("pune")).unwrap().len(),+ 1,+ "searchable at once"+ );+ }}diff --git a/crates/quince-core/src/drive.rs b/crates/quince-core/src/drive.rsindex fb40e3d..daf6e2b 100644--- a/crates/quince-core/src/drive.rs+++ b/crates/quince-core/src/drive.rs@@ -56,7 +56,7 @@ impl Library {/// Scoped to the folder rather than the whole tree: Drive is fetched a level at a time,/// so anything outside this folder is simply not part of this answer.pub fn put_drive_children(&mut self, parent_id: &str, items: &[DriveItem]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO drive_items (drivewsid, parent_id, name, extension, kind, size,diff --git a/crates/quince-core/src/lib.rs b/crates/quince-core/src/lib.rsindex 153dec1..5c19891 100644--- a/crates/quince-core/src/lib.rs+++ b/crates/quince-core/src/lib.rs@@ -44,6 +44,26 @@ fn account_tables(conn: &Connection) -> Result<Vec<String>> {Ok(rows.collect::<std::result::Result<_, _>>()?)}+/// Run every migration past the library's version, each with its version bump as one+/// transaction: a migration that fails part way, or a crash in the middle of one, leaves the+/// library at the version before it with none of it applied — never half a schema change+/// that the next open would try to make again over itself, nor a change made whose version+/// was never written.+fn migrate_with(conn: &mut Connection, migrations: &[&str]) -> Result<()> {+ let current: u32 = conn.query_row("PRAGMA user_version", [], |row| row.get(0))?;+ for (version, sql) in migrations.iter().enumerate() {+ let target = u32::try_from(version).unwrap_or(u32::MAX) + 1;+ if current < target {+ let tx = conn.transaction()?;+ tx.execute_batch(sql)?;+ // `user_version` lives in the database header, written inside the transaction.+ tx.pragma_update(None, "user_version", i64::from(target))?;+ tx.commit()?;+ }+ }+ Ok(())+}+/// A handle to the local library.pub struct Library {conn: Connection,@@ -68,25 +88,57 @@ impl Library {conn.pragma_update(None, "journal_mode", "WAL")?;conn.pragma_update(None, "synchronous", "NORMAL")?;conn.pragma_update(None, "foreign_keys", "ON")?;- let library = Self { conn };+ let mut library = Self { conn };library.migrate()?;Ok(library)}/// Bring the schema up to date. Idempotent, and safe to call on every open.- fn migrate(&self) -> Result<()> {- let current: u32 = self- .conn- .query_row("PRAGMA user_version", [], |row| row.get(0))?;- for (version, sql) in schema::MIGRATIONS.iter().enumerate() {- let target = u32::try_from(version).unwrap_or(u32::MAX) + 1;- if current < target {- self.conn.execute_batch(sql)?;- self.conn- .pragma_update(None, "user_version", i64::from(target))?;+ fn migrate(&mut self) -> Result<()> {+ migrate_with(&mut self.conn, schema::MIGRATIONS)+ }++ /// Run `apply` as one change to the library: everything it stores lands, or — if it+ /// fails, or the process dies part way — none of it does, and the library is as it was.+ ///+ /// A sync pass stores a service's records, tombstones, order and position in many calls;+ /// each was its own transaction, so a failure or a crash between them left half a pass —+ /// rows pruned and their replacements never stored, or records stored under a position+ /// that said they were not. Nests: every write in this crate is a savepoint, so one call+ /// inside another is part of the outer one.+ pub fn atomically<T, E>(+ &mut self,+ apply: impl FnOnce(&mut Self) -> std::result::Result<T, E>,+ ) -> std::result::Result<T, E>+ where+ E: From<Error>,+ {+ const NAME: &str = "quince_atomically";+ self.conn+ .execute_batch(&format!("SAVEPOINT {NAME}"))+ .map_err(|e| E::from(Error::from(e)))?;+ let undo = |conn: &Connection| {+ let _ = conn.execute_batch(&format!("ROLLBACK TO {NAME}; RELEASE {NAME}"));+ };+ let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| apply(&mut *self)));+ match outcome {+ Ok(Ok(value)) => match self.conn.execute_batch(&format!("RELEASE {NAME}")) {+ Ok(()) => Ok(value),+ Err(e) => {+ undo(&self.conn);+ Err(E::from(Error::from(e)))+ }+ },+ Ok(Err(e)) => {+ undo(&self.conn);+ Err(e)+ }+ // Left open, every later write would sit inside this savepoint and never commit.+ Err(panic) => {+ undo(&self.conn);+ std::panic::resume_unwind(panic)}}- Ok(())}pub fn schema_version(&self) -> Result<u32> {@@ -122,7 +174,7 @@ impl Library {/// Signed out and back in as someone else, the last account's data stayed and the new/// one's was laid over it, from the old account's sync positions.pub fn forget_account(&mut self) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;for table in account_tables(&tx)? {tx.execute(&format!("DELETE FROM \"{table}\""), [])?;}@@ -235,6 +287,125 @@ mod tests {assert_eq!(lib.state("drive_folder_on").unwrap().as_deref(), Some("1"));}+ /// A migration that fails part way leaves nothing of itself and the version where it was;+ /// the ones before it stay applied. Run again (fixed), it applies whole.+ #[test]+ fn a_failed_migration_leaves_the_library_at_the_version_before_it() {+ let mut conn = Connection::open_in_memory().unwrap();+ let good = "CREATE TABLE a (x INTEGER);";+ // The first statement would succeed on its own; the second fails.+ let bad = "CREATE TABLE b (x INTEGER); INSERT INTO nowhere VALUES (1);";+ assert!(migrate_with(&mut conn, &[good, bad]).is_err());+ let version: u32 = conn+ .query_row("PRAGMA user_version", [], |r| r.get(0))+ .unwrap();+ assert_eq!(version, 1, "the version bump went with the migration");+ let has = |conn: &Connection, t: &str| -> bool {+ conn.query_row(+ "SELECT EXISTS (SELECT 1 FROM sqlite_master WHERE name = ?1)",+ [t],+ |r| r.get(0),+ )+ .unwrap()+ };+ assert!(has(&conn, "a"), "the migration before it stays");+ assert!(!has(&conn, "b"), "nothing of the failed one persists");+ let fixed = "CREATE TABLE b (x INTEGER);";+ migrate_with(&mut conn, &[good, fixed]).unwrap();+ assert!(has(&conn, "b"));+ let version: u32 = conn+ .query_row("PRAGMA user_version", [], |r| r.get(0))+ .unwrap();+ assert_eq!(version, 2);+ }++ /// The same on disk, through a real file: what a crash mid-migration would find on reopen.+ #[test]+ fn a_failed_migration_is_not_on_disk_either() {+ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("library.db");+ {+ let mut conn = Connection::open(&path).unwrap();+ let _ = migrate_with(+ &mut conn,+ &[+ "CREATE TABLE a (x INTEGER);",+ "ALTER TABLE a ADD COLUMN y INTEGER; SELECT RAISE(ABORT, 'boom');",+ ],+ );+ }+ let conn = Connection::open(&path).unwrap();+ let version: u32 = conn+ .query_row("PRAGMA user_version", [], |r| r.get(0))+ .unwrap();+ assert_eq!(version, 1);+ let columns: i64 = conn+ .query_row("SELECT count(*) FROM pragma_table_info('a')", [], |r| {+ r.get(0)+ })+ .unwrap();+ assert_eq!(+ columns, 1,+ "the column of the failed migration is not there"+ );+ }++ /// One change made of many core writes — each its own savepoint — is all or nothing.+ #[test]+ fn an_atomic_change_that_fails_leaves_nothing_behind() {+ let mut lib = Library::in_memory().unwrap();+ lib.set_state("kept", "before").unwrap();+ let failed: std::result::Result<(), Error> = lib.atomically(|l| {+ l.set_state("kept", "after")?;+ l.mark_synced("notes", Some("new-token"))?;+ l.forget_account()?;+ // A failure after all of that: none of it may persist.+ Err(Error::Sqlite(rusqlite::Error::InvalidQuery))+ });+ assert!(failed.is_err());+ assert_eq!(lib.state("kept").unwrap().as_deref(), Some("before"));+ assert_eq!(lib.sync_token("notes").unwrap(), None);+ assert!(lib.conn().is_autocommit(), "nothing left open");++ lib.atomically(|l| -> Result<()> {+ l.set_state("kept", "after")?;+ // Nested: part of the outer change.+ l.atomically(|l| l.set_state("inner", "1"))+ })+ .unwrap();+ assert_eq!(lib.state("kept").unwrap().as_deref(), Some("after"));+ assert_eq!(lib.state("inner").unwrap().as_deref(), Some("1"));++ // A nested change that fails takes only itself back when the outer one carries on.+ lib.atomically(|l| -> Result<()> {+ l.set_state("outer", "1")?;+ let _ = l.atomically(|l| -> Result<()> {+ l.set_state("inner", "2")?;+ Err(Error::Sqlite(rusqlite::Error::InvalidQuery))+ });+ Ok(())+ })+ .unwrap();+ assert_eq!(lib.state("outer").unwrap().as_deref(), Some("1"));+ assert_eq!(lib.state("inner").unwrap().as_deref(), Some("1"));+ }++ /// A panic part way rolls back and leaves the connection usable, not stuck inside a+ /// savepoint that would swallow every later write.+ #[test]+ fn a_panic_in_an_atomic_change_rolls_it_back() {+ let mut lib = Library::in_memory().unwrap();+ let caught = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {+ let _: Result<()> = lib.atomically(|l| {+ l.set_state("k", "v").unwrap();+ panic!("mid-apply");+ });+ }));+ assert!(caught.is_err());+ assert!(lib.conn().is_autocommit());+ assert_eq!(lib.state("k").unwrap(), None);+ }+#[test]fn a_new_library_is_migrated_to_the_latest_schema() {let library = Library::in_memory().unwrap();diff --git a/crates/quince-core/src/notes.rs b/crates/quince-core/src/notes.rsindex db90516..451f576 100644--- a/crates/quince-core/src/notes.rs+++ b/crates/quince-core/src/notes.rs@@ -69,7 +69,7 @@ fn now() -> i64 {impl Library {pub fn put_note_folders(&mut self, folders: &[NoteFolder]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO note_folders (guid, title, sort_order, parent_guid, updated_at)@@ -152,7 +152,7 @@ impl Library {}pub fn put_notes(&mut self, notes: &[Note]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO notes (guid, folder_guid, title, snippet, body, locked, pinned,@@ -202,7 +202,7 @@ impl Library {/// consumed one before it was understood would leave a deleted note on screen forever —/// and saving one of those writes it back to iCloud.pub fn retain_notes(&mut self, keep: &[String]) -> Result<usize> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;let removed = {let mut known: std::collections::HashSet<&str> =keep.iter().map(String::as_str).collect();@@ -227,7 +227,7 @@ impl Library {}pub fn forget_notes(&mut self, note_guids: &[String]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("DELETE FROM notes WHERE guid = ?1")?;for guid in note_guids {@@ -298,7 +298,7 @@ impl Library {/// Forget folders Apple has deleted. A note still pointing at one is left unfiled here/// rather than lost; the next pass files it wherever Apple has it.pub fn remove_note_folders(&mut self, guids: &[String]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;for guid in guids {tx.execute("UPDATE notes SET folder_guid = NULL WHERE folder_guid = ?1",diff --git a/crates/quince-core/src/outbox.rs b/crates/quince-core/src/outbox.rsindex ff4adbf..608db74 100644--- a/crates/quince-core/src/outbox.rs+++ b/crates/quince-core/src/outbox.rs@@ -1,28 +1,58 @@//! Changes made on this computer that Apple has not yet taken. The library shows each at once;//! the app sends them behind it, in the order they were made, and keeps them here — across a//! restart, or while offline — until Apple has them.+//!+//! A change is recorded here in the same library as the records it changes, before anything+//! is sent: a crash at any point after the command returned finds it still waiting. One being+//! sent is counted as tried *before* it goes, so a change that may already be at Apple is never+//! rewritten in place — later edits queue behind it instead. One Apple turns down for good is+//! kept, marked refused, until the person sends it again or lets it go: never dropped unseen.use crate::{Library, Result};-use rusqlite::params;+use rusqlite::{params, OptionalExtension};/// One change waiting for Apple.#[derive(Debug, Clone, PartialEq, Eq)]pub struct Pending {pub id: i64,- /// Which part of iCloud it is for: "reminders", …+ /// Which part of iCloud it is for: "reminders", "notes", "contacts".pub service: String,/// The record it changes.pub record: String,- /// What it does, in the service's own words: "done", …+ /// What it does, in the service's own words: "done", "save", "create", …pub kind: String,/// The change itself, as JSON.pub payload: String,+ /// How many times it has been sent (or begun to be).pub tries: i64,}+/// A change Apple turned down for good, kept with its reason.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct Refused {+ pub change: Pending,+ pub reason: String,+ pub made_at: i64,+ pub refused_at: i64,+}++const COLUMNS: &str = "id, service, record, kind, payload, tries";++fn pending(r: &rusqlite::Row<'_>) -> rusqlite::Result<Pending> {+ Ok(Pending {+ id: r.get(0)?,+ service: r.get(1)?,+ record: r.get(2)?,+ kind: r.get(3)?,+ payload: r.get(4)?,+ tries: r.get(5)?,+ })+}+impl Library {- /// Queue a change. One still waiting of the same kind on the same record is replaced: only- /// the last word on a field needs to reach Apple (ticked, unticked, ticked is ticked).+ /// Queue a change. One still waiting of the same kind on the same record and never sent is+ /// replaced, and the new one goes to the back: only the last word on a field needs to reach+ /// Apple (ticked, unticked, ticked is ticked).pub fn outbox_push(&mut self,service: &str,@@ -30,9 +60,10 @@ impl Library {kind: &str,payload: &str,) -> Result<i64> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;tx.execute(- "DELETE FROM outbox WHERE service = ?1 AND record = ?2 AND kind = ?3 AND tries = 0",+ "DELETE FROM outbox WHERE service = ?1 AND record = ?2 AND kind = ?3 AND tries = 0+ AND refused_at IS NULL",params![service, record, kind],)?;tx.execute(@@ -44,25 +75,86 @@ impl Library {Ok(id)}- /// What is waiting for one service, oldest first.- pub fn outbox_pending(&self, service: &str) -> Result<Vec<Pending>> {- let mut stmt = self.conn.prepare(- "SELECT id, service, record, kind, payload, tries FROM outbox WHERE service = ?1 ORDER BY id",+ /// Queue a change at the back, whatever else waits.+ pub fn outbox_append(+ &mut self,+ service: &str,+ record: &str,+ kind: &str,+ payload: &str,+ ) -> Result<i64> {+ self.conn.execute(+ "INSERT INTO outbox (service, record, kind, payload, made_at) VALUES (?1, ?2, ?3, ?4, ?5)",+ params![service, record, kind, payload, jiff::Timestamp::now().as_second()],)?;- let rows = stmt.query_map(params![service], |r| {- Ok(Pending {- id: r.get(0)?,- service: r.get(1)?,- record: r.get(2)?,- kind: r.get(3)?,- payload: r.get(4)?,- tries: r.get(5)?,- })- })?;+ Ok(self.conn.last_insert_rowid())+ }++ /// Rewrite a waiting change where it stands in the queue — only while it has never been+ /// sent. Whether it was: `false` means it may be on its way, and the caller queues anew.+ pub fn outbox_amend(&mut self, id: i64, payload: &str) -> Result<bool> {+ let n = self.conn.execute(+ "UPDATE outbox SET payload = ?2 WHERE id = ?1 AND tries = 0 AND refused_at IS NULL",+ params![id, payload],+ )?;+ Ok(n == 1)+ }++ /// What is waiting (not refused) for one record of one kind, oldest first.+ pub fn outbox_waiting(&self, service: &str, record: &str, kind: &str) -> Result<Vec<Pending>> {+ let mut stmt = self.conn.prepare(&format!(+ "SELECT {COLUMNS} FROM outbox WHERE service = ?1 AND record = ?2 AND kind = ?3+ AND refused_at IS NULL ORDER BY id"+ ))?;+ let rows = stmt.query_map(params![service, record, kind], pending)?;Ok(rows.collect::<std::result::Result<_, _>>()?)}- /// Every change still waiting, whatever its service.+ /// What is waiting for one service, oldest first. Refused changes are not waiting.+ pub fn outbox_pending(&self, service: &str) -> Result<Vec<Pending>> {+ let mut stmt = self.conn.prepare(&format!(+ "SELECT {COLUMNS} FROM outbox WHERE service = ?1 AND refused_at IS NULL ORDER BY id"+ ))?;+ let rows = stmt.query_map(params![service], pending)?;+ Ok(rows.collect::<std::result::Result<_, _>>()?)+ }++ /// Everything waiting, every service, oldest first.+ pub fn outbox_all_pending(&self) -> Result<Vec<Pending>> {+ let mut stmt = self.conn.prepare(&format!(+ "SELECT {COLUMNS} FROM outbox WHERE refused_at IS NULL ORDER BY id"+ ))?;+ let rows = stmt.query_map([], pending)?;+ Ok(rows.collect::<std::result::Result<_, _>>()?)+ }++ /// The oldest change waiting for a service, counted as tried before it goes: from here on+ /// it may reach Apple, so it is never amended or replaced, only followed.+ pub fn outbox_take(&mut self, service: &str) -> Result<Option<Pending>> {+ let tx = self.conn.savepoint()?;+ let next = tx+ .query_row(+ &format!(+ "SELECT {COLUMNS} FROM outbox WHERE service = ?1 AND refused_at IS NULL+ ORDER BY id LIMIT 1"+ ),+ params![service],+ pending,+ )+ .optional()?;+ let Some(mut next) = next else {+ return Ok(None);+ };+ tx.execute(+ "UPDATE outbox SET tries = tries + 1 WHERE id = ?1",+ params![next.id],+ )?;+ tx.commit()?;+ next.tries += 1;+ Ok(Some(next))+ }++ /// Every change not yet at Apple — waiting or refused — whatever its service.pub fn outbox_count(&self) -> Result<usize> {let n: i64 = self.conn@@ -70,7 +162,7 @@ impl Library {Ok(usize::try_from(n).unwrap_or(0))}- /// Apple has it (or has refused it for good): no longer waiting.+ /// Apple has it: no longer waiting.pub fn outbox_done(&mut self, id: i64) -> Result<()> {self.conn.execute("DELETE FROM outbox WHERE id = ?1", params![id])?;@@ -80,15 +172,87 @@ impl Library {/// Not taken this time; tried again later. The reason is kept for the record.pub fn outbox_retry(&mut self, id: i64, error: &str) -> Result<()> {self.conn.execute(- "UPDATE outbox SET tries = tries + 1, error = ?2 WHERE id = ?1",+ "UPDATE outbox SET error = ?2 WHERE id = ?1",params![id, error],)?;Ok(())}+ /// Turned down for good: kept, with why, and no longer sent.+ pub fn outbox_refuse(&mut self, id: i64, reason: &str) -> Result<()> {+ self.conn.execute(+ "UPDATE outbox SET error = ?2, refused_at = ?3 WHERE id = ?1",+ params![id, reason, jiff::Timestamp::now().as_second()],+ )?;+ Ok(())+ }++ /// Every refused change, oldest first.+ pub fn outbox_refused(&self) -> Result<Vec<Refused>> {+ let mut stmt = self.conn.prepare(&format!(+ "SELECT {COLUMNS}, coalesce(error, ''), made_at, refused_at FROM outbox+ WHERE refused_at IS NOT NULL ORDER BY id"+ ))?;+ let rows = stmt.query_map([], |r| {+ Ok(Refused {+ change: pending(r)?,+ reason: r.get(6)?,+ made_at: r.get(7)?,+ refused_at: r.get(8)?,+ })+ })?;+ Ok(rows.collect::<std::result::Result<_, _>>()?)+ }++ /// One refused change, by id.+ pub fn outbox_refused_one(&self, id: i64) -> Result<Option<Refused>> {+ Ok(self+ .outbox_refused()?+ .into_iter()+ .find(|r| r.change.id == id))+ }++ /// A refused change sent again, at the back of the queue, as if just made.+ pub fn outbox_resend(&mut self, id: i64) -> Result<bool> {+ let tx = self.conn.savepoint()?;+ let row = tx+ .query_row(+ "SELECT service, record, kind, payload FROM outbox+ WHERE id = ?1 AND refused_at IS NOT NULL",+ params![id],+ |r| {+ Ok((+ r.get::<_, String>(0)?,+ r.get::<_, String>(1)?,+ r.get::<_, String>(2)?,+ r.get::<_, String>(3)?,+ ))+ },+ )+ .optional()?;+ let Some((service, record, kind, payload)) = row else {+ return Ok(false);+ };+ tx.execute("DELETE FROM outbox WHERE id = ?1", params![id])?;+ tx.execute(+ "INSERT INTO outbox (service, record, kind, payload, made_at) VALUES (?1, ?2, ?3, ?4, ?5)",+ params![service, record, kind, payload, jiff::Timestamp::now().as_second()],+ )?;+ tx.commit()?;+ Ok(true)+ }++ /// A refused change let go of, by the person's choice.+ pub fn outbox_discard(&mut self, id: i64) -> Result<()> {+ self.conn.execute(+ "DELETE FROM outbox WHERE id = ?1 AND refused_at IS NOT NULL",+ params![id],+ )?;+ Ok(())+ }+/// The list a reminder is in, if it is in the library.pub fn reminder_list_of(&self, guid: &str) -> Result<Option<String>> {- use rusqlite::OptionalExtension;Ok(self.conn.query_row(@@ -128,8 +292,10 @@ mod tests {vec![("r2", "true"), ("r1", "false")]);assert!(p.iter().all(|x| x.id != a));- // One already being tried is never replaced: it may be on its way.- lib.outbox_retry(p[0].id, "offline").unwrap();+ // One already taken to be sent is never replaced: it may be on its way.+ let taken = lib.outbox_take("reminders").unwrap().unwrap();+ assert_eq!((taken.record.as_str(), taken.tries), ("r2", 1));+ lib.outbox_retry(taken.id, "offline").unwrap();lib.outbox_push("reminders", "r2", "done", "false").unwrap();assert_eq!(lib.outbox_pending("reminders").unwrap().len(), 3);for x in lib.outbox_pending("reminders").unwrap() {@@ -138,4 +304,98 @@ mod tests {assert!(lib.outbox_pending("reminders").unwrap().is_empty());assert!(lib.outbox_pending("calendar").unwrap().is_empty());}++ /// An amendment rewrites a change where it stands — only while it was never sent.+ #[test]+ fn a_change_is_amended_in_place_until_it_is_taken() {+ let mut lib = Library::in_memory().unwrap();+ let edit = lib.outbox_append("reminders", "r1", "edit", "{a}").unwrap();+ lib.outbox_append("reminders", "r1", "done", "true")+ .unwrap();+ assert!(lib.outbox_amend(edit, "{a,b}").unwrap());+ let p = lib.outbox_pending("reminders").unwrap();+ assert_eq!(+ p.iter().map(|x| x.payload.as_str()).collect::<Vec<_>>(),+ vec!["{a,b}", "true"],+ "still first, as made"+ );+ lib.outbox_take("reminders").unwrap();+ assert!(+ !lib.outbox_amend(edit, "{a,b,c}").unwrap(),+ "taken: may be at Apple"+ );+ assert_eq!(+ lib.outbox_waiting("reminders", "r1", "edit").unwrap()[0].payload,+ "{a,b}"+ );+ }++ /// Recorded, then the app dies before anything is sent: reopened, the change is there,+ /// in order, and goes once.+ #[test]+ fn a_change_survives_a_crash_between_record_and_send() {+ let dir = tempfile::tempdir().unwrap();+ {+ let mut lib = Library::open(dir.path()).unwrap();+ lib.outbox_append("notes", "N1", "save", "one").unwrap();+ lib.outbox_append("notes", "N2", "save", "two").unwrap();+ // Taken and on its way when the process died: still there, counted as tried.+ lib.outbox_take("notes").unwrap();+ }+ let mut lib = Library::open(dir.path()).unwrap();+ let p = lib.outbox_pending("notes").unwrap();+ assert_eq!(+ p.iter()+ .map(|x| (x.record.as_str(), x.tries))+ .collect::<Vec<_>>(),+ vec![("N1", 1), ("N2", 0)]+ );+ // Amending the one that may have gone is refused; queued behind instead.+ assert!(!lib.outbox_amend(p[0].id, "one again").unwrap());+ let first = lib.outbox_take("notes").unwrap().unwrap();+ assert_eq!((first.record.as_str(), first.tries), ("N1", 2));+ lib.outbox_done(first.id).unwrap();+ let second = lib.outbox_take("notes").unwrap().unwrap();+ assert_eq!(second.record, "N2");+ lib.outbox_done(second.id).unwrap();+ assert!(+ lib.outbox_take("notes").unwrap().is_none(),+ "each sent once"+ );+ }++ /// A refused change is kept, with its reason and content, out of the queue; sent again it+ /// goes to the back; let go of, it is gone.+ #[test]+ fn a_refused_change_is_kept_until_sent_again_or_let_go() {+ let mut lib = Library::in_memory().unwrap();+ let a = lib+ .outbox_append("notes", "N1", "save", "my words")+ .unwrap();+ lib.outbox_append("notes", "N2", "save", "other").unwrap();+ lib.outbox_refuse(a, "changed in the same place").unwrap();+ assert_eq!(lib.outbox_pending("notes").unwrap().len(), 1);+ assert!(lib+ .outbox_take("notes")+ .unwrap()+ .is_some_and(|p| p.record == "N2"));+ let refused = lib.outbox_refused().unwrap();+ assert_eq!(refused.len(), 1);+ assert_eq!(refused[0].change.payload, "my words");+ assert_eq!(refused[0].reason, "changed in the same place");+ assert_eq!(lib.outbox_count().unwrap(), 2, "counted as unsent");+ // Never replaced by a push of the same kind.+ lib.outbox_push("notes", "N1", "save", "newer").unwrap();+ assert_eq!(lib.outbox_refused().unwrap().len(), 1);+ assert!(lib.outbox_resend(a).unwrap());+ let p = lib.outbox_pending("notes").unwrap();+ assert_eq!(+ p.iter().map(|x| x.payload.as_str()).collect::<Vec<_>>(),+ vec!["other", "newer", "my words"]+ );+ let again = p[2].id;+ lib.outbox_refuse(again, "still no").unwrap();+ lib.outbox_discard(again).unwrap();+ assert!(lib.outbox_refused().unwrap().is_empty());+ }}diff --git a/crates/quince-core/src/photos.rs b/crates/quince-core/src/photos.rsindex 66a75bd..4b05f11 100644--- a/crates/quince-core/src/photos.rs+++ b/crates/quince-core/src/photos.rs@@ -211,7 +211,7 @@ fn row_to_photo(r: &rusqlite::Row<'_>) -> rusqlite::Result<Photo> {impl Library {/// Photos written or replaced, by asset id.pub fn put_photos(&mut self, photos: &[Photo]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO photos (id, master, taken_at, added_at, kind, width, height, duration,@@ -276,7 +276,7 @@ impl Library {/// Photos gone from iCloud for good (expunged), by asset id.pub fn forget_photos(&mut self, ids: &[String]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;for id in ids {tx.execute("DELETE FROM photos WHERE id = ?1", params![id])?;}@@ -470,7 +470,7 @@ impl Library {/// Files added to the upload queue, waiting.pub fn queue_uploads(&mut self, uploads: &[Upload]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;for u in uploads {tx.execute("INSERT OR IGNORE INTO photo_uploads (id, batch, path, name, state, error, asset, added_at, album)@@ -572,7 +572,7 @@ impl Library {/// The albums, replaced by `albums`.pub fn replace_albums(&mut self, albums: &[Album]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;tx.execute("DELETE FROM photo_albums", [])?;for a in albums {tx.execute(@@ -594,7 +594,7 @@ impl Library {/// Which photos are in which album: `(album, asset, position)`, added or moved.pub fn put_album_items(&mut self, items: &[(String, String, i64)]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;for (album, asset, position) in items {tx.execute("INSERT INTO photo_album_items (album, asset, position) VALUES (?1, ?2, ?3)@@ -608,7 +608,7 @@ impl Library {/// Photos taken out of albums: `(album, asset)`.pub fn forget_album_items(&mut self, items: &[(String, String)]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;for (album, asset) in items {tx.execute("DELETE FROM photo_album_items WHERE album = ?1 AND asset = ?2",@@ -663,7 +663,7 @@ impl Library {/// An album gone, and which photos were in it with it. Apple leaves a deleted album's/// relation records standing, so they are dropped here.pub fn forget_album(&mut self, id: &str) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;tx.execute("DELETE FROM photo_albums WHERE id = ?1", params![id])?;tx.execute("DELETE FROM photo_album_items WHERE album = ?1",@@ -752,6 +752,142 @@ impl Library {}}+/// A whole read of Photos that takes more than one pass.+///+/// A large library is more change feed than one pass reads, so a whole read goes on across+/// passes from where the last one stopped. What each pass brings is stored at once, so the+/// library fills as it goes; what the read has seen is noted, so that when it reaches the end,+/// and only then, whatever it never saw is let go. The position it carries on from is kept+/// here too, and a pass is only taken as part of the read when it began at exactly that+/// position: one from anywhere else knows nothing of what the read saw before it.+///+/// Records that arrive without their other half at the end of an unfinished pass (an asset+/// whose master is in the next page, or a master whose asset is) are held until it comes.+const WALK_TABLES: &str = "+ CREATE TABLE IF NOT EXISTS photo_walk (+ kind TEXT NOT NULL,+ id TEXT NOT NULL,+ PRIMARY KEY (kind, id)+ ) STRICT, WITHOUT ROWID;+ CREATE TABLE IF NOT EXISTS photo_walk_held (+ id TEXT PRIMARY KEY,+ record TEXT NOT NULL+ ) STRICT;+";++impl Library {+ fn walk_tables(&self) -> Result<()> {+ self.conn.execute_batch(WALK_TABLES)?;+ Ok(())+ }++ /// A whole read starting from the beginning: anything an earlier one noted or held is+ /// dropped.+ pub fn begin_photo_walk(&mut self) -> Result<()> {+ self.walk_tables()?;+ self.conn+ .execute_batch("DELETE FROM photo_walk; DELETE FROM photo_walk_held;")?;+ Ok(())+ }++ /// Where the whole read underway carries on from, if one is.+ pub fn photo_walk_cursor(&self) -> Result<Option<String>> {+ self.walk_tables()?;+ Ok(self+ .conn+ .query_row("SELECT id FROM photo_walk WHERE kind = 'cursor'", [], |r| {+ r.get(0)+ })+ .optional()?)+ }++ /// The whole read underway, forgotten without letting anything go.+ pub fn forget_photo_walk(&mut self) -> Result<()> {+ self.walk_tables()?;+ self.conn.execute("DELETE FROM photo_walk", [])?;+ Ok(())+ }++ /// What a pass of the whole read stored, and where the next pass carries on from (none:+ /// the read starts over).+ pub fn note_photo_walk(+ &mut self,+ photos: &[String],+ albums: &[String],+ items: &[(String, String)],+ cursor: Option<&str>,+ ) -> Result<()> {+ self.walk_tables()?;+ let tx = self.conn.savepoint()?;+ {+ let mut stmt =+ tx.prepare("INSERT OR IGNORE INTO photo_walk (kind, id) VALUES (?1, ?2)")?;+ for id in photos {+ stmt.execute(params!["photo", id])?;+ }+ for id in albums {+ stmt.execute(params!["album", id])?;+ }+ for (album, asset) in items {+ stmt.execute(params!["item", format!("{album}\u{1f}{asset}")])?;+ }+ }+ tx.execute("DELETE FROM photo_walk WHERE kind = 'cursor'", [])?;+ if let Some(cursor) = cursor {+ tx.execute(+ "INSERT INTO photo_walk (kind, id) VALUES ('cursor', ?1)",+ params![cursor],+ )?;+ }+ tx.commit()?;+ Ok(())+ }++ /// The whole read reached the end: every photo, album and album's photo it never saw is+ /// gone from iCloud, and goes here.+ pub fn finish_photo_walk(&mut self) -> Result<()> {+ self.walk_tables()?;+ let tx = self.conn.savepoint()?;+ tx.execute_batch(+ "DELETE FROM photos+ WHERE id NOT IN (SELECT id FROM photo_walk WHERE kind = 'photo');+ DELETE FROM photo_albums+ WHERE id NOT IN (SELECT id FROM photo_walk WHERE kind = 'album');+ DELETE FROM photo_album_items+ WHERE album || char(31) || asset+ NOT IN (SELECT id FROM photo_walk WHERE kind = 'item');+ DELETE FROM photo_walk;",+ )?;+ tx.commit()?;+ Ok(())+ }++ /// Records held from an unfinished pass, as JSON, for the next pass to read first.+ pub fn photo_walk_held(&self) -> Result<Vec<String>> {+ self.walk_tables()?;+ let mut stmt = self+ .conn+ .prepare("SELECT record FROM photo_walk_held ORDER BY rowid")?;+ let rows = stmt.query_map([], |r| r.get(0))?;+ Ok(rows.collect::<std::result::Result<_, _>>()?)+ }++ /// The records held for the next pass, by record name, in place of those held before.+ pub fn hold_for_photo_walk(&mut self, records: &[(String, String)]) -> Result<()> {+ self.walk_tables()?;+ let tx = self.conn.savepoint()?;+ tx.execute("DELETE FROM photo_walk_held", [])?;+ for (id, record) in records {+ tx.execute(+ "INSERT OR REPLACE INTO photo_walk_held (id, record) VALUES (?1, ?2)",+ params![id, record],+ )?;+ }+ tx.commit()?;+ Ok(())+ }+}+#[cfg(test)]mod tests {use super::*;diff --git a/crates/quince-core/src/reminders.rs b/crates/quince-core/src/reminders.rsindex d19a038..95dd8df 100644--- a/crates/quince-core/src/reminders.rs+++ b/crates/quince-core/src/reminders.rs@@ -310,7 +310,7 @@ impl Library {/// "deleted". Using the replacing variant there would wipe the whole library on the/// first incremental refresh.pub fn merge_reminder_lists(&mut self, lists: &[ReminderList]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO reminder_lists (guid, title, colour, ctag, sort_order, enabled,@@ -353,7 +353,7 @@ impl Library {reminder_guids: &[String],list_guids: &[String],) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut drop_reminder = tx.prepare("DELETE FROM reminders WHERE guid = ?1")?;for guid in reminder_guids {@@ -379,7 +379,7 @@ impl Library {sections: &[ReminderSection],gone: &[String],) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut put = tx.prepare("INSERT INTO reminder_sections (guid, list_guid, title, created_at, updated_at)@@ -422,7 +422,7 @@ impl Library {list_guid: &str,placed: &[(String, String)],) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{tx.execute("UPDATE reminders SET section_guid = NULL WHERE list_guid = ?1",@@ -619,7 +619,7 @@ impl Library {/// Replace the set of lists, dropping any Apple no longer reports.pub fn put_reminder_lists(&mut self, lists: &[ReminderList]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO reminder_lists (guid, title, colour, ctag, sort_order, enabled,@@ -674,7 +674,7 @@ impl Library {/// the code knew what to do with it, that record would otherwise stay on screen/// forever. This is the floor under that.pub fn retain_reminders(&mut self, keep: &[String]) -> Result<usize> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;let removed = {let mut known: std::collections::HashSet<&str> =keep.iter().map(String::as_str).collect();@@ -725,8 +725,41 @@ impl Library {Ok(())}+ /// A reminder as changed (or made) here, before Apple has it: the fields a person edits,+ /// leaving Apple's own copy of the record (`raw`) and its change tag as they were, since+ /// those are what the write to Apple is made against.+ pub fn put_reminder_local(&mut self, r: &Reminder) -> Result<()> {+ self.conn.execute(+ "INSERT INTO reminders (guid, list_guid, title, notes, due_at, completed_at,+ priority, flagged, parent_guid, timezone, updated_at, all_day)+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)+ ON CONFLICT(guid) DO UPDATE SET+ list_guid = excluded.list_guid, title = excluded.title,+ notes = excluded.notes, due_at = excluded.due_at,+ completed_at = excluded.completed_at, priority = excluded.priority,+ flagged = excluded.flagged, parent_guid = excluded.parent_guid,+ timezone = excluded.timezone, all_day = excluded.all_day,+ updated_at = excluded.updated_at",+ params![+ r.guid,+ r.list_guid,+ r.title,+ r.notes,+ r.due_at,+ r.completed_at,+ r.priority,+ i64::from(r.flagged),+ r.parent_guid,+ r.timezone,+ now(),+ i64::from(r.all_day)+ ],+ )?;+ Ok(())+ }+pub fn put_reminders(&mut self, reminders: &[Reminder]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;{let mut stmt = tx.prepare("INSERT INTO reminders (guid, list_guid, title, notes, due_at, completed_at,@@ -797,7 +830,7 @@ impl Library {/// Replace the folders lists are filed under.pub fn put_reminder_groups(&mut self, groups: &[ReminderGroup]) -> Result<()> {- let tx = self.conn.transaction()?;+ let tx = self.conn.savepoint()?;tx.execute("DELETE FROM reminder_groups", [])?;{let mut stmt = tx.prepare(@@ -2077,3 +2110,1158 @@ mod list_sorting_tests {);}}++// ---------------------------------------------------------------------------------------+// Details Apple keeps beside a reminder: tags, a link, early alerts, custom smart lists.+// ---------------------------------------------------------------------------------------++/// One tag on one reminder: Apple's `Hashtag` record. The name is stored without the `#`.+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct ReminderHashtag {+ pub guid: String,+ pub reminder_guid: String,+ pub name: String,+}++/// One attachment on a reminder: Apple's `Attachment` record. Only `URL` ones carry a link;+/// `File` and `Image` are listed so their presence is known, never their bytes.+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct ReminderAttachment {+ pub guid: String,+ pub reminder_guid: String,+ /// Apple's `Type`: `URL`, `File` or `Image`.+ pub kind: String,+ pub url: Option<String>,+ pub uti: Option<String>,+}++/// An early alert ("remind me 30 minutes early"), one entry of the reminder's+/// `DueDateDeltaAlertsData`. `count` is how far before the due date, as a positive number;+/// Apple stores it negative. `unit` is Apple's: 0 minutes (the only one on the account+/// measured), then, by the order iOS offers them, 1 hours, 2 days, 3 weeks, 4 months.+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct EarlyAlert {+ pub id: String,+ pub count: i64,+ pub unit: i64,+}++/// Everything about one reminder this section reads, for its detail view.+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct ReminderDetail {+ pub guid: String,+ /// Tag names, without `#`, sorted as the phone shows them.+ pub tags: Vec<String>,+ pub url: Option<String>,+ pub early_alerts: Vec<EarlyAlert>,+ /// How many file or image attachments it has, which this app does not show yet.+ pub other_attachments: usize,+}++/// A tag across the whole account, and how many reminders still to do carry it.+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TagCount {+ pub name: String,+ pub open: usize,+}++/// A `SmartList` record: a built-in one (`today`, `flagged`, `assigned`…) or a custom one,+/// whose filter is kept as Apple's JSON and decoded with [`SmartFilter::decode`].+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct ReminderSmartList {+ pub guid: String,+ /// The last part of Apple's `SmartListType`: `custom`, `today`, `flagged`, `assigned`…+ pub kind: String,+ pub title: Option<String>,+ pub colour: Option<String>,+ pub emblem: Option<String>,+ pub pinned: bool,+ pub sorting: Option<String>,+ /// `FilterData` as Apple wrote it (JSON), for a custom list.+ pub filter: Option<String>,+}++/// What one sync pass read of the details. A whole pass replaces everything stored; an+/// incremental one lays itself over it.+#[derive(Debug, Clone, Default)]+pub struct ReminderDetailsPass {+ pub whole: bool,+ pub hashtags: Vec<ReminderHashtag>,+ pub attachments: Vec<ReminderAttachment>,+ /// Every reminder record in the pass with its early alerts — an empty list included, so a+ /// reminder whose alert was taken off on the phone loses it here — and the account id+ /// Apple writes inside them.+ pub early_alerts: Vec<(String, Option<String>, Vec<EarlyAlert>)>,+ pub smart_lists: Vec<ReminderSmartList>,+ /// Names of records Apple reports gone; any of the four kinds.+ pub gone: Vec<String>,+}++/// A custom smart list's filter, decoded from `FilterData`.+///+/// Only `{"priorities":["medium"]}` has been seen on a real account. The other keys are read+/// from the shapes Apple's filter editor offers (tags, date, priority, flagged, lists, and+/// whether all or any must match), leniently; anything not understood is named in `unknown`+/// rather than guessed at, and [`Library::reminders_in_smart_list`] says so.+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct SmartFilter {+ /// All criteria must hold (Apple's default), or any one.+ pub match_all: bool,+ pub tags: Option<TagFilter>,+ pub date: Option<DateFilter>,+ /// Apple's scale: 1 high, 5 medium, 9 low, 0 none.+ pub priorities: Vec<i64>,+ pub flagged: Option<bool>,+ /// List record names.+ pub lists: Vec<String>,+ /// Keys, or values, this decoder did not understand.+ pub unknown: Vec<String>,+}++#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TagFilter {+ /// Lower-cased, without `#`.+ pub names: Vec<String>,+ /// Every named tag (true) or any one of them.+ pub all: bool,+ /// "Any tag": a reminder carrying at least one.+ pub any_tag: bool,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase", tag = "kind")]+pub enum DateFilter {+ /// Has any due date.+ Any,+ /// Due today (overdue counts, as in Today).+ Today,+ /// Due before now and not done.+ Overdue,+ /// Due within `[from, to)`, Unix seconds.+ Range { from: i64, to: i64 },+ /// Due within the next `count` units from the start of today (`past`: the last ones).+ Relative {+ count: i64,+ unit: String,+ past: bool,+ },+}++/// Seconds between the Unix epoch and Apple's.+const APPLE_EPOCH: i64 = 978_307_200;++/// A date in a filter as Unix seconds, whichever clock Apple wrote it in.+fn filter_moment(v: &serde_json::Value) -> Option<i64> {+ #[allow(clippy::cast_possible_truncation)]+ let n = v.as_f64()? as i64;+ Some(if n > 100_000_000_000 {+ n / 1000+ } else if n < 1_200_000_000 {+ // Apple's epoch: seconds since 2001, which stays below this until 2039.+ n + APPLE_EPOCH+ } else {+ n+ })+}++fn priority_level(word: &str) -> Option<i64> {+ match word.to_ascii_lowercase().as_str() {+ "high" => Some(1),+ "medium" => Some(5),+ "low" => Some(9),+ "none" => Some(0),+ _ => None,+ }+}++/// Whether `priority` falls in the band `level` names, as EventKit bands them.+fn in_priority_band(priority: i64, level: i64) -> bool {+ match level {+ 1 => (1..=4).contains(&priority),+ 5 => priority == 5,+ 9 => (6..=9).contains(&priority),+ _ => priority == 0,+ }+}++fn tag_key(name: &str) -> String {+ name.trim().trim_start_matches('#').to_lowercase()+}++fn strings_in(v: &serde_json::Value) -> Vec<String> {+ let one = |x: &serde_json::Value| -> Option<String> {+ x.as_str().map(ToString::to_string).or_else(|| {+ ["name", "identifier", "id", "recordName"]+ .iter()+ .find_map(|k| x.get(*k).and_then(|s| s.as_str()).map(ToString::to_string))+ })+ };+ match v {+ serde_json::Value::Array(items) => items.iter().filter_map(one).collect(),+ other => one(other).into_iter().collect(),+ }+}++/// "and"/"all" is all; "or"/"any" is any.+fn all_or_any(v: &serde_json::Value) -> Option<bool> {+ let word = v.as_str()?.to_ascii_lowercase();+ if word.contains("all") || word == "and" {+ Some(true)+ } else if word.contains("any") || word == "or" {+ Some(false)+ } else {+ None+ }+}++impl SmartFilter {+ /// Decode Apple's `FilterData` JSON. Never fails: what is not understood is listed.+ #[must_use]+ pub fn decode(json: &str) -> Self {+ let mut out = SmartFilter {+ match_all: true,+ ..Default::default()+ };+ let Ok(serde_json::Value::Object(map)) = serde_json::from_str::<serde_json::Value>(json)+ else {+ out.unknown.push("(not JSON)".into());+ return out;+ };+ for (key, value) in &map {+ match key.as_str() {+ "minimumSupportedVersion" | "version" => {}+ "operation" | "matchingOperation" | "combination" | "match" => {+ match all_or_any(value) {+ Some(all) => out.match_all = all,+ None => out.unknown.push(key.clone()),+ }+ }+ "priorities" | "priority" => {+ for word in strings_in(value) {+ match priority_level(&word) {+ Some(level) => out.priorities.push(level),+ None => out.unknown.push(format!("priority {word}")),+ }+ }+ if let Some(n) = value.as_array() {+ for level in n.iter().filter_map(serde_json::Value::as_i64) {+ out.priorities.push(level);+ }+ }+ }+ "flagged" | "isFlagged" => match value {+ serde_json::Value::Bool(b) => out.flagged = Some(*b),+ serde_json::Value::Object(o) => {+ match o.values().find_map(serde_json::Value::as_bool) {+ Some(b) => out.flagged = Some(b),+ None => out.unknown.push(key.clone()),+ }+ }+ serde_json::Value::Number(n) => out.flagged = Some(n.as_i64() != Some(0)),+ _ => out.unknown.push(key.clone()),+ },+ "lists" | "listIDs" | "listIdentifiers" => {+ let ids = match value {+ serde_json::Value::Object(o) => o+ .iter()+ .filter(|(k, _)| k.to_ascii_lowercase().contains("list"))+ .flat_map(|(_, v)| strings_in(v))+ .collect(),+ other => strings_in(other),+ };+ out.lists.extend(ids.into_iter().map(|id| {+ if id.contains('/') {+ id+ } else {+ format!("List/{}", id.to_ascii_uppercase())+ }+ }));+ }+ "hashtags" | "tags" | "hashtagLabels" => {+ out.tags = Some(decode_tags(value, &mut out.unknown))+ }+ "date" | "dueDate" => out.date = decode_date(value, &mut out.unknown),+ other => out.unknown.push(other.to_string()),+ }+ }+ out+ }++ /// Whether this filter would show a reminder, given its tags (lower-cased) and `now`.+ fn holds(&self, r: &Reminder, tags: &[String], now: i64) -> bool {+ let mut checks: Vec<bool> = Vec::new();+ if let Some(t) = &self.tags {+ let has = |n: &String| tags.contains(n);+ checks.push(if t.any_tag && t.names.is_empty() {+ !tags.is_empty()+ } else if t.all {+ t.names.iter().all(has)+ } else {+ t.names.iter().any(has)+ });+ }+ if let Some(d) = &self.date {+ checks.push(date_holds(d, r, now));+ }+ if !self.priorities.is_empty() {+ checks.push(+ self.priorities+ .iter()+ .any(|&level| in_priority_band(r.priority, level)),+ );+ }+ if let Some(f) = self.flagged {+ checks.push(r.flagged == f);+ }+ if !self.lists.is_empty() {+ checks.push(+ self.lists+ .iter()+ .any(|l| l.eq_ignore_ascii_case(&r.list_guid)),+ );+ }+ if checks.is_empty() {+ return false;+ }+ if self.match_all {+ checks.iter().all(|c| *c)+ } else {+ checks.iter().any(|c| *c)+ }+ }+}++fn decode_tags(value: &serde_json::Value, unknown: &mut Vec<String>) -> TagFilter {+ let mut t = TagFilter {+ all: false,+ ..Default::default()+ };+ match value {+ serde_json::Value::Object(o) => {+ for (k, v) in o {+ let lower = k.to_ascii_lowercase();+ if lower.contains("operation") || lower == "mode" || lower == "match" {+ match all_or_any(v) {+ Some(all) => t.all = all,+ None => unknown.push(format!("tags.{k}")),+ }+ } else if lower.contains("any") && v.as_bool().is_some() {+ t.any_tag = v.as_bool().unwrap_or(false);+ } else if v.is_array() || v.is_string() {+ t.names.extend(strings_in(v).iter().map(|n| tag_key(n)));+ } else {+ unknown.push(format!("tags.{k}"));+ }+ }+ }+ serde_json::Value::Bool(true) => t.any_tag = true,+ other => t.names.extend(strings_in(other).iter().map(|n| tag_key(n))),+ }+ t.names.sort();+ t.names.dedup();+ t+}++fn decode_date(value: &serde_json::Value, unknown: &mut Vec<String>) -> Option<DateFilter> {+ if value.as_bool() == Some(true) {+ return Some(DateFilter::Any);+ }+ let kind = value+ .as_str()+ .or_else(|| {+ ["type", "kind", "dateType"]+ .iter()+ .find_map(|k| value.get(*k)?.as_str())+ })+ .map(str::to_ascii_lowercase)+ .unwrap_or_default();+ let get = |names: &[&str]| {+ names+ .iter()+ .find_map(|k| value.get(*k))+ .and_then(filter_moment)+ };+ let from = get(&["start", "startDate", "from", "lowerBound"]);+ let to = get(&["end", "endDate", "to", "upperBound"]);+ if let (Some(from), Some(to)) = (from, to) {+ return Some(DateFilter::Range { from, to });+ }+ let count = ["count", "value", "amount"]+ .iter()+ .find_map(|k| value.get(*k)?.as_i64());+ let unit = ["unit", "component"]+ .iter()+ .find_map(|k| value.get(*k))+ .and_then(|u| {+ u.as_str().map(str::to_ascii_lowercase).or_else(|| {+ u.as_i64().and_then(|n| {+ ["day", "week", "month", "year"]+ .get(usize::try_from(n).ok()?)+ .map(|s| (*s).to_string())+ })+ })+ });+ match (kind.as_str(), count, unit) {+ (k, Some(count), Some(unit)) if !k.contains("today") => Some(DateFilter::Relative {+ count,+ unit,+ past: k.contains("past") || k.contains("last") || count < 0,+ }),+ (k, _, _) if k.contains("today") => Some(DateFilter::Today),+ (k, _, _) if k.contains("overdue") || k.contains("past") => Some(DateFilter::Overdue),+ (k, _, _) if k.contains("any") || k == "scheduled" || k == "hasdate" => {+ Some(DateFilter::Any)+ }+ _ => {+ unknown.push(format!("date {value}"));+ None+ }+ }+}++fn date_holds(d: &DateFilter, r: &Reminder, now: i64) -> bool {+ let Some(due) = r.due_at else {+ return false;+ };+ let zone = jiff::tz::TimeZone::system();+ let today = jiff::Timestamp::from_second(now)+ .ok()+ .map(|t| t.to_zoned(zone.clone()).date());+ let day_start = |date: jiff::civil::Date| {+ date.to_zoned(zone.clone())+ .map_or(now, |z| z.timestamp().as_second())+ };+ match d {+ DateFilter::Any => true,+ DateFilter::Overdue => due < now,+ DateFilter::Today => {+ let end = today.and_then(|t| t.tomorrow().ok()).map_or(now, day_start);+ if r.all_day {+ due < all_day_bound(end)+ } else {+ due < end+ }+ }+ DateFilter::Range { from, to } => due >= *from && due < *to,+ DateFilter::Relative { count, unit, past } => {+ let Some(today) = today else { return false };+ let n = count.abs().clamp(0, 10_000);+ let span = match unit.as_str() {+ u if u.starts_with("week") => jiff::Span::new().weeks(n),+ u if u.starts_with("month") => jiff::Span::new().months(n),+ u if u.starts_with("year") => jiff::Span::new().years(n),+ _ => jiff::Span::new().days(n),+ };+ let start = day_start(today);+ if *past {+ let from = today.checked_sub(span).map_or(start, day_start);+ due >= from && due < start+ } else {+ let to = today.checked_add(span).map_or(start, day_start);+ due >= start && due < to+ }+ }+ }+}++/// What a custom smart list holds now, and which parts of its filter could not be read.+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct SmartListContents {+ pub reminders: Vec<Reminder>,+ /// Non-empty when part of Apple's filter was not understood: those parts were left out,+ /// so the list may hold more or fewer than the phone shows.+ pub unknown: Vec<String>,+}++impl Library {+ /// Store one pass of reminder details. See [`ReminderDetailsPass`].+ pub fn put_reminder_details(&mut self, pass: &ReminderDetailsPass) -> Result<()> {+ let tx = self.conn.savepoint()?;+ {+ if pass.whole {+ tx.execute_batch(+ "DELETE FROM reminder_hashtags; DELETE FROM reminder_attachments;+ DELETE FROM reminder_smart_lists;",+ )?;+ }+ let stamp = now();+ for gone in &pass.gone {+ tx.execute(+ "DELETE FROM reminder_hashtags WHERE guid = ?1",+ params![gone],+ )?;+ tx.execute(+ "DELETE FROM reminder_attachments WHERE guid = ?1",+ params![gone],+ )?;+ tx.execute(+ "DELETE FROM reminder_smart_lists WHERE guid = ?1",+ params![gone],+ )?;+ tx.execute(+ "DELETE FROM reminder_early_alerts WHERE reminder_guid = ?1",+ params![gone],+ )?;+ }+ let mut tag = tx.prepare(+ "INSERT INTO reminder_hashtags (guid, reminder_guid, name, updated_at)+ VALUES (?1, ?2, ?3, ?4)+ ON CONFLICT(guid) DO UPDATE SET reminder_guid = excluded.reminder_guid,+ name = excluded.name, updated_at = excluded.updated_at",+ )?;+ for h in &pass.hashtags {+ tag.execute(params![h.guid, h.reminder_guid, h.name, stamp])?;+ }+ let mut attach = tx.prepare(+ "INSERT INTO reminder_attachments (guid, reminder_guid, kind, url, uti, updated_at)+ VALUES (?1, ?2, ?3, ?4, ?5, ?6)+ ON CONFLICT(guid) DO UPDATE SET reminder_guid = excluded.reminder_guid,+ kind = excluded.kind, url = excluded.url, uti = excluded.uti,+ updated_at = excluded.updated_at",+ )?;+ for a in &pass.attachments {+ attach.execute(params![+ a.guid,+ a.reminder_guid,+ a.kind,+ a.url,+ a.uti,+ stamp+ ])?;+ }+ let mut clear =+ tx.prepare("DELETE FROM reminder_early_alerts WHERE reminder_guid = ?1")?;+ let mut alert = tx.prepare(+ "INSERT OR REPLACE INTO reminder_early_alerts (id, reminder_guid, count, unit, account_id)+ VALUES (?1, ?2, ?3, ?4, ?5)",+ )?;+ for (reminder, account, alerts) in &pass.early_alerts {+ clear.execute(params![reminder])?;+ for a in alerts {+ alert.execute(params![a.id, reminder, a.count, a.unit, account])?;+ }+ }+ let mut smart = tx.prepare(+ "INSERT INTO reminder_smart_lists (guid, kind, title, colour, emblem, pinned,+ sorting, filter, updated_at)+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)+ ON CONFLICT(guid) DO UPDATE SET kind = excluded.kind, title = excluded.title,+ colour = excluded.colour, emblem = excluded.emblem, pinned = excluded.pinned,+ sorting = excluded.sorting, filter = excluded.filter,+ updated_at = excluded.updated_at",+ )?;+ for s in &pass.smart_lists {+ smart.execute(params![+ s.guid,+ s.kind,+ s.title,+ s.colour,+ s.emblem,+ i64::from(s.pinned),+ s.sorting,+ s.filter,+ stamp+ ])?;+ }+ // A reminder that is gone takes its details with it.+ tx.execute_batch(+ "DELETE FROM reminder_hashtags WHERE reminder_guid NOT IN (SELECT guid FROM reminders);+ DELETE FROM reminder_attachments WHERE reminder_guid NOT IN (SELECT guid FROM reminders);+ DELETE FROM reminder_early_alerts WHERE reminder_guid NOT IN (SELECT guid FROM reminders);",+ )?;+ }+ tx.commit()?;+ Ok(())+ }++ /// One reminder's tags, link and early alerts.+ pub fn reminder_detail(&self, guid: &str) -> Result<ReminderDetail> {+ let mut tags: Vec<String> = {+ let mut stmt = self+ .conn+ .prepare("SELECT DISTINCT name FROM reminder_hashtags WHERE reminder_guid = ?1")?;+ let rows = stmt.query_map(params![guid], |r| r.get::<_, String>(0))?;+ rows.collect::<rusqlite::Result<_>>()?+ };+ tags.sort_by(|a, b| crate::fold::natural(a, b));+ tags.dedup_by(|a, b| a.eq_ignore_ascii_case(b));+ let mut stmt = self.conn.prepare(+ "SELECT kind, url FROM reminder_attachments WHERE reminder_guid = ?1 ORDER BY guid",+ )?;+ let attachments = stmt+ .query_map(params![guid], |r| {+ Ok((r.get::<_, String>(0)?, r.get::<_, Option<String>>(1)?))+ })?+ .collect::<rusqlite::Result<Vec<_>>>()?;+ let url = attachments+ .iter()+ .find(|(kind, url)| kind == "URL" && url.is_some())+ .and_then(|(_, url)| url.clone());+ let other_attachments = attachments.iter().filter(|(k, _)| k != "URL").count();+ let mut stmt = self.conn.prepare(+ "SELECT id, count, unit FROM reminder_early_alerts WHERE reminder_guid = ?1+ ORDER BY unit, count, id",+ )?;+ let early_alerts = stmt+ .query_map(params![guid], |r| {+ Ok(EarlyAlert {+ id: r.get(0)?,+ count: r.get(1)?,+ unit: r.get(2)?,+ })+ })?+ .collect::<rusqlite::Result<Vec<_>>>()?;+ Ok(ReminderDetail {+ guid: guid.to_string(),+ tags,+ url,+ early_alerts,+ other_attachments,+ })+ }++ /// One reminder's tag records, for a write that removes one by name.+ pub fn reminder_hashtags(&self, guid: &str) -> Result<Vec<ReminderHashtag>> {+ let mut stmt = self.conn.prepare(+ "SELECT guid, reminder_guid, name FROM reminder_hashtags WHERE reminder_guid = ?1",+ )?;+ let rows = stmt.query_map(params![guid], |r| {+ Ok(ReminderHashtag {+ guid: r.get(0)?,+ reminder_guid: r.get(1)?,+ name: r.get(2)?,+ })+ })?;+ Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)+ }++ /// Every tag on the account, as the tag browser lists them: one entry per name however it+ /// is capitalised, with how many reminders still to do carry it.+ pub fn reminder_tags(&self) -> Result<Vec<TagCount>> {+ let mut stmt = self.conn.prepare(+ "SELECT h.name, h.reminder_guid, r.completed_at IS NULL AND l.enabled = 1+ FROM reminder_hashtags h+ JOIN reminders r ON r.guid = h.reminder_guid+ JOIN reminder_lists l ON l.guid = r.list_guid",+ )?;+ let rows = stmt+ .query_map([], |r| {+ Ok((+ r.get::<_, String>(0)?,+ r.get::<_, String>(1)?,+ r.get::<_, i64>(2)? != 0,+ ))+ })?+ .collect::<rusqlite::Result<Vec<_>>>()?;+ let mut by: std::collections::BTreeMap<+ String,+ (String, std::collections::HashSet<String>),+ > = std::collections::BTreeMap::new();+ for (name, reminder, open) in rows {+ let entry = by+ .entry(tag_key(&name))+ .or_insert_with(|| (name.clone(), std::collections::HashSet::new()));+ if open {+ entry.1.insert(reminder);+ }+ }+ let mut out: Vec<TagCount> = by+ .into_values()+ .map(|(name, open)| TagCount {+ name,+ open: open.len(),+ })+ .collect();+ out.sort_by(|a, b| crate::fold::natural(&a.name, &b.name));+ Ok(out)+ }++ /// Reminders still to do carrying a tag, matched however it is capitalised.+ pub fn reminders_tagged(&self, name: &str) -> Result<Vec<Reminder>> {+ let key = tag_key(name);+ let mut stmt = self.conn.prepare(&format!(+ "SELECT {} FROM reminders r JOIN reminder_lists l ON l.guid = r.list_guid+ WHERE l.enabled = 1 AND r.completed_at IS NULL AND r.guid IN+ (SELECT reminder_guid FROM reminder_hashtags WHERE lower(name) = ?1)+ ORDER BY r.due_at IS NULL, r.due_at, r.priority DESC, r.title+ LIMIT {MOST_AT_ONCE}",+ prefixed_columns()+ ))?;+ // SQLite lowers ASCII only; the match is checked again in Rust below for the rest.+ let rows = stmt.query_map(params![key], reminder_row)?;+ let mut found: Vec<Reminder> = rows+ .collect::<rusqlite::Result<Vec<_>>>()?+ .into_iter()+ .map(|(r, _)| r)+ .collect();+ if found.is_empty() && !key.is_ascii() {+ let tagged: std::collections::HashSet<String> = self+ .all_tags_by_reminder()?+ .into_iter()+ .filter(|(_, tags)| tags.contains(&key))+ .map(|(r, _)| r)+ .collect();+ found = self+ .open_reminders()?+ .into_iter()+ .filter(|r| tagged.contains(&r.guid))+ .take(MOST_AT_ONCE)+ .collect();+ }+ Ok(found)+ }++ fn all_tags_by_reminder(&self) -> Result<std::collections::HashMap<String, Vec<String>>> {+ let mut stmt = self+ .conn+ .prepare("SELECT reminder_guid, name FROM reminder_hashtags")?;+ let mut by: std::collections::HashMap<String, Vec<String>> = Default::default();+ for row in stmt.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))? {+ let (reminder, name) = row?;+ by.entry(reminder).or_default().push(tag_key(&name));+ }+ Ok(by)+ }++ fn open_reminders(&self) -> Result<Vec<Reminder>> {+ let mut stmt = self.conn.prepare(&format!(+ "SELECT {} FROM reminders r JOIN reminder_lists l ON l.guid = r.list_guid+ WHERE l.enabled = 1 AND r.completed_at IS NULL+ ORDER BY r.due_at IS NULL, r.due_at, r.priority DESC, r.title",+ prefixed_columns()+ ))?;+ let rows = stmt.query_map([], reminder_row)?;+ Ok(rows+ .collect::<rusqlite::Result<Vec<_>>>()?+ .into_iter()+ .map(|(r, _)| r)+ .collect())+ }++ /// The account's smart lists, built-in and custom, as Apple holds them.+ pub fn reminder_smart_lists(&self) -> Result<Vec<ReminderSmartList>> {+ let mut stmt = self.conn.prepare(+ "SELECT guid, kind, title, colour, emblem, pinned, sorting, filter+ FROM reminder_smart_lists ORDER BY kind != 'custom', title, guid",+ )?;+ let rows = stmt.query_map([], |r| {+ Ok(ReminderSmartList {+ guid: r.get(0)?,+ kind: r.get(1)?,+ title: r.get(2)?,+ colour: r.get(3)?,+ emblem: r.get(4)?,+ pinned: r.get::<_, i64>(5)? != 0,+ sorting: r.get(6)?,+ filter: r.get(7)?,+ })+ })?;+ Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)+ }++ /// What a custom smart list holds at `now`, worked out here from its filter.+ pub fn reminders_in_smart_list(&self, guid: &str, now: i64) -> Result<SmartListContents> {+ let filter = self+ .reminder_smart_lists()?+ .into_iter()+ .find(|s| s.guid == guid)+ .and_then(|s| s.filter);+ let Some(filter) = filter else {+ return Ok(SmartListContents {+ reminders: Vec::new(),+ unknown: vec!["(no filter)".into()],+ });+ };+ let filter = SmartFilter::decode(&filter);+ Ok(SmartListContents {+ reminders: self.reminders_matching(&filter, now)?,+ unknown: filter.unknown,+ })+ }++ /// Reminders still to do that a decoded filter holds.+ pub fn reminders_matching(&self, filter: &SmartFilter, now: i64) -> Result<Vec<Reminder>> {+ let tags = self.all_tags_by_reminder()?;+ let none: Vec<String> = Vec::new();+ Ok(self+ .open_reminders()?+ .into_iter()+ .filter(|r| filter.holds(r, tags.get(&r.guid).unwrap_or(&none), now))+ .take(MOST_AT_ONCE)+ .collect())+ }++ /// The account id Apple writes inside early alerts, from any reminder that has one: a new+ /// alert is written with the same.+ pub fn early_alert_account(&self) -> Result<Option<String>> {+ use rusqlite::OptionalExtension;+ Ok(self+ .conn+ .query_row(+ "SELECT account_id FROM reminder_early_alerts WHERE account_id IS NOT NULL LIMIT 1",+ [],+ |r| r.get(0),+ )+ .optional()?)+ }++ /// A section made or renamed here, shown before the next pass brings Apple's copy.+ pub fn put_reminder_section_local(&mut self, section: &ReminderSection) -> Result<()> {+ self.put_reminder_sections(std::slice::from_ref(section), &[])+ }++ /// One reminder moved into a section of its list, or out of every one, here at once.+ /// A section not in this library, or in another list, places nothing.+ pub fn set_reminder_section(&mut self, reminder: &str, section: Option<&str>) -> Result<()> {+ match section {+ None => {+ self.conn.execute(+ "UPDATE reminders SET section_guid = NULL WHERE guid = ?1",+ params![reminder],+ )?;+ }+ Some(section) => {+ self.conn.execute(+ "UPDATE reminders SET section_guid = ?2 WHERE guid = ?1+ AND EXISTS (SELECT 1 FROM reminder_sections s+ WHERE s.guid = ?2 AND s.list_guid = reminders.list_guid)",+ params![reminder, section],+ )?;+ }+ }+ Ok(())+ }+}++/// [`REMINDER_COLUMNS`] qualified with `r.`, for queries that join the list.+fn prefixed_columns() -> String {+ "r.guid, r.list_guid, r.title, r.notes, r.due_at, r.completed_at, r.priority, r.flagged,+ r.parent_guid, r.recur_frequency, r.recur_interval, r.etag, r.timezone, r.section_guid,+ r.all_day,+ CASE WHEN json_valid(r.raw) THEN json_extract(r.raw, '$.fields.CreationDate.value') END"+ .to_string()+}++#[cfg(test)]+mod detail_tests {+ use super::*;++ fn reminder(guid: &str, list: &str) -> Reminder {+ Reminder {+ guid: guid.into(),+ list_guid: list.into(),+ title: guid.into(),+ ..Default::default()+ }+ }++ fn library() -> Library {+ let mut lib = Library::in_memory().unwrap();+ let list = |g: &str| ReminderList {+ guid: g.into(),+ title: g.into(),+ enabled: true,+ ..Default::default()+ };+ lib.put_reminder_lists(&[list("List/A"), list("List/B")])+ .unwrap();+ let mut high = reminder("Reminder/1", "List/A");+ high.priority = 1;+ let mut flagged = reminder("Reminder/2", "List/B");+ flagged.flagged = true;+ flagged.priority = 5;+ let mut done = reminder("Reminder/3", "List/A");+ done.completed_at = Some(1);+ lib.put_reminders(&[high, flagged, done, reminder("Reminder/4", "List/B")])+ .unwrap();+ let tag = |g: &str, r: &str, n: &str| ReminderHashtag {+ guid: g.into(),+ reminder_guid: r.into(),+ name: n.into(),+ };+ lib.put_reminder_details(&ReminderDetailsPass {+ whole: true,+ hashtags: vec![+ tag("Hashtag/a", "Reminder/1", "work"),+ tag("Hashtag/b", "Reminder/2", "Work"),+ tag("Hashtag/c", "Reminder/2", "home"),+ tag("Hashtag/d", "Reminder/3", "work"),+ ],+ attachments: vec![+ ReminderAttachment {+ guid: "Attachment/u".into(),+ reminder_guid: "Reminder/1".into(),+ kind: "URL".into(),+ url: Some("https://example.com/x".into()),+ uti: Some("public.url".into()),+ },+ ReminderAttachment {+ guid: "Attachment/f".into(),+ reminder_guid: "Reminder/1".into(),+ kind: "Image".into(),+ url: None,+ uti: Some("public.jpeg".into()),+ },+ ],+ early_alerts: vec![(+ "Reminder/1".into(),+ Some("ACCT".into()),+ vec![EarlyAlert {+ id: "E1".into(),+ count: 30,+ unit: 0,+ }],+ )],+ smart_lists: vec![ReminderSmartList {+ guid: "SmartList/S".into(),+ kind: "custom".into(),+ title: Some("Medium".into()),+ filter: Some(r#"{"priorities":["medium"]}"#.into()),+ ..Default::default()+ }],+ gone: vec![],+ })+ .unwrap();+ lib+ }++ #[test]+ fn a_reminder_detail_has_its_tags_link_and_early_alert() {+ let lib = library();+ let d = lib.reminder_detail("Reminder/1").unwrap();+ assert_eq!(d.tags, vec!["work".to_string()]);+ assert_eq!(d.url.as_deref(), Some("https://example.com/x"));+ assert_eq!(d.other_attachments, 1);+ assert_eq!(+ d.early_alerts,+ vec![EarlyAlert {+ id: "E1".into(),+ count: 30,+ unit: 0+ }]+ );+ assert_eq!(lib.early_alert_account().unwrap().as_deref(), Some("ACCT"));+ assert_eq!(+ lib.reminder_detail("Reminder/4").unwrap(),+ ReminderDetail {+ guid: "Reminder/4".into(),+ ..Default::default()+ }+ );+ }++ /// One entry per tag however it is capitalised, counting only reminders still to do.+ #[test]+ fn tags_are_listed_once_with_open_counts() {+ let lib = library();+ let tags = lib.reminder_tags().unwrap();+ let names: Vec<(&str, usize)> = tags.iter().map(|t| (t.name.as_str(), t.open)).collect();+ assert_eq!(names.len(), 2);+ assert!(names.contains(&("home", 1)));+ assert!(names+ .iter()+ .any(|(n, c)| n.eq_ignore_ascii_case("work") && *c == 2));+ let tagged: Vec<String> = lib+ .reminders_tagged("#WORK")+ .unwrap()+ .into_iter()+ .map(|r| r.guid)+ .collect();+ assert_eq!(tagged.len(), 2);+ assert!(+ !tagged.contains(&"Reminder/3".to_string()),+ "done ones are not shown"+ );+ }++ /// An incremental pass lays itself over what is stored; a gone record goes; a reminder+ /// that comes back without its alert loses it.+ #[test]+ fn an_incremental_pass_merges_and_forgets() {+ let mut lib = library();+ lib.put_reminder_details(&ReminderDetailsPass {+ whole: false,+ early_alerts: vec![("Reminder/1".into(), None, vec![])],+ gone: vec!["Hashtag/a".into(), "Attachment/u".into()],+ ..Default::default()+ })+ .unwrap();+ let d = lib.reminder_detail("Reminder/1").unwrap();+ assert!(d.tags.is_empty());+ assert_eq!(d.url, None);+ assert!(d.early_alerts.is_empty());+ assert_eq!(lib.reminder_detail("Reminder/2").unwrap().tags.len(), 2);+ assert_eq!(lib.reminder_smart_lists().unwrap().len(), 1, "kept");+ }++ /// A reminder deleted takes its details with it.+ #[test]+ fn details_of_a_deleted_reminder_go() {+ let mut lib = library();+ lib.forget_reminders(&["Reminder/2".into()], &[]).unwrap();+ lib.put_reminder_details(&ReminderDetailsPass::default())+ .unwrap();+ assert!(lib+ .reminder_tags()+ .unwrap()+ .iter()+ .all(|t| t.name != "home"));+ }++ /// The one filter measured on a real account.+ #[test]+ fn the_measured_priority_filter_decodes_and_matches() {+ let lib = library();+ let got = lib.reminders_in_smart_list("SmartList/S", 0).unwrap();+ assert!(got.unknown.is_empty());+ assert_eq!(+ got.reminders+ .iter()+ .map(|r| r.guid.as_str())+ .collect::<Vec<_>>(),+ vec!["Reminder/2"]+ );+ }++ #[test]+ fn common_filters_decode() {+ let f = SmartFilter::decode(+ r##"{"hashtags":{"hashtags":["#Work","home"],"operation":"or"},+ "flagged":true,"priorities":["high","low"],+ "lists":["0AB1-X"],"operation":"any",+ "date":{"type":"today"},"minimumSupportedVersion":20230430}"##,+ );+ assert!(!f.match_all);+ let tags = f.tags.clone().unwrap();+ assert_eq!(tags.names, vec!["home".to_string(), "work".to_string()]);+ assert!(!tags.all);+ assert_eq!(f.flagged, Some(true));+ assert_eq!(f.priorities, vec![1, 9]);+ assert_eq!(f.lists, vec!["List/0AB1-X".to_string()]);+ assert_eq!(f.date, Some(DateFilter::Today));+ assert!(f.unknown.is_empty(), "{:?}", f.unknown);++ let range = SmartFilter::decode(r#"{"date":{"start":800000000,"end":800086400}}"#);+ assert_eq!(+ range.date,+ Some(DateFilter::Range {+ from: 800_000_000 + APPLE_EPOCH,+ to: 800_086_400 + APPLE_EPOCH+ })+ );+ let relative =+ SmartFilter::decode(r#"{"date":{"type":"relative","count":3,"unit":"day"}}"#);+ assert!(matches!(+ relative.date,+ Some(DateFilter::Relative {+ count: 3,+ past: false,+ ..+ })+ ));+ }++ /// What is not understood is named, not guessed.+ #[test]+ fn unknown_filter_parts_are_reported() {+ let f = SmartFilter::decode(r#"{"location":{"x":1},"priorities":["urgent"]}"#);+ assert!(f.unknown.iter().any(|u| u == "location"));+ assert!(f.unknown.iter().any(|u| u.contains("urgent")));+ assert!(!SmartFilter::decode("not json").unknown.is_empty());+ }++ #[test]+ fn all_and_any_combine_as_apple_does() {+ let lib = library();+ let ids = |f: &str| -> Vec<String> {+ let mut v: Vec<String> = lib+ .reminders_matching(&SmartFilter::decode(f), 0)+ .unwrap()+ .into_iter()+ .map(|r| r.guid)+ .collect();+ v.sort();+ v+ };+ assert_eq!(+ ids(r#"{"hashtags":["work"],"flagged":true}"#),+ vec!["Reminder/2"]+ );+ assert_eq!(+ ids(r#"{"hashtags":["work"],"flagged":true,"operation":"any"}"#),+ vec!["Reminder/1", "Reminder/2"]+ );+ assert_eq!(+ ids(r#"{"lists":["List/B"]}"#),+ vec!["Reminder/2", "Reminder/4"]+ );+ assert_eq!(+ ids(r#"{"hashtags":{"hashtags":["work","home"],"operation":"and"}}"#),+ vec!["Reminder/2"]+ );+ assert!(ids("{}").is_empty(), "no criteria holds nothing");+ }++ #[test]+ fn date_filters_hold_against_the_clock() {+ let now = 1_800_000_000;+ let mut due = reminder("R", "L");+ due.due_at = Some(now - 60);+ assert!(date_holds(&DateFilter::Overdue, &due, now));+ assert!(date_holds(&DateFilter::Today, &due, now));+ assert!(date_holds(&DateFilter::Any, &due, now));+ let week = DateFilter::Relative {+ count: 7,+ unit: "day".into(),+ past: false,+ };+ due.due_at = Some(now + 3 * 86_400);+ assert!(date_holds(&week, &due, now));+ due.due_at = Some(now + 30 * 86_400);+ assert!(!date_holds(&week, &due, now));+ due.due_at = None;+ assert!(!date_holds(&DateFilter::Any, &due, now));+ }++ #[test]+ fn a_reminder_moves_into_a_section_of_its_own_list_only() {+ let mut lib = library();+ lib.put_reminder_section_local(&ReminderSection {+ guid: "ListSection/S".into(),+ list_guid: "List/A".into(),+ title: "Soon".into(),+ created_at: None,+ })+ .unwrap();+ lib.set_reminder_section("Reminder/1", Some("ListSection/S"))+ .unwrap();+ lib.set_reminder_section("Reminder/2", Some("ListSection/S"))+ .unwrap();+ assert_eq!(+ lib.reminder("Reminder/1")+ .unwrap()+ .unwrap()+ .section_guid+ .as_deref(),+ Some("ListSection/S")+ );+ assert_eq!(+ lib.reminder("Reminder/2").unwrap().unwrap().section_guid,+ None+ );+ lib.set_reminder_section("Reminder/1", None).unwrap();+ assert_eq!(+ lib.reminder("Reminder/1").unwrap().unwrap().section_guid,+ None+ );+ }+}diff --git a/crates/quince-core/src/schema.rs b/crates/quince-core/src/schema.rsindex 30db939..e0e0410 100644--- a/crates/quince-core/src/schema.rs+++ b/crates/quince-core/src/schema.rs@@ -527,4 +527,81 @@ pub const MIGRATIONS: &[&str] = &[r#"UPDATE sync_state SET token = NULL, last_full_at = NULL WHERE service = 'notes';"#,+ // A change Apple turned down for good stays, marked with when, rather than being thrown+ // away: what was typed is kept for the person to see, send again or let go.+ r#"+ ALTER TABLE outbox ADD COLUMN refused_at INTEGER;+ "#,+ // 43 — a contact's postal addresses, part by part.+ //+ // They were kept only as the flattened lines of an envelope, so a street, a town or a+ // postcode could not be changed on its own. Apple's card keeps each part separately+ // (`streetAddresses[].field.{street, city, state, postalCode, country, ...}`); this keeps+ // them the same way. The raw card was never stored, so nothing here can be filled from+ // what is already in the library: the position is forgotten, and the next Contacts pass+ // reads the book whole and fills it.+ r#"+ CREATE TABLE contact_addresses (+ contact_guid TEXT NOT NULL REFERENCES contacts(guid) ON DELETE CASCADE,+ position INTEGER NOT NULL,+ label TEXT,+ street TEXT,+ sub_locality TEXT,+ city TEXT,+ sub_administrative_area TEXT,+ state TEXT,+ postal_code TEXT,+ country TEXT,+ country_code TEXT,+ PRIMARY KEY (contact_guid, position)+ ) STRICT;+ UPDATE sync_state SET token = NULL WHERE service = 'contacts';+ "#,+ // 44 — reminder details Apple keeps beside the reminder: tags, a link, early alerts, and+ // custom smart lists.+ //+ // A tag is a `Hashtag` record (Name, Reminder) whose bare id the reminder lists in+ // `HashtagIDs`; a link is an `Attachment` record of Type "URL" listed in `AttachmentIDs`;+ // an early alert ("remind me 30 minutes early") is JSON in the reminder's own+ // `DueDateDeltaAlertsData`; a smart list is a `SmartList` record whose `FilterData` is+ // JSON. Reminders read again from the start so every reminder has them.+ r#"+ CREATE TABLE reminder_hashtags (+ guid TEXT PRIMARY KEY,+ reminder_guid TEXT NOT NULL,+ name TEXT NOT NULL,+ updated_at INTEGER NOT NULL+ ) STRICT;+ CREATE INDEX reminder_hashtags_by_reminder ON reminder_hashtags (reminder_guid);+ CREATE INDEX reminder_hashtags_by_name ON reminder_hashtags (name COLLATE NOCASE);+ CREATE TABLE reminder_attachments (+ guid TEXT PRIMARY KEY,+ reminder_guid TEXT NOT NULL,+ kind TEXT NOT NULL,+ url TEXT,+ uti TEXT,+ updated_at INTEGER NOT NULL+ ) STRICT;+ CREATE INDEX reminder_attachments_by_reminder ON reminder_attachments (reminder_guid);+ CREATE TABLE reminder_early_alerts (+ id TEXT NOT NULL,+ reminder_guid TEXT NOT NULL,+ count INTEGER NOT NULL,+ unit INTEGER NOT NULL,+ account_id TEXT,+ PRIMARY KEY (reminder_guid, id)+ ) STRICT;+ CREATE TABLE reminder_smart_lists (+ guid TEXT PRIMARY KEY,+ kind TEXT NOT NULL,+ title TEXT,+ colour TEXT,+ emblem TEXT,+ pinned INTEGER NOT NULL DEFAULT 0,+ sorting TEXT,+ filter TEXT,+ updated_at INTEGER NOT NULL+ ) STRICT;+ UPDATE sync_state SET token = NULL WHERE service = 'reminders';+ "#,];diff --git a/crates/quince-icloud/Cargo.toml b/crates/quince-icloud/Cargo.tomlindex 309fe49..6dee4ad 100644--- a/crates/quince-icloud/Cargo.toml+++ b/crates/quince-icloud/Cargo.toml@@ -19,6 +19,12 @@ uuid = { workspace = true }tokio = { workspace = true, features = ["fs", "io-util", "time"] }futures-util = { version = "0.3", default-features = false, features = ["std"] }sha1 = "0.10"+# Locked notes (notes_locked.rs): PBKDF2-SHA256 → AES key unwrap (RFC 3394) → AES-GCM.+sha2 = "0.10"+pbkdf2 = { version = "0.12", default-features = false, features = ["hmac"] }+aes = "0.8"+aes-kw = "0.2"+aes-gcm = { version = "0.10", default-features = false, features = ["aes", "alloc"] }[dev-dependencies]tokio = { workspace = true }diff --git a/crates/quince-icloud/src/calendar.rs b/crates/quince-icloud/src/calendar.rsindex ca7b449..d0436f4 100644--- a/crates/quince-icloud/src/calendar.rs+++ b/crates/quince-icloud/src/calendar.rs@@ -420,6 +420,44 @@ pub struct EventRepeat {pub count: Option<i64>,}+/// An edit made here, laid over the event as another device has since left it — what a save+/// refused as a conflict is saved as instead, the way Calendar settles two edits.+///+/// `base` is the event as this edit began from it, `mine` the edit, `theirs` Apple's copy now.+/// A field changed only there keeps their change; a field changed here is this edit's, even+/// where they changed it too — the edit being saved is the one the person is looking at. When+/// it happens is one field, not four: a start from one side and an end from the other could+/// make an event that ends before it begins. The etag is Apple's latest, which is what lets+/// the write through.+pub fn merge_edit(base: &Event, mine: &Event, theirs: &Event) -> Event {+ fn pick<T: PartialEq + Clone>(base: &T, mine: &T, theirs: &T) -> T {+ if mine == base {+ theirs.clone()+ } else {+ mine.clone()+ }+ }+ let when = |e: &Event| (e.starts_at, e.ends_at, e.all_day, e.timezone.clone());+ let (starts_at, ends_at, all_day, timezone) = pick(&when(base), &when(mine), &when(theirs));+ Event {+ guid: mine.guid.clone(),+ calendar_guid: pick(+ &base.calendar_guid,+ &mine.calendar_guid,+ &theirs.calendar_guid,+ ),+ title: pick(&base.title, &mine.title, &theirs.title),+ location: pick(&base.location, &mine.location, &theirs.location),+ starts_at,+ ends_at,+ all_day,+ timezone,+ url: pick(&base.url, &mine.url, &theirs.url),+ notes: pick(&base.notes, &mine.notes, &theirs.notes),+ etag: theirs.etag.clone(),+ }+}+/// Apple's calendar service.pub struct CalendarClient<'a> {http: &'a reqwest::Client,@@ -844,6 +882,28 @@ impl<'a> CalendarClient<'a> {Ok(event_of(&body).map(|_| body))}+ /// The event as Apple holds it now, read from the calendar and day it was last known in,+ /// or `None` where Apple no longer has it there — deleted, or moved away, on another+ /// device. Read-only.+ pub async fn current_event(&self, known: &Event) -> Result<Option<Event>> {+ let day = day_of(known.starts_at, event_zone(known).as_deref());+ let Some(body) = self.event_detail_body(known, &day).await? else {+ return Ok(None);+ };+ match event_of(&body) {+ Some(found) => event_from(&found),+ None => Ok(None),+ }+ }++ /// A calendar's ctag as Apple holds it now, for a write retried after a refusal.+ pub async fn current_ctag(&self, guid: &str) -> Result<Option<String>> {+ Ok(self+ .collection_detail(guid)+ .await?+ .and_then(|c| c.get("ctag").and_then(Value::as_str).map(str::to_string)))+ }+/// Apple's event object, in the shape its own web client sends.////// When Apple already has the event, its own record is the starting point and only the@@ -1265,6 +1325,70 @@ mod tests {use super::*;use serde_json::json;+ fn meeting() -> Event {+ Event {+ guid: "EV".into(),+ calendar_guid: "work".into(),+ title: "Planning".into(),+ location: Some("Room 1".into()),+ starts_at: 1_000_000,+ ends_at: 1_003_600,+ all_day: false,+ timezone: Some("Asia/Kolkata".into()),+ url: None,+ notes: None,+ etag: Some("v1".into()),+ }+ }++ /// Edits to different fields on two devices both survive; Apple's newest etag goes with it.+ #[test]+ fn a_conflict_on_different_fields_keeps_both_edits() {+ let base = meeting();+ let mut mine = base.clone();+ mine.title = "Planning, moved".into();+ mine.starts_at += 3600;+ mine.ends_at += 3600;+ let mut theirs = base.clone();+ theirs.location = Some("Room 7".into());+ theirs.notes = Some("Bring the numbers".into());+ theirs.etag = Some("v2".into());+ let merged = merge_edit(&base, &mine, &theirs);+ assert_eq!(merged.title, "Planning, moved");+ assert_eq!(merged.starts_at, base.starts_at + 3600);+ assert_eq!(merged.ends_at, base.ends_at + 3600);+ assert_eq!(merged.location.as_deref(), Some("Room 7"));+ assert_eq!(merged.notes.as_deref(), Some("Bring the numbers"));+ assert_eq!(merged.etag.as_deref(), Some("v2"));+ }++ /// The same field changed on both: this edit's, and their other changes are still kept.+ /// When it happens moves as one — never their start with this end.+ #[test]+ fn a_conflict_on_the_same_field_keeps_this_edit_for_it() {+ let base = meeting();+ let mut mine = base.clone();+ mine.title = "Mine".into();+ mine.ends_at += 1800;+ let mut theirs = base.clone();+ theirs.title = "Theirs".into();+ theirs.starts_at += 7200;+ theirs.ends_at += 7200;+ theirs.url = Some("https://example.com".into());+ theirs.etag = Some("v3".into());+ let merged = merge_edit(&base, &mine, &theirs);+ assert_eq!(merged.title, "Mine");+ assert_eq!(+ (merged.starts_at, merged.ends_at),+ (base.starts_at, base.ends_at + 1800)+ );+ assert_eq!(merged.url.as_deref(), Some("https://example.com"));+ assert_eq!(merged.etag.as_deref(), Some("v3"));+ // Nothing edited here: theirs, whole.+ let untouched = merge_edit(&base, &base, &theirs);+ assert_eq!(untouched, theirs);+ }+fn coloured(colour: &str) -> Calendar {Calendar {guid: colour.into(),diff --git a/crates/quince-icloud/src/ckdocument.rs b/crates/quince-icloud/src/ckdocument.rsindex 705f591..f018313 100644--- a/crates/quince-icloud/src/ckdocument.rs+++ b/crates/quince-icloud/src/ckdocument.rs@@ -722,20 +722,10 @@ fn rebuild_note_with(Some(out)}-/// A text object rewritten to say `new_text`, as a device would edit it: the merge records-/// edited in step and every other field copied through. The same message shape serves a-/// note's body and each cell of a Notes table, so a table's cells are edited by this too.-/// `None` when the object is not one this can rewrite truthfully.-pub(crate) fn rewrite_text_object(- object: &[u8],- old_text: &str,- new_text: &str,-) -> Option<Vec<u8>> {- rebuild_note(object, old_text, new_text)-}--/// [`rewrite_text_object`] for one edit at a known place: `removed` characters from character-/// `at` replaced by `inserted`.+/// A text object rewritten as a device would edit it — the merge records edited in step and+/// every other field copied through — for one edit at a known place: `removed` characters+/// from character `at` replaced by `inserted`. The same message shape serves a note's body+/// and a Notes table's texts (its rows' and columns' ordered sets).pub(crate) fn rewrite_text_object_at(object: &[u8],old_text: &str,@@ -1131,9 +1121,25 @@ pub fn set_runs(original: &[u8], runs: &[Run]) -> Option<Vec<u8>> {/// `old`: each one already in `old`, none used twice, and each on a run of exactly one/// object-replacement character.fn attachments_sound(old: &[Vec<u8>], new: &[Vec<u8>], units: &[u16]) -> Option<()> {+ attachments_sound_with(old, new, units, None)+}++/// [`attachments_sound`], with one attachment `added` allowed that `old` did not have — a+/// fresh id, never one `old` already used — which must then appear exactly once.+fn attachments_sound_with(+ old: &[Vec<u8>],+ new: &[Vec<u8>],+ units: &[u16],+ added: Option<&[u8]>,+) -> Option<()> {let id_of =|run: &[u8]| bytes_field(run, ATTACHMENT_INFO).and_then(|info| bytes_field(&info, 1));- let had: std::collections::HashSet<Vec<u8>> = old.iter().filter_map(|r| id_of(r)).collect();+ let mut had: std::collections::HashSet<Vec<u8>> = old.iter().filter_map(|r| id_of(r)).collect();+ if let Some(added) = added {+ if !had.insert(added.to_vec()) {+ return None;+ }+ }let mut used = std::collections::HashSet::new();let mut at = 0usize;for run in new {@@ -1149,6 +1155,9 @@ fn attachments_sound(old: &[Vec<u8>], new: &[Vec<u8>], units: &[u16]) -> Option<}at += length;}+ if added.is_some_and(|added| !used.contains(added)) {+ return None;+ }Some(())}@@ -1185,6 +1194,189 @@ pub fn attachments_sound_in_base64(original: &str, edited: &str) -> bool {.is_some()}+/// [`attachments_sound_in_base64`] for a write that adds one attachment: `edited` may refer+/// to `added` — an id `original` never used — and must, exactly once, on its own+/// object-replacement character; every other reference is held to the same rule as an edit.+#[must_use]+pub fn attachments_sound_adding_in_base64(original: &str, edited: &str, added: &str) -> bool {+ let (Ok(old), Ok(new)) = (B64.decode(original.trim()), B64.decode(edited.trim())) else {+ return false;+ };+ let Some(text) = inflate(&new)+ .and_then(|plain| field_at(&plain, TEXT_PATH).map(<[u8]>::to_vec))+ .and_then(|t| String::from_utf8(t).ok())+ else {+ return false;+ };+ let units: Vec<u16> = text.encode_utf16().collect();+ attachments_sound_with(+ &debug_attribute_runs(&old),+ &debug_attribute_runs(&new),+ &units,+ Some(added.as_bytes()),+ )+ .is_some()+}++/// A note's attribute runs, whole, in order.+fn runs_in(note: &[u8]) -> Option<Vec<Vec<u8>>> {+ let mut runs = Vec::new();+ let mut reader = Reader::new(note);+ while !reader.done() {+ let key = reader.varint()?;+ let (field, wire) = (key >> 3, key & 7);+ if field == ATTRIBUTE_RUN && wire == WIRE_LEN {+ let n = usize::try_from(reader.varint()?).ok()?;+ runs.push(reader.take(n)?.to_vec());+ } else {+ reader.skip(wire)?;+ }+ }+ Some(runs)+}++/// A note with its attribute runs replaced by `runs`, written where the first one stood and+/// every other field copied through.+fn with_runs(note: &[u8], runs: &[Vec<u8>]) -> Option<Vec<u8>> {+ let mut out = Vec::with_capacity(note.len() + 64);+ let mut reader = Reader::new(note);+ let mut wrote = false;+ while !reader.done() {+ let begin = reader.at;+ let key = reader.varint()?;+ let (field, wire) = (key >> 3, key & 7);+ reader.skip(wire)?;+ if field == ATTRIBUTE_RUN && wire == WIRE_LEN {+ if !wrote {+ for r in runs {+ out.extend_from_slice(&length_delimited(ATTRIBUTE_RUN, r));+ }+ wrote = true;+ }+ } else {+ out.extend_from_slice(note.get(begin..reader.at)?);+ }+ }+ if !wrote {+ for r in runs {+ out.extend_from_slice(&length_delimited(ATTRIBUTE_RUN, r));+ }+ }+ Some(out)+}++/// The run Notes gives an attachment's one character, as a phone writes it (measured on a+/// picture added on his iPhone): `1` length 1, `12` the attachment — `1` its id, `2` its+/// type identifier — `13` when it was placed (Unix seconds), then `2` the paragraph's setting,+/// which every run of a paragraph shares.+fn attachment_run(id: &str, uti: &str, stamp: u64, paragraph: Option<&[u8]>) -> Vec<u8> {+ let mut info = length_delimited(1, id.as_bytes());+ info.extend(length_delimited(2, uti.as_bytes()));+ let mut run = varint_field(1, 1);+ run.extend(length_delimited(ATTACHMENT_INFO, &info));+ run.extend(varint_field(13, stamp));+ if let Some(p) = paragraph {+ run.extend(length_delimited(2, p));+ }+ run+}++/// A note with an attachment placed at UTF-16 offset `at`: one object-replacement character+/// (U+FFFC) inserted there, the merge records edited for that one insertion as a device edits+/// them, and the character given a run of its own naming the attachment.+///+/// Everything else is copied through: the text around it, every other run, the versions. The+/// new run takes the setting of the paragraph it lands in — its style, its checklist item —+/// from that paragraph's own runs, so a picture put in a checklist line stays in that line.+/// `None`, and nothing to write, for an offset past the end or inside a surrogate pair, and for+/// any document [`replace_text`] would refuse.+#[must_use]+pub fn insert_attachment(+ original: &[u8],+ at: u64,+ id: &str,+ uti: &str,+ stamp: u64,+) -> Option<Vec<u8>> {+ let plain = inflate(original)?;+ let current = field_at(&plain, TEXT_PATH)?;+ // The same proof an edit needs: the document can be walked and put back byte for byte.+ if rewrite(&plain, TEXT_PATH, current)? != plain {+ return None;+ }+ let old_text = std::str::from_utf8(current).ok()?;+ let units: Vec<u16> = old_text.encode_utf16().collect();+ let place = usize::try_from(at).ok()?;+ if place > units.len()+ || units+ .get(place)+ .is_some_and(|u| (0xDC00..0xE000).contains(u))+ {+ return None;+ }+ let note = field_at(&plain, &TEXT_PATH[..2])?;+ // Runs that do not describe the text are not built on.+ if runs_in(note)?.iter().map(|r| run_length(r)).sum::<u64>() != units.len() as u64 {+ return None;+ }+ let mut new_units = units;+ new_units.insert(place, 0xFFFC);+ let new_text = String::from_utf16(&new_units).ok()?;+ let rebuilt = rebuild_note_with(note, old_text, &new_text, &[(at, 0, 1)])?;+ let runs = runs_in(&rebuilt)?;++ // Which run speaks for the paragraph: the one over its newline, or — the last paragraph,+ // which has none — over its last character other than the new one.+ let newline = new_units[place + 1..]+ .iter()+ .position(|&u| u == u16::from(b'\n'))+ .map(|i| place + 1 + i);+ let speaker = newline+ .or_else(|| (new_units.len() > place + 1).then(|| new_units.len() - 1))+ .or_else(|| (place > 0 && new_units[place - 1] != u16::from(b'\n')).then(|| place - 1));+ let run_over = |unit: usize| {+ let mut end = 0usize;+ runs.iter().find(|r| {+ end += usize::try_from(run_length(r)).unwrap_or(usize::MAX);+ unit < end+ })+ };+ let paragraph = speaker.and_then(run_over).and_then(|r| bytes_field(r, 2));++ let mut out = Vec::with_capacity(runs.len() + 2);+ let mut start = 0u64;+ for run in &runs {+ let end = start + run_length(run);+ if (start..end).contains(&at) {+ if at > start {+ out.push(set_varint_field(run, 1, at - start)?);+ }+ out.push(attachment_run(id, uti, stamp, paragraph.as_deref()));+ if end > at + 1 {+ out.push(set_varint_field(run, 1, end - at - 1)?);+ }+ } else {+ out.push(run.clone());+ }+ start = end;+ }+ let placed = with_runs(&rebuilt, &out)?;+ ensure_versions(&rewrite(&plain, &TEXT_PATH[..2], &placed)?)+}++/// [`insert_attachment`] over the base64 a CloudKit field carries, gzipped on the way back.+#[must_use]+pub fn insert_attachment_in_base64(+ original: &str,+ at: u64,+ id: &str,+ uti: &str,+ stamp: u64,+) -> Option<String> {+ let raw = B64.decode(original.trim()).ok()?;+ Some(B64.encode(gzip(&insert_attachment(&raw, at, id, uti, stamp)?)))+}+/// The text and its formatting together: the text replaced as [`replace_text`] replaces it,/// then the runs set as [`set_runs`] sets them. Over the base64 a CloudKit field carries.#[must_use]diff --git a/crates/quince-icloud/src/cloudkit.rs b/crates/quince-icloud/src/cloudkit.rsindex 1cd839b..9a9954c 100644--- a/crates/quince-icloud/src/cloudkit.rs+++ b/crates/quince-icloud/src/cloudkit.rs@@ -55,6 +55,11 @@ fn trouble_with(zone_result: &Value) -> Option<ZoneTrouble> {let reason = zone_result.get("reason").and_then(Value::as_str);match code {Some("ZONE_NOT_FOUND") => Some(ZoneTrouble::Missing),+ // An expired change token, with or without a reason. Without this arm a bare+ // `CHANGE_TOKEN_EXPIRED` matched nothing below and read as an empty, finished page:+ // "nothing changed", on a token that would never be read again — every change made+ // elsewhere from then on never arrived.+ Some("CHANGE_TOKEN_EXPIRED") => Some(ZoneTrouble::StaleCursor),// Apple says BAD_REQUEST for a cursor it will not read, with the reason naming the// continuation: "Unknown sync continuation type", "Invalid continuation format".Some("BAD_REQUEST")@@ -62,8 +67,10 @@ fn trouble_with(zone_result: &Value) -> Option<ZoneTrouble> {{Some(ZoneTrouble::StaleCursor)}- // A reason with no code at all still means the zone was refused.- Some(_) | None if reason.is_some() => Some(ZoneTrouble::Other("refused")),+ // A reason with no code at all still means the zone was refused; so does a code with+ // no reason — any code at all is Apple saying something went wrong with the zone.+ Some(_) => Some(ZoneTrouble::Other("refused")),+ None if reason.is_some() => Some(ZoneTrouble::Other("refused")),_ => None,}}@@ -251,12 +258,18 @@ impl<'a> ZoneClient<'a> {}async fn walk(&self, zone: &str, since: Option<&str>) -> Result<ZoneWalk> {+ let since = since.map(str::trim).filter(|t| !t.is_empty());let mut records = Vec::new();let mut token = since.map(ToString::to_string);let mut complete = false;- for _ in 0..MAX_PAGES {+ for page_no in 0..MAX_PAGES {let page = self.changes(zone, token.as_deref()).await?;+ // A cursor answered with no position at all was not taken: an expired one can+ // come back as an empty zone result, which read as "nothing changed" for good.+ if page_no == 0 && token.is_some() && page.sync_token.is_none() {+ return Err(Error::StaleCursor);+ }records.extend(page.records);token = page.sync_token;if !page.more_coming {@@ -270,6 +283,7 @@ impl<'a> ZoneClient<'a> {}Ok(ZoneWalk {records,+ from_start: since.is_none(),token,complete,})@@ -286,6 +300,22 @@ pub struct ZoneWalk {pub records: Vec<Value>,pub token: Option<String>,pub complete: bool,+ /// Read from the zone's beginning — no cursor asked for, or the cursor refused and the+ /// walk started over. A walk from a cursor carries only changes, where absence means+ /// unchanged; one started over after a refused cursor carries everything and is as+ /// authoritative as a first pass (`ZoneWalk::whole`).+ pub from_start: bool,+}++impl ZoneWalk {+ /// Whether this walk read the zone from its beginning — asked for no cursor, or its cursor+ /// refused and the walk started over — and to its end. Only such a walk is the whole truth+ /// that rows missing from it may be pruned by; any other carries changes, or part of the+ /// zone, where absence means nothing.+ #[must_use]+ pub fn whole(&self) -> bool {+ self.from_start && self.complete+ }}/// Field helpers. CloudKit wraps every value as `{"type": …, "value": …}`.@@ -906,19 +936,40 @@ impl ZoneClient<'_> {record_name: &str,record_type: &str,change_tag: Option<&str>,- mut changes: Value,+ changes: Value,) -> Result<Value> {- let current = self.lookup_record(zone, record_name).await?;- stamp_tokens(&mut changes, current.as_ref());- let tag = change_tag.map(ToString::to_string).or_else(|| {- current+ // The token map is one field written whole, worked out from the record as read. The+ // plain retry resent it after a conflict: every counter a phone had raised in between+ // went back to what it was before, and the phone's next merge could prefer an older+ // value of a field this write never touched. So each try is stamped from a fresh read,+ // and written only over that version.+ let mut tag = change_tag.map(ToString::to_string);+ for _ in 0..5 {+ let current = self.lookup_record(zone, record_name).await?;+ let mut stamped = changes.clone();+ stamp_tokens(&mut stamped, current.as_ref());+ let Some(fresh) = current.as_ref().and_then(|c| c.get("recordChangeTag")).and_then(Value::as_str)- .map(ToString::to_string)- });- self.update_record(zone, record_name, record_type, tag.as_deref(), changes)- .await+ else {+ // Nothing there to stamp against: Apple's own answer to the write says why.+ return self+ .update_record(zone, record_name, record_type, tag.as_deref(), stamped)+ .await;+ };+ // The caller's tag first, as before: a change made elsewhere since it was read is+ // still laid under this one, field by field, on the fresh read below.+ let first = tag.take().unwrap_or_else(|| fresh.to_string());+ match self+ .update_record_exact(zone, record_name, record_type, &first, stamped)+ .await+ {+ Err(Error::Conflict) => continue,+ other => return other,+ }+ }+ Err(Error::Conflict)}/// [`Self::update_record_signed`] with no retry: a conflict comes back as@@ -1020,18 +1071,29 @@ impl ZoneClient<'_> {record_type: &str,fields: Value,) -> Result<Value> {- self.modify(- zone,- json!({- "operationType": "create",- "record": {- "recordName": record_name,- "recordType": record_type,- "fields": fields,- },- }),- )- .await+ let made = self+ .modify(+ zone,+ json!({+ "operationType": "create",+ "record": {+ "recordName": record_name,+ "recordType": record_type,+ "fields": fields,+ },+ }),+ )+ .await;+ match made {+ // The connection dropped with the request out: Apple may have made it and the+ // answer been lost. Said to have failed, it was made again under a new name — a+ // second reminder, a second note. The name is ours, so Apple is asked.+ Err(Error::Network(e)) => match self.lookup_record(zone, record_name).await {+ Ok(Some(record)) => Ok(json!({ "records": [record] })),+ _ => Err(Error::Network(e)),+ },+ other => other,+ }}/// Create a record CloudKit names itself, as icloud.com creates a Photos album: no@@ -1497,6 +1559,138 @@ mod conflict_tests {);}+ /// A signed write that lost to a phone's is stamped again from the phone's version: the+ /// retry resent the token map worked out from the first read, putting back every counter+ /// the phone had raised in between — here the phone's title edit, which a field this+ /// write never touched then lost to an older title on the next merge.+ #[tokio::test]+ async fn a_signed_retry_keeps_the_tokens_another_device_raised() {+ let server = MockServer::start().await;+ let map = |title: u64| {+ json!({ "map": { "titleDocument": { "counter": title, "modificationTime": 1.0, "replicaID": "phone" } } })+ .to_string()+ };+ // First read: the title's token at 1. Second read: the phone has raised it to 7.+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .respond_with(+ ResponseTemplate::new(200).set_body_json(json!({ "records": [{+ "recordName": "Reminder/1", "recordChangeTag": "t1",+ "fields": { "ResolutionTokenMap": { "type": "STRING", "value": map(1) } } }] })),+ )+ .up_to_n_times(1)+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .respond_with(+ ResponseTemplate::new(200).set_body_json(json!({ "records": [{+ "recordName": "Reminder/1", "recordChangeTag": "t2",+ "fields": { "ResolutionTokenMap": { "type": "STRING", "value": map(7) } } }] })),+ )+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .and(wiremock::matchers::body_string_contains("\"t1\""))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "records": [{ "reason": "oplock", "serverErrorCode": "CONFLICT" }] })))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "records": [{ "recordName": "Reminder/1", "recordChangeTag": "t3" }] })))+ .mount(&server)+ .await;++ let http = reqwest::Client::new();+ let client = ZoneClient::new(&http, &server.uri(), "com.apple.reminders", vec![]);+ client+ .update_record_signed(+ "Reminders",+ "Reminder/1",+ "Reminder",+ Some("t1"),+ json!({ "Flagged": { "type": "NUMBER_INT64", "value": 1 } }),+ )+ .await+ .unwrap();+ let requests = server.received_requests().await.unwrap();+ let last = requests+ .iter()+ .rev()+ .find(|r| r.url.path().ends_with("/modify"))+ .unwrap();+ let body: Value = serde_json::from_slice(&last.body).unwrap();+ let record = &body["operations"][0]["record"];+ assert_eq!(record["recordChangeTag"], "t2");+ let tokens: Value = serde_json::from_str(+ record["fields"]["ResolutionTokenMap"]["value"]+ .as_str()+ .unwrap(),+ )+ .unwrap();+ assert_eq!(+ tokens["map"]["titleDocument"]["counter"], 7,+ "the phone's raised token is kept, not put back to 1"+ );+ assert_eq!(tokens["map"]["flagged"]["counter"], 1);+ }++ /// A create whose answer was lost on the way back is found at Apple under the name it was+ /// sent with and reported made, not failed — failed, it was made a second time.+ #[tokio::test]+ async fn a_create_whose_answer_was_lost_is_found_not_made_twice() {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .respond_with(+ ResponseTemplate::new(200)+ .set_delay(std::time::Duration::from_secs(2))+ .set_body_json(+ json!({ "records": [{ "recordName": "N1", "recordChangeTag": "t" }] }),+ ),+ )+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "records": [{ "recordName": "N1", "recordChangeTag": "t" }] })))+ .mount(&server)+ .await;+ let http = reqwest::Client::builder()+ .timeout(std::time::Duration::from_millis(300))+ .build()+ .unwrap();+ let client = ZoneClient::new(&http, &server.uri(), "com.apple.notes", vec![]);+ let made = client+ .create_record("Notes", "N1", "Note", json!({}))+ .await+ .expect("made at Apple, so made");+ assert_eq!(made["records"][0]["recordName"], "N1");++ // Not there: the failure stands, for the caller to keep and try again.+ let empty = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .respond_with(ResponseTemplate::new(200).set_delay(std::time::Duration::from_secs(2)))+ .mount(&empty)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "records": [{ "recordName": "N1", "serverErrorCode": "NOT_FOUND" }] })))+ .mount(&empty)+ .await;+ let client = ZoneClient::new(&http, &empty.uri(), "com.apple.notes", vec![]);+ assert!(matches!(+ client.create_record("Notes", "N1", "Note", json!({})).await,+ Err(Error::Network(_))+ ));+ }+/// CloudKit rejects an update with no change tag as a malformed request, not as a/// conflict — so there is nothing to recover from afterwards. The local copy genuinely/// may not have one: a record created a moment ago has a name before it has a tag, and@@ -1686,6 +1880,94 @@ mod trouble_tests {assert_eq!(walk.records.len(), 1);assert_eq!(walk.token.as_deref(), Some("fresh"));assert!(walk.complete);+ assert!(walk.whole(), "started over, the walk is the whole zone");+ }++ /// An expired change token — with Apple's reason, or as the bare code alone — is a cursor+ /// to start over from, never "nothing changed". The bare code used to match nothing and+ /// read as an empty, finished page, so the dead token was kept and nothing ever arrived.+ #[tokio::test]+ async fn an_expired_change_token_starts_the_walk_over() {+ for expired in [+ json!({ "serverErrorCode": "CHANGE_TOKEN_EXPIRED" }),+ json!({ "serverErrorCode": "CHANGE_TOKEN_EXPIRED", "reason": "change token expired" }),+ ] {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .and(wiremock::matchers::body_string_contains("old-token"))+ .respond_with(zone_reply(expired.clone()))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .respond_with(zone_reply(json!({+ "records": [record("Note/1", "Note")],+ "syncToken": "fresh",+ "moreComing": false+ })))+ .mount(&server)+ .await;+ let http = reqwest::Client::new();+ let uri = server.uri();+ let client = client(&http, &uri, "com.apple.notes");+ let walk = client+ .all_records("Notes", Some("old-token"))+ .await+ .unwrap_or_else(|e| panic!("{expired}: an expired token is started over: {e}"));+ assert_eq!(walk.records.len(), 1, "{expired}");+ assert_eq!(walk.token.as_deref(), Some("fresh"), "{expired}");+ assert!(walk.whole(), "{expired}: a full read, so it may prune");+ }+ }++ /// A cursor answered with no position at all was not taken, whatever the zone result+ /// said: it is started over, not stored as "nothing changed" with no token.+ #[tokio::test]+ async fn a_cursor_answered_with_no_position_starts_the_walk_over() {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .and(wiremock::matchers::body_string_contains("old-token"))+ .respond_with(zone_reply(json!({ "records": [], "moreComing": false })))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .respond_with(zone_reply(json!({+ "records": [record("Note/1", "Note")],+ "syncToken": "fresh",+ "moreComing": false+ })))+ .mount(&server)+ .await;+ let http = reqwest::Client::new();+ let uri = server.uri();+ let client = client(&http, &uri, "com.apple.notes");+ let walk = client+ .all_records("Notes", Some("old-token"))+ .await+ .unwrap();+ assert_eq!(walk.records.len(), 1);+ assert!(walk.whole());+ }++ /// A walk from a cursor Apple took carries only changes: never whole, never pruned by.+ #[tokio::test]+ async fn a_walk_from_a_good_cursor_is_not_whole() {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .respond_with(zone_reply(json!({+ "records": [], "syncToken": "next", "moreComing": false+ })))+ .mount(&server)+ .await;+ let http = reqwest::Client::new();+ let uri = server.uri();+ let client = client(&http, &uri, "com.apple.notes");+ let walk = client.all_records("Notes", Some("good")).await.unwrap();+ assert!(walk.complete && !walk.whole());}/// Trouble that is not a missing zone or a bad cursor is still worth telling somebodydiff --git a/crates/quince-icloud/src/contacts.rs b/crates/quince-icloud/src/contacts.rsindex 2fd2073..bb25e42 100644--- a/crates/quince-icloud/src/contacts.rs+++ b/crates/quince-icloud/src/contacts.rs@@ -4,9 +4,13 @@//! CloudKit, so `/co/startup` is the whole of it.use crate::{Error, Result};-use quince_core::contacts::{Contact, ContactMethod};+use quince_core::contacts::{Contact, ContactMethod, PostalAddress, ADDRESS_FIELDS};use serde_json::Value;+/// Editing a card's postal addresses part by part.+#[path = "contacts_address.rs"]+pub mod address;+fn string(v: &Value, key: &str) -> Option<String> {v.get(key).and_then(Value::as_str)@@ -39,33 +43,55 @@ fn methods_from(v: &Value, key: &str, kind: &str) -> Vec<ContactMethod> {/// Apple's postal address: a structured object, not a string.///-/// Flattened into the lines a person would write on an envelope, in the order they would-/// write them. Reading it as a string — which is what every other method array holds —-/// simply skipped it, so the one contact with an address showed none.+/// Flattened into the lines a person would write on an envelope, in the order the address's+/// country writes them. Reading it as a string — which is what every other method array+/// holds — simply skipped it, so the one contact with an address showed none.fn address_from(entry: &Value) -> Option<String> {+ postal_from(entry).map(|a| a.formatted())+}++/// One of Apple's `streetAddresses` entries, part by part. Measured on a real account:+/// `{ "label": "HOME", "field": { "street", "city", "state", "postalCode", "country" } }`,+/// the street holding its own line breaks; `countryCode`, `subLocality` and+/// `subAdministrativeArea` are read when a card has them. A field that is a plain string+/// reads as the street. `None` when nothing is in it.+fn postal_from(entry: &Value) -> Option<PostalAddress> {let field = entry.get("field")?;+ let mut address = PostalAddress {+ label: string(entry, "label"),+ ..PostalAddress::default()+ };if let Some(text) = field.as_str() {- return Some(text.trim().to_string()).filter(|s| !s.is_empty());- }-- let part = |key: &str| string(field, key);- let mut lines: Vec<String> = Vec::new();- if let Some(street) = part("street") {- lines.extend(street.lines().map(str::trim).map(ToString::to_string));- }- // City, state and postcode share a line, as they do on an envelope.- let locality: Vec<String> = ["city", "state", "postalCode"]- .iter()- .filter_map(|k| part(k))- .collect();- if !locality.is_empty() {- lines.push(locality.join(" "));- }- if let Some(country) = part("country") {- lines.push(country);+ address.street = Some(text.trim().to_string()).filter(|s| !s.is_empty());+ } else {+ for key in ADDRESS_FIELDS {+ let value = field.get(key).and_then(Value::as_str);+ address.set_field(key, value);+ }}+ (!address.is_empty()).then_some(address)+}- (!lines.is_empty()).then(|| lines.join("\n"))+/// Every card's addresses, part by part, as the library keeps them beside the card.+#[must_use]+pub fn parse_addresses(body: &Value) -> Vec<(String, Vec<PostalAddress>)> {+ body.get("contacts")+ .and_then(Value::as_array)+ .map(|cards| {+ cards+ .iter()+ .filter_map(|card| {+ let guid = string(card, "contactId")?;+ let addresses = card+ .get("streetAddresses")+ .and_then(Value::as_array)+ .map(|list| list.iter().filter_map(postal_from).collect())+ .unwrap_or_default();+ Some((guid, addresses))+ })+ .collect()+ })+ .unwrap_or_default()}fn contact_from(v: &Value) -> Option<Contact> {@@ -250,6 +276,7 @@ pub async fn fetch_book_with_tokens(contacts: parse(&body),lists: parse_lists(&body),me: me_card(&body),+ addresses: parse_addresses(&body),},Tokens {sync: token("syncToken")?,@@ -428,7 +455,28 @@ fn card_merged(contact: &Contact, existing: Option<&Value>, base: Option<&Contacif existing.is_some() && kind_unchanged(kind) {continue;}- object.insert(key.into(), of_kind(kind));+ // Edited from a base over Apple's current card: the edit laid over Apple's list, not+ // the form's list written whole — a number added on the phone while the form was open+ // here stays, as a name changed there does.+ let merged = match (base, existing) {+ (Some(base), Some(card)) => {+ let of = |c: &Contact| -> Vec<(String, Option<String>)> {+ c.methods+ .iter()+ .filter(|m| m.kind == kind && !m.value.trim().is_empty())+ .map(|m| (m.value.trim().to_string(), m.label.clone()))+ .collect()+ };+ let theirs = card+ .get(key)+ .and_then(Value::as_array)+ .cloned()+ .unwrap_or_default();+ Some(merge_methods(&theirs, &of(base), &of(contact)))+ }+ _ => None,+ };+ object.insert(key.into(), merged.unwrap_or_else(|| of_kind(kind)));}// Laid over Apple's current card, the write is against that card's version; otherwise@@ -446,6 +494,49 @@ fn card_merged(contact: &Contact, existing: Option<&Value>, base: Option<&Contaccard}+/// One kind of a card's numbers or addresses, as Apple holds it now (`theirs`), with the change+/// the form made (`base` to `mine`) laid over it: what the form took out goes, what it put in+/// is added — an edited entry in the old one's place — and everything else Apple has stays as+/// Apple has it, entries made on another device included.+fn merge_methods(+ theirs: &[Value],+ base: &[(String, Option<String>)],+ mine: &[(String, Option<String>)],+) -> Value {+ let matches = |entry: &Value, (value, label): &(String, Option<String>)| {+ entry.get("field").and_then(Value::as_str).map(str::trim) == Some(value.as_str())+ && entry.get("label").and_then(Value::as_str) == label.as_deref()+ };+ let entry = |(value, label): &(String, Option<String>)| {+ let mut e = serde_json::Map::new();+ e.insert("field".into(), Value::String(value.clone()));+ if let Some(label) = label {+ e.insert("label".into(), Value::String(label.clone()));+ }+ Value::Object(e)+ };+ let removed: Vec<&(String, Option<String>)> =+ base.iter().filter(|b| !mine.contains(b)).collect();+ let mut added = mine+ .iter()+ .filter(|m| !base.contains(m) && !theirs.iter().any(|t| matches(t, m)))+ .collect::<Vec<_>>()+ .into_iter();+ let mut out = Vec::with_capacity(theirs.len() + mine.len());+ for t in theirs {+ if removed.iter().any(|r| matches(t, r)) {+ // Edited rather than taken out: the new entry where the old one was.+ if let Some(a) = added.next() {+ out.push(entry(a));+ }+ } else {+ out.push(t.clone());+ }+ }+ out.extend(added.map(entry));+ Value::Array(out)+}+async fn write(http: &reqwest::Client,root: &str,@@ -517,9 +608,58 @@ pub async fn create());}// Apple's own client mints the id rather than asking the service for one.- let guid = uuid::Uuid::new_v4().to_string().to_uppercase();+ let guid = new_contact_id();+ // A fresh id: no card can hold it yet.+ write_new(http, root, params, tokens, &guid, contact).await?;+ Ok(guid)+}++/// An id for a card made here, minted before it is sent — Apple's own client does the same —+/// so the card can be shown at once, queued, and sent again without making a second.+pub fn new_contact_id() -> String {+ uuid::Uuid::new_v4().to_string().to_uppercase()+}++/// Whether a card is empty of everything Apple would keep.+pub fn blank_card(contact: &Contact) -> bool {+ let blank = |v: &Option<String>| v.as_deref().is_none_or(|s| s.trim().is_empty());+ blank(&contact.first_name)+ && blank(&contact.last_name)+ && blank(&contact.company)+ && contact.methods.iter().all(|m| m.value.trim().is_empty())+}++/// [`create`] under an id chosen beforehand. Sent again, it makes no second card: a card+/// Apple already holds under that id is left as it is.+pub async fn create_named(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ tokens: &Tokens,+ guid: &str,+ contact: &Contact,+) -> Result<()> {+ if blank_card(contact) {+ return Err(Error::Refused(+ "Add a name, a phone number or an email address first.".into(),+ ));+ }+ if card(http, root, params.clone(), guid).await?.is_some() {+ return Ok(());+ }+ write_new(http, root, params, tokens, guid, contact).await+}++async fn write_new(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ tokens: &Tokens,+ guid: &str,+ contact: &Contact,+) -> Result<()> {let mut fresh = contact.clone();- fresh.guid.clone_from(&guid);+ fresh.guid = guid.to_string();fresh.etag = None;write(@@ -531,7 +671,7 @@ pub async fn create(card_from(&fresh, None),).await?;- Ok(guid)+ Ok(())}/// Save changes to a contact.@@ -649,6 +789,8 @@ pub struct AddressBook {pub lists: Vec<ContactList>,/// The card that is this person's own, if they have said.pub me: Option<String>,+ /// Each card's postal addresses, part by part.+ pub addresses: Vec<(String, Vec<PostalAddress>)>,}/// Where the my-card id is kept between passes.@@ -1286,6 +1428,7 @@ pub async fn fetch(contacts: parse(&body),lists: parse_lists(&body),me: me_card(&body),+ addresses: parse_addresses(&body),})}@@ -1374,12 +1517,25 @@ async fn startup(all.extend(more);}}+ // Stopped at the page limit with cards still unread: stored, the book would be short, and+ // every card it missed would read as deleted.+ if have < wanted {+ return Err(Error::Protocol(+ "The address book is larger than Pomander reads in one go, so it was not stored short."+ .into(),+ ));+ }Ok(body)}/// Store a fetched address book. Touches no network.pub fn apply(library: &mut quince_core::Library, book: AddressBook) -> Result<usize> {+ library.atomically(|library| apply_whole(library, book))+}++fn apply_whole(library: &mut quince_core::Library, book: AddressBook) -> Result<usize> {library.put_contacts(&book.contacts)?;+ library.put_addresses(&book.addresses, true)?;library.set_state(LISTS_KEY,&serde_json::to_string(&book.lists).unwrap_or_else(|_| "[]".into()),@@ -1447,6 +1603,57 @@ mod list_tests {assert_eq!(card["streetAddresses"][0]["field"]["city"], "Pune");assert_eq!(card["etag"], "new", "against the version Apple holds now");}+ /// The form changed one number while the phone added another: the change goes over+ /// Apple's list, and the phone's number stays — written whole, the form's list dropped it.+ #[test]+ fn a_number_added_on_the_phone_survives_an_edit_of_another() {+ use quince_core::contacts::ContactMethod;+ let phone = |v: &str, l: Option<&str>| ContactMethod {+ kind: "phone".into(),+ label: l.map(Into::into),+ value: v.into(),+ };+ let mut base = super::parse(+ &serde_json::json!({ "contacts": [{ "contactId": "C1", "firstName": "A" }] }),+ )+ .remove(0);+ base.methods = vec![phone("+1 100", Some("home")), phone("+1 200", Some("work"))];+ let mut mine = base.clone();+ mine.methods = vec![phone("+1 101", Some("home")), phone("+1 200", Some("work"))];+ let apple = serde_json::json!({+ "contactId": "C1", "etag": "e2", "firstName": "A",+ "phones": [+ { "field": "+1 100", "label": "home" },+ { "field": "+1 200", "label": "work" },+ { "field": "+1 300", "label": "mobile" }+ ],+ });+ let card = super::card_merged(&mine, Some(&apple), Some(&base));+ let fields: Vec<&str> = card["phones"]+ .as_array()+ .unwrap()+ .iter()+ .map(|p| p["field"].as_str().unwrap())+ .collect();+ assert_eq!(+ fields,+ ["+1 101", "+1 200", "+1 300"],+ "the edit in place, the phone's kept"+ );++ // Taken out here: gone, the phone's still kept.+ let mut fewer = base.clone();+ fewer.methods = vec![phone("+1 200", Some("work"))];+ let card = super::card_merged(&fewer, Some(&apple), Some(&base));+ let fields: Vec<&str> = card["phones"]+ .as_array()+ .unwrap()+ .iter()+ .map(|p| p["field"].as_str().unwrap())+ .collect();+ assert_eq!(fields, ["+1 200", "+1 300"]);+ }+#[test]fn a_refused_group_write_is_an_error_not_a_save() {let busy = serde_json::json!({ "errors": [{ "groupId": "G", "etag": "e", "errorCode": 409, "errorMessage": "Conflict" }] });@@ -1622,6 +1829,36 @@ mod tests {.is_err());}+ /// A book still unread when the page limit is reached is refused too: returned as it+ /// stood, every card past the limit read as deleted.+ #[tokio::test]+ async fn a_book_past_the_page_limit_is_refused_not_stored_short() {+ use wiremock::matchers::{method, path};+ use wiremock::{Mock, MockServer, ResponseTemplate};+ let server = MockServer::start().await;+ let order: Vec<String> = (0..300).map(|i| format!("c{i}")).collect();+ Mock::given(method("GET"))+ .and(path("/co/startup"))+ .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({+ "syncToken": "S", "prefToken": "P", "contactsOrder": order,+ "contacts": [{ "contactId": "c0" }], "groups": []+ })))+ .mount(&server)+ .await;+ // One card a page: 200 pages leave a hundred unread.+ Mock::given(method("GET"))+ .and(path("/co/contacts/card/"))+ .respond_with(+ ResponseTemplate::new(200)+ .set_body_json(serde_json::json!({ "contacts": [{ "contactId": "x" }] })),+ )+ .mount(&server)+ .await;+ assert!(fetch(&reqwest::Client::new(), &server.uri(), vec![])+ .await+ .is_err());+ }+#[test]fn a_changeset_says_whether_anything_moved() {let mut t = Tokens {@@ -1885,6 +2122,48 @@ mod write_tests {assert!(server.received_requests().await.unwrap().is_empty());}+ /// A create sent again under its id — the answer lost, a queue replayed after a crash —+ /// finds the card at Apple and writes nothing; one not there yet is written once.+ #[tokio::test]+ async fn a_named_create_is_made_once() {+ let server = MockServer::start().await;+ Mock::given(path_regex(r".*/co/startup$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "contacts": [{ "contactId": "G1", "firstName": "Ada", "etag": "e" }],+ "syncToken": "s", "prefToken": "p"+ })))+ .mount(&server)+ .await;+ Mock::given(path_regex(r".*/co/contacts/card$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "contacts": [] })))+ .mount(&server)+ .await;+ let http = reqwest::Client::new();+ create_named(&http, &server.uri(), vec![], &tokens(), "G1", &person())+ .await+ .unwrap();+ let writes = |rs: &[Request]| {+ rs.iter()+ .filter(|r| r.url.path().ends_with("/card"))+ .count()+ };+ assert_eq!(+ writes(&server.received_requests().await.unwrap()),+ 0,+ "already there"+ );+ create_named(&http, &server.uri(), vec![], &tokens(), "G2", &person())+ .await+ .unwrap();+ let requests = server.received_requests().await.unwrap();+ assert_eq!(writes(&requests), 1, "made once");+ let card: Value = serde_json::from_slice(&requests.last().unwrap().body).unwrap();+ assert_eq!(+ card["contacts"][0]["contactId"], "G2",+ "under the id chosen beforehand"+ );+ }+/// A create gets a fresh id and no etag: an etag would claim to be replacing something.#[tokio::test]async fn a_create_mints_its_own_id() {@@ -2047,7 +2326,8 @@ mod shape_tests {.expect("the address is read");assert_eq!(address.value,- "12 Example Street\nSpringfield\nSpringfield ST 123456\nIndia"+ // India's order: town and PIN together, the state on its own line.+ "12 Example Street\nSpringfield\nSpringfield 123456\nST\nIndia");assert_eq!(address.label.as_deref(), Some("HOME"));}@@ -2220,3 +2500,59 @@ mod odd_card_tests {}}}++#[cfg(test)]+mod atomic_apply_tests {+ use super::*;+ use quince_core::contacts::Contact;++ fn person(guid: &str) -> Contact {+ Contact {+ guid: guid.into(),+ first_name: Some(guid.into()),+ middle_name: None,+ last_name: None,+ company: None,+ is_company: false,+ birthday: None,+ notes: None,+ photo_url: None,+ photo_signature: None,+ photo_crop: None,+ etag: None,+ methods: vec![],+ }+ }++ /// The book is stored (pruning whoever is not in it) and then its lists: a failure storing+ /// the lists — a crash part way — must not leave the people pruned and the rest unwritten.+ #[test]+ fn a_book_that_fails_part_way_stores_none_of_itself() {+ let mut library = quince_core::Library::in_memory().unwrap();+ library.put_contacts(&[person("A")]).unwrap();+ library+ .conn()+ .execute_batch(+ "CREATE TEMP TRIGGER crash BEFORE INSERT ON main.app_state+ BEGIN SELECT RAISE(ABORT, 'crash mid-apply'); END;",+ )+ .unwrap();+ let failed = apply(+ &mut library,+ AddressBook {+ contacts: vec![person("B")],+ lists: vec![],+ me: None,+ addresses: vec![],+ },+ );+ assert!(failed.is_err());+ let guids: Vec<String> = library+ .contacts(None)+ .unwrap()+ .into_iter()+ .map(|c| c.guid)+ .collect();+ assert_eq!(guids, vec!["A".to_string()], "the old book, whole");+ }+}diff --git a/crates/quince-icloud/src/contacts_address.rs b/crates/quince-icloud/src/contacts_address.rsnew file mode 100644index 0000000..a8213fd--- /dev/null+++ b/crates/quince-icloud/src/contacts_address.rs@@ -0,0 +1,605 @@+//! A card's postal addresses, edited part by part.+//!+//! An edit names an address by where it sat in the list the form opened, and says what to+//! do to it: set one part, set its label, take it out, or add a new one. The edit is laid+//! over the card's addresses as Apple holds them at the moment of writing — a part changed+//! on the phone since stays changed, as a number added there does in `merge_methods` — and+//! sent with the card's current etag and the book's sync token, so Apple refuses it rather+//! than overwrite a change it has not seen.++use super::{postal_from, startup, write, Tokens};+use crate::{Error, Result};+use quince_core::contacts::{country_code_for, PostalAddress, ADDRESS_FIELDS};+use serde::{Deserialize, Serialize};+use serde_json::{Map, Value};++/// One change to a card's addresses. `index` is a position in the list as it stands after+/// the edits before it in the same batch, starting from the list the form opened.+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+#[serde(tag = "op", rename_all = "camelCase")]+pub enum AddressEdit {+ /// One part, by Apple's name for it (`street`, `city`, `postalCode`, ...). Blank clears.+ #[serde(rename_all = "camelCase")]+ SetField {+ index: usize,+ field: String,+ value: Option<String>,+ },+ /// `HOME`, `WORK` or anything typed. Blank clears.+ #[serde(rename_all = "camelCase")]+ SetLabel {+ index: usize,+ label: Option<String>,+ },+ Add {+ address: PostalAddress,+ },+ Remove {+ index: usize,+ },+}++/// What an edit did to one address of the list the form opened.+// A handful at a time, built and dropped within one write: boxing buys nothing.+#[allow(clippy::large_enum_variant)]+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum AddressChange {+ Edited {+ base: PostalAddress,+ mine: PostalAddress,+ },+ Removed(PostalAddress),+ Added(PostalAddress),+}++/// The list after `edits`, and what changed from `base`. Refused when an edit names an+/// address or a part that is not there, before anything is sent.+///+/// # Errors+/// [`Error::Refused`] for an index past the end of the list or a part Apple does not have.+pub fn apply_edits(+ base: &[PostalAddress],+ edits: &[AddressEdit],+) -> Result<(Vec<PostalAddress>, Vec<AddressChange>)> {+ // Each address with where it came from in `base`, so an edit stays an edit however the+ // batch moves things around.+ let mut list: Vec<(Option<usize>, PostalAddress)> = base+ .iter()+ .cloned()+ .enumerate()+ .map(|(i, a)| (Some(i), a))+ .collect();+ let missing = || Error::Refused("That address is no longer on this card.".into());+ for edit in edits {+ match edit {+ AddressEdit::SetField {+ index,+ field,+ value,+ } => {+ let (_, address) = list.get_mut(*index).ok_or_else(missing)?;+ if !address.set_field(field, value.as_deref()) {+ return Err(Error::Refused(format!("An address has no part {field:?}.")));+ }+ // A country changed by name takes its code along, so Apple lays it out as the+ // new country rather than the old one; one this app has no code for drops a+ // code that would now be wrong.+ if field == "country"+ && !edits.iter().any(|e| {+ matches!(e, AddressEdit::SetField { index: i, field: f, .. }+ if i == index && f == "countryCode")+ })+ {+ let code = address.country.as_deref().and_then(country_code_for);+ address.country_code = code.map(ToString::to_string);+ }+ }+ AddressEdit::SetLabel { index, label } => {+ let (_, address) = list.get_mut(*index).ok_or_else(missing)?;+ address.label = label+ .as_deref()+ .map(str::trim)+ .filter(|l| !l.is_empty())+ .map(ToString::to_string);+ }+ AddressEdit::Add { address } => {+ // Through `set_field`, so what is stored is trimmed as a read would store it.+ let mut clean = PostalAddress::default();+ for key in ADDRESS_FIELDS {+ clean.set_field(key, address.field(key).and_then(Option::as_deref));+ }+ clean.label = address.label.clone();+ if clean.country_code.is_none() {+ clean.country_code = clean+ .country+ .as_deref()+ .and_then(country_code_for)+ .map(ToString::to_string);+ }+ list.push((None, clean));+ }+ AddressEdit::Remove { index } => {+ if *index >= list.len() {+ return Err(missing());+ }+ list.remove(*index);+ }+ }+ }++ let mut changes = Vec::new();+ for (i, b) in base.iter().enumerate() {+ match list.iter().find(|(from, _)| *from == Some(i)) {+ None => changes.push(AddressChange::Removed(b.clone())),+ // Emptied of every part is taken out: Apple keeps no blank address.+ Some((_, m)) if m.is_empty() => changes.push(AddressChange::Removed(b.clone())),+ Some((_, m)) if m != b => changes.push(AddressChange::Edited {+ base: b.clone(),+ mine: m.clone(),+ }),+ Some(_) => {}+ }+ }+ for (from, m) in &list {+ if from.is_none() && !m.is_empty() {+ changes.push(AddressChange::Added(m.clone()));+ }+ }+ let after = list+ .into_iter()+ .map(|(_, a)| a)+ .filter(|a| !a.is_empty())+ .collect();+ Ok((after, changes))+}++/// Apple's entry for an address: its label, and every part that holds something.+fn entry(address: &PostalAddress) -> Value {+ let mut field = Map::new();+ for key in ADDRESS_FIELDS {+ if let Some(Some(v)) = address.field(key) {+ field.insert(key.into(), Value::String(v.clone()));+ }+ }+ let mut e = Map::new();+ if let Some(label) = &address.label {+ e.insert("label".into(), Value::String(label.clone()));+ }+ e.insert("field".into(), Value::Object(field));+ Value::Object(e)+}++/// How many parts two addresses share, and how many `a` has.+fn shared(a: &PostalAddress, b: &PostalAddress) -> (usize, usize) {+ let mut same = 0;+ let mut has = 0;+ for key in ADDRESS_FIELDS {+ if let Some(Some(v)) = a.field(key) {+ has += 1;+ if b.field(key).and_then(Option::as_ref) == Some(v) {+ same += 1;+ }+ }+ }+ (same, has)+}++/// Which of Apple's entries is the address the form opened as `base`: the one equal to it,+/// or else — changed on another device since — the one sharing the most of its parts, as+/// long as that is at least half of them. Entries already claimed are skipped.+fn find(theirs: &[Option<PostalAddress>], claimed: &[bool], base: &PostalAddress) -> Option<usize> {+ let open = |i: &usize| !claimed[*i];+ if let Some(i) = (0..theirs.len())+ .filter(open)+ .find(|&i| theirs[i].as_ref() == Some(base))+ {+ return Some(i);+ }+ (0..theirs.len())+ .filter(open)+ .filter_map(|i| {+ let t = theirs[i].as_ref()?;+ let (same, has) = shared(base, t);+ let label = u8::from(t.label == base.label);+ (same > 0 && same * 2 >= has).then_some((same, label, i))+ })+ // Most parts in common, then the same label, then the earliest.+ .max_by(|a, b| (a.0, a.1).cmp(&(b.0, b.1)).then(b.2.cmp(&a.2)))+ .map(|(_, _, i)| i)+}++/// Apple's current `streetAddresses` with `changes` laid over it. An edited address has only+/// the parts (and label) the form changed written onto Apple's entry; every other part keeps+/// Apple's value now, and every key this app does not model stays as Apple sent it. Entries+/// the form never touched stay exactly as they are. An address edited here but gone at Apple+/// is added back, as an edited number is.+#[must_use]+pub fn merge_addresses(theirs: &[Value], changes: &[AddressChange]) -> Value {+ let parsed: Vec<Option<PostalAddress>> = theirs.iter().map(postal_from).collect();+ let mut claimed = vec![false; theirs.len()];+ let mut out: Vec<Option<Value>> = theirs.iter().cloned().map(Some).collect();+ let mut appended: Vec<Value> = Vec::new();++ for change in changes {+ match change {+ AddressChange::Removed(base) => {+ if let Some(i) = find(&parsed, &claimed, base) {+ claimed[i] = true;+ out[i] = None;+ }+ }+ AddressChange::Edited { base, mine } => {+ let Some(i) = find(&parsed, &claimed, base) else {+ appended.push(entry(mine));+ continue;+ };+ claimed[i] = true;+ let mut e = match out[i].take() {+ Some(Value::Object(e)) => e,+ _ => Map::new(),+ };+ // A field Apple sent as a plain string becomes parts.+ let mut field = match e.remove("field") {+ Some(Value::Object(f)) => f,+ Some(Value::String(text)) if !text.trim().is_empty() => {+ let mut f = Map::new();+ f.insert("street".into(), Value::String(text));+ f+ }+ _ => Map::new(),+ };+ for key in ADDRESS_FIELDS {+ let (was, now) = (base.field(key), mine.field(key));+ if was == now {+ continue;+ }+ match now.and_then(Option::as_ref) {+ Some(v) => {+ field.insert(key.into(), Value::String(v.clone()));+ }+ None => {+ field.remove(key);+ }+ }+ }+ if base.label != mine.label {+ match &mine.label {+ Some(l) => {+ e.insert("label".into(), Value::String(l.clone()));+ }+ None => {+ e.remove("label");+ }+ }+ }+ e.insert("field".into(), Value::Object(field));+ out[i] = Some(Value::Object(e));+ }+ AddressChange::Added(mine) => {+ let already = parsed.iter().any(|t| t.as_ref() == Some(mine));+ if !already {+ appended.push(entry(mine));+ }+ }+ }+ }+ Value::Array(out.into_iter().flatten().chain(appended).collect())+}++/// Write `edits` to the card `guid`, over its addresses as Apple holds them now. `base` is+/// the list the edits were made against. Answers the card's addresses as written.+///+/// A write that loses to one made elsewhere in between is read again and laid over again,+/// up to three times.+///+/// # Errors+/// [`Error::Refused`] for an edit that names nothing, or a card Apple does not have;+/// [`Error::Conflict`] when it keeps losing; otherwise when Apple cannot be reached.+pub async fn edit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ guid: &str,+ base: &[PostalAddress],+ edits: &[AddressEdit],+) -> Result<Vec<PostalAddress>> {+ let (after, changes) = apply_edits(base, edits)?;+ if changes.is_empty() {+ return Ok(after);+ }+ let mut attempt = 0;+ loop {+ attempt += 1;+ let body = startup(http, root, params.clone()).await?;+ let token = |key: &str| {+ body.get(key)+ .and_then(Value::as_str)+ .map(ToString::to_string)+ .ok_or_else(|| Error::Protocol(format!("/co/startup carried no {key}")))+ };+ let tokens = Tokens {+ sync: token("syncToken")?,+ pref: token("prefToken")?,+ };+ let Some(card) = body+ .get("contacts")+ .and_then(Value::as_array)+ .and_then(|cards| {+ cards+ .iter()+ .find(|c| c.get("contactId").and_then(Value::as_str) == Some(guid))+ })+ .cloned()+ else {+ return Err(Error::Refused(+ "Apple doesn't have this contact (yet, or any more), so the address wasn't saved."+ .into(),+ ));+ };+ let card = with_addresses(card, &changes);+ let written = card+ .get("streetAddresses")+ .and_then(Value::as_array)+ .map(|list| list.iter().filter_map(postal_from).collect())+ .unwrap_or_default();+ match write(+ http,+ root,+ params.clone(),+ &tokens,+ reqwest::Method::PUT,+ card,+ )+ .await+ {+ Ok(_) => return Ok(written),+ Err(Error::Conflict) if attempt < 3 => {}+ Err(e) => return Err(e),+ }+ }+}++/// Apple's card with its addresses merged and everything else — its etag included, so the+/// write is against the version just read — as Apple sent it.+fn with_addresses(mut card: Value, changes: &[AddressChange]) -> Value {+ let theirs = card+ .get("streetAddresses")+ .and_then(Value::as_array)+ .cloned()+ .unwrap_or_default();+ if let Some(object) = card.as_object_mut() {+ object.insert("streetAddresses".into(), merge_addresses(&theirs, changes));+ }+ card+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ fn home() -> PostalAddress {+ PostalAddress {+ label: Some("HOME".into()),+ street: Some("12 Example Street\nFlat 4".into()),+ city: Some("Springfield".into()),+ state: Some("ST".into()),+ postal_code: Some("123456".into()),+ country: Some("India".into()),+ ..PostalAddress::default()+ }+ }++ fn apple_home() -> Value {+ json!({+ "label": "HOME",+ "field": {+ "street": "12 Example Street\nFlat 4",+ "city": "Springfield",+ "state": "ST",+ "postalCode": "123456",+ "country": "India"+ }+ })+ }++ #[test]+ fn apples_address_reads_part_by_part() {+ let body = json!({ "contacts": [+ { "contactId": "C1", "streetAddresses": [apple_home(), { "field": {} }] },+ { "contactId": "C2" },+ { "streetAddresses": [apple_home()] }+ ]});+ let book = super::super::parse_addresses(&body);+ assert_eq!(+ book,+ [("C1".to_string(), vec![home()]), ("C2".to_string(), vec![])],+ "a blank address and a card with no id are left out"+ );+ let typed =+ postal_from(&json!({ "field": { "countryCode": "de", "subLocality": "Mitte" } }))+ .unwrap();+ assert_eq!(typed.country_code.as_deref(), Some("de"));+ assert_eq!(typed.sub_locality.as_deref(), Some("Mitte"));+ }++ /// The form changed the postcode while the phone changed the town: both stand, and the+ /// key this app does not model is sent back as Apple had it.+ #[test]+ fn a_part_changed_on_the_phone_survives_an_edit_of_another() {+ let (_, changes) = apply_edits(+ &[home()],+ &[AddressEdit::SetField {+ index: 0,+ field: "postalCode".into(),+ value: Some("654321".into()),+ }],+ )+ .unwrap();+ let mut theirs = apple_home();+ theirs["field"]["city"] = json!("Shelbyville");+ theirs["field"]["x-unmodelled"] = json!("kept");+ let other = json!({ "label": "WORK", "field": { "city": "Capital City" } });+ let merged = merge_addresses(&[theirs, other.clone()], &changes);+ let list = merged.as_array().unwrap();+ assert_eq!(list.len(), 2);+ assert_eq!(list[0]["field"]["postalCode"], "654321", "the edit here");+ assert_eq!(+ list[0]["field"]["city"], "Shelbyville",+ "the phone's change"+ );+ assert_eq!(list[0]["field"]["x-unmodelled"], "kept");+ assert_eq!(list[0]["label"], "HOME");+ assert_eq!(list[1], other, "an address not edited is untouched");+ }++ #[test]+ fn adding_removing_and_relabelling_lay_over_apples_list() {+ let work = PostalAddress {+ label: Some("WORK".into()),+ city: Some("Capital City".into()),+ ..PostalAddress::default()+ };+ let (after, changes) = apply_edits(+ &[home(), work.clone()],+ &[+ AddressEdit::Remove { index: 0 },+ // Index 0 is now the work address.+ AddressEdit::SetLabel {+ index: 0,+ label: Some("OFFICE".into()),+ },+ AddressEdit::Add {+ address: PostalAddress {+ city: Some(" Berlin ".into()),+ country: Some("Germany".into()),+ ..PostalAddress::default()+ },+ },+ ],+ )+ .unwrap();+ assert_eq!(after.len(), 2);+ assert_eq!(after[1].city.as_deref(), Some("Berlin"), "trimmed");+ assert_eq!(after[1].country_code.as_deref(), Some("de"), "coded");++ // The phone added a third address meanwhile.+ let phones = json!({ "label": "OTHER", "field": { "city": "Ogdenville" } });+ let merged = merge_addresses(+ &[+ apple_home(),+ json!({ "label": "WORK", "field": { "city": "Capital City" } }),+ phones.clone(),+ ],+ &changes,+ );+ let list = merged.as_array().unwrap();+ let labels: Vec<&str> = list+ .iter()+ .map(|e| e["label"].as_str().unwrap_or(""))+ .collect();+ assert_eq!(labels, ["OFFICE", "OTHER", ""]);+ assert_eq!(list[1], phones);+ assert_eq!(list[2]["field"]["city"], "Berlin");+ assert_eq!(list[2]["field"]["countryCode"], "de");+ }++ #[test]+ fn a_cleared_part_is_taken_off_and_a_new_country_brings_its_code() {+ let mut coded = home();+ coded.country_code = Some("in".into());+ let (after, changes) = apply_edits(+ &[coded],+ &[+ AddressEdit::SetField {+ index: 0,+ field: "state".into(),+ value: Some(" ".into()),+ },+ AddressEdit::SetField {+ index: 0,+ field: "country".into(),+ value: Some("France".into()),+ },+ ],+ )+ .unwrap();+ assert_eq!(after[0].country_code.as_deref(), Some("fr"));+ let mut theirs = apple_home();+ theirs["field"]["countryCode"] = json!("in");+ let merged = merge_addresses(&[theirs], &changes);+ let field = &merged[0]["field"];+ assert!(field.get("state").is_none(), "cleared, not sent blank");+ assert_eq!(field["country"], "France");+ assert_eq!(field["countryCode"], "fr");+ }++ #[test]+ fn an_edit_naming_nothing_is_refused_before_anything_is_sent() {+ let bad_index = apply_edits(&[home()], &[AddressEdit::Remove { index: 1 }]);+ assert!(matches!(bad_index, Err(Error::Refused(_))));+ let bad_field = apply_edits(+ &[home()],+ &[AddressEdit::SetField {+ index: 0,+ field: "planet".into(),+ value: None,+ }],+ );+ assert!(matches!(bad_field, Err(Error::Refused(_))));+ let (_, none) = apply_edits(&[home()], &[]).unwrap();+ assert!(none.is_empty());+ }++ /// Edited here, deleted on the phone: the edit comes back as an address, as an edited+ /// number does. Removed here and already gone there: nothing to do.+ #[test]+ fn an_address_gone_at_apple_comes_back_only_if_edited_here() {+ let (_, edited) = apply_edits(+ &[home()],+ &[AddressEdit::SetField {+ index: 0,+ field: "city".into(),+ value: Some("Pune".into()),+ }],+ )+ .unwrap();+ let merged = merge_addresses(&[], &edited);+ assert_eq!(merged[0]["field"]["city"], "Pune");+ let (_, removed) = apply_edits(&[home()], &[AddressEdit::Remove { index: 0 }]).unwrap();+ assert_eq!(merge_addresses(&[], &removed), json!([]));+ }++ #[test]+ fn the_card_keeps_its_etag_and_everything_else() {+ let (_, changes) = apply_edits(+ &[home()],+ &[AddressEdit::SetField {+ index: 0,+ field: "city".into(),+ value: Some("Pune".into()),+ }],+ )+ .unwrap();+ let card = with_addresses(+ json!({ "contactId": "C1", "etag": "e9", "phones": [{ "field": "+1" }],+ "streetAddresses": [apple_home()] }),+ &changes,+ );+ assert_eq!(card["etag"], "e9");+ assert_eq!(card["phones"][0]["field"], "+1");+ assert_eq!(card["streetAddresses"][0]["field"]["city"], "Pune");+ }++ #[test]+ fn an_edit_reads_back_as_json_the_window_sends() {+ let edits: Vec<AddressEdit> = serde_json::from_value(json!([+ { "op": "setField", "index": 0, "field": "postalCode", "value": "1" },+ { "op": "setLabel", "index": 0, "label": null },+ { "op": "add", "address": { "city": "Pune" } },+ { "op": "remove", "index": 1 }+ ]))+ .unwrap();+ assert_eq!(edits.len(), 4);+ }+}diff --git a/crates/quince-icloud/src/notes.rs b/crates/quince-icloud/src/notes.rsindex 293edba..91cff71 100644--- a/crates/quince-icloud/src/notes.rs+++ b/crates/quince-icloud/src/notes.rs@@ -15,6 +15,13 @@ use serde_json::Value;const CONTAINER: &str = "com.apple.notes";const ZONE: &str = "Notes";+/// A picture or file added to a note (behind `attach::NOTE_ATTACH_WRITES`).+#[path = "notes_attach.rs"]+pub mod attach;+/// Password-locked notes, opened read-only.+#[path = "notes_locked.rs"]+pub mod locked;+/// The first folder in a note's `Folders` list, where it has one.fn first_folder(record: &Value) -> Option<String> {record@@ -156,6 +163,7 @@ pub async fn fetch_cloudkit() -> Result<NotesFetch> {let client = ZoneClient::new(http, ckdatabasews_root, CONTAINER, params);let mut walk = client.all_records(ZONE, since).await?;+ let whole = walk.whole();// Long notes' files, eight at a time: one after another, a first pass over an account// with many long notes waited on each download in turn.let wanted: Vec<(usize, String)> = walk@@ -180,7 +188,9 @@ pub async fn fetch_cloudkit(token: walk.token,// A walk cut short by the page cap is not the whole truth, whatever it was asked// for — pruning against a partial view would delete records that are perfectly fine.- incremental: since.is_some() || !walk.complete,+ // A cursor Apple refused (expired) started the walk over from the beginning: that+ // walk is the whole zone, and rows deleted while the cursor sat unused are pruned by it.+ incremental: !whole,})}@@ -258,6 +268,14 @@ pub const TEMPLATE_KEY: &str = "notes.document_template";pub fn apply_cloudkit(library: &mut quince_core::Library,fetched: NotesFetch,+) -> Result<(usize, usize, Option<String>)> {+ // One pass is one change: a failure or crash part way leaves the library as it was.+ library.atomically(|library| apply_cloudkit_whole(library, fetched))+}++fn apply_cloudkit_whole(+ library: &mut quince_core::Library,+ fetched: NotesFetch,) -> Result<(usize, usize, Option<String>)> {let NotesFetch {records,@@ -722,22 +740,125 @@ pub fn merge_edits(base: &str, mine: &str, theirs: &str) -> Option<String> {return Some(theirs.to_string());}let b: Vec<char> = base.chars().collect();- let m = script(&b, &mine.chars().collect::<Vec<_>>());- let t = script(&b, &theirs.chars().collect::<Vec<_>>());+ let m = hunks(&script(&b, &mine.chars().collect::<Vec<_>>()), b.len());+ let t = hunks(&script(&b, &theirs.chars().collect::<Vec<_>>()), b.len());let mut out = String::with_capacity(mine.len().max(theirs.len()) + 16);- for gap in 0..=b.len() {- let (ta, ma) = (&t.added[gap], &m.added[gap]);- out.extend(ta.iter());- if ma != ta {- out.extend(ma.iter());- }- if gap < b.len() && !m.removed[gap] && !t.removed[gap] {- out.push(b[gap]);+ let mut at = 0;+ for (from, to, mine_hunks, their_hunks) in clusters(&m, &t) {+ out.extend(&b[at..from]);+ let ours = render(&b, mine_hunks, from, to);+ let other = render(&b, their_hunks, from, to);+ if mine_hunks.is_empty() {+ out.extend(other);+ } else if their_hunks.is_empty() || ours == other {+ out.extend(ours);+ } else if extends(&ours, &other) {+ // One is the other written further: most often Apple holding an earlier save of+ // this very text, read back late. Both kept, every save wrote the note once more+ // (a long note pasted in became five copies of itself).+ out.extend(ours);+ } else if extends(&other, &ours) {+ out.extend(other);+ } else {+ out.extend(other);+ out.extend(ours);}+ at = to;}+ out.extend(&b[at..]);Some(out)}+/// One change to `base`: its characters `start..end` replaced by `text` (an insertion where+/// the two are equal).+struct Hunk {+ start: usize,+ end: usize,+ text: Vec<char>,+}++/// An edit as its separate changes, in order: each a run of removed characters with what was+/// added around and among them, or an addition alone.+fn hunks(script: &Script, len: usize) -> Vec<Hunk> {+ let mut out = Vec::new();+ let mut gap = 0;+ while gap <= len {+ if script.added[gap].is_empty() && !(gap < len && script.removed[gap]) {+ gap += 1;+ continue;+ }+ let start = gap;+ let mut text = Vec::new();+ loop {+ text.extend(&script.added[gap]);+ if gap < len && script.removed[gap] {+ gap += 1;+ } else {+ break;+ }+ }+ out.push(Hunk {+ start,+ end: gap,+ text,+ });+ // The character at `gap` stays; the next change can start no sooner than after it.+ gap += 1;+ }+ out+}++/// The two edits' changes, grouped where they meet: a group is every change on either side+/// that touches the same stretch of `base` (or the same point in it), with that stretch.+fn clusters<'a>(+ mine: &'a [Hunk],+ theirs: &'a [Hunk],+) -> Vec<(usize, usize, &'a [Hunk], &'a [Hunk])> {+ let (mut i, mut j) = (0, 0);+ let mut out = Vec::new();+ while i < mine.len() || j < theirs.len() {+ let first = match (mine.get(i), theirs.get(j)) {+ (Some(a), Some(b)) => a.start.min(b.start),+ (Some(a), None) => a.start,+ (None, Some(b)) => b.start,+ (None, None) => break,+ };+ let (i0, j0) = (i, j);+ let mut end = first;+ loop {+ if let Some(h) = mine.get(i).filter(|h| h.start <= end) {+ end = end.max(h.end);+ i += 1;+ } else if let Some(h) = theirs.get(j).filter(|h| h.start <= end) {+ end = end.max(h.end);+ j += 1;+ } else {+ break;+ }+ }+ out.push((first, end, &mine[i0..i], &theirs[j0..j]));+ }+ out+}++/// `base[from..to]` as one side's changes leave it.+fn render(base: &[char], changes: &[Hunk], from: usize, to: usize) -> Vec<char> {+ let mut out = Vec::new();+ let mut at = from;+ for h in changes {+ out.extend(&base[at..h.start]);+ out.extend(&h.text);+ at = h.end;+ }+ out.extend(&base[at..to]);+ out+}++/// Whether `longer` is `shorter` with more written before or after it.+fn extends(longer: &[char], shorter: &[char]) -> bool {+ longer.len() > shorter.len() && (longer.starts_with(shorter) || longer.ends_with(shorter))+}+/// Set one paragraph of a note — a style from the Aa menu, or a checklist tick — written/// over what Apple holds now, with the text and everything else in the document unchanged.pub async fn set_paragraph_cloudkit(@@ -2424,6 +2545,32 @@ mod merge_tests {assert_eq!(merge_edits("a", "ab", "a").as_deref(), Some("ab"));}+ /// Apple holding an earlier save of this very text (its own write read back late, or a+ /// base that was not moved on): the text is written once, not once more per save. A+ /// 42,000-character note pasted in had become five copies of itself.+ #[test]+ fn an_earlier_save_of_the_same_text_is_not_written_twice() {+ let long: String = (0..4000).map(|i| format!("line {i}\n")).collect();+ let first = &long[..long.len() / 2];+ // Base empty, Apple has half of it, the editor all of it.+ assert_eq!(+ merge_edits("", &long, first).as_deref(),+ Some(long.as_str())+ );+ // Base the note's first line; the same, and with the editor further still.+ let more = format!("{long}and more");+ assert_eq!(+ merge_edits("line 0\n", &more, &long).as_deref(),+ Some(more.as_str())+ );+ // A title typed after, at the start, on top of a late copy.+ let titled = format!("Title\n{long}");+ assert_eq!(+ merge_edits("", &titled, &long).as_deref(),+ Some(titled.as_str())+ );+ }+#[test]fn text_beyond_ascii_is_cut_by_character() {assert_eq!(merge_edits("ü 𝐔", "ü 𝐔 x", "Ü 𝐔").as_deref(), Some("Ü 𝐔 x"));@@ -2622,3 +2769,69 @@ pub async fn set_table_cell_cloudkit(.and_then(crate::table::cells_from_base64).ok_or_else(|| Error::Protocol("Apple kept a table this cannot read back".into()))}++#[cfg(test)]+mod atomic_apply_tests {+ use super::*;+ use serde_json::json;++ /// A failure as the pass stores its position — the last thing it writes — standing in for+ /// a crash part way through.+ fn fail_on_position(library: &quince_core::Library) {+ library+ .conn()+ .execute_batch(+ "CREATE TEMP TRIGGER crash_i BEFORE INSERT ON main.sync_state+ BEGIN SELECT RAISE(ABORT, 'crash mid-apply'); END;+ CREATE TEMP TRIGGER crash_u BEFORE UPDATE ON main.sync_state+ BEGIN SELECT RAISE(ABORT, 'crash mid-apply'); END;",+ )+ .unwrap();+ }++ /// A pass that fails part way leaves the library as it was: the note it had already+ /// removed is still there, and the position is the old one.+ #[test]+ fn a_pass_that_fails_part_way_stores_none_of_itself() {+ let mut library = quince_core::Library::in_memory().unwrap();+ library+ .put_notes(&[Note {+ guid: "N1".into(),+ folder_guid: None,+ title: "Kept".into(),+ snippet: None,+ body: Some("Kept".into()),+ locked: false,+ pinned: false,+ created_at: None,+ modified_at: None,+ editable: true,+ etag: None,+ runs: None,+ }])+ .unwrap();+ library.mark_synced("notes", Some("old")).unwrap();+ fail_on_position(&library);+ let pass = || NotesFetch {+ records: vec![json!({ "recordName": "N1", "deleted": true })],+ token: Some("new".into()),+ incremental: true,+ };+ assert!(apply_cloudkit(&mut library, pass()).is_err());+ assert!(+ library.note("N1").unwrap().is_some(),+ "the removal rolled back"+ );+ assert_eq!(library.sync_token("notes").unwrap().as_deref(), Some("old"));+ assert!(library.conn().is_autocommit());++ // Nothing failing, the same pass lands whole.+ library+ .conn()+ .execute_batch("DROP TRIGGER temp.crash_i; DROP TRIGGER temp.crash_u;")+ .unwrap();+ apply_cloudkit(&mut library, pass()).unwrap();+ assert!(library.note("N1").unwrap().is_none());+ assert_eq!(library.sync_token("notes").unwrap().as_deref(), Some("new"));+ }+}diff --git a/crates/quince-icloud/src/notes_attach.rs b/crates/quince-icloud/src/notes_attach.rsnew file mode 100644index 0000000..bd79967--- /dev/null+++ b/crates/quince-icloud/src/notes_attach.rs@@ -0,0 +1,938 @@+//! A picture or file added to a note, as a phone adds one.+//!+//! Measured on his account (read-only, `probe/examples/notes_attach_locked_shape.rs`): a+//! picture added on his iPhone is three things written together.+//!+//! * A `Media` record holding the file: `Asset` (ASSETID — `fileChecksum`, `receipt`,+//! `referenceChecksum`, `size`, `wrappingKey`), `FilenameEncrypted` (the name, plain UTF-8),+//! `Deleted` 0 and `MinimumSupportedNotesVersion` — the note's own (14 on a new note, 0 on an+//! old one: it matched the note every time). Its record `parent` is the note.+//! * An `Attachment` record: `UTI` (STRING) and `UTIEncrypted` (the same, plain bytes), `Note`+//! and `Media` (REFERENCE, VALIDATE), `CreationDate` / `LastModificationDate`, `FileSize`,+//! `Deleted` 0, the same minimum version, `Orientation` 0, `ImageFilterType` 0,+//! `HandwritingSummaryVersion` 0 and the eight `CroppingQuad…` corners of the unit square;+//! a picture also `Width` / `Height` (DOUBLE), a file its name in `TitleEncrypted`. Its+//! record `parent` is the note too.+//! * The note's document, with one U+FFFC where the attachment sits and a run of its own for+//! it (see [`crate::ckdocument::insert_attachment`]).+//!+//! What the phone adds that is left out here, on purpose: preview renderings+//! (`PreviewImages` and their sizes), OCR / image-classification summaries and their version+//! numbers, and `ReplicaIDToNotesVersionDataEncrypted`. All are worked out from the file by a+//! device — a version number written without its summary would tell the phone the work is done+//! when it is not — and the last is the server's to keep (see `document_like_apples`).+//!+//! The three go in one atomic `records/modify`, the note's part written only over the exact+//! version it was built from: if a phone edited the note meanwhile, nothing is written, the+//! note is read again, the attachment is placed again — moved along with the other device's+//! edit — and the three are sent again. The file is uploaded once, before any of that.+//!+//! Off until a supervised live test: see [`NOTE_ATTACH_WRITES`].++use crate::cloudkit::ZoneClient;+use crate::{Error, Result};+use base64::{engine::general_purpose::STANDARD as B64, Engine};+use serde::Serialize;+use serde_json::{json, Value};++/// Whether adding a file to a note may write to iCloud at all. False until the live test on a+/// throwaway note has been watched end to end on a phone.+pub const NOTE_ATTACH_WRITES: bool = false;++const CONTAINER: &str = "com.apple.notes";+const ZONE: &str = "Notes";++/// The largest file put in a note here.+pub const MOST_BYTES: u64 = 100 * 1024 * 1024;++/// What was added, to show it at once.+#[derive(Debug, Clone, Serialize, PartialEq)]+#[serde(rename_all = "camelCase")]+pub struct Attached {+ pub attachment: String,+ pub media: String,+ pub uti: String,+ /// Where it landed, in UTF-16 units of the text Apple now holds.+ pub offset: u64,+ /// The note's text as written, with the attachment's character in it.+ pub body: String,+}++/// The type identifier Notes records for a file, from its name.+#[must_use]+pub fn uti_for(name: &str) -> &'static str {+ let ext = std::path::Path::new(name)+ .extension()+ .and_then(|e| e.to_str())+ .map(str::to_ascii_lowercase)+ .unwrap_or_default();+ match ext.as_str() {+ "jpg" | "jpeg" => "public.jpeg",+ "png" => "public.png",+ "heic" => "public.heic",+ "heif" => "public.heif",+ "gif" => "com.compuserve.gif",+ "tif" | "tiff" => "public.tiff",+ "webp" => "org.webmproject.webp",+ "pdf" => "com.adobe.pdf",+ "txt" => "public.plain-text",+ "md" => "net.daringfireball.markdown",+ "csv" => "public.comma-separated-values-text",+ "json" => "public.json",+ "rtf" => "public.rtf",+ "html" | "htm" => "public.html",+ "zip" => "public.zip-archive",+ "mp3" => "public.mp3",+ "m4a" => "com.apple.m4a-audio",+ "wav" => "com.microsoft.waveform-audio",+ "mp4" => "public.mpeg-4",+ "mov" => "com.apple.quicktime-movie",+ "docx" => "org.openxmlformats.wordprocessingml.document",+ "xlsx" => "org.openxmlformats.spreadsheetml.sheet",+ "pptx" => "org.openxmlformats.presentationml.presentation",+ "pages" => "com.apple.iwork.pages.sffpages",+ "numbers" => "com.apple.iwork.numbers.sffnumbers",+ "key" => "com.apple.iwork.keynote.sffkey",+ _ => "public.data",+ }+}++/// A picture's pixel size, read from its header: PNG, JPEG, GIF, WebP and HEIC.+#[must_use]+pub fn image_size(b: &[u8]) -> Option<(u32, u32)> {+ let be32 = |i: usize| Some(u32::from_be_bytes(b.get(i..i + 4)?.try_into().ok()?));+ let be16 = |i: usize| {+ Some(u32::from(u16::from_be_bytes(+ b.get(i..i + 2)?.try_into().ok()?,+ )))+ };+ let le16 = |i: usize| {+ Some(u32::from(u16::from_le_bytes(+ b.get(i..i + 2)?.try_into().ok()?,+ )))+ };+ if b.starts_with(b"\x89PNG\r\n\x1a\n") {+ return Some((be32(16)?, be32(20)?));+ }+ if b.starts_with(b"GIF8") {+ return Some((le16(6)?, le16(8)?));+ }+ if b.starts_with(b"\xff\xd8") {+ let mut i = 2;+ while i + 9 < b.len() {+ if b[i] != 0xFF {+ return None;+ }+ let marker = b[i + 1];+ if marker == 0xFF {+ i += 1;+ continue;+ }+ // Start-of-frame markers, not DHT (C4), JPG (C8) or DAC (CC).+ if (0xC0..=0xCF).contains(&marker) && !matches!(marker, 0xC4 | 0xC8 | 0xCC) {+ return Some((be16(i + 7)?, be16(i + 5)?));+ }+ i += 2 + usize::try_from(be16(i + 2)?).ok()?;+ }+ return None;+ }+ if b.len() > 30 && &b[0..4] == b"RIFF" && &b[8..12] == b"WEBP" {+ let le24 = |i: usize| -> Option<u32> {+ let s = b.get(i..i + 3)?;+ Some(u32::from(s[0]) | u32::from(s[1]) << 8 | u32::from(s[2]) << 16)+ };+ return match &b[12..16] {+ b"VP8X" => Some((le24(24)? + 1, le24(27)? + 1)),+ b"VP8 " => Some((le16(26)? & 0x3FFF, le16(28)? & 0x3FFF)),+ b"VP8L" => {+ let v = u32::from_le_bytes(b.get(21..25)?.try_into().ok()?);+ Some(((v & 0x3FFF) + 1, ((v >> 14) & 0x3FFF) + 1))+ }+ _ => None,+ };+ }+ if b.get(4..8) == Some(b"ftyp") {+ // HEIF: the largest `ispe` (image spatial extent) is the picture; the rest are+ // thumbnails and tiles.+ let mut best: Option<(u32, u32)> = None;+ let mut i = 0;+ while let Some(at) = b[i..].windows(4).position(|w| w == b"ispe") {+ let p = i + at + 4;+ if let (Some(w), Some(h)) = (be32(p + 4), be32(p + 8)) {+ if best.is_none_or(|(bw, bh)| {+ u64::from(w) * u64::from(h) > u64::from(bw) * u64::from(bh)+ }) {+ best = Some((w, h));+ }+ }+ i = p;+ }+ return best;+ }+ None+}++fn int(value: i64) -> Value {+ json!({ "type": "INT64", "value": value })+}++fn double(value: f64) -> Value {+ json!({ "type": "DOUBLE", "value": value })+}++fn bare(text: &str) -> Value {+ json!({ "type": "ENCRYPTED_BYTES", "value": B64.encode(text.as_bytes()) })+}++/// The `Media` record's fields, as a phone writes them.+#[must_use]+pub fn media_fields(asset: &Value, filename: &str, min_version: i64) -> Value {+ json!({+ "Asset": { "type": "ASSETID", "value": asset },+ "FilenameEncrypted": bare(filename),+ "Deleted": int(0),+ "MinimumSupportedNotesVersion": int(min_version),+ })+}++/// What an attachment's record says about the file.+pub struct Described<'a> {+ pub uti: &'a str,+ pub filename: &'a str,+ pub size: u64,+ pub pixels: Option<(u32, u32)>,+ pub min_version: i64,+ pub stamp_ms: i64,+}++/// The `Attachment` record's fields, as a phone writes them (see the module notes for what is+/// left out and why).+#[must_use]+pub fn attachment_fields(note: Value, media: Value, d: &Described<'_>) -> Value {+ let mut f = json!({+ "UTI": { "type": "STRING", "value": d.uti },+ "UTIEncrypted": bare(d.uti),+ "Note": note,+ "Media": media,+ "CreationDate": { "type": "TIMESTAMP", "value": d.stamp_ms },+ "LastModificationDate": { "type": "TIMESTAMP", "value": d.stamp_ms },+ "FileSize": int(i64::try_from(d.size).unwrap_or(i64::MAX)),+ "Deleted": int(0),+ "MinimumSupportedNotesVersion": int(d.min_version),+ "Orientation": int(0),+ "ImageFilterType": int(0),+ "HandwritingSummaryVersion": int(0),+ "CroppingQuadBottomLeftX": double(0.0),+ "CroppingQuadBottomLeftY": double(0.0),+ "CroppingQuadBottomRightX": double(1.0),+ "CroppingQuadBottomRightY": double(0.0),+ "CroppingQuadTopLeftX": double(0.0),+ "CroppingQuadTopLeftY": double(1.0),+ "CroppingQuadTopRightX": double(1.0),+ "CroppingQuadTopRightY": double(1.0),+ });+ match d.pixels {+ Some((w, h)) => {+ f["Width"] = double(f64::from(w));+ f["Height"] = double(f64::from(h));+ }+ None => f["TitleEncrypted"] = bare(d.filename),+ }+ f+}++/// Where the attachment goes in the note as Apple holds it now (`current`, the field's+/// base64), and the document with it there.+///+/// `at` is in UTF-16 units of `base` — the text the person was looking at — when given, and+/// of Apple's text otherwise. When Apple's text has moved on since `base`, the place moves with+/// it, by the same merge a save uses; a place that cannot be carried across is refused rather+/// than guessed.+pub fn place_in_document(+ current: &str,+ base: Option<&str>,+ at: u64,+ id: &str,+ uti: &str,+ stamp: u64,+) -> Result<(String, u64)> {+ let moved = || {+ Error::Refused(+ "This note changed on another device right where the file was going, so nothing was added. Try again."+ .into(),+ )+ };+ let theirs = crate::ckdocument::stored_text_from_base64(current).ok_or_else(|| {+ Error::Refused("Pomander couldn't read this note's text as Apple holds it.".into())+ })?;+ let place = match base {+ Some(base) if base != theirs => {+ let mut mine: Vec<u16> = base.encode_utf16().collect();+ let i = usize::try_from(at).map_err(|_| moved())?;+ if i > mine.len() {+ return Err(moved());+ }+ mine.insert(i, 0xFFFC);+ let mine = String::from_utf16(&mine).map_err(|_| moved())?;+ let merged = super::merge_edits(base, &mine, &theirs).ok_or_else(moved)?;+ let (t, m): (Vec<u16>, Vec<u16>) = (+ theirs.encode_utf16().collect(),+ merged.encode_utf16().collect(),+ );+ let p = t.iter().zip(&m).take_while(|(a, b)| a == b).count();+ // The merge must be Apple's text with exactly our one character added.+ if m.len() != t.len() + 1 || m[p] != 0xFFFC || m[p + 1..] != t[p..] {+ return Err(moved());+ }+ p as u64+ }+ _ => at,+ };+ let document = crate::ckdocument::insert_attachment_in_base64(current, place, id, uti, stamp)+ .ok_or_else(|| {+ Error::Refused(+ "Pomander can’t safely add a file to this note yet, so nothing was changed.".into(),+ )+ })?;+ super::fits_inline(&document)?;+ if !crate::ckdocument::attachments_sound_adding_in_base64(current, &document, id) {+ return Err(Error::Refused(super::ATTACHMENTS_UNSOUND.into()));+ }+ Ok((document, place))+}++/// CloudKit's query parameters, as [`ZoneClient`] sends them.+fn ck_query(params: &[(String, String)]) -> Vec<(String, String)> {+ let mut q = params.to_vec();+ q.push(("ckjsBuildVersion".into(), "17DProjectDev77".into()));+ q.push(("ckjsVersion".into(), "2.6.1".into()));+ q+}++async fn post(+ http: &reqwest::Client,+ url: &str,+ params: &[(String, String)],+ body: &Value,+) -> Result<Value> {+ for tries in 1..=3u64 {+ let response = http+ .post(url)+ .query(&ck_query(params))+ .json(body)+ .send()+ .await?;+ let status = response.status();+ let text = response.text().await.unwrap_or_default();+ if status.as_u16() == 450 {+ return Err(Error::ReauthRequired);+ }+ let busy = matches!(status.as_u16(), 429 | 503)+ || status.as_u16() == 409+ && (text.contains("\"ZONE_BUSY\"") || text.contains("\"TRY_AGAIN_LATER\""));+ if busy {+ tokio::time::sleep(std::time::Duration::from_secs(2 * tries)).await;+ continue;+ }+ if !status.is_success() {+ return Err(Error::Protocol(format!(+ "CloudKit refused it ({status}): {}",+ text.chars().take(200).collect::<String>()+ )));+ }+ return serde_json::from_str(&text)+ .map_err(|e| Error::Protocol(format!("CloudKit returned invalid JSON: {e}")));+ }+ Err(Error::Busy)+}++fn database(root: &str, op: &str) -> String {+ format!(+ "{}/database/1/{CONTAINER}/production/private/{op}",+ root.trim_end_matches('/')+ )+}++/// The file's bytes into CloudKit for `Media/<media>.Asset`, checked: Apple's receipt must+/// name exactly the bytes sent. Answers the ASSETID value a record carries.+async fn upload_asset(+ http: &reqwest::Client,+ root: &str,+ params: &[(String, String)],+ media: &str,+ bytes: Vec<u8>,+) -> Result<Value> {+ let offered = post(+ http,+ &database(root, "assets/upload"),+ params,+ &json!({+ "zoneID": { "zoneName": ZONE, "zoneType": "REGULAR_CUSTOM_ZONE" },+ "tokens": [{ "recordType": "Media", "recordName": media, "fieldName": "Asset" }],+ }),+ )+ .await?;+ let url = offered+ .pointer("/tokens/0/url")+ .and_then(Value::as_str)+ .ok_or_else(|| Error::Protocol("CloudKit offered nowhere to put the file".into()))?+ .to_string();+ let size = bytes.len() as u64;+ let mut sum = crate::drive::AppleChecksum::default();+ sum.update(&bytes);+ let local = sum.finish();+ let sent = http+ .post(&url)+ .header("content-type", "application/octet-stream")+ .body(bytes)+ .send()+ .await?;+ let status = sent.status();+ let text = sent.text().await.unwrap_or_default();+ if !status.is_success() {+ return Err(Error::Protocol(format!("the upload answered {status}")));+ }+ let receipt: Value = serde_json::from_str(&text)+ .map_err(|e| Error::Protocol(format!("the upload's receipt was not JSON: {e}")))?;+ let single = receipt+ .get("singleFile")+ .filter(|s| s.get("receipt").is_some())+ .ok_or_else(|| Error::Protocol("the upload gave no receipt".into()))?;+ if single.get("size").and_then(Value::as_u64) != Some(size)+ || single.get("fileChecksum").and_then(Value::as_str) != Some(local.as_str())+ {+ return Err(Error::Protocol(+ "the bytes Apple received are not the file's, so nothing was added".into(),+ ));+ }+ let of = |k: &str| single.get(k).cloned().unwrap_or(Value::Null);+ Ok(json!({+ "fileChecksum": of("fileChecksum"),+ "receipt": of("receipt"),+ "referenceChecksum": of("referenceChecksum"),+ "size": size,+ "wrappingKey": of("wrappingKey"),+ }))+}++/// Add the file at `path` to note `guid` at UTF-16 offset `at` of `base` (or of Apple's text).+pub async fn attach_file_cloudkit(+ http: &reqwest::Client,+ ckdatabasews_root: &str,+ params: Vec<(String, String)>,+ guid: &str,+ path: &std::path::Path,+ base: Option<&str>,+ at: u64,+) -> Result<Attached> {+ if !NOTE_ATTACH_WRITES {+ return Err(Error::Refused(+ "Adding files to notes isn’t switched on yet. Nothing was changed.".into(),+ ));+ }+ attach_file_unguarded(http, ckdatabasews_root, params, guid, path, base, at).await+}++async fn attach_file_unguarded(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ guid: &str,+ path: &std::path::Path,+ base: Option<&str>,+ at: u64,+) -> Result<Attached> {+ let filename = path+ .file_name()+ .and_then(|n| n.to_str())+ .ok_or_else(|| Error::Refused("That file has no name to give it.".into()))?+ .to_string();+ let size = tokio::fs::metadata(path)+ .await+ .map_err(|e| Error::Refused(format!("Couldn’t read {filename}: {e}")))?+ .len();+ if size == 0 || size > MOST_BYTES {+ return Err(Error::Refused(format!(+ "{filename} is {} — a note takes files up to {} MB.",+ if size == 0 {+ "empty".to_string()+ } else {+ format!("{} MB", size / 1_048_576)+ },+ MOST_BYTES / 1_048_576+ )));+ }+ let bytes = tokio::fs::read(path)+ .await+ .map_err(|e| Error::Refused(format!("Couldn’t read {filename}: {e}")))?;+ let uti = uti_for(&filename);+ let pixels = if crate::note_media::kind_of(uti) == "image" {+ image_size(&bytes)+ } else {+ None+ };++ let client = ZoneClient::new(http, root, CONTAINER, params.clone());+ // The note first: there is no point uploading into a note that is not there.+ if client.lookup_record(ZONE, guid).await?.is_none() {+ return Err(Error::Refused("Apple no longer has that note.".into()));+ }+ let attachment = uuid::Uuid::new_v4().to_string().to_uppercase();+ let media = uuid::Uuid::new_v4().to_string().to_uppercase();+ let asset = upload_asset(http, root, ¶ms, &media, bytes).await?;++ for _ in 0..4 {+ let note = client+ .lookup_record(ZONE, guid)+ .await?+ .ok_or_else(|| Error::Refused("Apple no longer has that note.".into()))?;+ let current = note+ .pointer("/fields/TextDataEncrypted/value")+ .and_then(Value::as_str)+ .ok_or_else(|| {+ Error::Refused("That note has no body Apple will let us read.".into())+ })?;+ let tag = note+ .get("recordChangeTag")+ .and_then(Value::as_str)+ .ok_or(Error::Conflict)?;+ let now_ms = super::now_millis();+ let stamp = u64::try_from(now_ms / 1000).unwrap_or(0);+ let (document, offset) = place_in_document(current, base, at, &attachment, uti, stamp)?;+ let min_version = note+ .pointer("/fields/MinimumSupportedNotesVersion/value")+ .and_then(Value::as_i64)+ .unwrap_or(0);+ let described = Described {+ uti,+ filename: &filename,+ size,+ pixels,+ min_version,+ stamp_ms: now_ms,+ };+ let parent = json!({ "recordName": guid });+ let operations = json!([+ { "operationType": "create", "record": {+ "recordName": media, "recordType": "Media", "parent": parent,+ "fields": media_fields(&asset, &filename, min_version),+ } },+ { "operationType": "create", "record": {+ "recordName": attachment, "recordType": "Attachment", "parent": parent,+ "fields": attachment_fields(+ client.reference_to(ZONE, guid),+ client.reference_to(ZONE, &media),+ &described,+ ),+ } },+ { "operationType": "update", "record": {+ "recordName": guid, "recordType": "Note", "recordChangeTag": tag,+ "fields": {+ "TextDataEncrypted": { "type": "ENCRYPTED_BYTES", "value": document },+ "ModificationDate": { "type": "TIMESTAMP", "value": now_ms },+ },+ } },+ ]);+ let answer = post(+ http,+ &database(root, "records/modify"),+ ¶ms,+ &json!({+ "operations": operations,+ "zoneID": { "zoneName": ZONE, "zoneType": "REGULAR_CUSTOM_ZONE" },+ "atomic": true,+ }),+ )+ .await?;+ match outcome(&answer) {+ Ok(()) => {+ let body =+ crate::ckdocument::stored_text_from_base64(&document).unwrap_or_default();+ return Ok(Attached {+ attachment,+ media,+ uti: uti.to_string(),+ offset,+ body,+ });+ }+ // The note moved (or the zone was busy): nothing was written; place it again.+ Err(Error::Conflict | Error::Busy) => {}+ Err(e) => return Err(e),+ }+ }+ Err(Error::Refused(+ "This note keeps changing on another device, so the file wasn’t added yet. Try again in a moment.".into(),+ ))+}++/// What an atomic `records/modify` came to: every record written, the note moved under us+/// (Conflict), the zone busy, or refused.+fn outcome(answer: &Value) -> Result<()> {+ let records = answer+ .get("records")+ .and_then(Value::as_array)+ .ok_or_else(|| Error::Protocol("CloudKit didn’t say what it wrote".into()))?;+ if records.len() != 3 {+ return Err(Error::Protocol(+ "CloudKit didn’t answer for every record".into(),+ ));+ }+ let mut failure: Option<Error> = None;+ for r in records {+ let Some(reason) = r.get("reason").and_then(Value::as_str) else {+ continue;+ };+ let code = r+ .get("serverErrorCode")+ .and_then(Value::as_str)+ .unwrap_or("");+ let this = if code == "CONFLICT" || reason.to_ascii_lowercase().contains("oplock") {+ Error::Conflict+ } else if matches!(code, "ZONE_BUSY" | "TRY_AGAIN_LATER") {+ Error::Busy+ } else if code == "ATOMIC_ERROR" {+ // Failed only because another of the three did: that one says why.+ continue;+ } else {+ Error::Protocol(format!("CloudKit refused the attachment: {reason}"))+ };+ failure = Some(match (failure, this) {+ (Some(Error::Protocol(p)), _) | (_, Error::Protocol(p)) => Error::Protocol(p),+ (_, e) => e,+ });+ }+ match failure {+ None if records.iter().all(|r| r.get("recordChangeTag").is_some()) => Ok(()),+ None => Err(Error::Protocol(+ "CloudKit wrote only part of the attachment".into(),+ )),+ Some(e) => Err(e),+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use wiremock::matchers::{method, path_regex};+ use wiremock::{Mock, MockServer, ResponseTemplate};++ #[test]+ fn type_identifiers_come_from_the_name() {+ assert_eq!(uti_for("IMG_1.JPG"), "public.jpeg");+ assert_eq!(uti_for("a.heic"), "public.heic");+ assert_eq!(uti_for("report.pdf"), "com.adobe.pdf");+ assert_eq!(+ uti_for("sheet.xlsx"),+ "org.openxmlformats.spreadsheetml.sheet"+ );+ assert_eq!(uti_for("noext"), "public.data");+ assert_eq!(crate::note_media::kind_of(uti_for("x.png")), "image");+ }++ #[test]+ fn picture_sizes_are_read_from_headers() {+ let mut png = b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR".to_vec();+ png.extend(640u32.to_be_bytes());+ png.extend(480u32.to_be_bytes());+ assert_eq!(image_size(&png), Some((640, 480)));+ let gif = b"GIF89a\x20\x03\x58\x02";+ assert_eq!(image_size(gif), Some((800, 600)));+ // SOI, an APP0 of length 4, then SOF0: precision, height 300, width 400.+ let jpeg = [+ 0xFF, 0xD8, 0xFF, 0xE0, 0, 4, 0, 0, 0xFF, 0xC0, 0, 17, 8, 0x01, 0x2C, 0x01, 0x90, 3, 0,+ 0, 0, 0,+ ];+ assert_eq!(image_size(&jpeg), Some((400, 300)));+ let mut heic = b"\0\0\0\x18ftypheic".to_vec();+ for (w, h) in [(512u32, 512u32), (4032, 3024)] {+ heic.extend(b"\0\0\0\x14ispe\0\0\0\0");+ heic.extend(w.to_be_bytes());+ heic.extend(h.to_be_bytes());+ }+ assert_eq!(image_size(&heic), Some((4032, 3024)));+ assert_eq!(image_size(b"not a picture"), None);+ }++ /// The records carry the fields measured on a phone's picture, and only those.+ #[test]+ fn records_are_shaped_like_the_phones() {+ let d = Described {+ uti: "public.jpeg",+ filename: "cat.jpg",+ size: 1234,+ pixels: Some((585, 90)),+ min_version: 14,+ stamp_ms: 1_792_549_727_010,+ };+ let f = attachment_fields(json!("NOTE-REF"), json!("MEDIA-REF"), &d);+ let mut names: Vec<&String> = f.as_object().unwrap().keys().collect();+ names.sort();+ assert_eq!(+ names,+ [+ "CreationDate",+ "CroppingQuadBottomLeftX",+ "CroppingQuadBottomLeftY",+ "CroppingQuadBottomRightX",+ "CroppingQuadBottomRightY",+ "CroppingQuadTopLeftX",+ "CroppingQuadTopLeftY",+ "CroppingQuadTopRightX",+ "CroppingQuadTopRightY",+ "Deleted",+ "FileSize",+ "HandwritingSummaryVersion",+ "Height",+ "ImageFilterType",+ "LastModificationDate",+ "Media",+ "MinimumSupportedNotesVersion",+ "Note",+ "Orientation",+ "UTI",+ "UTIEncrypted",+ "Width",+ ]+ );+ assert_eq!(f["UTIEncrypted"]["value"], B64.encode("public.jpeg"));+ assert_eq!(f["Width"], json!({ "type": "DOUBLE", "value": 585.0 }));+ assert_eq!(f["MinimumSupportedNotesVersion"]["value"], 14);+ let file = attachment_fields(+ json!(0),+ json!(0),+ &Described {+ pixels: None,+ uti: "com.adobe.pdf",+ filename: "a.pdf",+ ..d+ },+ );+ assert!(file.get("Width").is_none());+ assert_eq!(file["TitleEncrypted"]["value"], B64.encode("a.pdf"));+ let m = media_fields(&json!({ "receipt": "r" }), "cat.jpg", 14);+ assert_eq!(m["FilenameEncrypted"]["value"], B64.encode("cat.jpg"));+ assert_eq!(m["Asset"]["type"], "ASSETID");+ }++ const ID: &str = "11111111-2222-3333-4444-555555555555";++ /// The document change on a synthetic note: one U+FFFC where asked, a run of its own+ /// naming the attachment, the guard satisfied — and the place carried across a phone's+ /// edit made meanwhile.+ #[test]+ fn the_attachment_lands_where_asked_even_after_an_edit_elsewhere() {+ let original = crate::ckdocument::text_to_base64("Shopping\nmilk\n");+ let (doc, at) = place_in_document(&original, None, 9, ID, "public.jpeg", 1).unwrap();+ assert_eq!(at, 9);+ assert_eq!(+ crate::ckdocument::stored_text_from_base64(&doc).unwrap(),+ "Shopping\n\u{FFFC}milk\n"+ );+ let runs = crate::ckdocument::runs_from_base64(&doc);+ let mut from = 0;+ let mine: Vec<_> = runs+ .iter()+ .filter_map(|r| {+ from += r.length;+ r.attachment.as_deref().map(|a| (a, from - 1, r.length))+ })+ .collect();+ assert_eq!(mine, [(ID, 9, 1)]);+ assert_eq!(runs.iter().map(|r| r.length).sum::<u64>(), 15);+ assert!(crate::ckdocument::attachments_sound_adding_in_base64(+ &original, &doc, ID+ ));+ // The ordinary guard, which allows no new attachment, refuses it — the new one is+ // only ever allowed by name.+ assert!(!crate::ckdocument::attachments_sound_in_base64(+ &original, &doc+ ));+ // Once written, editing that note again is an ordinary, sound edit.+ let edited =+ crate::ckdocument::replace_text_in_base64(&doc, "Shopping!\n\u{FFFC}milk\n").unwrap();+ assert!(crate::ckdocument::attachments_sound_in_base64(+ &doc, &edited+ ));++ // The phone added a line at the top since the person looked: the picture still goes+ // before "milk".+ let theirs = crate::ckdocument::text_to_base64("Today\nShopping\nmilk\n");+ let (doc, at) =+ place_in_document(&theirs, Some("Shopping\nmilk\n"), 9, ID, "public.jpeg", 1).unwrap();+ assert_eq!(at, 15);+ assert_eq!(+ crate::ckdocument::stored_text_from_base64(&doc).unwrap(),+ "Today\nShopping\n\u{FFFC}milk\n"+ );+ }++ #[test]+ fn a_bad_place_or_a_reused_id_is_refused() {+ let original = crate::ckdocument::text_to_base64("ab");+ assert!(place_in_document(&original, None, 3, ID, "public.png", 1).is_err());+ // "😀" is two UTF-16 units; between them is no place at all.+ let emoji = crate::ckdocument::text_to_base64("😀");+ assert!(place_in_document(&emoji, None, 1, ID, "public.png", 1).is_err());+ let (doc, _) = place_in_document(&original, None, 2, ID, "public.png", 1).unwrap();+ // The same id a second time is one attachment in two places.+ assert!(place_in_document(&doc, None, 0, ID, "public.png", 1).is_err());+ }++ /// The paragraph a picture lands in keeps its setting: in a checklist line, the+ /// attachment's run carries that line's checklist item, as the phone's did.+ #[test]+ fn the_attachment_takes_its_paragraphs_setting() {+ use crate::ckdocument::ParagraphChange;+ let plain = crate::ckdocument::text_to_base64("todo\nbuy\n");+ let listed = crate::ckdocument::set_paragraph_in_base64(+ &plain,+ 5,+ ParagraphChange::Style(103),+ Some("buy"),+ )+ .unwrap();+ let (doc, _) = place_in_document(&listed, None, 8, ID, "public.png", 1).unwrap();+ let runs = crate::ckdocument::runs_from_base64(&doc);+ let pic = runs.iter().find(|r| r.attachment.is_some()).unwrap();+ assert_eq!(pic.style, Some(103));+ assert_eq!(runs.iter().map(|r| r.length).sum::<u64>(), 10);+ }++ fn modify_ok() -> ResponseTemplate {+ ResponseTemplate::new(200).set_body_json(json!({ "records": [+ { "recordName": "M", "recordChangeTag": "a" },+ { "recordName": "A", "recordChangeTag": "b" },+ { "recordName": "N", "recordChangeTag": "c" },+ ] }))+ }++ /// The whole write against a stand-in CloudKit: the file uploaded once, then a conflict on+ /// the note (a phone edited it) sends nothing twice by mistake — the note is read again and+ /// the three records go again, atomically, the note over its new version.+ #[tokio::test]+ async fn a_conflict_reads_the_note_again_and_places_it_again() {+ let server = MockServer::start().await;+ let dir = std::env::temp_dir().join(format!("quince-attach-{}", uuid::Uuid::new_v4()));+ std::fs::create_dir_all(&dir).unwrap();+ let file = dir.join("pic.png");+ let mut png = b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR".to_vec();+ png.extend(2u32.to_be_bytes());+ png.extend(3u32.to_be_bytes());+ std::fs::write(&file, &png).unwrap();+ let mut sum = crate::drive::AppleChecksum::default();+ sum.update(&png);+ let checksum = sum.finish();++ let note = |tag: &str, text: &str| {+ json!({ "records": [{ "recordName": "N", "recordType": "Note", "recordChangeTag": tag,+ "fields": { "TextDataEncrypted": { "type": "ENCRYPTED_BYTES",+ "value": crate::ckdocument::text_to_base64(text) },+ "MinimumSupportedNotesVersion": { "type": "INT64", "value": 14 } } }] })+ };+ // Lookups: before the upload, then once per attempt — the second attempt sees the+ // phone's edit.+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(note("t1", "a\nb")))+ .up_to_n_times(2)+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(note("t2", "zz\na\nb")))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/assets/upload$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "tokens": [{+ "recordName": "M", "fieldName": "Asset", "url": format!("{}/put", server.uri()) }] })))+ .expect(1)+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/put$"))+ .respond_with(+ ResponseTemplate::new(200).set_body_json(json!({ "singleFile": {+ "fileChecksum": checksum, "receipt": "R", "referenceChecksum": "RC",+ "size": png.len(), "wrappingKey": "WK" } })),+ )+ .expect(1)+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .respond_with(+ ResponseTemplate::new(200).set_body_json(json!({ "records": [+ { "recordName": "M", "serverErrorCode": "ATOMIC_ERROR", "reason": "atomic" },+ { "recordName": "A", "serverErrorCode": "ATOMIC_ERROR", "reason": "atomic" },+ { "recordName": "N", "serverErrorCode": "CONFLICT", "reason": "oplock" },+ ] })),+ )+ .up_to_n_times(1)+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .respond_with(modify_ok())+ .mount(&server)+ .await;++ let http = reqwest::Client::new();+ let done = attach_file_unguarded(&http, &server.uri(), vec![], "N", &file, Some("a\nb"), 2)+ .await+ .unwrap();+ assert_eq!(done.body, "zz\na\n\u{FFFC}b");+ assert_eq!(done.offset, 5);++ let sent = server.received_requests().await.unwrap();+ let writes: Vec<Value> = sent+ .iter()+ .filter(|r| r.url.path().ends_with("/records/modify"))+ .map(|r| serde_json::from_slice(&r.body).unwrap())+ .collect();+ assert_eq!(writes.len(), 2);+ let last = &writes[1];+ assert_eq!(last["atomic"], true);+ let ops = last["operations"].as_array().unwrap();+ assert_eq!(ops[0]["record"]["recordType"], "Media");+ assert_eq!(ops[0]["record"]["parent"]["recordName"], "N");+ assert_eq!(ops[0]["record"]["fields"]["Asset"]["value"]["receipt"], "R");+ assert_eq!(ops[1]["record"]["recordType"], "Attachment");+ assert_eq!(ops[1]["record"]["fields"]["Width"]["value"], 2.0);+ assert_eq!(+ ops[1]["record"]["fields"]["MinimumSupportedNotesVersion"]["value"],+ 14+ );+ assert_eq!(ops[2]["record"]["recordChangeTag"], "t2");+ // The same records, by the same names, both times: nothing made twice.+ assert_eq!(+ writes[0]["operations"][0]["record"]["recordName"],+ ops[0]["record"]["recordName"]+ );+ assert_eq!(+ writes[0]["operations"][1]["record"]["recordName"],+ ops[1]["record"]["recordName"]+ );+ let _ = std::fs::remove_dir_all(&dir);+ }++ /// Off, nothing is sent at all.+ #[tokio::test]+ async fn switched_off_it_sends_nothing() {+ let server = MockServer::start().await;+ let http = reqwest::Client::new();+ let refused = attach_file_cloudkit(+ &http,+ &server.uri(),+ vec![],+ "N",+ std::path::Path::new("/nonexistent/x.png"),+ None,+ 0,+ )+ .await;+ assert!(matches!(refused, Err(Error::Refused(_))));+ assert!(server.received_requests().await.unwrap().is_empty());+ }+}diff --git a/crates/quince-icloud/src/notes_locked.rs b/crates/quince-icloud/src/notes_locked.rsnew file mode 100644index 0000000..1f23b17--- /dev/null+++ b/crates/quince-icloud/src/notes_locked.rs@@ -0,0 +1,357 @@+//! Password-locked notes (the Notes password, on an account without Advanced Data Protection),+//! opened read-only with the password the person types.+//!+//! The scheme is the one apple_cloud_notes_parser documents for NoteStore and icloud.com uses+//! in the browser: the password and the note's own salt through PBKDF2-HMAC-SHA256 (the+//! note's iteration count, 16 bytes out) give a key-encryption key; that unwraps (AES key+//! wrap, RFC 3394) the note's wrapped key; and that key opens the note's body with AES-GCM,+//! the note's initialization vector (16 bytes — not GCM's usual 12) and its tag. What comes+//! out is the same gzipped document an unlocked note keeps in `TextDataEncrypted`.+//!+//! What was measured, and what was not. On his account two `PasswordProtectedNote_UserSpecific`+//! records exist, and `AccountData` carries `CryptoPassphraseVerifier` and+//! `LockedNotesMode` = 2 — but both notes those records point at are gone (tombstones in the+//! zone walk, not found on lookup), so no live locked note was there to read. The field names+//! below are therefore the documented ones, each also accepted without its `Encrypted`+//! suffix, and a note carrying none of them is said to be locked in a way this cannot open —+//! never guessed at.+//!+//! Read only. Nothing here writes a locked note, and the password is never stored: it is used+//! for the one derivation and dropped (the app keeps it in memory for the session only).++use crate::cloudkit::ZoneClient;+use crate::{Error, Result};+use base64::{engine::general_purpose::STANDARD as B64, Engine};+use serde::Serialize;+use serde_json::Value;++const CONTAINER: &str = "com.apple.notes";+const ZONE: &str = "Notes";++/// The fields a locked note's record carries, each tried with and without `Encrypted`.+const SALT: &str = "CryptoSalt";+const ITERATIONS: &str = "CryptoIterationCount";+const WRAPPED_KEY: &str = "CryptoWrappedKey";+const IV: &str = "CryptoInitializationVector";+const TAG: &str = "CryptoTag";+const HINT: &str = "PasswordHint";+const BODY: &str = "TextDataEncrypted";++/// Bounds on the iteration count a record may ask for: Apple's are in the tens of thousands;+/// a record asking for billions is not one to spend a minute of CPU on.+const MOST_ITERATIONS: u32 = 10_000_000;++/// What a locked note's record holds to open it with.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct Sealed {+ pub salt: Vec<u8>,+ pub iterations: u32,+ pub wrapped_key: Vec<u8>,+ pub iv: Vec<u8>,+ pub tag: Vec<u8>,+ pub ciphertext: Vec<u8>,+}++/// A locked note, opened: its text and formatting, as an unlocked note's are read.+#[derive(Debug, Clone, Serialize, PartialEq)]+#[serde(rename_all = "camelCase")]+pub struct Unlocked {+ pub body: String,+ pub runs: Vec<crate::ckdocument::Run>,+}++/// A bytes field, as `name` + `Encrypted` or as `name`.+fn bytes_of(record: &Value, name: &str) -> Option<Vec<u8>> {+ [format!("{name}Encrypted"), name.to_string()]+ .iter()+ .find_map(|k| record.pointer(&format!("/fields/{k}/value"))?.as_str())+ .and_then(|v| B64.decode(v.trim()).ok())+ .filter(|b| !b.is_empty())+}++fn number_of(record: &Value, name: &str) -> Option<i64> {+ [format!("{name}Encrypted"), name.to_string()]+ .iter()+ .find_map(|k| record.pointer(&format!("/fields/{k}/value"))?.as_i64())+}++/// Whether a note record carries the fields a password-locked note has.+#[must_use]+pub fn is_sealed(record: &Value) -> bool {+ bytes_of(record, WRAPPED_KEY).is_some() && bytes_of(record, SALT).is_some()+}++/// The sealed parts of a locked note's record, or why it cannot be opened here.+pub fn sealed(record: &Value) -> Result<Sealed> {+ let not_here = || {+ Error::Refused(+ "This note is locked in a way Pomander can’t open — open it on an Apple device.".into(),+ )+ };+ if record.pointer(&format!("/fields/{BODY}")).is_none()+ && record.pointer("/fields/TextDataAsset").is_some()+ {+ return Err(Error::Refused(+ "This locked note is too long for Pomander to open yet.".into(),+ ));+ }+ let iterations = number_of(record, ITERATIONS)+ .and_then(|n| u32::try_from(n).ok())+ .filter(|n| (1..=MOST_ITERATIONS).contains(n))+ .ok_or_else(not_here)?;+ Ok(Sealed {+ salt: bytes_of(record, SALT).ok_or_else(not_here)?,+ iterations,+ wrapped_key: bytes_of(record, WRAPPED_KEY).ok_or_else(not_here)?,+ iv: bytes_of(record, IV).ok_or_else(not_here)?,+ tag: bytes_of(record, TAG).ok_or_else(not_here)?,+ ciphertext: record+ .pointer(&format!("/fields/{BODY}/value"))+ .and_then(Value::as_str)+ .and_then(|v| B64.decode(v.trim()).ok())+ .ok_or_else(not_here)?,+ })+}++/// The hint the person left with the password, if there is one.+#[must_use]+pub fn hint(record: &Value) -> Option<String> {+ let bytes = bytes_of(record, HINT)?;+ let text = String::from_utf8(bytes).ok()?;+ let t = text.trim();+ (!t.is_empty()).then(|| t.to_string())+}++fn wrong_password() -> Error {+ Error::Refused("That password didn’t open this note.".into())+}++/// The note's key, unwrapped with the key the password derives.+fn note_key(sealed: &Sealed, password: &str) -> Result<Vec<u8>> {+ let mut kek = [0u8; 16];+ pbkdf2::pbkdf2_hmac::<sha2::Sha256>(+ password.as_bytes(),+ &sealed.salt,+ sealed.iterations,+ &mut kek,+ );+ let wrapped = &sealed.wrapped_key;+ // RFC 3394 output is the key plus 8 bytes; a 16- or 32-byte key is all AES-GCM takes.+ if !matches!(wrapped.len(), 24 | 40) {+ return Err(Error::Protocol(format!(+ "a locked note's wrapped key was {} bytes",+ wrapped.len()+ )));+ }+ let mut key = vec![0u8; wrapped.len() - 8];+ let unwrapped = aes_kw::KekAes128::from(kek).unwrap(wrapped, &mut key);+ kek.fill(0);+ // The unwrap carries its own integrity check: a wrong password fails here.+ unwrapped.map_err(|_| wrong_password())?;+ Ok(key)+}++/// Open the body: the plaintext document (as `TextDataEncrypted` carries an unlocked one).+pub fn decrypt(sealed: &Sealed, password: &str) -> Result<Vec<u8>> {+ use aes_gcm::aead::consts::U16;+ use aes_gcm::aead::{generic_array::GenericArray, AeadInPlace, KeyInit};+ if sealed.iv.len() != 16 || sealed.tag.len() != 16 {+ return Err(Error::Protocol(format!(+ "a locked note's IV/tag were {}/{} bytes, not 16/16",+ sealed.iv.len(),+ sealed.tag.len()+ )));+ }+ let mut key = note_key(sealed, password)?;+ let nonce = GenericArray::from_slice(&sealed.iv);+ let tag = GenericArray::from_slice(&sealed.tag);+ let mut buffer = sealed.ciphertext.clone();+ let opened = match key.len() {+ 16 => aes_gcm::AesGcm::<aes::Aes128, U16>::new_from_slice(&key)+ .map_err(|_| wrong_password())?+ .decrypt_in_place_detached(nonce, b"", &mut buffer, tag),+ _ => aes_gcm::AesGcm::<aes::Aes256, U16>::new_from_slice(&key)+ .map_err(|_| wrong_password())?+ .decrypt_in_place_detached(nonce, b"", &mut buffer, tag),+ };+ key.fill(0);+ opened.map_err(|_| wrong_password())?;+ Ok(buffer)+}++/// A locked note's record opened with `password`: its text and formatting.+pub fn unlock(record: &Value, password: &str) -> Result<Unlocked> {+ let plain = decrypt(&sealed(record)?, password)?;+ let encoded = B64.encode(&plain);+ let body = crate::ckdocument::stored_text_from_base64(&encoded)+ .or_else(|| crate::ckdocument::text_from_bytes(&plain))+ .ok_or_else(|| {+ Error::Protocol("the note opened, but its text is in a shape this can’t read".into())+ })?;+ Ok(Unlocked {+ body,+ runs: crate::ckdocument::runs_from_base64(&encoded),+ })+}++async fn record_of(+ http: &reqwest::Client,+ ckdatabasews_root: &str,+ params: Vec<(String, String)>,+ guid: &str,+) -> Result<Value> {+ ZoneClient::new(http, ckdatabasews_root, CONTAINER, params)+ .lookup_record(ZONE, guid)+ .await?+ .ok_or_else(|| Error::Refused("Apple no longer has that note.".into()))+}++/// Open a locked note as Apple holds it now. Reads only.+pub async fn unlock_cloudkit(+ http: &reqwest::Client,+ ckdatabasews_root: &str,+ params: Vec<(String, String)>,+ guid: &str,+ password: &str,+) -> Result<Unlocked> {+ let record = record_of(http, ckdatabasews_root, params, guid).await?;+ unlock(&record, password)+}++/// A locked note's password hint, as Apple holds it now.+pub async fn hint_cloudkit(+ http: &reqwest::Client,+ ckdatabasews_root: &str,+ params: Vec<(String, String)>,+ guid: &str,+) -> Result<Option<String>> {+ let record = record_of(http, ckdatabasews_root, params, guid).await?;+ Ok(hint(&record))+}++#[cfg(test)]+mod tests {+ use super::*;+ use aes_gcm::aead::consts::U16;+ use aes_gcm::aead::{generic_array::GenericArray, AeadInPlace, KeyInit};+ use serde_json::json;++ fn hex(s: &str) -> Vec<u8> {+ (0..s.len())+ .step_by(2)+ .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())+ .collect()+ }++ /// RFC 3394 §4.1: 128-bit key data with a 128-bit KEK.+ #[test]+ fn key_unwrap_matches_rfc_3394() {+ let kek: [u8; 16] = hex("000102030405060708090A0B0C0D0E0F").try_into().unwrap();+ let wrapped = hex("1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5");+ let mut out = [0u8; 16];+ aes_kw::KekAes128::from(kek)+ .unwrap(&wrapped, &mut out)+ .unwrap();+ assert_eq!(out.to_vec(), hex("00112233445566778899AABBCCDDEEFF"));+ }++ /// RFC 7914 §11: PBKDF2-HMAC-SHA256("passwd", "salt", 1).+ #[test]+ fn pbkdf2_sha256_matches_rfc_7914() {+ let mut out = [0u8; 16];+ pbkdf2::pbkdf2_hmac::<sha2::Sha256>(b"passwd", b"salt", 1, &mut out);+ assert_eq!(out.to_vec(), hex("55ac046e56e3089fec1691c22544b605"));+ }++ /// A locked note built the way Apple builds one: a random note key wrapped under the+ /// password's key, the document sealed with AES-GCM and a 16-byte IV.+ fn seal(password: &str, document: &[u8], iterations: u32) -> Value {+ let salt = b"0123456789abcdef".to_vec();+ let mut kek = [0u8; 16];+ pbkdf2::pbkdf2_hmac::<sha2::Sha256>(password.as_bytes(), &salt, iterations, &mut kek);+ let note_key = hex("8899aabbccddeeff0011223344556677");+ let mut wrapped = [0u8; 24];+ aes_kw::KekAes128::from(kek)+ .wrap(¬e_key, &mut wrapped)+ .unwrap();+ let iv = b"IV-sixteen-bytes".to_vec();+ let mut body = document.to_vec();+ let tag = aes_gcm::AesGcm::<aes::Aes128, U16>::new_from_slice(¬e_key)+ .unwrap()+ .encrypt_in_place_detached(GenericArray::from_slice(&iv), b"", &mut body)+ .unwrap();+ json!({ "recordName": "N", "recordType": "Note", "fields": {+ "CryptoSaltEncrypted": { "type": "ENCRYPTED_BYTES", "value": B64.encode(&salt) },+ "CryptoIterationCount": { "type": "INT64", "value": iterations },+ "CryptoWrappedKeyEncrypted": { "type": "ENCRYPTED_BYTES", "value": B64.encode(wrapped) },+ "CryptoInitializationVectorEncrypted": { "type": "ENCRYPTED_BYTES", "value": B64.encode(&iv) },+ "CryptoTagEncrypted": { "type": "ENCRYPTED_BYTES", "value": B64.encode(tag) },+ "PasswordHintEncrypted": { "type": "ENCRYPTED_BYTES", "value": B64.encode("the dog") },+ "TextDataEncrypted": { "type": "ENCRYPTED_BYTES", "value": B64.encode(&body) },+ } })+ }++ #[test]+ fn the_right_password_opens_the_note() {+ let document = B64+ .decode(crate::ckdocument::text_to_base64("Secret plans\nline two"))+ .unwrap();+ let record = seal("hunter2", &document, 2000);+ assert!(is_sealed(&record));+ let opened = unlock(&record, "hunter2").unwrap();+ assert_eq!(opened.body, "Secret plans\nline two");+ assert_eq!(opened.runs.iter().map(|r| r.length).sum::<u64>(), 21);+ assert_eq!(hint(&record).as_deref(), Some("the dog"));+ }++ #[test]+ fn a_wrong_password_is_refused_in_words() {+ let document = B64.decode(crate::ckdocument::text_to_base64("x")).unwrap();+ let record = seal("hunter2", &document, 1000);+ let err = unlock(&record, "hunter3").unwrap_err().to_string();+ assert!(err.contains("password"), "{err}");+ }++ #[test]+ fn a_tampered_body_is_refused() {+ let document = B64+ .decode(crate::ckdocument::text_to_base64("abc"))+ .unwrap();+ let mut record = seal("pw", &document, 1000);+ let mut body = B64+ .decode(+ record["fields"]["TextDataEncrypted"]["value"]+ .as_str()+ .unwrap(),+ )+ .unwrap();+ body[0] ^= 1;+ record["fields"]["TextDataEncrypted"]["value"] = json!(B64.encode(body));+ assert!(unlock(&record, "pw").is_err());+ }++ /// The field names without `Encrypted` are read too.+ #[test]+ fn plain_field_names_are_read_too() {+ let document = B64.decode(crate::ckdocument::text_to_base64("hi")).unwrap();+ let mut record = seal("pw", &document, 1000);+ let fields = record["fields"].as_object_mut().unwrap();+ for name in [SALT, WRAPPED_KEY, IV, TAG] {+ let v = fields.remove(&format!("{name}Encrypted")).unwrap();+ fields.insert(name.to_string(), v);+ }+ assert_eq!(unlock(&record, "pw").unwrap().body, "hi");+ }++ /// A note with none of the fields (a passcode-locked note, or an unlocked one) is never+ /// guessed at.+ #[test]+ fn a_note_without_the_fields_is_not_guessed_at() {+ let record = json!({ "fields": { "TextDataEncrypted": { "value": "AAAA" } } });+ assert!(!is_sealed(&record));+ assert!(matches!(unlock(&record, "pw"), Err(Error::Refused(_))));+ let mut huge = seal("pw", b"x", 1000);+ huge["fields"]["CryptoIterationCount"]["value"] = json!(4_000_000_000_u64);+ assert!(matches!(unlock(&huge, "pw"), Err(Error::Refused(_))));+ }+}diff --git a/crates/quince-icloud/src/photos.rs b/crates/quince-icloud/src/photos.rsindex 0111297..a46be3c 100644--- a/crates/quince-icloud/src/photos.rs+++ b/crates/quince-icloud/src/photos.rs@@ -11,23 +11,36 @@ use crate::Result;use base64::Engine;use quince_core::photos::{Album, Kind, Photo};use serde_json::Value;-use std::collections::HashMap;+use std::collections::{HashMap, HashSet};pub const CONTAINER: &str = "com.apple.photos.cloud";pub const ZONE: &str = "PrimarySync";/// The library's sync token, in the library's sync state.pub const SERVICE: &str = "photos";-/// What a walk of the zone brought.+/// What one pass of the change feed brought.pub struct PhotosFetch {pub records: Vec<Value>,+ /// Where the next pass carries on from. When the pass did not finish, this is a position+ /// partway through, and the next pass picks up from it rather than starting over.pub token: Option<String>,- /// From a token: only what changed. Without one: everything, and anything not in it is gone.+ /// The position this pass began at, when it began at one Apple took.+ pub from: Option<String>,+ /// From a token: only what changed. Without one (none held, or the one held refused):+ /// a whole read from the beginning, and what it never sees is gone.pub incremental: bool,pub complete: bool,}-/// The change feed from `since` (or from the start).+/// How many pages of the change feed one pass reads (500 records each). A library larger+/// than this is read over several passes, each carrying on where the last stopped.+const PASS_PAGES: usize = 100;++/// One pass of the change feed from `since` (or from the start).+///+/// A `since` that Apple will not read any more (an expired or malformed change token) is+/// dropped and the pass reads from the start instead, and says so: that is a whole read,+/// not a pass over what changed.pub async fn fetch(http: &reqwest::Client,ckdatabasews_root: &str,@@ -35,15 +48,77 @@ pub async fn fetch(since: Option<&str>,) -> Result<PhotosFetch> {let client = ZoneClient::new(http, ckdatabasews_root, CONTAINER, params);- let walk = client.all_records(ZONE, since).await?;+ if let Some(from) = since.map(str::trim).filter(|t| !t.is_empty()) {+ match walk(&client, Some(from)).await {+ Ok((records, token, complete)) => {+ return Ok(PhotosFetch {+ records,+ token,+ from: Some(from.to_string()),+ incremental: true,+ complete,+ })+ }+ Err(e) if refused_token(&e) => {+ quiet!("photos: the change token was refused; reading from the start");+ }+ Err(e) => return Err(e),+ }+ }+ let (records, token, complete) = walk(&client, None).await?;Ok(PhotosFetch {- records: walk.records,- token: walk.token,- incremental: since.is_some(),- complete: walk.complete,+ records,+ token,+ from: None,+ incremental: false,+ complete,})}+/// Whether an error is Apple refusing the change token, rather than anything else.+///+/// The cloudkit layer names a refused continuation `StaleCursor`; an expired token+/// (`CHANGE_TOKEN_EXPIRED`) or a `BAD_REQUEST` about the token comes up as the zone refused,+/// with Apple's words, which speak of the token.+fn refused_token(e: &crate::Error) -> bool {+ match e {+ crate::Error::StaleCursor => true,+ crate::Error::Protocol(text) => {+ let text = text.to_lowercase();+ text.contains("token") || text.contains("continuation")+ }+ _ => false,+ }+}++/// Up to `PASS_PAGES` pages from `since`: the records, where to carry on from, and whether+/// the feed was read to its end.+async fn walk(+ client: &ZoneClient<'_>,+ since: Option<&str>,+) -> Result<(Vec<Value>, Option<String>, bool)> {+ let mut records = Vec::new();+ let mut token = since.map(str::to_string);+ for page_no in 0..PASS_PAGES {+ let page = client.changes(ZONE, token.as_deref()).await?;+ // A token answered with no position at all was not taken: an expired one can come+ // back as the zone's error code alone, which reads as an empty zone.+ if page_no == 0 && since.is_some() && page.sync_token.is_none() {+ return Err(crate::Error::StaleCursor);+ }+ records.extend(page.records);+ token = page.sync_token;+ if !page.more_coming {+ return Ok((records, token, true));+ }+ // "More coming" with no position to carry on from would loop forever.+ if token.is_none() {+ break;+ }+ }+ Ok((records, token, false))+}+/// Where each of a photo's pictures can be downloaded now. They expire: never stored.#[derive(Debug, Clone, Default, PartialEq, Eq)]pub struct Links {@@ -284,18 +359,50 @@ fn with_asset(mut p: Photo, asset: &Value) -> Photo {p}-/// A pass applied to the library: everything replaced on a full pass, merged on an incremental-/// one. Answers how many photos changed, and every master's links seen, for the app to keep.+/// A pass applied to the library, merged in as it comes, so a large library shows as it fills.+///+/// A pass over what changed is only that. A whole read (one from the start, or one carrying+/// on from exactly where the last pass of it stopped) also notes what it saw, and when it+/// reaches the end lets go of whatever it never saw: nothing is pruned on a read that has not+/// finished. Answers how many photos changed, and every master's links seen, for the app to+/// keep.pub fn apply(library: &mut quince_core::Library,fetched: PhotosFetch,+) -> Result<(usize, HashMap<String, Links>)> {+ // One pass is one change: a failure or crash part way leaves the library as it was.+ library.atomically(|library| apply_whole(library, fetched))+}++fn apply_whole(+ library: &mut quince_core::Library,+ fetched: PhotosFetch,) -> Result<(usize, HashMap<String, Links>)> {let PhotosFetch {- records,+ records: fresh,token,+ from,incremental,complete,} = fetched;+ let walking = if incremental {+ let carrying_on = from.is_some() && library.photo_walk_cursor()? == from;+ if !carrying_on {+ library.forget_photo_walk()?;+ }+ carrying_on+ } else {+ library.begin_photo_walk()?;+ library.mark_full_sync(SERVICE)?;+ true+ };+ // What the last pass held back comes first, so this pass's own records win over it.+ let records: Vec<Value> = library+ .photo_walk_held()?+ .iter()+ .filter_map(|r| serde_json::from_str(r).ok())+ .chain(fresh)+ .collect();let mut masters: HashMap<String, &Value> = HashMap::new();let mut assets: Vec<&Value> = Vec::new();let mut gone: Vec<String> = Vec::new();@@ -380,53 +487,79 @@ pub fn apply(.map(|(k, m)| (k.clone(), links_of(m))).collect();let mut photos = Vec::new();+ // Masters an asset in this pass was built from, and assets whose master is not here yet.+ let mut used: HashSet<&str> = HashSet::new();+ let mut waiting: Vec<&Value> = Vec::new();for a in assets {let master = a.pointer("/fields/masterRef/value/recordName").and_then(Value::as_str);- let built = match master.and_then(|m| masters.get(m)) {- Some(m) => photo_of(a, m),+ let built = match master.and_then(|m| masters.get(m).map(|r| (m, r))) {+ Some((name, m)) => {+ used.insert(name);+ photo_of(a, m)+ }// Only the asset changed: its flags laid over the photo already known.None => field::record_name(a).and_then(|id| library.photo(&id).ok().flatten()).map(|p| with_asset(p, a)),};- if let Some(p) = built {- photos.push(p);+ match built {+ Some(p) => photos.push(p),+ None if master.is_some() => waiting.push(a),+ None => {}}}let changed = photos.len() + gone.len();- if incremental {- library.put_photos(&photos)?;- library.forget_photos(&gone)?;- library.put_album_items(&in_albums)?;- library.forget_album_items(&out_of_albums)?;- if albums_seen {- let mut all = library.albums()?;- all.retain(|a| !albums_touched.contains(&a.id) && !gone.contains(&a.id));- for id in albums_touched.iter().chain(&gone) {- if !albums.iter().any(|b| &b.id == id) {- library.forget_album(id)?;- }+ library.put_photos(&photos)?;+ library.forget_photos(&gone)?;+ library.put_album_items(&in_albums)?;+ library.forget_album_items(&out_of_albums)?;+ let album_ids: Vec<String> = albums.iter().map(|a| a.id.clone()).collect();+ let mut all = library.albums()?;+ let known: HashSet<String> = all.iter().map(|a| a.id.clone()).collect();+ let gone_albums: HashSet<&String> = gone.iter().filter(|g| known.contains(*g)).collect();+ if albums_seen || !gone_albums.is_empty() {+ all.retain(|a| !albums_touched.contains(&a.id) && !gone_albums.contains(&a.id));+ for id in albums_touched.iter().chain(gone_albums.iter().copied()) {+ if !album_ids.contains(id) {+ library.forget_album(id)?;}- all.extend(albums);- library.replace_albums(&all)?;- library.forget_orphan_albums()?;}- } else if complete {- // A full pass that finished is the whole truth; one that stopped early is not, and- // pruning on it would drop photos that are fine.- library.replace_photos(&photos)?;- library.replace_albums(&albums)?;- library.replace_album_items(&in_albums)?;+ all.extend(albums);+ library.replace_albums(&all)?;library.forget_orphan_albums()?;- } else {- library.put_photos(&photos)?;- library.put_album_items(&in_albums)?;}- if complete {- library.mark_synced(SERVICE, token.as_deref())?;+ if walking {+ let seen: Vec<String> = photos.iter().map(|p| p.id.clone()).collect();+ let items: Vec<(String, String)> = in_albums+ .iter()+ .map(|(album, asset, _)| (album.clone(), asset.clone()))+ .collect();+ let carry_on_from = if complete { None } else { token.as_deref() };+ library.note_photo_walk(&seen, &album_ids, &items, carry_on_from)?;+ if complete {+ library.finish_photo_walk()?;+ library.forget_orphan_albums()?;+ }}+ // An asset and its master split across the end of an unfinished pass: the half that came+ // is held for the next pass, where the other half is.+ let mut held: Vec<(String, String)> = Vec::new();+ if !complete {+ let unused = masters+ .iter()+ .filter(|(name, _)| !used.contains(name.as_str()))+ .map(|(_, r)| *r);+ for r in unused.chain(waiting) {+ if let Some(name) = field::record_name(r) {+ held.push((name, r.to_string()));+ }+ }+ }+ library.hold_for_photo_walk(&held)?;+ // Unfinished, this is where the next pass carries on from, so each pass gets further.+ library.mark_synced(SERVICE, token.as_deref())?;Ok((changed, links))}@@ -1154,6 +1287,35 @@ mod tests {/// A full pass replaces the library; a later asset-only change (deleted) is laid over the/// photo already known; an expunged asset goes.+ /// A pass that fails as it stores its position — its last write, standing in for a crash+ /// part way — stores none of the photos it had already put in.+ #[test]+ fn a_pass_that_fails_part_way_stores_none_of_itself() {+ let mut lib = quince_core::Library::in_memory().unwrap();+ lib.conn()+ .execute_batch(+ "CREATE TEMP TRIGGER crash_i BEFORE INSERT ON main.sync_state+ BEGIN SELECT RAISE(ABORT, 'crash mid-apply'); END;+ CREATE TEMP TRIGGER crash_u BEFORE UPDATE ON main.sync_state+ BEGIN SELECT RAISE(ABORT, 'crash mid-apply'); END;",+ )+ .unwrap();+ let pass = PhotosFetch {+ records: vec![master(), asset(json!({}))],+ token: Some("T1".into()),+ from: None,+ incremental: false,+ complete: true,+ };+ assert!(apply(&mut lib, pass).is_err());+ assert!(lib+ .photos(quince_core::photos::View::Library)+ .unwrap()+ .is_empty());+ assert_eq!(lib.sync_token(SERVICE).unwrap(), None);+ assert!(lib.conn().is_autocommit());+ }+#[test]fn passes_build_and_keep_the_library() {let mut lib = quince_core::Library::in_memory().unwrap();@@ -1164,6 +1326,7 @@ mod tests {json!({"recordName": "A1-IN-AL", "recordType": "CPLContainerRelation", "fields": {"containerId": {"value": "AL"}, "itemId": {"value": "A1"}, "position": {"value": 1024}}}),],token: Some("T1".into()),+ from: None,incremental: false,complete: true,};@@ -1177,6 +1340,7 @@ mod tests {let change = PhotosFetch {records: vec![asset(json!({"isDeleted": 1}))],token: Some("T2".into()),+ from: None,incremental: true,complete: true,};@@ -1197,6 +1361,7 @@ mod tests {let expunged = PhotosFetch {records: vec![json!({"recordName": "A1", "deleted": true})],token: Some("T3".into()),+ from: None,incremental: true,complete: true,};@@ -1219,6 +1384,7 @@ mod tests {let pass = |records, incremental| PhotosFetch {records,token: Some("T".into()),+ from: None,incremental,complete: true,};@@ -1263,6 +1429,7 @@ mod tests {let pass = |records, incremental| PhotosFetch {records,token: Some("T".into()),+ from: None,incremental,complete: true,};@@ -1364,6 +1531,7 @@ mod tests {let pass = |records, incremental| PhotosFetch {records,token: Some("T".into()),+ from: None,incremental,complete: true,};@@ -1504,4 +1672,252 @@ mod tests {assert_eq!(modifies.len(), 1);assert!(!String::from_utf8_lossy(&modifies[0].body).contains("KEPT"));}++ fn master_named(name: &str) -> Value {+ let mut m = master();+ m["recordName"] = json!(name);+ m+ }++ fn asset_named(name: &str, master: &str) -> Value {+ let mut a = asset(json!({}));+ a["recordName"] = json!(name);+ a["fields"]["masterRef"] = json!({"value": {"recordName": master}});+ a+ }++ fn ids(lib: &quince_core::Library) -> Vec<String> {+ let mut ids: Vec<String> = lib+ .photos(quince_core::photos::View::Library)+ .unwrap()+ .into_iter()+ .map(|p| p.id)+ .collect();+ ids.sort();+ ids+ }++ /// A library too large for one pass is read over several: each pass is stored as it+ /// comes and the next carries on from where it stopped, an asset whose master fell in+ /// the other pass is still made whole, and only once the read reaches the end is what it+ /// never saw let go.+ #[test]+ fn a_large_library_is_read_over_several_passes() {+ let mut lib = quince_core::Library::in_memory().unwrap();+ let before = |records| PhotosFetch {+ records,+ token: Some("T0".into()),+ from: None,+ incremental: false,+ complete: true,+ };+ apply(+ &mut lib,+ before(vec![master_named("MX"), asset_named("AX", "MX")]),+ )+ .unwrap();+ assert_eq!(ids(&lib), ["AX"]);++ // The daily whole read begins, and stops partway with a master's asset still to come.+ let first = PhotosFetch {+ records: vec![+ master_named("M1"),+ asset_named("A1", "M1"),+ master_named("M2"),+ ],+ token: Some("C1".into()),+ from: None,+ incremental: false,+ complete: false,+ };+ apply(&mut lib, first).unwrap();+ assert_eq!(+ ids(&lib),+ ["A1", "AX"],+ "seen so far shows; nothing pruned yet"+ );+ assert_eq!(+ lib.sync_token(SERVICE).unwrap().as_deref(),+ Some("C1"),+ "the next pass carries on from here"+ );++ let second = PhotosFetch {+ records: vec![asset_named("A2", "M2")],+ token: Some("T1".into()),+ from: Some("C1".into()),+ incremental: true,+ complete: true,+ };+ apply(&mut lib, second).unwrap();+ assert_eq!(+ ids(&lib),+ ["A1", "A2"],+ "the split photo is whole; the one the read never saw is gone"+ );+ assert_eq!(lib.sync_token(SERVICE).unwrap().as_deref(), Some("T1"));+ assert_eq!(+ lib.photo("A2").unwrap().unwrap().filename.as_deref(),+ Some("IMG_0001.JPG")+ );++ // An ordinary pass afterwards prunes nothing.+ let after = PhotosFetch {+ records: vec![master_named("M3"), asset_named("A3", "M3")],+ token: Some("T2".into()),+ from: Some("T1".into()),+ incremental: true,+ complete: true,+ };+ apply(&mut lib, after).unwrap();+ assert_eq!(ids(&lib), ["A1", "A2", "A3"]);+ }++ /// A pass over what changed that is too long for one pass keeps its place too, rather+ /// than reading the same pages again next time; and it is never taken for a whole read.+ #[test]+ fn a_long_pass_over_changes_keeps_its_place() {+ let mut lib = quince_core::Library::in_memory().unwrap();+ let whole = PhotosFetch {+ records: vec![master_named("M1"), asset_named("A1", "M1")],+ token: Some("T0".into()),+ from: None,+ incremental: false,+ complete: true,+ };+ apply(&mut lib, whole).unwrap();+ let part = PhotosFetch {+ records: vec![master_named("M2"), asset_named("A2", "M2")],+ token: Some("C1".into()),+ from: Some("T0".into()),+ incremental: true,+ complete: false,+ };+ apply(&mut lib, part).unwrap();+ assert_eq!(lib.sync_token(SERVICE).unwrap().as_deref(), Some("C1"));+ let rest = PhotosFetch {+ records: vec![],+ token: Some("T1".into()),+ from: Some("C1".into()),+ incremental: true,+ complete: true,+ };+ apply(&mut lib, rest).unwrap();+ assert_eq!(ids(&lib), ["A1", "A2"], "nothing pruned");+ }++ fn zone_reply(zone: Value) -> wiremock::ResponseTemplate {+ wiremock::ResponseTemplate::new(200).set_body_json(json!({ "zones": [zone] }))+ }++ /// The whole library as Apple answers a walk from the start.+ async fn library_server(refusal: Value) -> wiremock::MockServer {+ use wiremock::matchers::{body_string_contains, method, path_regex};+ use wiremock::{Mock, MockServer};+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .and(body_string_contains("old-token"))+ .respond_with(zone_reply(refusal))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .respond_with(zone_reply(json!({+ "records": [master_named("M1"), asset_named("A1", "M1"),+ master_named("M2"), asset_named("A2", "M2")],+ "syncToken": "fresh",+ "moreComing": false+ })))+ .mount(&server)+ .await;+ server+ }++ /// A change token Apple will no longer read (expired, or refused as a bad request) is+ /// dropped and the library read whole: not taken as "nothing changed", and nothing it+ /// still has deleted.+ #[tokio::test]+ async fn a_refused_change_token_reads_the_library_whole() {+ let refusals = [+ json!({"serverErrorCode": "CHANGE_TOKEN_EXPIRED", "reason": "change token expired"}),+ json!({"serverErrorCode": "CHANGE_TOKEN_EXPIRED"}),+ json!({"serverErrorCode": "BAD_REQUEST", "reason": "Unknown sync continuation type"}),+ json!({"serverErrorCode": "BAD_REQUEST", "reason": "Invalid sync token"}),+ ];+ for refusal in refusals {+ let server = library_server(refusal.clone()).await;+ let http = reqwest::Client::new();+ let fetched = fetch(&http, &server.uri(), vec![], Some("old-token"))+ .await+ .unwrap_or_else(|e| panic!("{refusal}: a refused token is recovered from: {e}"));+ assert!(+ !fetched.incremental,+ "{refusal}: a whole read, not a pass over changes"+ );+ assert!(fetched.from.is_none() && fetched.complete);+ assert_eq!(fetched.token.as_deref(), Some("fresh"));++ let mut lib = quince_core::Library::in_memory().unwrap();+ let had = PhotosFetch {+ records: vec![+ master_named("M1"),+ asset_named("A1", "M1"),+ master_named("MX"),+ asset_named("AX", "MX"),+ ],+ token: Some("old-token".into()),+ from: None,+ incremental: false,+ complete: true,+ };+ apply(&mut lib, had).unwrap();+ let (changed, _) = apply(&mut lib, fetched).unwrap();+ assert_eq!(changed, 2, "{refusal}: not reported as nothing changed");+ assert_eq!(+ ids(&lib),+ ["A1", "A2"],+ "{refusal}: kept, added, and only the gone one pruned"+ );+ assert_eq!(lib.sync_token(SERVICE).unwrap().as_deref(), Some("fresh"));+ }+ }++ /// Other trouble is not mistaken for a refused token.+ #[tokio::test]+ async fn other_trouble_is_not_a_refused_token() {+ let server = library_server(+ json!({"serverErrorCode": "QUOTA_EXCEEDED", "reason": "Quota exceeded"}),+ )+ .await;+ let http = reqwest::Client::new();+ assert!(fetch(&http, &server.uri(), vec![], Some("old-token"))+ .await+ .is_err());+ }++ /// One pass reads at most `PASS_PAGES` pages and says where it got to, so the next+ /// carries on from there instead of starting over.+ #[tokio::test]+ async fn a_pass_stops_at_its_budget_and_says_where() {+ use wiremock::matchers::{method, path_regex};+ use wiremock::{Mock, MockServer};+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone"))+ .respond_with(zone_reply(json!({+ "records": [master_named("M1")], "syncToken": "further", "moreComing": true+ })))+ .mount(&server)+ .await;+ let http = reqwest::Client::new();+ let fetched = fetch(&http, &server.uri(), vec![], None).await.unwrap();+ assert!(!fetched.complete);+ assert_eq!(fetched.token.as_deref(), Some("further"));+ assert_eq!(fetched.records.len(), PASS_PAGES);+ let again = fetch(&http, &server.uri(), vec![], Some("further"))+ .await+ .unwrap();+ assert!(again.incremental && again.from.as_deref() == Some("further"));+ }}diff --git a/crates/quince-icloud/src/reminders.rs b/crates/quince-icloud/src/reminders.rsindex 8eb69c8..8b5d3ef 100644--- a/crates/quince-icloud/src/reminders.rs+++ b/crates/quince-icloud/src/reminders.rs@@ -391,6 +391,10 @@ mod tests {use crate::cloudkit::{field, ZoneClient};+/// Tags, links, early alerts, smart lists and section moves.+#[path = "reminders_details.rs"]+pub mod details;+const CONTAINER: &str = "com.apple.reminders";const ZONE: &str = "Reminders";@@ -771,6 +775,7 @@ pub async fn fetch_cloudkit() -> Result<RemindersFetch> {let client = ZoneClient::new(http, ckdatabasews_root, CONTAINER, params);let walk = client.all_records(ZONE, since).await?;+ let whole = walk.whole();let memberships = fetch_memberships(http, &walk.records).await;Ok(RemindersFetch {memberships,@@ -778,7 +783,9 @@ pub async fn fetch_cloudkit(token: walk.token,// A walk that stopped at its page cap saw only part of the zone, so it cannot be// treated as the whole truth however it was asked for.- incremental: since.is_some() || !walk.complete,+ // A cursor Apple refused (expired) started the walk over from the beginning: that+ // walk is the whole zone, and rows deleted while the cursor sat unused are pruned by it.+ incremental: !whole,})}@@ -786,6 +793,14 @@ pub async fn fetch_cloudkit(pub fn apply_cloudkit(library: &mut quince_core::Library,fetched: RemindersFetch,+) -> Result<(usize, usize, Option<String>)> {+ // One pass is one change: a failure or crash part way leaves the library as it was.+ library.atomically(|library| apply_cloudkit_whole(library, fetched))+}++fn apply_cloudkit_whole(+ library: &mut quince_core::Library,+ fetched: RemindersFetch,) -> Result<(usize, usize, Option<String>)> {let RemindersFetch {records,@@ -811,6 +826,11 @@ pub fn apply_cloudkit(let mut rules: std::collections::HashMap<String, (i64, i64)> = std::collections::HashMap::new();// Reminders whose record lists repeat rules, whether or not the rules came in this pass.let mut with_rules: std::collections::HashSet<String> = std::collections::HashSet::new();+ // Tags, links, early alerts and smart lists, stored after the reminders they hang off.+ let mut details = quince_core::reminders::ReminderDetailsPass {+ whole: !incremental,+ ..Default::default()+ };for record in &records {let Some(name) = field::record_name(record) else {@@ -832,6 +852,7 @@ pub fn apply_cloudkit(gone_reminders.push(name.clone());gone_sections.push(name.clone());gone_alarms.push(name.clone());+ details.gone.push(name.clone());gone_lists.push(name);}continue;@@ -850,8 +871,22 @@ pub fn apply_cloudkit(with_rules.insert(name.clone());}reminders.extend(reminder_from_record(record));+ let (account, alerts) = details::early_alerts_from_record(record);+ details.early_alerts.push((name, account, alerts));}}+ "Hashtag" => match (removed, details::hashtag_from_record(record)) {+ (false, Some(tag)) => details.hashtags.push(tag),+ _ => details.gone.push(name),+ },+ "Attachment" => match (removed, details::attachment_from_record(record)) {+ (false, Some(a)) => details.attachments.push(a),+ _ => details.gone.push(name),+ },+ "SmartList" => match (removed, details::smart_list_from_record(record)) {+ (false, Some(list)) => details.smart_lists.push(list),+ _ => details.gone.push(name),+ },// Only List records are the lists people made. ListSection is a heading inside// one, and SmartList is a built-in filter — Today, Scheduled, Flagged — which// carries a SmartListType instead of a Name and appeared as phantom entries@@ -1051,6 +1086,8 @@ pub fn apply_cloudkit(let keep: Vec<String> = reminders.iter().map(|r| r.guid.clone()).collect();library.retain_reminders(&keep)?;}+ // After the prune above, so a reminder gone takes its details with it in this same pass.+ library.put_reminder_details(&details)?;library.mark_synced("reminders", token.as_deref())?;Ok((lists.len(), reminders.len(), token))}@@ -1175,11 +1212,55 @@ pub async fn create_cloudkit());}- let client = ZoneClient::new(http, ckdatabasews_root, CONTAINER, params);- let record_name = format!(+ let record_name = new_reminder_name();+ create_cloudkit_named(+ http,+ ckdatabasews_root,+ params,+ &record_name,+ list_guid,+ title,+ )+ .await?;+ Ok(record_name)+}++/// A record name for a reminder made here, chosen before it is sent — so the same name can be+/// shown at once, queued, and sent again without making a second.+pub fn new_reminder_name() -> String {+ format!("Reminder/{}",uuid::Uuid::new_v4().to_string().to_uppercase()- );+ )+}++/// [`create_cloudkit`] under a name chosen beforehand, exactly once: sent again — the answer+/// lost, the app closed before it heard, a queue replayed — a reminder Apple already holds+/// under that name is left as it is, not made twice.+pub async fn create_cloudkit_named(+ http: &reqwest::Client,+ ckdatabasews_root: &str,+ params: Vec<(String, String)>,+ record_name: &str,+ list_guid: &str,+ title: &str,+) -> Result<()> {+ let title = title.trim();+ if title.is_empty() {+ return Err(Error::Protocol("a reminder needs a title".into()));+ }+ if list_guid.trim().is_empty() {+ return Err(Error::Protocol(+ "a reminder has to go in a list, and this account has none yet".into(),+ ));+ }+ let client = ZoneClient::new(http, ckdatabasews_root, CONTAINER, params);+ if client.lookup_record(ZONE, record_name).await?.is_some() {+ // Made already; its place in the list is made sure of (adding twice adds once).+ let _ = place_in_list(&client, list_guid, record_name, None).await;+ return Ok(());+ }+ let record_name = record_name.to_string();let stamp = now_millis();client@@ -1207,7 +1288,7 @@ pub async fn create_cloudkit(// failure here costs its place in the order, never the reminder.let _ = place_in_list(&client, list_guid, &record_name, None).await;- Ok(record_name)+ Ok(())}/// Add a reminder to the end of a list's `ReminderIDs`, and take it out of the list it left.@@ -2208,6 +2289,50 @@ mod incremental_tests {.unwrap();assert!(library.reminders_in("List/a", true).unwrap().is_empty());}++ /// A change token Apple has expired — sent as the bare code — is a full read, not+ /// "nothing changed": the pass starts over, takes the new token, and prunes what was+ /// deleted while the token sat unused (its tombstone long gone).+ #[tokio::test]+ async fn an_expired_token_is_a_full_read_that_prunes() {+ let http = reqwest::Client::new();+ let mut library = Library::in_memory().unwrap();+ let first = serve(json!({ "zones": [{+ "records": [list("List/a", "GYM"), reminder("Reminder/1", "Squats"),+ reminder("Reminder/2", "Deadlifts")],+ "syncToken": "t1", "moreComing": false }] }))+ .await;+ sync_cloudkit(&http, &first.uri(), vec![], &mut library, None)+ .await+ .unwrap();++ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone$"))+ .and(wiremock::matchers::body_string_contains("\"t1\""))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "zones": [{+ "zoneID": { "zoneName": "Reminders" },+ "serverErrorCode": "CHANGE_TOKEN_EXPIRED" }] })))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/changes/zone$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "zones": [{+ "records": [list("List/a", "GYM"), reminder("Reminder/1", "Squats")],+ "syncToken": "t9", "moreComing": false }] })))+ .mount(&server)+ .await;+ let (_, _, token) = sync_cloudkit(&http, &server.uri(), vec![], &mut library, Some("t1"))+ .await+ .unwrap();+ assert_eq!(token.as_deref(), Some("t9"), "the fresh token is kept");+ let left = library.reminders_in("List/a", true).unwrap();+ assert_eq!(+ left.iter().map(|r| r.guid.as_str()).collect::<Vec<_>>(),+ vec!["Reminder/1"],+ "deleted while the token sat unused, it is pruned by the full read"+ );+ }}#[cfg(test)]@@ -2313,8 +2438,10 @@ mod write_tests {"the caller needs the record name: {name}");- let sent: Value =- serde_json::from_slice(&server.received_requests().await.unwrap()[0].body).unwrap();+ // Asked first whether the name is taken (a create sent again makes nothing more).+ let requests = server.received_requests().await.unwrap();+ assert!(requests[0].url.path().ends_with("/records/lookup"));+ let sent: Value = serde_json::from_slice(&requests[1].body).unwrap();let record = &sent["operations"][0]["record"];assert_eq!(sent["operations"][0]["operationType"], "create");assert_eq!(record["recordType"], "Reminder");@@ -2332,6 +2459,53 @@ mod write_tests {);}+ /// Sent again under the same name — the answer lost, or a queue replayed after a crash —+ /// a reminder Apple already holds is not made a second time.+ #[tokio::test]+ async fn a_create_sent_again_makes_nothing_more() {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "records": [{ "recordName": "Reminder/ONCE", "recordType": "Reminder",+ "recordChangeTag": "t1", "fields": {} }]+ })))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .respond_with(+ ResponseTemplate::new(200)+ .set_body_json(json!({ "records": [{ "recordName": "x" }] })),+ )+ .mount(&server)+ .await;+ let http = reqwest::Client::new();+ create_cloudkit_named(+ &http,+ &server.uri(),+ vec![],+ "Reminder/ONCE",+ "List/abc",+ "Once",+ )+ .await+ .unwrap();+ let creates = server+ .received_requests()+ .await+ .unwrap()+ .iter()+ .filter(|r| {+ serde_json::from_slice::<Value>(&r.body)+ .ok()+ .and_then(|b| b.pointer("/operations/0/operationType").cloned())+ == Some(json!("create"))+ })+ .count();+ assert_eq!(creates, 0, "already at Apple: no second create");+ }+#[tokio::test]async fn an_empty_title_is_refused_before_any_request() {let server = accepting().await;@@ -4774,3 +4948,61 @@ mod list_order_write_tests {);}}++#[cfg(test)]+mod atomic_apply_tests {+ use super::*;+ use serde_json::json;++ /// A pass that fails as it stores its position — its last write, standing in for a crash+ /// part way — leaves every reminder it had already removed or stored as it was.+ #[test]+ fn a_pass_that_fails_part_way_stores_none_of_itself() {+ let mut library = quince_core::Library::in_memory().unwrap();+ library+ .put_reminder_lists(&[ReminderList {+ guid: "List/a".into(),+ title: "A".into(),+ enabled: true,+ ..Default::default()+ }])+ .unwrap();+ library+ .put_reminders(&[Reminder {+ guid: "Reminder/1".into(),+ list_guid: "List/a".into(),+ title: "Kept".into(),+ ..Default::default()+ }])+ .unwrap();+ library.mark_synced("reminders", Some("old")).unwrap();+ library+ .conn()+ .execute_batch(+ "CREATE TEMP TRIGGER crash_i BEFORE INSERT ON main.sync_state+ BEGIN SELECT RAISE(ABORT, 'crash mid-apply'); END;+ CREATE TEMP TRIGGER crash_u BEFORE UPDATE ON main.sync_state+ BEGIN SELECT RAISE(ABORT, 'crash mid-apply'); END;",+ )+ .unwrap();+ let failed = apply_cloudkit(+ &mut library,+ RemindersFetch {+ memberships: std::collections::HashMap::new(),+ records: vec![json!({ "recordName": "Reminder/1", "deleted": true })],+ token: Some("new".into()),+ incremental: true,+ },+ );+ assert!(failed.is_err());+ assert!(+ library.reminder("Reminder/1").unwrap().is_some(),+ "the removal rolled back with the rest"+ );+ assert_eq!(+ library.sync_token("reminders").unwrap().as_deref(),+ Some("old")+ );+ assert!(library.conn().is_autocommit());+ }+}diff --git a/crates/quince-icloud/src/reminders_details.rs b/crates/quince-icloud/src/reminders_details.rsnew file mode 100644index 0000000..8c52ebe--- /dev/null+++ b/crates/quince-icloud/src/reminders_details.rs@@ -0,0 +1,1402 @@+//! Reminder details beyond the reminder record's own fields: tags, a link, early alerts,+//! custom smart lists, and moving a reminder between a list's sections.+//!+//! What Apple's records look like, read from a real account (842 reminders) and from+//! icloud.com's own Reminders bundle:+//!+//! - **Tags.** A `Hashtag` record (`Hashtag/<UUID>`: `Name`, `Reminder` reference, `Deleted`),+//! one per tag per reminder. The reminder lists the bare ids in `HashtagIDs`. There is no+//! account-wide tag record (`HashtagLabel` is not a record type): the tags on the account are+//! the names across its live `Hashtag` records. `Name` carries no `#`.+//! - **URL.** An `Attachment` record (`Attachment/<UUID>`: `Type` "URL", `UTI`, `URL` as+//! base64 bytes, `Reminder` reference), listed by bare id in the reminder's `AttachmentIDs`.+//! `File` and `Image` attachments are the same record with a file asset instead.+//! - **Early alert.** JSON in the reminder's own `DueDateDeltaAlertsData` (ENCRYPTED_BYTES):+//! `{accountIdentifier, reminderIdentifier, minimumSupportedVersion: 20230430,+//! dueDateDeltaAlerts: [{identifier, dueDateDeltaCount: -30, dueDateDeltaUnit: 0,+//! creationDate, minimumSupportedAppVersion: 0}]}` — 49 reminders carry one, all "30 early".+//! - **Smart lists.** `SmartList` records: built-in ones carry only `SmartListType`+//! (`com.apple.reminders.smartlist.today`, `.flagged`, `.assigned`…); a custom one also+//! `Name`, `Color`, `BadgeEmblem` and `FilterData`, JSON such as `{"priorities":["medium"]}`.+//! - **Sections.** `ListSection` records (`DisplayName`, `List`, `CreationDate`); which reminder+//! sits in which is the list's `MembershipsOfRemindersInSectionsAsData` file —+//! `{minimumSupportedVersion, memberships: [{memberID, groupID?, modifiedOn}]}`, an entry with+//! no `groupID` being a reminder taken out of every section — beside a+//! `MembershipsOfRemindersInSectionsChecksum` whose token is what devices merge on.+//!+//! Every write here is behind [`REMINDER_DETAIL_WRITES`].++use crate::cloudkit::{field, ZoneClient};+use crate::{Error, Result};+use base64::{engine::general_purpose::STANDARD as B64, Engine};+use quince_core::reminders::{+ EarlyAlert, ReminderAttachment, ReminderHashtag, ReminderSection, ReminderSmartList,+};+use serde_json::{json, Value};++const CONTAINER: &str = "com.apple.reminders";+const ZONE: &str = "Reminders";++/// Writes of tags, links, early alerts and sections stay off until each has been tried once,+/// supervised, against a real account and seen to arrive on a phone as written. Until then+/// every write function refuses before touching the network. Reading is unaffected.+pub const REMINDER_DETAIL_WRITES: bool = false;++/// The version Apple writes into each of these JSON blobs, as measured.+const MINIMUM_SUPPORTED_VERSION: i64 = 20_230_430;++/// Seconds between the Unix epoch and Apple's.+const APPLE_EPOCH: f64 = 978_307_200.0;++fn gate(enabled: bool) -> Result<()> {+ if enabled {+ Ok(())+ } else {+ Err(Error::Refused(+ "Pomander can't change this yet: writing it is still being checked against Apple's apps."+ .into(),+ ))+ }+}++fn writes() -> Result<()> {+ gate(REMINDER_DETAIL_WRITES || cfg!(test))+}++fn apple_now() -> f64 {+ std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .map_or(0.0, |d| d.as_secs_f64())+ - APPLE_EPOCH+}++fn now_millis() -> i64 {+ std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .map_or(0, |d| i64::try_from(d.as_millis()).unwrap_or(i64::MAX))+}++fn bare(name: &str) -> &str {+ name.rsplit('/').next().unwrap_or(name)+}++fn new_id() -> String {+ uuid::Uuid::new_v4().to_string().to_uppercase()+}++fn deleted(record: &Value) -> bool {+ field::flag(record, "Deleted")+ || record+ .get("deleted")+ .and_then(Value::as_bool)+ .unwrap_or(false)+}++/// A string field that may be plain or base64 bytes (`URL` is bytes on icloud.com's model).+fn text_or_bytes(record: &Value, name: &str) -> Option<String> {+ let v = record.pointer(&format!("/fields/{name}"))?;+ let raw = v.get("value")?.as_str()?;+ let is_bytes = v+ .get("type")+ .and_then(Value::as_str)+ .is_some_and(|t| t.ends_with("BYTES"));+ if is_bytes {+ B64.decode(raw.trim())+ .ok()+ .and_then(|b| String::from_utf8(b).ok())+ } else {+ Some(raw.to_string())+ }+}++/// A record's list of bare ids, such as `HashtagIDs`; `EMPTY_LIST` and absence are empty.+#[must_use]+pub fn id_list(record: &Value, name: &str) -> Vec<String> {+ record+ .pointer(&format!("/fields/{name}/value"))+ .and_then(Value::as_array)+ .map(|ids| {+ ids.iter()+ .filter_map(|v| v.as_str().map(ToString::to_string))+ .collect()+ })+ .unwrap_or_default()+}++// ---------------------------------------------------------------------------------------+// Reading+// ---------------------------------------------------------------------------------------++/// A live `Hashtag` record as a tag, or `None`.+#[must_use]+pub fn hashtag_from_record(record: &Value) -> Option<ReminderHashtag> {+ if deleted(record) {+ return None;+ }+ let name = field::string(record, "Name")?;+ let name = name.trim().trim_start_matches('#').trim().to_string();+ (!name.is_empty()).then_some(())?;+ Some(ReminderHashtag {+ guid: field::record_name(record)?,+ reminder_guid: field::reference(record, "Reminder")?,+ name,+ })+}++/// A live `Attachment` record, its link read where it is a URL one.+#[must_use]+pub fn attachment_from_record(record: &Value) -> Option<ReminderAttachment> {+ if deleted(record) {+ return None;+ }+ let kind = field::string(record, "Type").unwrap_or_else(|| "File".into());+ Some(ReminderAttachment {+ guid: field::record_name(record)?,+ reminder_guid: field::reference(record, "Reminder")?,+ url: (kind == "URL")+ .then(|| text_or_bytes(record, "URL"))+ .flatten()+ .map(|u| u.trim().to_string())+ .filter(|u| !u.is_empty()),+ uti: field::string(record, "UTI"),+ kind,+ })+}++/// A reminder's early alerts and the account id Apple writes beside them. A reminder with+/// none, or a blob that does not read, has none.+#[must_use]+pub fn early_alerts_from_record(record: &Value) -> (Option<String>, Vec<EarlyAlert>) {+ let Some(blob) = early_alert_blob(record) else {+ return (None, Vec::new());+ };+ let account = blob+ .get("accountIdentifier")+ .and_then(Value::as_str)+ .map(ToString::to_string);+ let alerts = blob+ .get("dueDateDeltaAlerts")+ .and_then(Value::as_array)+ .map(|alerts| {+ alerts+ .iter()+ .filter_map(|a| {+ Some(EarlyAlert {+ id: a.get("identifier")?.as_str()?.to_string(),+ count: a.get("dueDateDeltaCount")?.as_i64()?.abs(),+ unit: a.get("dueDateDeltaUnit")?.as_i64()?,+ })+ })+ .collect()+ })+ .unwrap_or_default();+ (account, alerts)+}++fn early_alert_blob(record: &Value) -> Option<Value> {+ let raw = field::string(record, "DueDateDeltaAlertsData")?;+ let bytes = B64.decode(raw.trim()).ok()?;+ serde_json::from_slice(&bytes).ok()+}++/// A `SmartList` record, built-in or custom, or `None` once deleted.+#[must_use]+pub fn smart_list_from_record(record: &Value) -> Option<ReminderSmartList> {+ if deleted(record) {+ return None;+ }+ let kind = field::string(record, "SmartListType")?;+ let kind = kind.rsplit('.').next().unwrap_or(&kind).to_string();+ let filter = field::string(record, "FilterData")+ .and_then(|b| B64.decode(b.trim()).ok())+ .and_then(|b| String::from_utf8(b).ok());+ Some(ReminderSmartList {+ guid: field::record_name(record)?,+ kind,+ title: field::string(record, "Name"),+ colour: field::string(record, "Color").and_then(|c| {+ serde_json::from_str::<Value>(&c)+ .ok()+ .and_then(|v| v.get("daHexString")?.as_str().map(str::to_ascii_uppercase))+ }),+ emblem: field::string(record, "BadgeEmblem").filter(|e| !e.trim().is_empty()),+ pinned: record+ .pointer("/fields/PinnedDate/value")+ .and_then(Value::as_i64)+ .is_some_and(|ms| ms > 0),+ sorting: field::string(record, "SortingStyle"),+ filter,+ })+}++// ---------------------------------------------------------------------------------------+// Pure builders, for the writes below+// ---------------------------------------------------------------------------------------++/// A tag name as Apple stores it: no `#`, no spaces (the phone ends a tag at one).+pub fn tag_name(name: &str) -> Result<String> {+ let name = name.trim().trim_start_matches('#').trim();+ if name.is_empty() {+ return Err(Error::Refused("A tag needs a name.".into()));+ }+ if name.chars().any(char::is_whitespace) || name.contains('#') {+ return Err(Error::Refused(+ "A tag is one word: no spaces, and only the one # at the start.".into(),+ ));+ }+ if name.chars().count() > 100 {+ return Err(Error::Refused("That tag is too long.".into()));+ }+ Ok(name.to_string())+}++/// A link as it will be stored: trimmed, with a scheme, no spaces.+pub fn link(url: &str) -> Result<String> {+ let url = url.trim();+ let scheme_ok = url.split_once(':').is_some_and(|(scheme, rest)| {+ !scheme.is_empty()+ && scheme+ .chars()+ .next()+ .is_some_and(|c| c.is_ascii_alphabetic())+ && scheme+ .chars()+ .all(|c| c.is_ascii_alphanumeric() || "+-.".contains(c))+ && !rest.is_empty()+ });+ if !scheme_ok || url.chars().any(char::is_whitespace) || url.len() > 4096 {+ return Err(Error::Refused(+ "That isn't a link Reminders can open (it needs to start like https://).".into(),+ ));+ }+ Ok(url.to_string())+}++/// The new `DueDateDeltaAlertsData` JSON: what the reminder had, with its alerts replaced by+/// `alert` (or none). Keys Apple added that this does not know are kept as they were.+#[must_use]+pub fn early_alert_json(+ existing: Option<&Value>,+ account: &str,+ reminder_guid: &str,+ alert: Option<(i64, i64)>,+ now_apple: f64,+) -> Value {+ let mut blob = existing+ .filter(|v| v.is_object())+ .cloned()+ .unwrap_or_else(|| json!({}));+ blob["accountIdentifier"] = json!(account);+ blob["reminderIdentifier"] = json!(bare(reminder_guid));+ if blob.get("minimumSupportedVersion").is_none() {+ blob["minimumSupportedVersion"] = json!(MINIMUM_SUPPORTED_VERSION);+ }+ blob["dueDateDeltaAlerts"] = match alert {+ None => json!([]),+ Some((count, unit)) => json!([{+ "identifier": new_id(),+ "dueDateDeltaCount": -count.abs(),+ "dueDateDeltaUnit": unit,+ "creationDate": now_apple,+ "minimumSupportedAppVersion": 0,+ }]),+ };+ blob+}++/// The list's membership file with one reminder placed in `section` (a section record name),+/// or out of every one. Every other entry, and any key Apple added, is kept as it was; the+/// entry changed carries `modified_on` (Apple's seconds), which is what devices merge by.+pub fn place_in_section(+ file: Option<&[u8]>,+ reminder_guid: &str,+ section: Option<&str>,+ modified_on: f64,+) -> Result<Vec<u8>> {+ let mut doc: Value = match file.filter(|b| !b.is_empty()) {+ None => json!({ "minimumSupportedVersion": MINIMUM_SUPPORTED_VERSION, "memberships": [] }),+ Some(bytes) => serde_json::from_slice(bytes).map_err(|_| {+ Error::Refused(+ "This list's sections are in a form Pomander doesn't read, so nothing was moved."+ .into(),+ )+ })?,+ };+ if !doc.is_object() {+ return Err(Error::Refused(+ "This list's sections are in a form Pomander doesn't read, so nothing was moved."+ .into(),+ ));+ }+ if !doc.get("memberships").is_some_and(Value::is_array) {+ doc["memberships"] = json!([]);+ }+ let member = bare(reminder_guid).to_string();+ let entries = doc["memberships"]+ .as_array_mut()+ .expect("made an array above");+ let at = entries.iter().position(|m| {+ m.get("memberID")+ .and_then(Value::as_str)+ .is_some_and(|id| id.eq_ignore_ascii_case(&member))+ });+ let mut entry = at.map_or_else(|| json!({ "memberID": member }), |i| entries[i].clone());+ match section {+ Some(s) => entry["groupID"] = json!(bare(s)),+ None => {+ if let Some(o) = entry.as_object_mut() {+ o.remove("groupID");+ }+ }+ }+ entry["modifiedOn"] = json!(modified_on);+ match at {+ Some(i) => entries[i] = entry,+ None => entries.push(entry),+ }+ serde_json::to_vec(&doc).map_err(|e| Error::Protocol(e.to_string()))+}++/// The checksum written beside the membership file: SHA-512 of its bytes, in hex.+///+/// Apple's own value is 128 hex digits too, but it does not match SHA-512 (or SHA3-512 or+/// BLAKE2b) of the downloaded file under any arrangement tried — so what Apple hashes is not+/// known. Devices merge on the checksum field's resolution token, which this write advances;+/// whether a phone also re-derives the checksum is what the supervised live test has to show.+#[must_use]+pub fn membership_checksum(bytes: &[u8]) -> String {+ use sha2::{Digest, Sha512};+ Sha512::digest(bytes)+ .iter()+ .map(|b| format!("{b:02x}"))+ .collect()+}++/// The record's `ResolutionTokenMap` with only `keys` advanced, as a field value.+///+/// `ZoneClient::update_record_signed` advances a token for every field it writes. A section+/// move writes the file and its checksum, but Apple keeps a token for the checksum alone+/// (`membershipsOfRemindersInSectionsChecksum`), so this stamps exactly that.+#[must_use]+pub fn stamp_only(current: &Value, keys: &[&str], now_apple: f64) -> Value {+ let mut map: Value = current+ .pointer("/fields/ResolutionTokenMap/value")+ .and_then(Value::as_str)+ .and_then(|s| serde_json::from_str(s).ok())+ .filter(|v: &Value| v.get("map").is_some_and(Value::is_object))+ .unwrap_or_else(|| json!({ "map": {} }));+ let writer = crate::topotext::writer_id();+ for key in keys {+ let counter = map["map"][*key]["counter"].as_u64().unwrap_or(0) + 1;+ map["map"][*key] =+ json!({ "counter": counter, "modificationTime": now_apple, "replicaID": writer });+ }+ json!({ "type": "STRING", "value": map.to_string() })+}++// ---------------------------------------------------------------------------------------+// Writes+// ---------------------------------------------------------------------------------------++fn client<'a>(+ http: &'a reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+) -> ZoneClient<'a> {+ ZoneClient::new(http, root, CONTAINER, params)+}++async fn live_reminder(zc: &ZoneClient<'_>, reminder_guid: &str) -> Result<Value> {+ match zc.lookup_record(ZONE, reminder_guid).await? {+ Some(r) if !deleted(&r) => Ok(r),+ _ => Err(Error::Refused("Apple no longer has that reminder.".into())),+ }+}++/// The live records a reminder lists under `ids_field`, each with its record name.+async fn listed(+ zc: &ZoneClient<'_>,+ reminder: &Value,+ ids_field: &str,+ prefix: &str,+) -> Result<Vec<Value>> {+ let mut out = Vec::new();+ for id in id_list(reminder, ids_field) {+ if let Some(r) = zc.lookup_record(ZONE, &format!("{prefix}/{id}")).await? {+ if !deleted(&r) {+ out.push(r);+ }+ }+ }+ Ok(out)+}++/// A field change adding `id` to a reminder's id list, or `None` if it is there already.+fn with_id(reminder: &Value, ids_field: &str, id: &str) -> Option<Value> {+ let mut ids = id_list(reminder, ids_field);+ if ids.iter().any(|x| x.eq_ignore_ascii_case(id)) {+ return None;+ }+ ids.push(id.to_string());+ Some(json!({+ ids_field: { "type": "STRING_LIST", "value": ids },+ "LastModifiedDate": { "type": "TIMESTAMP", "value": now_millis() },+ }))+}++/// A field change taking `ids` out of a reminder's id list, or `None` if none are there.+fn without_ids(reminder: &Value, ids_field: &str, ids: &[String]) -> Option<Value> {+ let before = id_list(reminder, ids_field);+ let after: Vec<String> = before+ .iter()+ .filter(|x| !ids.iter().any(|g| g.eq_ignore_ascii_case(x)))+ .cloned()+ .collect();+ (after.len() != before.len()).then(|| {+ json!({+ ids_field: { "type": "STRING_LIST", "value": after },+ "LastModifiedDate": { "type": "TIMESTAMP", "value": now_millis() },+ })+ })+}++/// Tag a reminder. Answers the `Hashtag` record's name — the one already there, if the+/// reminder carries this tag (however capitalised).+///+/// As a repeat is set: the tag record is made first, then the reminder pointed at it, so the+/// reminder never lists a tag that does not exist.+pub async fn add_tag_cloudkit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ reminder_guid: &str,+ name: &str,+) -> Result<String> {+ writes()?;+ let name = tag_name(name)?;+ let zc = client(http, root, params);+ let reminder = live_reminder(&zc, reminder_guid).await?;+ for tag in listed(&zc, &reminder, "HashtagIDs", "Hashtag").await? {+ if field::string(&tag, "Name")+ .is_some_and(|n| n.trim_start_matches('#').eq_ignore_ascii_case(&name))+ {+ if let Some(guid) = field::record_name(&tag) {+ return Ok(guid);+ }+ }+ }+ let id = new_id();+ let guid = format!("Hashtag/{id}");+ zc.create_record(+ ZONE,+ &guid,+ "Hashtag",+ json!({+ // Encrypted as every other name a person types into Reminders is (a list's, a+ // section's, a smart list's).+ "Name": { "type": "STRING", "value": name, "isEncrypted": true },+ "Reminder": zc.reference_to(ZONE, reminder_guid),+ "Deleted": { "type": "NUMBER_INT64", "value": 0 },+ }),+ )+ .await?;+ zc.edit_record_signed(ZONE, reminder_guid, "Reminder", |r| {+ with_id(r, "HashtagIDs", &id)+ })+ .await?;+ Ok(guid)+}++/// Take a tag off a reminder: the reminder stops listing it, then the tag record is marked+/// deleted, as Apple's clients mark records.+pub async fn remove_tag_cloudkit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ reminder_guid: &str,+ name: &str,+) -> Result<()> {+ writes()?;+ let name = tag_name(name)?;+ let zc = client(http, root, params);+ let reminder = live_reminder(&zc, reminder_guid).await?;+ let matching: Vec<String> = listed(&zc, &reminder, "HashtagIDs", "Hashtag")+ .await?+ .iter()+ .filter(|t| {+ field::string(t, "Name")+ .is_some_and(|n| n.trim_start_matches('#').eq_ignore_ascii_case(&name))+ })+ .filter_map(field::record_name)+ .collect();+ if matching.is_empty() {+ return Ok(());+ }+ let ids: Vec<String> = matching.iter().map(|g| bare(g).to_string()).collect();+ zc.edit_record_signed(ZONE, reminder_guid, "Reminder", |r| {+ without_ids(r, "HashtagIDs", &ids)+ })+ .await?;+ for guid in &matching {+ zc.update_record(+ ZONE,+ guid,+ "Hashtag",+ None,+ json!({ "Deleted": { "type": "NUMBER_INT64", "value": 1 } }),+ )+ .await?;+ }+ Ok(())+}++/// Set or clear a reminder's link. An existing URL attachment is changed in place; a new one+/// is made and then listed on the reminder; clearing unlists it and marks it deleted.+pub async fn set_url_cloudkit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ reminder_guid: &str,+ url: Option<&str>,+) -> Result<()> {+ writes()?;+ let url = url.map(link).transpose()?;+ let zc = client(http, root, params);+ let reminder = live_reminder(&zc, reminder_guid).await?;+ let existing: Vec<String> = listed(&zc, &reminder, "AttachmentIDs", "Attachment")+ .await?+ .iter()+ .filter(|a| field::string(a, "Type").as_deref() == Some("URL"))+ .filter_map(field::record_name)+ .collect();+ let url_field =+ |u: &str| json!({ "type": "ENCRYPTED_BYTES", "value": B64.encode(u.as_bytes()) });+ match (url, existing.first()) {+ (Some(u), Some(guid)) => {+ zc.update_record(+ ZONE,+ guid,+ "Attachment",+ None,+ json!({ "URL": url_field(&u) }),+ )+ .await?;+ }+ (Some(u), None) => {+ let id = new_id();+ zc.create_record(+ ZONE,+ &format!("Attachment/{id}"),+ "Attachment",+ json!({+ "Type": { "type": "STRING", "value": "URL" },+ "UTI": { "type": "STRING", "value": "public.url" },+ "URL": url_field(&u),+ "Reminder": zc.reference_to(ZONE, reminder_guid),+ "Deleted": { "type": "NUMBER_INT64", "value": 0 },+ "Imported": { "type": "NUMBER_INT64", "value": 0 },+ }),+ )+ .await?;+ zc.edit_record_signed(ZONE, reminder_guid, "Reminder", |r| {+ with_id(r, "AttachmentIDs", &id)+ })+ .await?;+ }+ (None, _) if existing.is_empty() => {}+ (None, _) => {+ let ids: Vec<String> = existing.iter().map(|g| bare(g).to_string()).collect();+ zc.edit_record_signed(ZONE, reminder_guid, "Reminder", |r| {+ without_ids(r, "AttachmentIDs", &ids)+ })+ .await?;+ for guid in &existing {+ zc.update_record(+ ZONE,+ guid,+ "Attachment",+ None,+ json!({ "Deleted": { "type": "NUMBER_INT64", "value": 1 } }),+ )+ .await?;+ }+ }+ }+ Ok(())+}++/// Set a reminder's early alert — `count` units before it is due (unit 0 minutes, 1 hours,+/// 2 days, 3 weeks, 4 months; only minutes is measured) — or clear it with `None`.+///+/// Apple writes an account id inside the alert. It is taken from the reminder's own alert+/// if it has one, else `account` (from any other reminder's, see+/// `Library::early_alert_account`); with neither, nothing is written.+pub async fn set_early_alert_cloudkit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ reminder_guid: &str,+ alert: Option<(i64, i64)>,+ account: Option<&str>,+) -> Result<()> {+ writes()?;+ if let Some((count, unit)) = alert {+ if count == 0 || count.abs() > 10_000 || !(0..=4).contains(&unit) {+ return Err(Error::Refused(+ "That isn't an early reminder Apple offers.".into(),+ ));+ }+ }+ let zc = client(http, root, params);+ let reminder = live_reminder(&zc, reminder_guid).await?;+ if alert.is_some() && field::int(&reminder, "DueDate").is_none() {+ return Err(Error::Refused(+ "Give this a date before asking to be reminded early.".into(),+ ));+ }+ let account = early_alert_blob(&reminder)+ .and_then(|b| {+ b.get("accountIdentifier")?+ .as_str()+ .map(ToString::to_string)+ })+ .or_else(|| account.map(ToString::to_string))+ .ok_or_else(|| {+ Error::Refused(+ "Set one early reminder on an Apple device first; Pomander needs what it writes."+ .into(),+ )+ })?;+ let now = apple_now();+ zc.edit_record_signed(ZONE, reminder_guid, "Reminder", |r| {+ if alert.is_none() && early_alert_blob(r).is_none() {+ return None;+ }+ let blob = early_alert_json(+ early_alert_blob(r).as_ref(),+ &account,+ reminder_guid,+ alert,+ now,+ );+ Some(json!({+ "DueDateDeltaAlertsData": {+ "type": "ENCRYPTED_BYTES",+ "value": B64.encode(blob.to_string().as_bytes()),+ },+ "LastModifiedDate": { "type": "TIMESTAMP", "value": now_millis() },+ }))+ })+ .await?;+ Ok(())+}++/// Make a section in a list. Answers it, to be shown before the next pass.+pub async fn create_section_cloudkit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ list_guid: &str,+ title: &str,+) -> Result<ReminderSection> {+ writes()?;+ let title = title.trim();+ if title.is_empty() {+ return Err(Error::Refused("A section needs a name.".into()));+ }+ let zc = client(http, root, params);+ let guid = format!("ListSection/{}", new_id());+ let stamp = now_millis();+ zc.create_record_signed(+ ZONE,+ &guid,+ "ListSection",+ json!({+ "DisplayName": { "type": "STRING", "value": title, "isEncrypted": true },+ "List": zc.reference_to(ZONE, list_guid),+ "CreationDate": { "type": "TIMESTAMP", "value": stamp },+ "Deleted": { "type": "NUMBER_INT64", "value": 0 },+ "Imported": { "type": "NUMBER_INT64", "value": 0 },+ }),+ )+ .await?;+ Ok(ReminderSection {+ guid,+ list_guid: list_guid.to_string(),+ title: title.to_string(),+ created_at: Some(stamp / 1000),+ })+}++/// Rename a section.+pub async fn rename_section_cloudkit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ section_guid: &str,+ title: &str,+) -> Result<()> {+ writes()?;+ let title = title.trim();+ if title.is_empty() {+ return Err(Error::Refused("A section needs a name.".into()));+ }+ client(http, root, params)+ .update_record_signed(+ ZONE,+ section_guid,+ "ListSection",+ None,+ json!({ "DisplayName": { "type": "STRING", "value": title, "isEncrypted": true } }),+ )+ .await?;+ Ok(())+}++/// The query string every CloudKit request carries, as `ZoneClient` sends it.+fn query(params: &[(String, String)]) -> Vec<(String, String)> {+ let mut q = params.to_vec();+ q.push(("ckjsBuildVersion".into(), "17DProjectDev77".into()));+ q.push(("ckjsVersion".into(), "2.6.1".into()));+ q+}++/// Upload one file for a record's asset field, as CloudKit JS does: ask for an address+/// (`assets/upload`), post the bytes there, and answer the receipt Apple gives — the value+/// the field is then written with.+async fn upload_asset(+ http: &reqwest::Client,+ root: &str,+ params: &[(String, String)],+ record_type: &str,+ record_name: &str,+ field_name: &str,+ bytes: Vec<u8>,+) -> Result<Value> {+ let url = format!(+ "{}/database/1/{CONTAINER}/production/private/assets/upload",+ root.trim_end_matches('/')+ );+ let asked = http+ .post(&url)+ .query(&query(params))+ .json(&json!({+ "zoneID": { "zoneName": ZONE, "zoneType": "REGULAR_CUSTOM_ZONE" },+ "tokens": [{ "recordType": record_type, "recordName": record_name, "fieldName": field_name }],+ }))+ .send()+ .await?;+ let status = asked.status();+ if status.as_u16() == 450 {+ return Err(Error::ReauthRequired);+ }+ let answer: Value =+ serde_json::from_str(&asked.text().await.unwrap_or_default()).unwrap_or(Value::Null);+ let to = answer+ .pointer("/tokens/0/url")+ .and_then(Value::as_str)+ .ok_or_else(|| Error::Protocol(format!("CloudKit gave nowhere to upload to ({status})")))?;+ let size = bytes.len();+ let part = reqwest::multipart::Part::bytes(bytes)+ .file_name("file")+ .mime_str("application/octet-stream")+ .map_err(|e| Error::Protocol(e.to_string()))?;+ let sent = http+ .post(to)+ .multipart(reqwest::multipart::Form::new().part("files", part))+ .send()+ .await?;+ let status = sent.status();+ let text = sent.text().await.unwrap_or_default();+ if !status.is_success() {+ return Err(Error::Protocol(format!(+ "Apple would not take the file ({status})"+ )));+ }+ let receipt: Value = serde_json::from_str(&text)+ .map_err(|e| Error::Protocol(format!("Apple's upload reply was not JSON: {e}")))?;+ let single = receipt+ .get("singleFile")+ .filter(|s| s.get("receipt").is_some())+ .cloned()+ .ok_or_else(|| Error::Protocol("Apple took the bytes but gave no receipt".into()))?;+ if single+ .get("size")+ .and_then(Value::as_u64)+ .is_some_and(|s| s != size as u64)+ {+ return Err(Error::Protocol(+ "Apple received a different file than was sent".into(),+ ));+ }+ Ok(single)+}++const MEMBERSHIP_FILE: &str = "MembershipsOfRemindersInSectionsAsData";+const MEMBERSHIP_SUM: &str = "MembershipsOfRemindersInSectionsChecksum";++/// Move a reminder into a section of its list, or out of every one (`section` `None`).+///+/// The placement is the list's membership file: read as Apple holds it now, this one entry+/// changed, uploaded, and written onto the list over exactly the version read — another+/// device's placement made meanwhile is read again and kept, never overwritten.+pub async fn move_to_section_cloudkit(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ list_guid: &str,+ reminder_guid: &str,+ section: Option<&str>,+) -> Result<()> {+ writes()?;+ let zc = client(http, root, params.clone());+ let reminder = live_reminder(&zc, reminder_guid).await?;+ if field::reference(&reminder, "List").as_deref() != Some(list_guid) {+ return Err(Error::Refused("That reminder isn't in this list.".into()));+ }+ if let Some(section) = section {+ match zc.lookup_record(ZONE, section).await? {+ Some(s)+ if !deleted(&s) && field::reference(&s, "List").as_deref() == Some(list_guid) => {}+ _ => return Err(Error::Refused("That section isn't in this list.".into())),+ }+ }+ for _ in 0..5 {+ let Some(list) = zc.lookup_record(ZONE, list_guid).await? else {+ return Err(Error::Refused("That list is no longer in iCloud.".into()));+ };+ let Some(tag) = list.get("recordChangeTag").and_then(Value::as_str) else {+ return Err(Error::Conflict);+ };+ let current = match list+ .pointer(&format!("/fields/{MEMBERSHIP_FILE}/value/downloadURL"))+ .and_then(Value::as_str)+ {+ None => None,+ Some(url) => {+ let got = http.get(url.replace("${f}", "memberships")).send().await?;+ if !got.status().is_success() {+ return Err(Error::Protocol(format!(+ "the list's sections did not download ({})",+ got.status()+ )));+ }+ Some(got.bytes().await?.to_vec())+ }+ };+ let now = apple_now();+ let file = place_in_section(current.as_deref(), reminder_guid, section, now)?;+ let sum = membership_checksum(&file);+ let receipt = upload_asset(+ http,+ root,+ ¶ms,+ "List",+ list_guid,+ MEMBERSHIP_FILE,+ file,+ )+ .await?;+ let changes = json!({+ MEMBERSHIP_FILE: { "type": "ASSETID", "value": receipt },+ MEMBERSHIP_SUM: { "type": "STRING", "value": sum, "isEncrypted": true },+ "ResolutionTokenMap": stamp_only(&list, &["membershipsOfRemindersInSectionsChecksum"], now),+ });+ match zc+ .update_record_exact(ZONE, list_guid, "List", tag, changes)+ .await+ {+ Err(Error::Conflict) => continue,+ other => return other.map(|_| ()),+ }+ }+ Err(Error::Conflict)+}++#[cfg(test)]+mod tests {+ use super::*;++ fn b64(s: &str) -> String {+ B64.encode(s.as_bytes())+ }++ /// The gate refuses when off, and is off: flipping it is for a supervised live test.+ #[test]+ fn writes_stay_off_until_a_supervised_live_test() {+ const { assert!(!REMINDER_DETAIL_WRITES) };+ assert!(matches!(gate(false), Err(Error::Refused(_))));+ assert!(gate(true).is_ok());+ }++ #[test]+ fn a_hashtag_record_reads_as_a_tag() {+ let r = json!({ "recordName": "Hashtag/H1", "recordType": "Hashtag", "fields": {+ "Name": { "type": "STRING", "value": "#Errands", "isEncrypted": true },+ "Reminder": { "type": "REFERENCE", "value": { "recordName": "Reminder/R1" } },+ "Deleted": { "type": "NUMBER_INT64", "value": 0 } } });+ assert_eq!(+ hashtag_from_record(&r),+ Some(ReminderHashtag {+ guid: "Hashtag/H1".into(),+ reminder_guid: "Reminder/R1".into(),+ name: "Errands".into()+ })+ );+ let mut gone = r.clone();+ gone["fields"]["Deleted"]["value"] = json!(1);+ assert_eq!(hashtag_from_record(&gone), None);+ }++ /// The link is bytes on icloud.com's model; a plain string reads too.+ #[test]+ fn a_url_attachment_reads_its_link() {+ let r = json!({ "recordName": "Attachment/A", "recordType": "Attachment", "fields": {+ "Type": { "type": "STRING", "value": "URL" },+ "UTI": { "type": "STRING", "value": "public.url" },+ "URL": { "type": "ENCRYPTED_BYTES", "value": b64("https://apple.com/x?y=1") },+ "Reminder": { "type": "REFERENCE", "value": { "recordName": "Reminder/R1" } } } });+ let a = attachment_from_record(&r).unwrap();+ assert_eq!(a.url.as_deref(), Some("https://apple.com/x?y=1"));+ assert_eq!(a.kind, "URL");+ let mut plain = r.clone();+ plain["fields"]["URL"] = json!({ "type": "STRING", "value": "https://a.b" });+ assert_eq!(+ attachment_from_record(&plain).unwrap().url.as_deref(),+ Some("https://a.b")+ );+ let mut image = r;+ image["fields"]["Type"]["value"] = json!("Image");+ assert_eq!(attachment_from_record(&image).unwrap().url, None);+ }++ /// The shape measured on 49 reminders.+ #[test]+ fn the_measured_early_alert_reads() {+ let blob = r#"{"accountIdentifier":"6D05-ACCT","minimumSupportedVersion":20230430,"reminderIdentifier":"9C68","dueDateDeltaAlerts":[{"identifier":"10A8","dueDateDeltaCount":-30,"creationDate":803667432.61867201,"dueDateDeltaUnit":0,"minimumSupportedAppVersion":0}]}"#;+ let r = json!({ "fields": { "DueDateDeltaAlertsData": { "type": "ENCRYPTED_BYTES", "value": b64(blob) } } });+ let (account, alerts) = early_alerts_from_record(&r);+ assert_eq!(account.as_deref(), Some("6D05-ACCT"));+ assert_eq!(+ alerts,+ vec![EarlyAlert {+ id: "10A8".into(),+ count: 30,+ unit: 0+ }]+ );+ assert_eq!(+ early_alerts_from_record(&json!({ "fields": {} })),+ (None, vec![])+ );+ }++ #[test]+ fn an_early_alert_is_written_in_apples_shape_keeping_unknown_keys() {+ let existing = json!({ "accountIdentifier": "OLD", "minimumSupportedVersion": 20230430,+ "somethingNew": 7, "dueDateDeltaAlerts": [{ "identifier": "X" }] });+ let blob = early_alert_json(Some(&existing), "ACCT", "Reminder/R1", Some((15, 0)), 800.5);+ assert_eq!(blob["accountIdentifier"], "ACCT");+ assert_eq!(blob["reminderIdentifier"], "R1");+ assert_eq!(blob["somethingNew"], 7);+ let a = &blob["dueDateDeltaAlerts"][0];+ assert_eq!(a["dueDateDeltaCount"], -15);+ assert_eq!(a["dueDateDeltaUnit"], 0);+ assert_eq!(a["creationDate"], 800.5);+ assert_eq!(a["minimumSupportedAppVersion"], 0);+ assert_eq!(blob["dueDateDeltaAlerts"].as_array().unwrap().len(), 1);+ let cleared = early_alert_json(None, "ACCT", "Reminder/R1", None, 1.0);+ assert_eq!(cleared["dueDateDeltaAlerts"], json!([]));+ assert_eq!(cleared["minimumSupportedVersion"], 20230430);+ }++ #[test]+ fn smart_lists_read_built_in_and_custom() {+ let custom = json!({ "recordName": "SmartList/C", "recordType": "SmartList", "fields": {+ "SmartListType": { "type": "STRING", "value": "com.apple.reminders.smartlist.custom" },+ "Name": { "type": "STRING", "value": "Medium", "isEncrypted": true },+ "Color": { "type": "STRING", "value": "{\"daHexString\":\"#ff9500\"}" },+ "FilterData": { "type": "ENCRYPTED_BYTES", "value": b64(r#"{"priorities":["medium"]}"#) },+ "Deleted": { "type": "NUMBER_INT64", "value": 0 } } });+ let s = smart_list_from_record(&custom).unwrap();+ assert_eq!(s.kind, "custom");+ assert_eq!(s.title.as_deref(), Some("Medium"));+ assert_eq!(s.colour.as_deref(), Some("#FF9500"));+ assert_eq!(s.filter.as_deref(), Some(r#"{"priorities":["medium"]}"#));+ let today = json!({ "recordName": "SmartList/T", "recordType": "SmartList", "fields": {+ "SmartListType": { "type": "STRING", "value": "com.apple.reminders.smartlist.today" },+ "PinnedDate": { "type": "TIMESTAMP", "value": 1_700_000_000_000_i64 } } });+ let t = smart_list_from_record(&today).unwrap();+ assert_eq!((t.kind.as_str(), t.pinned, t.filter), ("today", true, None));+ }++ #[test]+ fn tag_names_and_links_are_checked() {+ assert_eq!(tag_name(" #Errands ").unwrap(), "Errands");+ assert!(tag_name("#").is_err());+ assert!(tag_name("two words").is_err());+ assert!(tag_name("a#b").is_err());+ assert_eq!(link(" https://apple.com ").unwrap(), "https://apple.com");+ assert!(link("mailto:[email protected]").is_ok());+ assert!(link("apple.com").is_err());+ assert!(link("https://a b").is_err());+ }++ /// The measured file: a placement changed in place, another kept, a new one added, and+ /// one taken out keeps its entry without a groupID — as Apple's own files do.+ #[test]+ fn a_placement_changes_one_entry_and_keeps_the_rest() {+ let file = br#"{"minimumSupportedVersion":20230430,"future":true,"memberships":[+ {"memberID":"AAA","modifiedOn":1.5},+ {"memberID":"BBB","modifiedOn":2.5,"groupID":"S1"}]}"#;+ let moved: Value = serde_json::from_slice(+ &place_in_section(Some(file), "Reminder/aaa", Some("ListSection/S2"), 9.0).unwrap(),+ )+ .unwrap();+ assert_eq!(moved["future"], true);+ let m = moved["memberships"].as_array().unwrap();+ assert_eq!(m.len(), 2);+ assert_eq!(m[0]["groupID"], "S2");+ assert_eq!(m[0]["modifiedOn"], 9.0);+ assert_eq!(+ m[1],+ json!({"memberID":"BBB","modifiedOn":2.5,"groupID":"S1"})+ );++ let out: Value = serde_json::from_slice(+ &place_in_section(Some(file), "Reminder/BBB", None, 10.0).unwrap(),+ )+ .unwrap();+ assert_eq!(+ out["memberships"][1],+ json!({"memberID":"BBB","modifiedOn":10.0})+ );++ let fresh: Value = serde_json::from_slice(+ &place_in_section(None, "Reminder/CCC", Some("ListSection/S1"), 3.0).unwrap(),+ )+ .unwrap();+ assert_eq!(fresh["minimumSupportedVersion"], 20230430);+ assert_eq!(fresh["memberships"][0]["memberID"], "CCC");++ assert!(place_in_section(Some(b"not json"), "Reminder/A", None, 1.0).is_err());+ }++ #[test]+ fn only_the_checksum_token_is_advanced() {+ let list = json!({ "fields": { "ResolutionTokenMap": { "type": "STRING", "value":+ r#"{"map":{"membershipsOfRemindersInSectionsChecksum":{"counter":3,"modificationTime":1,"replicaID":"P"},"name":{"counter":2,"modificationTime":1,"replicaID":"P"}}}"# } } });+ let stamped = stamp_only(&list, &["membershipsOfRemindersInSectionsChecksum"], 5.0);+ let map: Value = serde_json::from_str(stamped["value"].as_str().unwrap()).unwrap();+ assert_eq!(+ map["map"]["membershipsOfRemindersInSectionsChecksum"]["counter"],+ 4+ );+ assert_eq!(map["map"]["name"]["counter"], 2);+ assert_eq!(map["map"].as_object().unwrap().len(), 2);+ assert_eq!(membership_checksum(b"").len(), 128);+ }++ /// A sync pass carrying every kind lands in the library; a later pass's tombstones and a+ /// reminder sent again without its alert take them away.+ #[test]+ fn a_pass_stores_the_details_and_a_later_one_removes_them() {+ use crate::reminders::{apply_cloudkit, RemindersFetch};+ let alert = r#"{"accountIdentifier":"ACCT","dueDateDeltaAlerts":[{"identifier":"E","dueDateDeltaCount":-30,"dueDateDeltaUnit":0}]}"#;+ let reminder = |alerts: bool| {+ let mut r = json!({ "recordName": "Reminder/R1", "recordType": "Reminder", "fields": {+ "List": { "type": "REFERENCE", "value": { "recordName": "List/L" } },+ "TitleDocument": { "type": "ENCRYPTED_BYTES", "value": crate::ckdocument::text_to_base64("x") },+ "HashtagIDs": { "type": "STRING_LIST", "value": ["H"] } } });+ if alerts {+ r["fields"]["DueDateDeltaAlertsData"] =+ json!({ "type": "ENCRYPTED_BYTES", "value": b64(alert) });+ }+ r+ };+ let records = vec![+ json!({ "recordName": "List/L", "recordType": "List", "fields": {+ "Name": { "type": "STRING", "value": "L" } } }),+ reminder(true),+ json!({ "recordName": "Hashtag/H", "recordType": "Hashtag", "fields": {+ "Name": { "type": "STRING", "value": "work" },+ "Reminder": { "type": "REFERENCE", "value": { "recordName": "Reminder/R1" } } } }),+ json!({ "recordName": "Attachment/A", "recordType": "Attachment", "fields": {+ "Type": { "type": "STRING", "value": "URL" },+ "URL": { "type": "ENCRYPTED_BYTES", "value": b64("https://apple.com") },+ "Reminder": { "type": "REFERENCE", "value": { "recordName": "Reminder/R1" } } } }),+ json!({ "recordName": "SmartList/S", "recordType": "SmartList", "fields": {+ "SmartListType": { "type": "STRING", "value": "com.apple.reminders.smartlist.custom" },+ "FilterData": { "type": "ENCRYPTED_BYTES", "value": b64(r#"{"hashtags":["work"]}"#) } } }),+ ];+ let mut lib = quince_core::Library::in_memory().unwrap();+ let pass = |records: Vec<Value>, incremental: bool| RemindersFetch {+ records,+ token: None,+ incremental,+ memberships: Default::default(),+ };+ apply_cloudkit(&mut lib, pass(records, false)).unwrap();+ let d = lib.reminder_detail("Reminder/R1").unwrap();+ assert_eq!(d.tags, vec!["work".to_string()]);+ assert_eq!(d.url.as_deref(), Some("https://apple.com"));+ assert_eq!(d.early_alerts.len(), 1);+ let in_list = lib.reminders_in_smart_list("SmartList/S", 0).unwrap();+ assert_eq!(in_list.reminders.len(), 1);+ assert_eq!(lib.reminder_tags().unwrap().len(), 1);++ apply_cloudkit(+ &mut lib,+ pass(+ vec![+ reminder(false),+ json!({ "recordName": "Hashtag/H", "deleted": true }),+ json!({ "recordName": "Attachment/A", "deleted": true }),+ ],+ true,+ ),+ )+ .unwrap();+ let d = lib.reminder_detail("Reminder/R1").unwrap();+ assert!(d.tags.is_empty() && d.url.is_none() && d.early_alerts.is_empty());+ assert_eq!(+ lib.reminder_smart_lists().unwrap().len(),+ 1,+ "unchanged, kept"+ );+ }++ mod live_shape {+ use super::*;+ use wiremock::matchers::{body_string_contains, method, path_regex};+ use wiremock::{Mock, MockServer, Request, ResponseTemplate};++ fn reminder() -> Value {+ json!({ "recordName": "Reminder/R1", "recordType": "Reminder", "recordChangeTag": "t1",+ "fields": {+ "List": { "type": "REFERENCE", "value": { "recordName": "List/L" } },+ "HashtagIDs": { "type": "EMPTY_LIST", "value": [] },+ "AttachmentIDs": { "type": "EMPTY_LIST", "value": [] },+ "DueDate": { "type": "TIMESTAMP", "value": 1_800_000_000_000_i64 },+ "Deleted": { "type": "NUMBER_INT64", "value": 0 } } })+ }++ async fn lookup(server: &MockServer, name: &str, record: Value) {+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/lookup$"))+ .and(body_string_contains(name))+ .respond_with(+ ResponseTemplate::new(200).set_body_json(json!({ "records": [record] })),+ )+ .mount(server)+ .await;+ }++ async fn modify_ok(server: &MockServer) {+ Mock::given(method("POST"))+ .and(path_regex(r".*/records/modify$"))+ .respond_with(|req: &Request| {+ let body: Value = serde_json::from_slice(&req.body).unwrap();+ let name = body["operations"][0]["record"]["recordName"].clone();+ ResponseTemplate::new(200).set_body_json(+ json!({ "records": [{ "recordName": name, "recordChangeTag": "t2" }] }),+ )+ })+ .mount(server)+ .await;+ }++ fn modifies(requests: &[Request]) -> Vec<Value> {+ requests+ .iter()+ .filter(|r| r.url.path().ends_with("/records/modify"))+ .map(|r| serde_json::from_slice::<Value>(&r.body).unwrap()["operations"][0].clone())+ .collect()+ }++ /// The tag record first, then the reminder pointed at its bare id.+ #[tokio::test]+ async fn adding_a_tag_makes_the_record_then_lists_it() {+ let server = MockServer::start().await;+ lookup(&server, "Reminder/R1", reminder()).await;+ modify_ok(&server).await;+ let http = reqwest::Client::new();+ let guid = add_tag_cloudkit(&http, &server.uri(), vec![], "Reminder/R1", "#Errands")+ .await+ .unwrap();+ let ops = modifies(&server.received_requests().await.unwrap());+ assert_eq!(ops[0]["operationType"], "create");+ assert_eq!(ops[0]["record"]["recordType"], "Hashtag");+ assert_eq!(ops[0]["record"]["recordName"], guid);+ assert_eq!(ops[0]["record"]["fields"]["Name"]["value"], "Errands");+ assert_eq!(+ ops[0]["record"]["fields"]["Reminder"]["value"]["recordName"],+ "Reminder/R1"+ );+ assert_eq!(ops[1]["operationType"], "update");+ assert_eq!(+ ops[1]["record"]["recordChangeTag"], "t1",+ "over the version read"+ );+ assert_eq!(+ ops[1]["record"]["fields"]["HashtagIDs"],+ json!({ "type": "STRING_LIST", "value": [bare(&guid)] })+ );+ assert!(+ ops[1]["record"]["fields"]["ResolutionTokenMap"].is_object(),+ "signed"+ );+ }++ #[tokio::test]+ async fn a_link_is_a_new_url_attachment() {+ let server = MockServer::start().await;+ lookup(&server, "Reminder/R1", reminder()).await;+ modify_ok(&server).await;+ let http = reqwest::Client::new();+ set_url_cloudkit(+ &http,+ &server.uri(),+ vec![],+ "Reminder/R1",+ Some("https://apple.com"),+ )+ .await+ .unwrap();+ let ops = modifies(&server.received_requests().await.unwrap());+ let made = &ops[0]["record"];+ assert_eq!(made["recordType"], "Attachment");+ assert_eq!(made["fields"]["Type"]["value"], "URL");+ assert_eq!(made["fields"]["URL"]["value"], b64("https://apple.com"));+ let id = bare(made["recordName"].as_str().unwrap()).to_string();+ assert_eq!(+ ops[1]["record"]["fields"]["AttachmentIDs"]["value"],+ json!([id])+ );+ }++ #[tokio::test]+ async fn an_early_alert_needs_an_account_id_from_somewhere() {+ let server = MockServer::start().await;+ lookup(&server, "Reminder/R1", reminder()).await;+ modify_ok(&server).await;+ let http = reqwest::Client::new();+ let refused = set_early_alert_cloudkit(+ &http,+ &server.uri(),+ vec![],+ "Reminder/R1",+ Some((30, 0)),+ None,+ )+ .await;+ assert!(matches!(refused, Err(Error::Refused(_))));+ assert!(modifies(&server.received_requests().await.unwrap()).is_empty());++ set_early_alert_cloudkit(+ &http,+ &server.uri(),+ vec![],+ "Reminder/R1",+ Some((30, 0)),+ Some("ACCT"),+ )+ .await+ .unwrap();+ let ops = modifies(&server.received_requests().await.unwrap());+ let sent = ops[0]["record"]["fields"]["DueDateDeltaAlertsData"]["value"]+ .as_str()+ .unwrap();+ let blob: Value = serde_json::from_slice(&B64.decode(sent).unwrap()).unwrap();+ assert_eq!(blob["accountIdentifier"], "ACCT");+ assert_eq!(blob["dueDateDeltaAlerts"][0]["dueDateDeltaCount"], -30);+ }++ /// The list's file downloaded, changed, uploaded, and the list written with the+ /// receipt and its checksum, only the checksum's token advanced.+ #[tokio::test]+ async fn moving_into_a_section_rewrites_the_lists_file() {+ let server = MockServer::start().await;+ lookup(&server, "Reminder/R1", reminder()).await;+ lookup(&server, "ListSection/S1", json!({ "recordName": "ListSection/S1", "recordChangeTag": "s",+ "fields": { "List": { "type": "REFERENCE", "value": { "recordName": "List/L" } } } })).await;+ lookup(+ &server,+ "\"List/L\"",+ json!({ "recordName": "List/L", "recordChangeTag": "l1",+ "fields": {+ MEMBERSHIP_FILE: { "type": "ASSETID", "value": {+ "downloadURL": format!("{}/file/${{f}}", server.uri()) } },+ "ResolutionTokenMap": { "type": "STRING", "value": "{\"map\":{}}" } } }),+ )+ .await;+ Mock::given(method("GET"))+ .and(path_regex(r"^/file/"))+ .respond_with(ResponseTemplate::new(200).set_body_string(+ r#"{"minimumSupportedVersion":20230430,"memberships":[{"memberID":"X","modifiedOn":1.0,"groupID":"S1"}]}"#,+ ))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r".*/assets/upload$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "tokens": [{ "url": format!("{}/put", server.uri()) }] })))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path_regex(r"^/put$"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "singleFile": { "receipt": "RCPT", "fileChecksum": "c", "wrappingKey": "w", "referenceChecksum": "r" } })))+ .mount(&server)+ .await;+ modify_ok(&server).await;+ let http = reqwest::Client::new();+ move_to_section_cloudkit(+ &http,+ &server.uri(),+ vec![],+ "List/L",+ "Reminder/R1",+ Some("ListSection/S1"),+ )+ .await+ .unwrap();+ let requests = server.received_requests().await.unwrap();+ let uploaded = requests.iter().find(|r| r.url.path() == "/put").unwrap();+ let body = String::from_utf8_lossy(&uploaded.body);+ assert!(body.contains(r#""memberID":"R1""#) && body.contains(r#""groupID":"S1""#));+ assert!(+ body.contains(r#""memberID":"X""#),+ "the other placement kept"+ );+ let ops = modifies(&requests);+ let fields = &ops[0]["record"]["fields"];+ assert_eq!(ops[0]["record"]["recordChangeTag"], "l1");+ assert_eq!(fields[MEMBERSHIP_FILE]["value"]["receipt"], "RCPT");+ assert_eq!(fields[MEMBERSHIP_SUM]["value"].as_str().unwrap().len(), 128);+ let map: Value =+ serde_json::from_str(fields["ResolutionTokenMap"]["value"].as_str().unwrap())+ .unwrap();+ assert_eq!(map["map"].as_object().unwrap().len(), 1);+ }++ #[tokio::test]+ async fn a_section_of_another_list_is_refused() {+ let server = MockServer::start().await;+ lookup(&server, "Reminder/R1", reminder()).await;+ lookup(&server, "ListSection/S9", json!({ "recordName": "ListSection/S9", "recordChangeTag": "s",+ "fields": { "List": { "type": "REFERENCE", "value": { "recordName": "List/OTHER" } } } })).await;+ let http = reqwest::Client::new();+ let r = move_to_section_cloudkit(+ &http,+ &server.uri(),+ vec![],+ "List/L",+ "Reminder/R1",+ Some("ListSection/S9"),+ )+ .await;+ assert!(matches!(r, Err(Error::Refused(_))));+ }+ }+}diff --git a/crates/quince-icloud/src/table.rs b/crates/quince-icloud/src/table.rsindex d6c8945..f422071 100644--- a/crates/quince-icloud/src/table.rs+++ b/crates/quince-icloud/src/table.rs@@ -316,55 +316,619 @@ fn cell_object(document: &[u8], row: usize, column: usize) -> Option<usize> {(doc.object(cell)?.0 == 10).then_some(cell)}-/// The table's document with one cell's text changed, edited as a device edits it.-///-/// Only a cell already typed in is written: its text object exists, and is rewritten in-/// place with its merge records moved in step (the same rewrite a note's body takes). A cell-/// never typed in has no object yet, and making one is not attempted. Before anything is-/// returned it is proven that the rewrite is exact: written back with the text it already-/// had, the document must come out byte for byte as it was — anything this does not model-/// would break that, and the cell is then left alone.+/// Who makes a cell edit, and when: what a phone stamps into the records an edit writes.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct CellEditor {+ /// This installation's replica id: the uuid it signs text with, the same every run (the+ /// app keeps it in the library as `documents.writer`; see `topotext::set_writer`).+ pub replica: [u8; 16],+ /// Unix seconds, for the new attribute run's field 13.+ pub unix_seconds: u64,+ /// The paragraph uuid a cell gets when it has no run to take one from (a cell never+ /// typed in). A phone gives such a cell a fresh one.+ pub paragraph: [u8; 16],+}++impl CellEditor {+ /// This installation, now.+ #[must_use]+ pub fn this_installation() -> Self {+ Self {+ replica: crate::topotext::writer_bytes(),+ unix_seconds: std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .map_or(0, |d| d.as_secs()),+ paragraph: *uuid::Uuid::new_v4().as_bytes(),+ }+ }+}++/// The table's document with one cell's text changed, by this installation, now. See+/// [`with_cell_by`].#[must_use]pub fn with_cell(document: &[u8], row: usize, column: usize, text: &str) -> Option<Vec<u8>> {+ with_cell_by(+ document,+ row,+ column,+ text,+ &CellEditor::this_installation(),+ )+}++/// The table's document with one cell's text changed, written the way a phone writes it+/// (measured; docs/notes-tables-crdt.md):+///+/// - The table's writer list (data field 7) is a map from writer uuid to its clocks (next+/// character, next timestamp), kept **sorted by uuid**, and a writer number in any text of+/// the table is its 1-based place in that sorted list. An editor new to the table goes in+/// at its sorted place, and every text in the table is renumbered to match — the step whose+/// absence (appending instead) made Apple read the phone's own characters as another+/// writer's, and keep both copies.+/// - The cell's merge records: what was typed is a substring under the editor's number with+/// its next character clock; what was removed is marked deleted (never dropped) and stamped+/// with the editor's next timestamp. The cached string is the new text.+/// - The cell's attribute runs: what was typed gets a run of its own, patterned on the run+/// beside it (so its paragraph style and uuid carry on), stamped with the time in Unix+/// seconds at field 13; a cell never typed in gets `{1: n, 2: {9: paragraph uuid}, 13: t}`.+/// - An empty data field 2, which every document a phone has edited carries.+///+/// The version vector (data field 1), the uuid list (field 6) and every other object are left+/// as they are: a phone's text-only edit was measured leaving them untouched. Nor is the+/// record's `ReplicaIDToNotesVersionDataEncrypted` the document's business: it is an+/// account-wide list of devices, identical on every record, that no edit changes.+///+/// Refused (`None`) for anything this cannot do exactly: a writer list that is not sorted (a+/// document an earlier build of this app wrote), records or runs that would not re-encode+/// byte for byte as Apple wrote them, an object of a kind this does not know when texts must+/// be renumbered, or a result that does not read back as the same table with that one cell+/// changed.+#[must_use]+pub fn with_cell_by(+ document: &[u8],+ row: usize,+ column: usize,+ text: &str,+ editor: &CellEditor,+) -> Option<Vec<u8>> {+ let before = cells(document)?;let cell = cell_object(document, row, column)?;let (version_at, version_bytes) = live_version(document)?;let version = fields(version_bytes)?;let data_bytes = bytes(&version, 3).next()?;let data = fields(data_bytes)?;++ let mut writers = TableWriters::read(bytes(&data, 7).next()?)?;let object = bytes(&data, 3).nth(cell)?;- let string = bytes(&fields(object)?, 10).next()?;- let old = bytes(&fields(string)?, 2)- .next()- .map(|b| String::from_utf8_lossy(b).into_owned())- .unwrap_or_default();-- let writers = bytes(&data, 7).next()?;- let rebuild = |new_text: &str| -> Option<Vec<u8>> {- let (new_string, new_writers) = edit_table_text(string, writers, |lent| {- crate::ckdocument::rewrite_text_object(lent, &old, new_text)- })?;- let new_object = splice(object, 10, 0, &new_string)?;- let new_data = splice(- &splice(data_bytes, 3, cell, &new_object)?,- 7,- 0,- &new_writers,- )?;- let new_version = splice(version_bytes, 3, 0, &new_data)?;- splice(document, 2, version_at, &new_version)- };- // The proof: the splice itself, with the string as it was, changes nothing.- let same = splice(object, 10, 0, string)- .and_then(|o| splice(data_bytes, 3, cell, &o))- .and_then(|d| splice(version_bytes, 3, 0, &d))- .and_then(|v| splice(document, 2, version_at, &v))?;- if same != document {+ let mut cell_text = CellText::read(bytes(&fields(object)?, 10).next()?)?;+ let old: Vec<u16> = cell_text.text.encode_utf16().collect();+ let new: Vec<u16> = text.encode_utf16().collect();+ if old == new {+ return Some(document.to_vec());+ }+ let prefix = old.iter().zip(&new).take_while(|(a, b)| a == b).count();+ let suffix = old[prefix..]+ .iter()+ .rev()+ .zip(new[prefix..].iter().rev())+ .take_while(|(a, b)| a == b)+ .count();+ let from = prefix as u64;+ let removed = (old.len() - prefix - suffix) as u64;+ let inserted = (new.len() - prefix - suffix) as u64;++ // The editor's number, and — when it is new to the table and sorts before writers+ // already there — every text renumbered to keep each character with its writer.+ let (me, shift_from) = writers.own(editor.replica);+ let mut objects: Vec<Vec<u8>> = Vec::new();+ for o in bytes(&data, 3) {+ objects.push(match shift_from {+ Some(from) => renumber_object(o, from)?,+ None => o.to_vec(),+ });+ }+ if let Some(from) = shift_from {+ cell_text.renumber(from);+ }++ cell_text.edit(&mut writers, me, from, removed, inserted, editor)?;+ cell_text.text = text.to_owned();+ let string = bytes(&fields(&objects[cell])?, 10).next()?.to_vec();+ let new_string = cell_text.encode(&string)?;+ objects[cell] = splice(&objects[cell], 10, 0, &new_string)?;++ let mut new_data = Vec::with_capacity(data_bytes.len() + 128);+ let mut object_n = 0usize;+ let has_two = data.iter().any(|(t, _)| *t == 2);+ for (tag, raw) in raw_fields(data_bytes)? {+ match tag {+ 1 => {+ new_data.extend_from_slice(raw);+ if !has_two {+ put_len(2, &[], &mut new_data);+ }+ }+ 3 => {+ put_len(3, objects.get(object_n)?, &mut new_data);+ object_n += 1;+ }+ 7 => put_len(7, &writers.encode(), &mut new_data),+ _ => new_data.extend_from_slice(raw),+ }+ }+ let new_version = splice(version_bytes, 3, 0, &new_data)?;+ let out = splice(document, 2, version_at, &new_version)?;++ // It reads back as the same table with that one cell changed.+ let mut expected = before;+ *expected.get_mut(row)?.get_mut(column)? = text.to_owned();+ (cells(&out)? == expected).then_some(out)+}++/// The end marker's character clock.+const END_CLOCK: u64 = 0xFFFF_FFFF;++/// The table's writer list (data field 7): `{1: {1: uuid, 2: {1: next character},+/// 2: {1: next timestamp}}, …}`, sorted by uuid. A text's writer number is a 1-based place in+/// it.+#[derive(Debug, Clone, PartialEq, Eq)]+struct TableWriters(Vec<([u8; 16], Vec<u64>)>);++impl TableWriters {+ /// The list, proven to re-encode as it was written and to be in the order Apple keeps it.+ fn read(list: &[u8]) -> Option<Self> {+ let mut out = Vec::new();+ for (tag, entry) in fields(list)? {+ let (1, Wire::Bytes(entry)) = (tag, entry) else {+ return None;+ };+ let mut uuid = None;+ let mut clocks = Vec::new();+ for (tag, value) in fields(entry)? {+ match (tag, value) {+ (1, Wire::Bytes(u)) if uuid.is_none() => {+ uuid = Some(<[u8; 16]>::try_from(u).ok()?);+ }+ (2, Wire::Bytes(c)) => {+ let cf = fields(c)?;+ if cf.len() != 1 {+ return None;+ }+ clocks.push(int(&cf, 1)?);+ }+ _ => return None,+ }+ }+ out.push((uuid?, clocks));+ }+ let writers = Self(out);+ let sorted = writers.0.windows(2).all(|w| w[0].0 < w[1].0);+ (sorted && writers.encode() == list).then_some(writers)+ }++ fn encode(&self) -> Vec<u8> {+ let mut list = Vec::new();+ for (uuid, clocks) in &self.0 {+ let mut entry = Vec::new();+ put_len(1, uuid, &mut entry);+ for c in clocks {+ let mut clock = Vec::new();+ put_int(1, *c, &mut clock);+ put_len(2, &clock, &mut entry);+ }+ put_len(1, &entry, &mut list);+ }+ list+ }++ /// The editor's 1-based number. One new to the list goes in at its sorted place, clocks+ /// at zero; then every number from that place up moves up one, and that place is+ /// answered too (`None` when nothing moves).+ fn own(&mut self, replica: [u8; 16]) -> (u64, Option<u64>) {+ let (at, shift) = match self.0.binary_search_by(|(u, _)| u.cmp(&replica)) {+ Ok(at) => (at, None),+ Err(at) => {+ self.0.insert(at, (replica, vec![0, 0]));+ let moved = at + 1 < self.0.len();+ (at, moved.then_some(at as u64 + 1))+ }+ };+ while self.0[at].1.len() < 2 {+ self.0[at].1.push(0);+ }+ (at as u64 + 1, shift)+ }++ /// Take `n` characters (`which` 0) or timestamps (`which` 1) from writer `me`'s clock.+ fn take(&mut self, me: u64, which: usize, n: u64) -> Option<u64> {+ let clock = self+ .0+ .get_mut(usize::try_from(me.checked_sub(1)?).ok()?)?+ .1+ .get_mut(which)?;+ let at = *clock;+ *clock += n;+ Some(at)+ }+}++/// One substring of a table text's merge records: `{1: id, 2: length, 3: timestamp,+/// 4: deleted, 5: next}`, where an id and a timestamp are `{1: writer, 2: clock}`.+#[derive(Debug, Clone, PartialEq, Eq)]+struct Piece {+ id: (u64, u64),+ length: u64,+ stamp: (u64, u64),+ deleted: bool,+}++fn pair_of(b: &[u8]) -> Option<(u64, u64)> {+ let f = fields(b)?;+ if f.iter()+ .any(|(t, w)| !matches!((t, w), (1 | 2, Wire::Int(_))))+ {+ return None;+ }+ Some((int(&f, 1).unwrap_or(0), int(&f, 2).unwrap_or(0)))+}++fn put_pair(tag: u64, (a, b): (u64, u64), out: &mut Vec<u8>) {+ let mut m = Vec::new();+ put_int(1, a, &mut m);+ put_int(2, b, &mut m);+ put_len(tag, &m, out);+}++/// A text's merge records, refused unless they are one chain from the start marker to the+/// end marker, in reading order, that re-encodes byte for byte.+fn read_pieces(text: &[u8]) -> Option<Vec<Piece>> {+ let mut pieces = Vec::new();+ let mut original = Vec::new();+ for (i, raw) in bytes(&fields(text)?, 3).enumerate() {+ put_len(3, raw, &mut original);+ let mut p = Piece {+ id: (0, 0),+ length: 0,+ stamp: (0, 0),+ deleted: false,+ };+ let mut next = None;+ for (tag, value) in fields(raw)? {+ match (tag, value) {+ (1, Wire::Bytes(b)) => p.id = pair_of(b)?,+ (2, Wire::Int(v)) => p.length = v,+ (3, Wire::Bytes(b)) => p.stamp = pair_of(b)?,+ (4, Wire::Int(v)) => p.deleted = v != 0,+ (5, Wire::Int(v)) if next.is_none() => next = Some(v),+ _ => return None,+ }+ }+ if next.is_some_and(|n| n != i as u64 + 1) {+ return None;+ }+ pieces.push(p);+ }+ let n = pieces.len();+ if n < 2+ || pieces[0].id != (0, 0)+ || pieces[0].length != 0+ || pieces[n - 1].id != (0, END_CLOCK)+ || pieces[n - 1].length != 0+ {return None;}- let out = rebuild(text)?;- // And what was written reads back as meant.- let read = cells(&out)?;- (read.get(row)?.get(column)? == text).then_some(out)+ (encode_pieces(&pieces) == original).then_some(pieces)+}++fn encode_pieces(pieces: &[Piece]) -> Vec<u8> {+ let mut out = Vec::new();+ let last = pieces.len().saturating_sub(1);+ for (i, p) in pieces.iter().enumerate() {+ let mut m = Vec::new();+ put_pair(1, p.id, &mut m);+ put_int(2, p.length, &mut m);+ put_pair(3, p.stamp, &mut m);+ if p.deleted {+ put_int(4, 1, &mut m);+ }+ if i != last {+ put_int(5, i as u64 + 1, &mut m);+ }+ put_len(3, &m, &mut out);+ }+ out+}++/// Writer numbers from `from` up moved up one, in a run of pieces. Number 0 (the markers)+/// is nobody's and stays.+fn renumber_pieces(pieces: &mut [Piece], from: u64) {+ for p in pieces {+ if p.id.0 >= from {+ p.id.0 += 1;+ }+ if p.stamp.0 >= from {+ p.stamp.0 += 1;+ }+ }+}++/// A text message with its merge records replaced, every other field where it was.+fn with_pieces(text: &[u8], pieces: &[Piece]) -> Option<Vec<u8>> {+ let mut out = Vec::with_capacity(text.len() + 16);+ let mut wrote = false;+ for (tag, raw) in raw_fields(text)? {+ match tag {+ 3 if !wrote => {+ out.extend(encode_pieces(pieces));+ wrote = true;+ }+ 3 => {}+ _ => out.extend_from_slice(raw),+ }+ }+ wrote.then_some(out)+}++/// A text message renumbered (see [`renumber_pieces`]).+fn renumber_text(text: &[u8], from: u64) -> Option<Vec<u8>> {+ let mut pieces = read_pieces(text)?;+ renumber_pieces(&mut pieces, from);+ with_pieces(text, &pieces)+}++/// A table object with the writer numbers in its texts renumbered: a cell's text (kind 10)+/// and an ordered set's (kind 16, at 1 → 1 → 1). Objects that hold no text — registers+/// (1), dictionaries (6), custom objects (13) — are kept as they are; any other kind is one+/// this does not know, and refused.+fn renumber_object(object: &[u8], from: u64) -> Option<Vec<u8>> {+ let of = fields(object)?;+ let [(kind, Wire::Bytes(body))] = of.as_slice() else {+ return None;+ };+ match kind {+ 1 | 6 | 13 => Some(object.to_vec()),+ 10 => splice(object, 10, 0, &renumber_text(body, from)?),+ 16 => {+ let array = bytes(&fields(body)?, 1).next()?;+ let string_array = bytes(&fields(array)?, 1).next()?;+ let text = bytes(&fields(string_array)?, 1).next()?;+ let string_array = splice(string_array, 1, 0, &renumber_text(text, from)?)?;+ let array = splice(array, 1, 0, &string_array)?;+ splice(object, 16, 0, &splice(body, 1, 0, &array)?)+ }+ _ => None,+ }+}++/// A cell's text object, as far as an edit touches it: the cached text, its merge records in+/// reading order, and its attribute runs. Every other field is copied through.+struct CellText {+ text: String,+ pieces: Vec<Piece>,+ runs: Vec<Vec<u8>>,+}++fn run_units(run: &[u8]) -> Option<u64> {+ int(&fields(run)?, 1)+}++impl CellText {+ /// A cell's text, refused unless its records read (see [`read_pieces`]) and agree with+ /// its text, and its runs cover the text exactly.+ fn read(object: &[u8]) -> Option<Self> {+ let f = fields(object)?;+ // A writer list inside the text: no phone writes one in a table.+ if bytes(&f, 4).next().is_some() {+ return None;+ }+ let text = String::from_utf8(bytes(&f, 2).next()?.to_vec()).ok()?;+ let pieces = read_pieces(object)?;+ let runs: Vec<Vec<u8>> = bytes(&f, 5).map(<[u8]>::to_vec).collect();+ let units = text.encode_utf16().count() as u64;+ let live: u64 = pieces.iter().filter(|p| !p.deleted).map(|p| p.length).sum();+ let covered = runs.iter().map(|r| run_units(r)).sum::<Option<u64>>()?;+ (live == units && covered == units).then_some(Self { text, pieces, runs })+ }++ fn renumber(&mut self, from: u64) {+ renumber_pieces(&mut self.pieces, from);+ }++ /// The object with this text, these records and these runs in the places the old ones+ /// held; every other field as it was.+ fn encode(&self, original: &[u8]) -> Option<Vec<u8>> {+ let mut runs = Vec::new();+ for r in &self.runs {+ put_len(5, r, &mut runs);+ }+ let mut out = Vec::with_capacity(original.len() + 64);+ let (mut wrote_pieces, mut wrote_runs) = (false, false);+ for (tag, raw) in raw_fields(original)? {+ match tag {+ 2 => put_len(2, self.text.as_bytes(), &mut out),+ 3 if !wrote_pieces => {+ out.extend(encode_pieces(&self.pieces));+ wrote_pieces = true;+ }+ 5 if !wrote_runs => {+ out.extend_from_slice(&runs);+ wrote_runs = true;+ }+ 3 | 5 => {}+ _ => out.extend_from_slice(raw),+ }+ }+ // A cell never typed in has no runs; they go after its records, where a phone puts+ // them.+ if !wrote_runs {+ out.extend_from_slice(&runs);+ }+ wrote_pieces.then_some(out)+ }++ /// Make live offset `at` fall between two pieces.+ fn split_at(&mut self, at: u64) {+ let mut offset = 0;+ for i in 0..self.pieces.len() {+ if self.pieces[i].deleted {+ continue;+ }+ let len = self.pieces[i].length;+ if offset < at && at < offset + len {+ let keep = at - offset;+ let mut tail = self.pieces[i].clone();+ tail.id.1 += keep;+ tail.length -= keep;+ self.pieces[i].length = keep;+ self.pieces.insert(i + 1, tail);+ return;+ }+ offset += len;+ }+ }++ /// `removed` units at `from` replaced by `inserted` new ones, by writer `me`, in the+ /// records and the runs.+ fn edit(+ &mut self,+ writers: &mut TableWriters,+ me: u64,+ from: u64,+ removed: u64,+ inserted: u64,+ editor: &CellEditor,+ ) -> Option<()> {+ if removed > 0 {+ // Marked deleted, never dropped, and stamped: each deletion a phone makes+ // carries the timestamp it was made at.+ let stamp = (me, writers.take(me, 1, 1)?);+ self.split_at(from);+ self.split_at(from + removed);+ let mut offset = 0;+ for p in &mut self.pieces {+ if p.deleted {+ continue;+ }+ if offset >= from && offset + p.length <= from + removed && p.length > 0 {+ p.deleted = true;+ p.stamp = stamp;+ }+ offset += p.length;+ }+ }+ if inserted > 0 {+ self.split_at(from);+ // Right after the live character before `from` (after the start marker at 0).+ let mut offset = 0;+ let mut place = self.pieces.len() - 1;+ for (i, p) in self.pieces.iter().enumerate().skip(1) {+ if offset == from {+ place = i;+ break;+ }+ if !p.deleted {+ offset += p.length;+ }+ }+ let clock = writers.take(me, 0, inserted)?;+ let stamp = writers.take(me, 1, 1)?;+ self.pieces.insert(+ place,+ Piece {+ id: (me, clock),+ length: inserted,+ stamp: (me, stamp),+ deleted: false,+ },+ );+ }+ self.runs = edit_runs(&self.runs, from, removed, inserted, editor)?;+ Some(())+ }+}++/// `run` with field `tag` set to `value` (a varint), in its place or appended.+fn with_run_int(run: &[u8], tag: u64, value: u64) -> Option<Vec<u8>> {+ let mut out = Vec::with_capacity(run.len() + 6);+ let mut set = false;+ for (t, raw) in raw_fields(run)? {+ if t == tag {+ if !set {+ put_int(tag, value, &mut out);+ set = true;+ }+ } else {+ out.extend_from_slice(raw);+ }+ }+ if !set {+ put_int(tag, value, &mut out);+ }+ Some(out)+}++/// A cell's attribute runs after an edit, as a phone leaves them: what was removed cut out+/// of the runs it fell in, and what was typed a run of its own at its place, patterned on+/// the run before it (else the one after), so the paragraph style and its uuid carry on, and+/// stamped with the time (field 13). With no run to pattern on (a cell never typed in) it is+/// `{1: n, 2: {9: paragraph uuid}, 13: t}`.+fn edit_runs(+ runs: &[Vec<u8>],+ from: u64,+ removed: u64,+ inserted: u64,+ editor: &CellEditor,+) -> Option<Vec<Vec<u8>>> {+ let end = from + removed;+ // (pattern, length), and where the new run goes with what it is patterned on.+ let mut out: Vec<(Vec<u8>, u64)> = Vec::with_capacity(runs.len() + 2);+ let mut slot: Option<(usize, Vec<u8>)> = None;+ let mut cursor = 0u64;+ for run in runs {+ let len = run_units(run)?;+ let (start, stop) = (cursor, cursor + len);+ cursor = stop;+ let head = from.saturating_sub(start).min(len);+ let tail = stop.saturating_sub(end).min(len);+ if head + tail > len {+ return None;+ }+ if head > 0 {+ out.push((run.clone(), head));+ if slot.is_none() && from <= stop {+ slot = Some((out.len(), run.clone()));+ }+ } else if slot.is_none() && from <= start {+ slot = Some((out.len(), run.clone()));+ }+ if tail > 0 {+ out.push((run.clone(), tail));+ }+ }+ if inserted > 0 {+ let (at, pattern) = slot.unwrap_or_else(|| {+ (+ out.len(),+ out.last().map(|(r, _)| r.clone()).unwrap_or_default(),+ )+ });+ let pattern = if pattern.is_empty() {+ let mut style = Vec::new();+ put_len(9, &editor.paragraph, &mut style);+ let mut run = Vec::new();+ put_int(1, inserted, &mut run);+ put_len(2, &style, &mut run);+ run+ } else {+ pattern+ };+ let run = with_run_int(&pattern, 13, editor.unix_seconds)?;+ out.insert(at.min(out.len()), (run, inserted));+ }+ out.into_iter()+ .filter(|(_, n)| *n > 0)+ .map(|(r, n)| with_run_int(&r, 1, n))+ .collect()}/// A table's text (a cell or an ordered set's) edited by `edit`, against the writer list@@ -386,6 +950,11 @@ fn edit_table_text(put_len(4, writers, &mut lent);let edited = edit(&lent)?;let new_writers = bytes(&fields(&edited)?, 4).next()?.to_vec();+ // Apple keeps this list sorted by uuid and reads a writer number as a place in that+ // order; a writer appended out of order would hand the phone's characters to another+ // writer (docs/notes-tables-crdt.md). Row and column writes do not renumber, so they are+ // refused when the list would come out unsorted.+ TableWriters::read(&new_writers)?;let mut back = Vec::with_capacity(edited.len());for (tag, raw) in raw_fields(&edited)? {if tag != 4 {@@ -1143,3 +1712,341 @@ pub fn cells(document: &[u8]) -> Option<Vec<Vec<String>>> {.collect(),)}++#[cfg(test)]+mod tests {+ use super::*;++ /// A 2×2 table a phone made and nobody typed in (iOS, 2026-10-21), gzip + base64.+ const PHONE_BLANK: &[&str] = &[+ "H4sIAAAAAAAC/+NgEJrCx8EgwCDVy8fFxsUCZDJKBWT5cQhIaXEwCKkpqRhAgS4WAgak2DgYhZgMGIE0M5BmBtKs",+ "QJoDSLMBaV4pHi4uiNlAHpOUbpY2B6OUOgeTkLKSonNQSGJSTqpzfk5pbp5LZlFqcklmfp5PalpJSH5QZnpGidR5",+ "xibG04xcixi5qrh8hNje798DRFICYANBLgfTGoxgEUagCJMUmNZgkhLj4gDK/QcCfqA6OFuLiYMRhIVEgF4UcN8/",+ "Zdc0O58NW/8ompg/bY4GijIKCXRslzZpf+khtX1CwmqWOrGjQipcAlxMBiBvsUhBAwoswg4UYYOJIKlixVDFDhOR",+ "4sni4mACBg6LEBMajwmFx4zCY6F1SFy+5dZXeNKjYYXps9Rqi3hhSEiULeB1iFVzXbrz8ZdVur7zYqB+5AL6iBPF",+ "jzxAEW60kACp4sJQxYM1JFhReGwoPHYUHoeUmhHEfE6gaXwo5nMDRQTh5sPUAXUZ8KOoAyVMAbg6vSAdIQYsIYkj",+ "3EhWj+wOIQx3CNPLHUocmSmpeSWZJZVKYslF2DKeEktxak6aEltyUVB+ebESZ2iop4tnXkpqhRJnchFEbbESd3Jq",+ "Tg6UoyWenJ+rl1hQkJOq5xzkEqLnF+xXmpuUWoRFIrikKDMvXUsUQwJki5YYmjCwZCgFcrQ0MMSDUtMzi0tSi3xL",+ "c0oywxJzSlN9UhOLS7SUiVCJYTvQmqLUVC1JrMJ++SmpWNzrkliSiF04VcsQIZyXX5JarOfp7JyTX5oSXJmXDPS9",+ "f1IWMKQdgYFdBowG1zJgdCD7EKbFDegfkI7g1BxIxASXgAxXwlQZEuJYmpKZH5SanF+UAgpebcJq9NyKEtNzQVar",+ "YlMcUpSYV5xclFlQEpwKUSaOrgxabGNKAPWDJIwEHnPIZbx94qQ1MeuT0uaqqWuNBNq5omP9WF339HemNm5q7ftn",+ "hFHKGglcUoqI7r3svah/1rrP+k5J+4wwymcjgVOTnsYvMnO+Nl2xUaJ21UQzI4ySy0jgMMe39l/s/mH7/LPf5135",+ "8tQIoxyzkuGS4sJwpRATsFpi4mAEAHKl+GwZBwAA",+ ];++ /// A table a phone made and then typed into, cell by cell, with a row added and one+ /// removed along the way (iOS, 2026-10-21). Its cells' text is replaced by synthetic text+ /// of the same lengths; every merge record, run and clock is the phone's.+ const PHONE_TYPED: &[&str] = &[+ "H4sIAAAAAAAC/5WXfUwTdxjHe20p16PAcSDMU6CUt7NAxbo450SEIorWoqXo3IvSl4OWlRbKVcAti69TTJyZmc6J",+ "0+iWLYvbPzPuTadzW5YsZm/J4v7YjMl02aIyEufcH4ruud7TjnJH5y7A736f5/t7e+55fj9+pIo5XEyqaBW7v5jS",+ "UVp41TAqdlW3g6RZM6liKkxltfjUKPyJP6yOJBh1LQGlBkoNlGlQUlDqoMxmDRQV611Uqdma7iqSYCtJNVNqKrE5",+ "XW5PkLeFg9GeUFMgwnuFQDhk5zsFV9gZ6PIL7G1iK3GToL4iqBcJqoPRjZ07Az8sHetRnHys5IgYIYCo2VjJqVkm",+ "RtQ0ESOkkeA0bD5Fgv4+PNnQNvFuVpOE+Mvkwbrp1Rvn/zY81vrGiZIKZt3XxzKAEgxtOFZ3/uOTKzefqLGf/fHX",+ "ez8w8yiaUteKa9Wykv/UMZIORIeEiBE9EDJOmLKEKl2m0scJa+imSDX4UMuoJ9XUSTVNUk2bVEtLqunYb8GZFwjq",+ "OEFtouz/y5cP5LcFLTfWOi7ZRg7MO/5e48i8IslvH3158hH3KXvhzvq5dcSbjgJcvwFWm5G0/iwgmZO8JKoMMlWW",+ "opfSk2pkUk2fVKPYCqvUfyb0Rif1nwEkN9F/XCdGck6SjgTCJHRntc7TWqa0bSgk+Hkh4DV6+WDQKPCDQrVRGOrl",+ "fcZwyOg29vrDU7pbD58rOXSzMHQzYqErsWxkFDAtMhqZHlgashz8eGJbHY6QC+EhjZCOqgIICrE0gIpEVSG4TlLp",+ "UVWOfWWDikJWiWNmActAxiHLBGZANgtHENtm4gizaQZHyJoysGZC6DDL6SPnG/vmd7buff/o3pbvlub0+a/d/eWi",+ "DqxaRev1lNZRtJKK1jG06hWtf6JVo2i9hdY0RetfaFVe0W3Rylqc1bD5ymNjCv8kBWaeLDCnJQLT5/QwOiksp4w8",+ "DX6jVIk+EzZzmP03qufNRZ/ZF50b+aDn1uhpj//32Oy3G5xbDEz9A4R/iH/MCBpjXzTgfcboiYQHQsbO8KCxO9rT",+ "O+UEGzCwaJigRBqR5EBiSMSGhIG0kEgTktxEUixBYowlhcSakRUDi6fFUmRFsbSQ2DJkBcD0OEILshJIC4ksR2KC",+ "pJDICiSlkBISsSMpSyTESiTlkBAScSCp4LKRtCKp5Ggkq5BwXA6S1UhmcQwSJxIzl4ukDUkVl4fEhaSam4akHUkN",+ "l49kDRILV4BkLZLZ3ENIHkdSy01Hsg7JHI5F8gQSKzcDyZNI5nIzkTyF5GGuEH3/NJI68H0RsvXIFgErRrYBWT0w",+ "I7IOZIuBlSBzI3sUmAlH9cCpICVBKaqCuCE3gKoMVX2JVClH1QD2ZQNVBbJBZI3AKrHlEJzUUksOVc/BiRWLU1DN",+ "YnOoNHjfRmBTFWdmc2NoexwtB10Vwh1x2AKwGuELcbgMYA3CnXG4FKAF4a44bAY4G+FwHC4BWIsT2g1HCE5oDur2",+ "x3UrQGdF3QEicWzMTbGJaBU3kb8nbp8y652Jm7rMei9l2/toVStaN4+n6nkLWilF6za0Km+L28cnHBcy687xCQeC",+ "zDo8nmpFr6Sc88HxVOt9NeW4h1L2PJJyRYdFq4kM+PiQEBCGTPneiNJ/9iZtPx/sNOm8EWd4oN+kb29vaWoJ+fhB",+ "k94bkbT9pgzx8MCKucAb7rG4e3uDvMXmbHJZHG2OaI+HjygY2oRIINRlniYziKOY8ydhuHpEoWLmZNzJdwX6BT6y",+ "MhoUAmvcwShv5939grn0AZSy0WGYCM+bpytiR9jHK8y3yS24lTFvnvMvDoUFvt/SYrMFw1EfHL1eWH2rpxs83QDO",+ "3gifYclG+BwTVxhv0gzrEVu08UHpw7QJYucmudLlaoj6AmEn7w1HfKJ7q/5bY2mOuLt6xKHLlcSuiDvU740EeoU2",+ "XpIVTJbhvVBugPaiwUpfIYv8o1cbzS913zSd3LT/XSvd137twpqqVueZZwf/yOtYyFrps3s+vHjm58YTw0MvDwwM",+ "f3HISr/16cG6oHbx6NFPOiLrxywuq+yuZ6UXlmXssVau2HDknd2rr3iMn1tlNz8rPey/dGdfiUP19vWrpnv7Xrts",+ "ld19rLTvxo7y+ruLf9p1uX3P6/5T31tlN6EFhdQMSrYSRkMegasyaf8Hd6TLFqEPAAA=",+ ];++ fn phone(parts: &[&str]) -> Vec<u8> {+ use base64::Engine;+ let raw = base64::engine::general_purpose::STANDARD+ .decode(parts.concat())+ .unwrap();+ inflate(&raw).unwrap()+ }++ fn editor(first: u8) -> CellEditor {+ CellEditor {+ replica: [first; 16],+ unix_seconds: 1_792_600_000,+ paragraph: [0x5a; 16],+ }+ }++ fn data(document: &[u8]) -> Vec<u8> {+ let version = fields(live_version(document).unwrap().1).unwrap();+ let data = bytes(&version, 3).next().unwrap().to_vec();+ data+ }++ fn writers(document: &[u8]) -> TableWriters {+ TableWriters::read(bytes(&fields(&data(document)).unwrap(), 7).next().unwrap()).unwrap()+ }++ /// Data fields 1 (version vector) and 6 (uuids), as written.+ fn structure_clocks(document: &[u8]) -> (Vec<Vec<u8>>, Vec<Vec<u8>>) {+ let d = data(document);+ let f = fields(&d).unwrap();+ (+ bytes(&f, 1).map(<[u8]>::to_vec).collect(),+ bytes(&f, 6).map(<[u8]>::to_vec).collect(),+ )+ }++ /// Each object's texts as pieces whose writer is a uuid, not a number: who wrote what.+ /// A piece with its writer as a uuid (none for the markers): writer, clock, length, deleted.+ type Owned = (Option<[u8; 16]>, u64, u64, bool);++ fn attributed(document: &[u8]) -> Vec<Vec<Owned>> {+ let list = writers(document);+ let d = data(document);+ bytes(&fields(&d).unwrap(), 3)+ .map(|o| {+ let (kind, body) = match fields(o).unwrap().first().unwrap() {+ (k, Wire::Bytes(b)) => (*k, *b),+ _ => unreachable!(),+ };+ let text = match kind {+ 10 => body.to_vec(),+ 16 => {+ let a = bytes(&fields(body).unwrap(), 1).next().unwrap();+ let s = bytes(&fields(a).unwrap(), 1).next().unwrap();+ bytes(&fields(s).unwrap(), 1).next().unwrap().to_vec()+ }+ _ => return Vec::new(),+ };+ read_pieces(&text)+ .unwrap()+ .iter()+ .map(|p| {+ let who = (p.id.0 > 0).then(|| list.0[p.id.0 as usize - 1].0);+ (who, p.id.1, p.length, p.deleted)+ })+ .collect()+ })+ .collect()+ }++ /// Field numbers in order, a repeat folded into one.+ fn tags(message: &[u8]) -> Vec<u64> {+ let mut out: Vec<u64> = Vec::new();+ for (t, _) in fields(message).unwrap() {+ if out.last() != Some(&t) {+ out.push(t);+ }+ }+ out+ }++ fn cell_text(document: &[u8], row: usize, column: usize) -> Vec<u8> {+ let at = cell_object(document, row, column).unwrap();+ let d = data(document);+ let object = bytes(&fields(&d).unwrap(), 3).nth(at).unwrap().to_vec();+ let text = bytes(&fields(&object).unwrap(), 10)+ .next()+ .unwrap()+ .to_vec();+ text+ }++ fn dominates(after: &TableWriters, before: &TableWriters) -> bool {+ let ge =+ before.0.iter().all(|(u, c)| {+ after.0.iter().find(|(v, _)| v == u).is_some_and(|(_, d)| {+ d.len() >= c.len() && d.iter().zip(c).all(|(x, y)| x >= y)+ })+ });+ ge && after != before+ }++ #[test]+ fn the_phone_documents_read_as_phone_tables() {+ assert_eq!(+ cells(&phone(PHONE_BLANK)).unwrap(),+ vec![vec![String::new(); 2]; 2]+ );+ let typed = cells(&phone(PHONE_TYPED)).unwrap();+ assert_eq!(typed.len(), 2);+ assert_eq!(typed[1][1], "");+ assert_eq!(typed[0][0].encode_utf16().count(), 6);+ // One writer, the phone, its list sorted as every list Apple writes is.+ assert_eq!(writers(&phone(PHONE_TYPED)).0.len(), 1);+ }++ /// Writers that sort before the phone's (as this installation's 6b… does) and after it.+ #[test]+ fn an_edit_to_a_phone_typed_table_reads_back_and_its_clocks_dominate() {+ let base = phone(PHONE_TYPED);+ for first in [0x10, 0x6b, 0xf0] {+ let out = with_cell_by(&base, 1, 1, "Synthetic", &editor(first)).unwrap();+ let mut expected = cells(&base).unwrap();+ expected[1][1] = "Synthetic".into();+ assert_eq!(cells(&out).unwrap(), expected);+ assert!(dominates(&writers(&out), &writers(&base)));+ // And an edit on top of that one dominates it in turn, as the same writer.+ let again = with_cell_by(&out, 1, 1, "Synth", &editor(first)).unwrap();+ assert_eq!(cells(&again).unwrap()[1][1], "Synth");+ assert!(dominates(&writers(&again), &writers(&out)));+ assert_eq!(writers(&again).0.len(), 2);+ // The table's structure clock is a phone's to move, not a text edit's.+ assert_eq!(structure_clocks(&again), structure_clocks(&base));+ }+ }++ #[test]+ fn a_round_trip_keeps_every_phone_replica_and_who_wrote_what() {+ let base = phone(PHONE_TYPED);+ let before = attributed(&base);+ // Into the middle of a typed cell, by a writer that sorts first.+ let old = cells(&base).unwrap()[0][1].clone();+ let mut text = old.clone();+ text.insert_str(4, "XY");+ let out = with_cell_by(&base, 0, 1, &text, &editor(0x01)).unwrap();+ assert_eq!(cells(&out).unwrap()[0][1], text);+ let after = attributed(&out);+ let edited = cell_object(&base, 0, 1).unwrap();+ for (i, (b, a)) in before.iter().zip(&after).enumerate() {+ if i == edited {+ // Every character the phone wrote is still the phone's, live or deleted.+ let live = |v: &[Owned]| {+ v.iter()+ .filter(|p| p.0.is_some())+ .flat_map(|&(w, c, n, d)| (c..c + n).map(move |k| (w, k, d)))+ .collect::<Vec<_>>()+ };+ let mine = Some([0x01; 16]);+ let theirs: Vec<_> = live(a).into_iter().filter(|p| p.0 != mine).collect();+ assert_eq!(theirs, live(b));+ } else {+ assert_eq!(a, b, "object {i} attributed as the phone wrote it");+ }+ }+ // Every replica entry the phone wrote is kept: its clocks, the structure's clock and+ // its uuids.+ let w = writers(&out);+ for (u, c) in &writers(&base).0 {+ assert_eq!(w.0.iter().find(|(v, _)| v == u).map(|x| &x.1), Some(c));+ }+ assert_eq!(structure_clocks(&out), structure_clocks(&base));+ assert_eq!(w.0[0].0, [0x01; 16], "the new writer at its sorted place");+ }++ /// What a write changes, against what a phone's own edits changed (blank → typed): the+ /// same fields in the same order, at every level, and nothing else.+ #[test]+ fn a_write_mirrors_a_phone_write_field_for_field() {+ let blank = phone(PHONE_BLANK);+ let typed = phone(PHONE_TYPED);+ let ours = with_cell_by(&blank, 0, 0, "Hi there", &editor(0xf0)).unwrap();++ // The document: version vector, the empty field 2 a phone adds, objects, keys, types,+ // uuids, writers.+ assert_eq!(tags(&data(&ours)), tags(&data(&typed)));+ assert_eq!(tags(&data(&ours)), vec![1, 2, 3, 4, 5, 6, 7]);+ assert!(!fields(&data(&blank)).unwrap().iter().any(|(t, _)| *t == 2));++ // The cell: text, records, runs.+ let phone_cell = cell_text(&typed, 0, 0);+ let our_cell = cell_text(&ours, 0, 0);+ assert_eq!(tags(&our_cell), tags(&phone_cell));+ assert_eq!(tags(&our_cell), vec![2, 3, 5]);+ let pieces = |c: &[u8]| -> Vec<Vec<u8>> {+ bytes(&fields(c).unwrap(), 3).map(<[u8]>::to_vec).collect()+ };+ let (p, o) = (pieces(&phone_cell), pieces(&our_cell));+ assert_eq!(p.len(), 3, "start, the typed stretch, end");+ assert_eq!(o.len(), 3);+ for (a, b) in p.iter().zip(&o) {+ assert_eq!(tags(a), tags(b));+ for t in [1, 3] {+ assert_eq!(+ tags(bytes(&fields(a).unwrap(), t).next().unwrap()),+ vec![1, 2]+ );+ assert_eq!(+ tags(bytes(&fields(b).unwrap(), t).next().unwrap()),+ vec![1, 2]+ );+ }+ }+ // The run: length, paragraph style {9: uuid}, time.+ let runs = |c: &[u8]| -> Vec<Vec<u8>> {+ bytes(&fields(c).unwrap(), 5).map(<[u8]>::to_vec).collect()+ };+ let (pr, or) = (runs(&phone_cell), runs(&our_cell));+ assert_eq!(or.len(), 1);+ assert_eq!(tags(&pr[0]), tags(&or[0]));+ assert_eq!(tags(&or[0]), vec![1, 2, 13]);+ let style = |r: &[u8]| bytes(&fields(r).unwrap(), 2).next().unwrap().to_vec();+ assert_eq!(tags(&style(&pr[0])), vec![9]);+ assert_eq!(style(&or[0]), [&[0x4a, 16][..], &[0x5a; 16]].concat());+ assert_eq!(int(&fields(&or[0]).unwrap(), 13), Some(1_792_600_000));++ // The writers: each entry {1: uuid, 2: {1: chars}, 2: {1: stamps}}, sorted.+ let w = writers(&ours);+ assert_eq!(w.0.len(), 2);+ assert!(w.0.iter().all(|(_, c)| c.len() == 2));+ assert_eq!(w.0[1], ([0xf0; 16], vec![8, 1]));+ assert_eq!(w.0[0], writers(&blank).0[0], "the phone's entry as it was");++ // Nothing else moved: every other object byte for byte, the structure clock too.+ let edited = cell_object(&blank, 0, 0).unwrap();+ let (b, o) = (data(&blank), data(&ours));+ let objects = |d: &[u8]| -> Vec<Vec<u8>> {+ bytes(&fields(d).unwrap(), 3).map(<[u8]>::to_vec).collect()+ };+ for (i, (x, y)) in objects(&b).iter().zip(objects(&o).iter()).enumerate() {+ if i != edited {+ assert_eq!(x, y, "object {i}");+ }+ }+ assert_eq!(structure_clocks(&ours), structure_clocks(&blank));+ }++ /// A deletion is stamped when it is made, as each of the phone's are; the characters stay.+ #[test]+ fn a_deletion_is_stamped_and_kept_as_a_phone_keeps_one() {+ let blank = phone(PHONE_BLANK);+ let one = with_cell_by(&blank, 1, 0, "Hello", &editor(0xf0)).unwrap();+ let two = with_cell_by(&one, 1, 0, "Help", &editor(0xf0)).unwrap();+ assert_eq!(cells(&two).unwrap()[1][0], "Help");+ let pieces = read_pieces(&cell_text(&two, 1, 0)).unwrap();+ let me = 2;+ let deleted: Vec<_> = pieces.iter().filter(|p| p.deleted).collect();+ assert_eq!(deleted.len(), 1);+ assert_eq!(+ (deleted[0].id, deleted[0].length),+ ((me, 3), 2),+ "\"lo\" kept, deleted"+ );+ assert_eq!(deleted[0].stamp, (me, 1), "stamped with the next timestamp");+ let typed = pieces+ .iter()+ .find(|p| !p.deleted && p.id == (me, 5))+ .unwrap();+ assert_eq!((typed.length, typed.stamp), (1, (me, 2)));+ // The runs still cover the text exactly.+ let runs: u64 = bytes(&fields(&cell_text(&two, 1, 0)).unwrap(), 5)+ .map(|r| run_units(r).unwrap())+ .sum();+ assert_eq!(runs, 4);+ assert_eq!(writers(&two).0[1].1, vec![6, 3]);+ }++ /// A list this app once wrote out of order cannot be read the way Apple reads it, so it is+ /// not written to.+ #[test]+ fn an_unsorted_writer_list_is_refused() {+ let mut w = writers(&phone(PHONE_BLANK));+ w.0.insert(0, ([0xff; 16], vec![1, 1]));+ assert!(TableWriters::read(&w.encode()).is_none());+ }+}diff --git a/crates/quince-icloud/tests/fuzz_notes.rs b/crates/quince-icloud/tests/fuzz_notes.rsnew file mode 100644index 0000000..b50d353--- /dev/null+++ b/crates/quince-icloud/tests/fuzz_notes.rs@@ -0,0 +1,108 @@+//! A note's document is whatever its record holds — a shared note's, anyone's. Malformed bytes+//! make a note unreadable, never the app panic: random bytes, and a real document cut and+//! flipped, go through every reader.++use quince_icloud::{ckdocument, mergeable, topotext};++/// A small, seeded generator: the same run every time.+struct Rng(u64);+impl Rng {+ fn next(&mut self) -> u64 {+ self.0 ^= self.0 << 13;+ self.0 ^= self.0 >> 7;+ self.0 ^= self.0 << 17;+ self.0+ }+ fn below(&mut self, n: usize) -> usize {+ usize::try_from(self.next() % n.max(1) as u64).unwrap_or(0)+ }+}++fn b64(bytes: &[u8]) -> String {+ use base64::Engine;+ base64::engine::general_purpose::STANDARD.encode(bytes)+}++fn every_reader(bytes: &[u8]) {+ let _ = ckdocument::text_from_bytes(bytes);+ let _ = ckdocument::set_runs(bytes, &[]);+ let _ = ckdocument::replace_text(bytes, "hello\nworld");+ let _ = ckdocument::repair_runs(bytes);+ let _ = mergeable::ordered_strings(bytes);+ let _ = topotext::debug_graph(bytes);+ let text = b64(bytes);+ let _ = ckdocument::text_from_base64(&text);+ let _ = ckdocument::stored_text_from_base64(&text);+ let _ = ckdocument::has_attachments_in_base64(&text);+ let _ = ckdocument::repair_runs_in_base64(&text);+ let _ = ckdocument::replace_rich_in_base64(&text, "x", &[]);+}++#[test]+fn malformed_note_documents_never_panic() {+ let mut rng = Rng(0x9E37_79B9_7F4A_7C15);+ let real = {+ use base64::Engine;+ base64::engine::general_purpose::STANDARD+ .decode(ckdocument::text_to_base64(+ "A title\nSome body text, with a list:\n• one",+ ))+ .unwrap()+ };+ // The protobuf itself, out of its gzip: mutations then reach the parser, not the inflater.+ let real = {+ use std::io::Read;+ let mut out = Vec::new();+ flate2::read::GzDecoder::new(&real[..])+ .read_to_end(&mut out)+ .unwrap();+ out+ };+ let mut cases: Vec<Vec<u8>> = Vec::new();+ for _ in 0..3000 {+ let len = rng.below(256);+ cases.push((0..len).map(|_| rng.next() as u8).collect());+ }+ for _ in 0..3000 {+ let mut doc = real.clone();+ for _ in 0..=rng.below(6) {+ match rng.below(4) {+ 0 if !doc.is_empty() => {+ let at = rng.below(doc.len());+ doc[at] = rng.next() as u8;+ }+ 1 => doc.truncate(rng.below(doc.len() + 1)),+ 2 => {+ let at = rng.below(doc.len() + 1);+ // A length or a field number past anything real.+ doc.splice(+ at..at,+ [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01],+ );+ }+ _ => {+ let at = rng.below(doc.len() + 1);+ doc.insert(at, rng.next() as u8);+ }+ }+ }+ // And as Apple sends it, gzipped, too.+ let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::fast());+ std::io::Write::write_all(&mut gz, &doc).unwrap();+ cases.push(gz.finish().unwrap());+ cases.push(doc);+ }+ let mut panics = Vec::new();+ for (i, case) in cases.iter().enumerate() {+ if std::panic::catch_unwind(|| every_reader(case)).is_err() {+ panics.push(i);+ }+ }+ assert!(+ panics.is_empty(),+ "{} of {} panicked, first: {:02x?}",+ panics.len(),+ cases.len(),+ panics.first().map(|&i| &cases[i])+ );+}diff --git a/crates/quince-media/Cargo.toml b/crates/quince-media/Cargo.tomlindex ccc5fa4..010c2c7 100644--- a/crates/quince-media/Cargo.toml+++ b/crates/quince-media/Cargo.toml@@ -11,8 +11,9 @@ fast_image_resize = "6.1.0"image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }png = "0.17"-# HEIC decoded with libheif where the system has it (Linux packages it everywhere). On Windows-# it is not built yet: HEIC is shown at Apple's own JPEG sizes there until the system's own-# decoder (the Windows Imaging Component) is used.-[target.'cfg(not(windows))'.dependencies]+# HEIC decoded with libheif: the system's on Linux, and on Windows one built in by vcpkg+# (`libheif[core,libde265]`, decoding only; see the Windows workflow) — not Windows' own+# decoder, which needs two Store extensions most machines do not have. Left out only of the+# MinGW cross-check, which has no vcpkg.+[target.'cfg(not(all(windows, target_env = "gnu")))'.dependencies]libheif-rs = "3.0.0"diff --git a/crates/quince-media/src/lib.rs b/crates/quince-media/src/lib.rsindex b120124..af9b5db 100644--- a/crates/quince-media/src/lib.rs+++ b/crates/quince-media/src/lib.rs@@ -99,16 +99,16 @@ fn cut(image: image::DynamicImage, crop: Option<Crop>) -> image::DynamicImage {////// # Errors/// When the bytes are not a HEIF image libheif can decode.-#[cfg(windows)]+#[cfg(all(windows, target_env = "gnu"))]pub fn heic_to_jpeg(_bytes: &[u8]) -> Result<Vec<u8>, String> {- Err("HEIC pictures are not decoded on Windows yet.".into())+ Err("HEIC pictures are not decoded in this build.".into())}-/// A HEIC picture made a JPEG (see the Windows variant above for where it is not).+/// A HEIC picture made a JPEG (see the variant above for the one build where it is not).////// # Errors/// When the bytes are not a HEIF image libheif can decode.-#[cfg(not(windows))]+#[cfg(not(all(windows, target_env = "gnu")))]pub fn heic_to_jpeg(bytes: &[u8]) -> Result<Vec<u8>, String> {use libheif_rs::{ColorSpace, HeifContext, LibHeif, RgbChroma};let lib = LibHeif::new();diff --git a/crates/quince-vfs/src/fuse.rs b/crates/quince-vfs/src/fuse.rsindex f66389c..c11ed47 100644--- a/crates/quince-vfs/src/fuse.rs+++ b/crates/quince-vfs/src/fuse.rs@@ -182,23 +182,16 @@ impl DriveFs {/// When the folder for the bytes cannot be made.pub fn with_writes(mut self, dir: &Path) -> std::io::Result<Self> {let writes = Arc::new(Writes::new(dir)?);- let waiting = writes.load();self.inner_mut().writes = Some(Arc::clone(&writes));- for (old, pending) in waiting {- let ino = self- .0+ // Each to the inode it has now (see `Writes::take_back`: never moved straight across).+ let waiting = writes.take_back(|pending| {+ self.0.inodes.lock().unwrap_or_else(std::sync::PoisonError::into_inner)- .local(&pending.folder, &pending.name);- // Its bytes moved to the inode it has now.- let from = writes.staging(old, &pending.name);- let to = writes.staging(ino, &pending.name);- if let Some(dir) = to.parent() {- std::fs::create_dir_all(dir)?;- }- std::fs::rename(&from, &to)?;- writes.drop_staging(old);+ .local(&pending.folder, &pending.name)+ })?;+ for (ino, pending) in waiting {writes.items.lock()@@ -1784,6 +1777,9 @@ pub fn mount(fs: DriveFs, at: &Path) -> std::io::Result<fuser::BackgroundSessionMountOption::Subtype("quince".into()),MountOption::NoSuid,MountOption::NoDev,+ // Files from iCloud are never run from here (none is given an executable mode+ // either): one put in a shared folder by someone else stays a file to open.+ MountOption::NoExec,MountOption::NoAtime,MountOption::DefaultPermissions,];diff --git a/crates/quince-vfs/src/writes.rs b/crates/quince-vfs/src/writes.rsindex e861bf3..9a1c4b3 100644--- a/crates/quince-vfs/src/writes.rs+++ b/crates/quince-vfs/src/writes.rs@@ -207,13 +207,88 @@ impl Writes {.map(|(i, p)| (*i, p)).collect();if let Ok(json) = serde_json::to_vec(&keep) {+ // Each waiting file's bytes on the disk before the journal names them, and the+ // journal on the disk before it replaces the last: after a power cut, a journal+ // naming bytes the disk never kept would send an empty file over the real one.+ for (ino, p) in &keep {+ if let Ok(f) = std::fs::File::open(self.staging(*ino, &p.name)) {+ let _ = f.sync_all();+ }+ }let part = self.journal().with_extension("json.part");- if std::fs::write(&part, json).is_ok() {+ let written = std::fs::File::create(&part).and_then(|mut f| {+ std::io::Write::write_all(&mut f, &json)?;+ f.sync_all()+ });+ if written.is_ok() {let _ = std::fs::rename(&part, self.journal());}}}+ /// Where a waiting file's bytes are held while every waiting file moves to its new inode:+ /// apart from every inode's own folder, so no move lands on another's.+ fn held(&self, old: u64) -> PathBuf {+ self.dir.join(".restore").join(old.to_string())+ }++ /// What was waiting when the folder last went away, moved to the inodes it has now —+ /// `place` gives each one its new number.+ ///+ /// Inode numbers start again from the same place at every mount, so a file's old number+ /// is often another's new one, or its own: moved straight across, a file whose new number+ /// was its old one had its folder emptied by the clean-up after the move, and two files+ /// trading numbers had one's bytes laid over or deleted with the other's — a file saved+ /// offline and carried over two restarts was lost. Every one is first set aside, out of+ /// the way of all numbers, then placed; one set aside when the app stopped in between is+ /// found there again.+ ///+ /// # Errors+ /// When the disk refuses a move. Nothing is deleted before its bytes are where they go.+ pub fn take_back(+ &self,+ mut place: impl FnMut(&Pending) -> u64,+ ) -> std::io::Result<Vec<(u64, Pending)>> {+ // Set aside by a start that stopped half-way: back where the journal says they are.+ if let Ok(entries) = std::fs::read_dir(self.dir.join(".restore")) {+ for entry in entries.flatten() {+ let Some(old) = entry+ .file_name()+ .to_str()+ .and_then(|n| n.parse::<u64>().ok())+ else {+ continue;+ };+ let home = self.dir.join(old.to_string());+ if !home.exists() {+ std::fs::rename(entry.path(), &home)?;+ }+ }+ }+ let waiting = self.load();+ std::fs::create_dir_all(self.dir.join(".restore"))?;+ for (old, _) in &waiting {+ // A copy left set aside beside the one the journal names (load() saw it at home)+ // is the older of the two.+ if self.held(*old).exists() {+ std::fs::remove_dir_all(self.held(*old))?;+ }+ std::fs::rename(self.dir.join(old.to_string()), self.held(*old))?;+ }+ let mut placed = Vec::with_capacity(waiting.len());+ for (old, pending) in waiting {+ let ino = place(&pending);+ let to = self.staging(ino, &pending.name);+ if let Some(dir) = to.parent() {+ std::fs::create_dir_all(dir)?;+ }+ std::fs::rename(self.held(old).join(&pending.name), &to)?;+ let _ = std::fs::remove_dir_all(self.held(old));+ placed.push((ino, pending));+ }+ Ok(placed)+ }+/// What was waiting when the folder last went away, with where its bytes are.#[must_use]pub fn load(&self) -> Vec<(u64, Pending)> {@@ -390,4 +465,72 @@ mod tests {assert_eq!(again[0].1.name, "a.txt");assert_eq!(again[0].1.open, 0, "nothing is open after a restart");}++ fn waiting(name: &str) -> Pending {+ Pending {+ folder: "F".into(),+ name: name.into(),+ replaces: None,+ open: 0,+ dirty: true,+ generation: 1,+ modified: SystemTime::now(),+ sender: false,+ quiet_since: None,+ sending: false,+ failure: None,+ }+ }++ fn stage(w: &Writes, ino: u64, name: &str, bytes: &[u8]) {+ std::fs::create_dir_all(w.staging(ino, name).parent().unwrap()).unwrap();+ std::fs::write(w.staging(ino, name), bytes).unwrap();+ w.items.lock().unwrap().insert(ino, waiting(name));+ }++ /// Inode numbers start from the same place every mount. A file given back its own number+ /// had its bytes deleted by the clean-up after the move; two trading numbers lost one.+ #[test]+ fn files_carried_over_a_restart_keep_their_bytes_whatever_numbers_they_get() {+ let dir = tempfile::tempdir().unwrap();+ let w = Writes::new(dir.path()).unwrap();+ stage(&w, 2, "a.txt", b"first");+ stage(&w, 3, "b.txt", b"second");+ stage(&w, 4, "c.txt", b"third");+ w.save();+ let again = Writes::new(dir.path()).unwrap();+ // c keeps 4; a and b trade.+ let placed = again+ .take_back(|p| match p.name.as_str() {+ "a.txt" => 3,+ "b.txt" => 2,+ _ => 4,+ })+ .unwrap();+ assert_eq!(placed.len(), 3);+ for (ino, p) in &placed {+ let bytes = std::fs::read(again.staging(*ino, &p.name)).unwrap();+ let want: &[u8] = match p.name.as_str() {+ "a.txt" => b"first",+ "b.txt" => b"second",+ _ => b"third",+ };+ assert_eq!(bytes, want, "{} at {ino}", p.name);+ }+ }++ /// Stopped after setting the files aside and before placing them: the next start finds+ /// them where they were set aside, not missing.+ #[test]+ fn files_set_aside_when_the_app_stopped_are_found_again() {+ let dir = tempfile::tempdir().unwrap();+ let w = Writes::new(dir.path()).unwrap();+ stage(&w, 9, "a.txt", b"kept");+ w.save();+ std::fs::create_dir_all(dir.path().join(".restore")).unwrap();+ std::fs::rename(dir.path().join("9"), dir.path().join(".restore").join("9")).unwrap();+ let placed = Writes::new(dir.path()).unwrap().take_back(|_| 2).unwrap();+ assert_eq!(placed.len(), 1);+ assert_eq!(std::fs::read(w.staging(2, "a.txt")).unwrap(), b"kept");+ }}diff --git a/packaging/README.md b/packaging/README.mdindex f919a61..b39d2c1 100644--- a/packaging/README.md+++ b/packaging/README.md@@ -43,3 +43,25 @@ that looks finished and has never been run. It is next, on a machine that can bu`webkit2gtk-4.1` for the window, `libsecret` for the keyring. The app starts without thesecond and cannot stay signed in, which is most of the point of it.++## Opening files and quick capture++Calendar (`.ics`) and contact (`.vcf`) files open in Pomander's import sheet+(`src-tauri/src/intake.rs`): read on this computer, shown, and added only when confirmed.++- **Linux:** the main entry declares `MimeType=text/calendar;text/vcard;text/x-vcard;` and takes+ `%U`; the metainfo files list the same types under `<provides>`. The per-app entries do not+ claim them, so "Open With" offers one "Pomander", not a second "Calendar" beside GNOME's.+- **Windows:** `bundle.fileAssociations` in `tauri.conf.json` registers `.ics`/`.ical` and+ `.vcf`/`.vcard` in both the NSIS and MSI installers; Explorer passes the path on the command+ line, and a second launch hands it to the running Pomander (single instance).++`pomander --new reminder` and `pomander --new note` open the quick-capture window. They are+`Actions=` on the main entry and on the Reminders and Notes entries (right-click in a dock or+launcher).++**Windows jump-list tasks are not set up.** A jump list's tasks are written by the running app+through the shell's `ICustomDestinationList` COM interface; neither Tauri nor its NSIS/MSI+templates have a way to declare them. Adding them means a Windows-only call at startup+(`windows` crate, `Win32_UI_Shell`) registering two `IShellLink` tasks with the arguments+above. Until then, the same commands work from a shortcut's Target field.diff --git a/packaging/apps/dev.quince.client.Calendar.desktop b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Calendar.desktopsimilarity index 81%rename from packaging/apps/dev.quince.client.Calendar.desktoprename to packaging/apps/io.github.yashwanthkamireddi.Pomander.Calendar.desktopindex cf19a35..76b6297 100644--- a/packaging/apps/dev.quince.client.Calendar.desktop+++ b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Calendar.desktop@@ -7,9 +7,9 @@ Name=CalendarGenericName=Calendar for iCloudComment=Your iCloud calendars, on this computerExec=pomander --app calendar-Icon=dev.quince.client+Icon=io.github.yashwanthkamireddi.PomanderTerminal=falseCategories=Office;Keywords=Pomander;iCloud;events;schedule;StartupNotify=true-StartupWMClass=dev.quince.client.Calendar+StartupWMClass=io.github.yashwanthkamireddi.Pomander.Calendardiff --git a/packaging/apps/dev.quince.client.Contacts.desktop b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Contacts.desktopsimilarity index 81%rename from packaging/apps/dev.quince.client.Contacts.desktoprename to packaging/apps/io.github.yashwanthkamireddi.Pomander.Contacts.desktopindex cdf9748..90728f4 100644--- a/packaging/apps/dev.quince.client.Contacts.desktop+++ b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Contacts.desktop@@ -7,9 +7,9 @@ Name=ContactsGenericName=Contacts for iCloudComment=Your iCloud contacts, on this computerExec=pomander --app contacts-Icon=dev.quince.client+Icon=io.github.yashwanthkamireddi.PomanderTerminal=falseCategories=Office;Keywords=Pomander;iCloud;people;address;StartupNotify=true-StartupWMClass=dev.quince.client.Contacts+StartupWMClass=io.github.yashwanthkamireddi.Pomander.Contactsdiff --git a/packaging/apps/dev.quince.client.Drive.desktop b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Drive.desktopsimilarity index 81%rename from packaging/apps/dev.quince.client.Drive.desktoprename to packaging/apps/io.github.yashwanthkamireddi.Pomander.Drive.desktopindex 4bb7ad9..6739765 100644--- a/packaging/apps/dev.quince.client.Drive.desktop+++ b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Drive.desktop@@ -7,9 +7,9 @@ Name=DriveGenericName=Drive for iCloudComment=iCloud Drive, on this computerExec=pomander --app drive-Icon=dev.quince.client+Icon=io.github.yashwanthkamireddi.PomanderTerminal=falseCategories=Office;Keywords=Pomander;iCloud;files;folders;documents;StartupNotify=true-StartupWMClass=dev.quince.client.Drive+StartupWMClass=io.github.yashwanthkamireddi.Pomander.Drivediff --git a/packaging/apps/dev.quince.client.Notes.desktop b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Notes.desktopsimilarity index 62%rename from packaging/apps/dev.quince.client.Notes.desktoprename to packaging/apps/io.github.yashwanthkamireddi.Pomander.Notes.desktopindex de9faef..9c28891 100644--- a/packaging/apps/dev.quince.client.Notes.desktop+++ b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Notes.desktop@@ -7,9 +7,15 @@ Name=NotesGenericName=Notes for iCloudComment=Notes from iCloud, on this computerExec=pomander --app notes-Icon=dev.quince.client+Icon=io.github.yashwanthkamireddi.PomanderTerminal=falseCategories=Office;Keywords=Pomander;iCloud;notes;memo;StartupNotify=true-StartupWMClass=dev.quince.client.Notes+Actions=new-note;+StartupWMClass=io.github.yashwanthkamireddi.Pomander.Notes++# A quick capture: one field, Enter, and it is in iCloud (src-tauri/src/intake.rs).+[Desktop Action new-note]+Name=New Note+Exec=pomander --new notediff --git a/packaging/apps/dev.quince.client.Photos.desktop b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Photos.desktopsimilarity index 81%rename from packaging/apps/dev.quince.client.Photos.desktoprename to packaging/apps/io.github.yashwanthkamireddi.Pomander.Photos.desktopindex fec2d7c..765fa3f 100644--- a/packaging/apps/dev.quince.client.Photos.desktop+++ b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Photos.desktop@@ -7,9 +7,9 @@ Name=PhotosGenericName=Photos for iCloudComment=iCloud Photos, on this computerExec=pomander --app photos-Icon=dev.quince.client+Icon=io.github.yashwanthkamireddi.PomanderTerminal=falseCategories=Office;Keywords=Pomander;iCloud;pictures;images;gallery;StartupNotify=true-StartupWMClass=dev.quince.client.Photos+StartupWMClass=io.github.yashwanthkamireddi.Pomander.Photosdiff --git a/packaging/apps/dev.quince.client.Reminders.desktop b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Reminders.desktopsimilarity index 62%rename from packaging/apps/dev.quince.client.Reminders.desktoprename to packaging/apps/io.github.yashwanthkamireddi.Pomander.Reminders.desktopindex 8afc6ef..f96ffb5 100644--- a/packaging/apps/dev.quince.client.Reminders.desktop+++ b/packaging/apps/io.github.yashwanthkamireddi.Pomander.Reminders.desktop@@ -7,9 +7,15 @@ Name=RemindersGenericName=Reminders for iCloudComment=Reminders from iCloud, on this computerExec=pomander --app reminders-Icon=dev.quince.client+Icon=io.github.yashwanthkamireddi.PomanderTerminal=falseCategories=Office;Keywords=Pomander;iCloud;todo;tasks;lists;StartupNotify=true-StartupWMClass=dev.quince.client.Reminders+Actions=new-reminder;+StartupWMClass=io.github.yashwanthkamireddi.Pomander.Reminders++# A quick capture: one field, Enter, and it is in iCloud (src-tauri/src/intake.rs).+[Desktop Action new-reminder]+Name=New Reminder+Exec=pomander --new reminderdiff --git a/packaging/arch/PKGBUILD b/packaging/arch/PKGBUILDindex 0cf4598..52c7e13 100644--- a/packaging/arch/PKGBUILD+++ b/packaging/arch/PKGBUILD@@ -70,20 +70,20 @@ package() {# through that, so the rename happens here.install -Dm755 "$srcdir/target/release/quince-app" "$pkgdir/usr/bin/pomander"install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"- install -Dm644 packaging/dev.quince.client.metainfo.xml \- "$pkgdir/usr/share/metainfo/dev.quince.client.metainfo.xml"+ install -Dm644 packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xml \+ "$pkgdir/usr/share/metainfo/io.github.yashwanthkamireddi.Pomander.metainfo.xml"# The same entry the .deb and .rpm get, with the names this package uses filled in.sed -e 's/{{name}}/Pomander/' \-e 's/{{comment}}/Your iCloud, on this computer/' \-e 's/{{exec}}/pomander/g' \- -e 's/{{icon}}/dev.quince.client/' \+ -e 's/{{icon}}/io.github.yashwanthkamireddi.Pomander/' \-e 's/{{categories}}/Office;Calendar;ContactManagement;/' \- packaging/dev.quince.client.desktop.in \- > "$srcdir/dev.quince.client.desktop"- install -Dm644 "$srcdir/dev.quince.client.desktop" \- "$pkgdir/usr/share/applications/dev.quince.client.desktop"+ packaging/io.github.yashwanthkamireddi.Pomander.desktop.in \+ > "$srcdir/io.github.yashwanthkamireddi.Pomander.desktop"+ install -Dm644 "$srcdir/io.github.yashwanthkamireddi.Pomander.desktop" \+ "$pkgdir/usr/share/applications/io.github.yashwanthkamireddi.Pomander.desktop"install -Dm644 src-tauri/icons/icon.png \- "$pkgdir/usr/share/icons/hicolor/512x512/apps/dev.quince.client.png"+ "$pkgdir/usr/share/icons/hicolor/512x512/apps/io.github.yashwanthkamireddi.Pomander.png"# The six apps, each its own launcher entry (pomander --app notes, …).for entry in packaging/apps/*.desktop; doinstall -Dm644 "$entry" "$pkgdir/usr/share/applications/$(basename "$entry")"diff --git a/packaging/aur/PKGBUILD b/packaging/aur/PKGBUILDindex 395a8f4..86b99d3 100644--- a/packaging/aur/PKGBUILD+++ b/packaging/aur/PKGBUILD@@ -76,20 +76,20 @@ package() {# through that, so the rename happens here.install -Dm755 "$srcdir/target/release/quince-app" "$pkgdir/usr/bin/pomander"install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"- install -Dm644 packaging/dev.quince.client.metainfo.xml \- "$pkgdir/usr/share/metainfo/dev.quince.client.metainfo.xml"+ install -Dm644 packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xml \+ "$pkgdir/usr/share/metainfo/io.github.yashwanthkamireddi.Pomander.metainfo.xml"# The same entry the .deb and .rpm get, with the names this package uses filled in.sed -e 's/{{name}}/Pomander/' \-e 's/{{comment}}/Your iCloud, on this computer/' \-e 's/{{exec}}/pomander/g' \- -e 's/{{icon}}/dev.quince.client/' \+ -e 's/{{icon}}/io.github.yashwanthkamireddi.Pomander/' \-e 's/{{categories}}/Office;Calendar;ContactManagement;/' \- packaging/dev.quince.client.desktop.in \- > "$srcdir/dev.quince.client.desktop"- install -Dm644 "$srcdir/dev.quince.client.desktop" \- "$pkgdir/usr/share/applications/dev.quince.client.desktop"+ packaging/io.github.yashwanthkamireddi.Pomander.desktop.in \+ > "$srcdir/io.github.yashwanthkamireddi.Pomander.desktop"+ install -Dm644 "$srcdir/io.github.yashwanthkamireddi.Pomander.desktop" \+ "$pkgdir/usr/share/applications/io.github.yashwanthkamireddi.Pomander.desktop"install -Dm644 src-tauri/icons/icon.png \- "$pkgdir/usr/share/icons/hicolor/512x512/apps/dev.quince.client.png"+ "$pkgdir/usr/share/icons/hicolor/512x512/apps/io.github.yashwanthkamireddi.Pomander.png"# The six apps, each its own launcher entry (pomander --app notes, …).for entry in packaging/apps/*.desktop; doinstall -Dm644 "$entry" "$pkgdir/usr/share/applications/$(basename "$entry")"diff --git a/packaging/flatpak/README.md b/packaging/flatpak/README.mdnew file mode 100644index 0000000..d555636--- /dev/null+++ b/packaging/flatpak/README.md@@ -0,0 +1,110 @@+# Flatpak (Flathub) packaging++| File | What it is |+|---|---|+| `io.github.yashwanthkamireddi.Pomander.yml` | The manifest. Builds offline from the vendored sources below. |+| `cargo-sources.json` | Every crate in `Cargo.lock`, generated by `flatpak-cargo-generator.py`. |+| `node-sources.json` | Every npm package in `package-lock.json`, generated by `flatpak-node-generator`. |+| `io.github.yashwanthkamireddi.Pomander.desktop` | The main launcher entry. |+| `io.github.yashwanthkamireddi.Pomander.metainfo.xml` | The AppStream metadata a software centre shows. |++**Status: never built.** The development machine has no `flatpak` or `flatpak-builder`. Checked so far:+the manifest parses as YAML, both source files parse as JSON, `appstreamcli validate --pedantic`+passes on the metainfo, and `desktop-file-validate` passes on the desktop file.++## The identifier++The Tauri identifier in `src-tauri/tauri.conf.json` is this app ID, so the window's Wayland app+ID, the six per-app windows (`<id>.Notes`, … in `src-tauri/src/apps.rs`) and the single-instance+D-Bus name (`<id>.SingleInstance`, which a sandbox may own without `--own-name`) all match the+exported desktop files. Installs from before the switch (`dev.quince.client`) are moved over at+first launch by `src-tauri/src/migrate.rs`; inside the sandbox there is nothing to move (its data+lives under `~/.var/app/<id>/`), so a Flatpak starts with an empty library and fills it from iCloud.++## Runtime and modules++- `org.gnome.Platform` / `org.gnome.Sdk` 51, which ships webkit2gtk-4.1, gtk3, libsecret,+ GStreamer and libheif (from freedesktop-sdk 26.08).+- SDK extensions `rust-stable` and `node24`.+- **libheif**: in the runtime, so not bundled. It is built without an HEVC decoder; the libde265+ plugin comes from `org.freedesktop.Platform.codecs-extra`, which the runtime downloads by itself.+ HEIC decoding inside the sandbox is unverified.+- **fuse3**: not bundled. `fuser` is built with `default-features = false`, which links no libfuse.+- **libayatana-appindicator** (tray): from Flathub's `shared-modules`.++## Permissions++| Granted | Why |+|---|---|+| `--share=network` | iCloud. |+| `--socket=wayland`, `--socket=fallback-x11`, `--share=ipc` | The window; X11 only without Wayland. |+| `--device=dri` | GPU rendering for WebKitGTK. |+| `--talk-name=org.freedesktop.secrets` | The Apple ID session lives in the Secret Service keyring. |+| `--talk-name=org.freedesktop.Notifications` | Reminder alerts. |+| `--talk-name=org.kde.StatusNotifierWatcher` | The tray icon. |+| `--filesystem=xdg-download` | Drive and Photos save straight to `~/Downloads`, not through the portal. |++Left out on purpose:++- **The FUSE device.** Drive and Photos as folders need `/dev/fuse` (only reachable with+ `--device=all`) and a `fusermount3` that can't be setuid in the sandbox, so in practice a host+ escape (`--talk-name=org.freedesktop.Flatpak`). Flathub reviewers will push back on that, so the+ folders are unavailable in the Flatpak. If they're ever wanted, add `--device=all` and document+ why in the manifest.+- **`--system-talk-name=org.freedesktop.login1`** (wake on resume). Without it, alerts fall back+ to their ten-minute check.++## Regenerating the sources++Regenerate whenever `Cargo.lock` or `package-lock.json` changes. Run from the repository root.+`cargo-sources.json` was generated from the working tree's `Cargo.lock` on 2026-10-21, which has+uncommitted changes (libheif-rs 3.0). Commit them before building, because the build uses `--locked`+against the committed lockfile.++```sh+# Cargo: the generator is a single script with inline uv metadata.+curl -LO https://raw.githubusercontent.com/flatpak/flatpak-builder-tools/master/cargo/flatpak-cargo-generator.py+uv run --script flatpak-cargo-generator.py Cargo.lock -o packaging/flatpak/cargo-sources.json++# npm: flatpak-node-generator is a Python package in the same repository.+uvx --from 'git+https://github.com/flatpak/flatpak-builder-tools.git#subdirectory=node' \+ flatpak-node-generator npm package-lock.json --esbuild -o packaging/flatpak/node-sources.json+```++`--esbuild` (or an equivalent electron/esbuild option in your generator version) places the esbuild+binary that `ESBUILD_BINARY_PATH` in the manifest points at. Without it, Vite can't run offline.++## Building locally++The manifest's main source is `type: git, path: ../..`, so it builds the repository's **committed**+HEAD. Commit first. The desktop file and metainfo are separate file sources, so they're picked up+even before they're committed.++```sh+flatpak remote-add --user --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo+flatpak install --user flathub org.gnome.Platform//51 org.gnome.Sdk//51 \+ org.freedesktop.Sdk.Extension.rust-stable//26.08 org.freedesktop.Sdk.Extension.node24//26.08+# Match the extension branch to the freedesktop-sdk the GNOME runtime is built on+# (`flatpak info org.gnome.Sdk//51` shows it).++cd packaging/flatpak+git clone --depth 1 https://github.com/flathub/shared-modules.git++flatpak-builder --user --install --force-clean build-dir io.github.yashwanthkamireddi.Pomander.yml+flatpak run io.github.yashwanthkamireddi.Pomander+```++`build-dir/`, `.flatpak-builder/` and `shared-modules/` are build output. Don't commit them.++Lint before submitting:++```sh+flatpak run --command=flatpak-builder-lint org.flatpak.Builder manifest io.github.yashwanthkamireddi.Pomander.yml+flatpak run --command=flatpak-builder-lint org.flatpak.Builder repo repo+```++## Before Flathub++- Point the git source at the public repository at a release tag and commit.+- Add `<screenshots>` and `<branding>` colours to the metainfo; Flathub's linter asks for both.+- Confirm HEIC decodes and the keyring session survives a restart inside the sandbox.diff --git a/packaging/flatpak/cargo-sources.json b/packaging/flatpak/cargo-sources.jsonnew file mode 100644index 0000000..3d1c8ee--- /dev/null+++ b/packaging/flatpak/cargo-sources.json@@ -0,0 +1,8133 @@+[+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/adler2/adler2-2.0.1.crate",+ "sha256": "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa",+ "dest": "cargo/vendor/adler2-2.0.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa\", \"files\": {}}",+ "dest": "cargo/vendor/adler2-2.0.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/aes/aes-0.8.4.crate",+ "sha256": "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0",+ "dest": "cargo/vendor/aes-0.8.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0\", \"files\": {}}",+ "dest": "cargo/vendor/aes-0.8.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ahash/ahash-0.8.12.crate",+ "sha256": "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75",+ "dest": "cargo/vendor/ahash-0.8.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75\", \"files\": {}}",+ "dest": "cargo/vendor/ahash-0.8.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/aho-corasick/aho-corasick-1.1.5.crate",+ "sha256": "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba",+ "dest": "cargo/vendor/aho-corasick-1.1.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba\", \"files\": {}}",+ "dest": "cargo/vendor/aho-corasick-1.1.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/alloc-no-stdlib/alloc-no-stdlib-3.0.0.crate",+ "sha256": "c2fb6cfd47bf496ff64095c20eaba0c201404ee38714d4142fcfa1dc334fcc7a",+ "dest": "cargo/vendor/alloc-no-stdlib-3.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c2fb6cfd47bf496ff64095c20eaba0c201404ee38714d4142fcfa1dc334fcc7a\", \"files\": {}}",+ "dest": "cargo/vendor/alloc-no-stdlib-3.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/alloc-stdlib/alloc-stdlib-0.3.0.crate",+ "sha256": "0b5c1865780388bfa186411ab5f247819487fc4864c6e9c3106611fa347586e1",+ "dest": "cargo/vendor/alloc-stdlib-0.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0b5c1865780388bfa186411ab5f247819487fc4864c6e9c3106611fa347586e1\", \"files\": {}}",+ "dest": "cargo/vendor/alloc-stdlib-0.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/android_system_properties/android_system_properties-0.1.6.crate",+ "sha256": "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc",+ "dest": "cargo/vendor/android_system_properties-0.1.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc\", \"files\": {}}",+ "dest": "cargo/vendor/android_system_properties-0.1.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/anyhow/anyhow-1.0.104.crate",+ "sha256": "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470",+ "dest": "cargo/vendor/anyhow-1.0.104"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470\", \"files\": {}}",+ "dest": "cargo/vendor/anyhow-1.0.104",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/assert-json-diff/assert-json-diff-2.0.2.crate",+ "sha256": "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12",+ "dest": "cargo/vendor/assert-json-diff-2.0.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12\", \"files\": {}}",+ "dest": "cargo/vendor/assert-json-diff-2.0.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-broadcast/async-broadcast-0.7.2.crate",+ "sha256": "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532",+ "dest": "cargo/vendor/async-broadcast-0.7.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532\", \"files\": {}}",+ "dest": "cargo/vendor/async-broadcast-0.7.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-channel/async-channel-2.5.0.crate",+ "sha256": "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2",+ "dest": "cargo/vendor/async-channel-2.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2\", \"files\": {}}",+ "dest": "cargo/vendor/async-channel-2.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-compression/async-compression-0.4.46.crate",+ "sha256": "4f10dafd0c8d2e51ae9a748805777613ed0bbe17bf586b76c8311f45c020a32f",+ "dest": "cargo/vendor/async-compression-0.4.46"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4f10dafd0c8d2e51ae9a748805777613ed0bbe17bf586b76c8311f45c020a32f\", \"files\": {}}",+ "dest": "cargo/vendor/async-compression-0.4.46",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-executor/async-executor-1.14.0.crate",+ "sha256": "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a",+ "dest": "cargo/vendor/async-executor-1.14.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a\", \"files\": {}}",+ "dest": "cargo/vendor/async-executor-1.14.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-io/async-io-2.6.0.crate",+ "sha256": "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc",+ "dest": "cargo/vendor/async-io-2.6.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc\", \"files\": {}}",+ "dest": "cargo/vendor/async-io-2.6.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-lock/async-lock-3.4.2.crate",+ "sha256": "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311",+ "dest": "cargo/vendor/async-lock-3.4.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311\", \"files\": {}}",+ "dest": "cargo/vendor/async-lock-3.4.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-process/async-process-2.5.0.crate",+ "sha256": "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75",+ "dest": "cargo/vendor/async-process-2.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75\", \"files\": {}}",+ "dest": "cargo/vendor/async-process-2.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-recursion/async-recursion-1.1.1.crate",+ "sha256": "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11",+ "dest": "cargo/vendor/async-recursion-1.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11\", \"files\": {}}",+ "dest": "cargo/vendor/async-recursion-1.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-signal/async-signal-0.2.14.crate",+ "sha256": "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485",+ "dest": "cargo/vendor/async-signal-0.2.14"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485\", \"files\": {}}",+ "dest": "cargo/vendor/async-signal-0.2.14",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-task/async-task-4.7.1.crate",+ "sha256": "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de",+ "dest": "cargo/vendor/async-task-4.7.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de\", \"files\": {}}",+ "dest": "cargo/vendor/async-task-4.7.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/async-trait/async-trait-0.1.89.crate",+ "sha256": "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb",+ "dest": "cargo/vendor/async-trait-0.1.89"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb\", \"files\": {}}",+ "dest": "cargo/vendor/async-trait-0.1.89",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/atk/atk-0.18.2.crate",+ "sha256": "241b621213072e993be4f6f3a9e4b45f65b7e6faad43001be957184b7bb1824b",+ "dest": "cargo/vendor/atk-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"241b621213072e993be4f6f3a9e4b45f65b7e6faad43001be957184b7bb1824b\", \"files\": {}}",+ "dest": "cargo/vendor/atk-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/atk-sys/atk-sys-0.18.2.crate",+ "sha256": "c5e48b684b0ca77d2bbadeef17424c2ea3c897d44d566a1617e7e8f30614d086",+ "dest": "cargo/vendor/atk-sys-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c5e48b684b0ca77d2bbadeef17424c2ea3c897d44d566a1617e7e8f30614d086\", \"files\": {}}",+ "dest": "cargo/vendor/atk-sys-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/atomic-waker/atomic-waker-1.1.2.crate",+ "sha256": "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0",+ "dest": "cargo/vendor/atomic-waker-1.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0\", \"files\": {}}",+ "dest": "cargo/vendor/atomic-waker-1.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/atomic_refcell/atomic_refcell-0.1.14.crate",+ "sha256": "21e4227379beff4205943696e6c3e0cd809bacdf3f0edd6e3dd153e2269571a4",+ "dest": "cargo/vendor/atomic_refcell-0.1.14"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"21e4227379beff4205943696e6c3e0cd809bacdf3f0edd6e3dd153e2269571a4\", \"files\": {}}",+ "dest": "cargo/vendor/atomic_refcell-0.1.14",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/autocfg/autocfg-1.5.1.crate",+ "sha256": "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53",+ "dest": "cargo/vendor/autocfg-1.5.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53\", \"files\": {}}",+ "dest": "cargo/vendor/autocfg-1.5.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/base64/base64-0.21.7.crate",+ "sha256": "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567",+ "dest": "cargo/vendor/base64-0.21.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567\", \"files\": {}}",+ "dest": "cargo/vendor/base64-0.21.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/base64/base64-0.22.1.crate",+ "sha256": "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6",+ "dest": "cargo/vendor/base64-0.22.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6\", \"files\": {}}",+ "dest": "cargo/vendor/base64-0.22.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/base64/base64-0.23.1.crate",+ "sha256": "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5",+ "dest": "cargo/vendor/base64-0.23.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5\", \"files\": {}}",+ "dest": "cargo/vendor/base64-0.23.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bit-set/bit-set-0.8.0.crate",+ "sha256": "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3",+ "dest": "cargo/vendor/bit-set-0.8.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3\", \"files\": {}}",+ "dest": "cargo/vendor/bit-set-0.8.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bit-vec/bit-vec-0.8.0.crate",+ "sha256": "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7",+ "dest": "cargo/vendor/bit-vec-0.8.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7\", \"files\": {}}",+ "dest": "cargo/vendor/bit-vec-0.8.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bitflags/bitflags-1.3.2.crate",+ "sha256": "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a",+ "dest": "cargo/vendor/bitflags-1.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a\", \"files\": {}}",+ "dest": "cargo/vendor/bitflags-1.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bitflags/bitflags-2.13.2.crate",+ "sha256": "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06",+ "dest": "cargo/vendor/bitflags-2.13.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06\", \"files\": {}}",+ "dest": "cargo/vendor/bitflags-2.13.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/block-buffer/block-buffer-0.10.4.crate",+ "sha256": "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71",+ "dest": "cargo/vendor/block-buffer-0.10.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71\", \"files\": {}}",+ "dest": "cargo/vendor/block-buffer-0.10.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/block-padding/block-padding-0.3.3.crate",+ "sha256": "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93",+ "dest": "cargo/vendor/block-padding-0.3.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93\", \"files\": {}}",+ "dest": "cargo/vendor/block-padding-0.3.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/block2/block2-0.6.2.crate",+ "sha256": "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5",+ "dest": "cargo/vendor/block2-0.6.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5\", \"files\": {}}",+ "dest": "cargo/vendor/block2-0.6.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/blocking/blocking-1.7.0.crate",+ "sha256": "a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa",+ "dest": "cargo/vendor/blocking-1.7.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa\", \"files\": {}}",+ "dest": "cargo/vendor/blocking-1.7.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/brotli/brotli-9.0.0.crate",+ "sha256": "f8b851b75c23ca7873623d612fe49bd1989aeb03d08fb9432187eb253d3d4c6b",+ "dest": "cargo/vendor/brotli-9.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f8b851b75c23ca7873623d612fe49bd1989aeb03d08fb9432187eb253d3d4c6b\", \"files\": {}}",+ "dest": "cargo/vendor/brotli-9.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/brotli-decompressor/brotli-decompressor-6.0.1.crate",+ "sha256": "941cd9bd4ddab83cb46fa5a2d428f1c857b24ac78cb876cf7beb710840934bd7",+ "dest": "cargo/vendor/brotli-decompressor-6.0.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"941cd9bd4ddab83cb46fa5a2d428f1c857b24ac78cb876cf7beb710840934bd7\", \"files\": {}}",+ "dest": "cargo/vendor/brotli-decompressor-6.0.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bs58/bs58-0.5.1.crate",+ "sha256": "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4",+ "dest": "cargo/vendor/bs58-0.5.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4\", \"files\": {}}",+ "dest": "cargo/vendor/bs58-0.5.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bumpalo/bumpalo-3.20.3.crate",+ "sha256": "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649",+ "dest": "cargo/vendor/bumpalo-3.20.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649\", \"files\": {}}",+ "dest": "cargo/vendor/bumpalo-3.20.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bytemuck/bytemuck-1.25.2.crate",+ "sha256": "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797",+ "dest": "cargo/vendor/bytemuck-1.25.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797\", \"files\": {}}",+ "dest": "cargo/vendor/bytemuck-1.25.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/byteorder/byteorder-1.5.0.crate",+ "sha256": "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b",+ "dest": "cargo/vendor/byteorder-1.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b\", \"files\": {}}",+ "dest": "cargo/vendor/byteorder-1.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/byteorder-lite/byteorder-lite-0.1.0.crate",+ "sha256": "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495",+ "dest": "cargo/vendor/byteorder-lite-0.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495\", \"files\": {}}",+ "dest": "cargo/vendor/byteorder-lite-0.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/bytes/bytes-1.12.1.crate",+ "sha256": "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04",+ "dest": "cargo/vendor/bytes-1.12.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04\", \"files\": {}}",+ "dest": "cargo/vendor/bytes-1.12.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cairo-rs/cairo-rs-0.18.5.crate",+ "sha256": "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2",+ "dest": "cargo/vendor/cairo-rs-0.18.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2\", \"files\": {}}",+ "dest": "cargo/vendor/cairo-rs-0.18.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cairo-sys-rs/cairo-sys-rs-0.18.2.crate",+ "sha256": "685c9fa8e590b8b3d678873528d83411db17242a73fccaed827770ea0fedda51",+ "dest": "cargo/vendor/cairo-sys-rs-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"685c9fa8e590b8b3d678873528d83411db17242a73fccaed827770ea0fedda51\", \"files\": {}}",+ "dest": "cargo/vendor/cairo-sys-rs-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/camino/camino-1.2.5.crate",+ "sha256": "bb1307f12aa967b5a58416e87b3653360e0fd614a016b6e970db08fecbb1b80d",+ "dest": "cargo/vendor/camino-1.2.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bb1307f12aa967b5a58416e87b3653360e0fd614a016b6e970db08fecbb1b80d\", \"files\": {}}",+ "dest": "cargo/vendor/camino-1.2.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cargo-platform/cargo-platform-0.1.9.crate",+ "sha256": "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea",+ "dest": "cargo/vendor/cargo-platform-0.1.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea\", \"files\": {}}",+ "dest": "cargo/vendor/cargo-platform-0.1.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cargo_metadata/cargo_metadata-0.19.2.crate",+ "sha256": "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba",+ "dest": "cargo/vendor/cargo_metadata-0.19.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba\", \"files\": {}}",+ "dest": "cargo/vendor/cargo_metadata-0.19.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cargo_toml/cargo_toml-1.0.1.crate",+ "sha256": "82f4b26e751e711a5302649417f2da046dce6391b2ea30a4820f37462314f0b9",+ "dest": "cargo/vendor/cargo_toml-1.0.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"82f4b26e751e711a5302649417f2da046dce6391b2ea30a4820f37462314f0b9\", \"files\": {}}",+ "dest": "cargo/vendor/cargo_toml-1.0.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cbc/cbc-0.1.2.crate",+ "sha256": "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6",+ "dest": "cargo/vendor/cbc-0.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6\", \"files\": {}}",+ "dest": "cargo/vendor/cbc-0.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cc/cc-1.4.5.crate",+ "sha256": "005ec2760ca554fae18df7a11195552ec576cd665632a881bc011d5bb2fd4d80",+ "dest": "cargo/vendor/cc-1.4.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"005ec2760ca554fae18df7a11195552ec576cd665632a881bc011d5bb2fd4d80\", \"files\": {}}",+ "dest": "cargo/vendor/cc-1.4.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cesu8/cesu8-1.1.0.crate",+ "sha256": "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c",+ "dest": "cargo/vendor/cesu8-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c\", \"files\": {}}",+ "dest": "cargo/vendor/cesu8-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cfb/cfb-0.14.0.crate",+ "sha256": "a347dcabdae9c31b0825fd6a8bed285ec9c2acb89c47827126d52fa4f59cece3",+ "dest": "cargo/vendor/cfb-0.14.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a347dcabdae9c31b0825fd6a8bed285ec9c2acb89c47827126d52fa4f59cece3\", \"files\": {}}",+ "dest": "cargo/vendor/cfb-0.14.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cfg-expr/cfg-expr-0.15.8.crate",+ "sha256": "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02",+ "dest": "cargo/vendor/cfg-expr-0.15.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02\", \"files\": {}}",+ "dest": "cargo/vendor/cfg-expr-0.15.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cfg-expr/cfg-expr-0.20.10.crate",+ "sha256": "9ba9e9ec16c447027685b1f897b720e18e9a8afd00bd7332c483537e38086c9f",+ "dest": "cargo/vendor/cfg-expr-0.20.10"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9ba9e9ec16c447027685b1f897b720e18e9a8afd00bd7332c483537e38086c9f\", \"files\": {}}",+ "dest": "cargo/vendor/cfg-expr-0.20.10",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cfg-if/cfg-if-1.0.4.crate",+ "sha256": "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801",+ "dest": "cargo/vendor/cfg-if-1.0.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801\", \"files\": {}}",+ "dest": "cargo/vendor/cfg-if-1.0.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cfg_aliases/cfg_aliases-0.2.2.crate",+ "sha256": "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527",+ "dest": "cargo/vendor/cfg_aliases-0.2.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527\", \"files\": {}}",+ "dest": "cargo/vendor/cfg_aliases-0.2.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/chacha20/chacha20-0.10.2.crate",+ "sha256": "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06",+ "dest": "cargo/vendor/chacha20-0.10.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06\", \"files\": {}}",+ "dest": "cargo/vendor/chacha20-0.10.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/chrono/chrono-0.4.45.crate",+ "sha256": "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327",+ "dest": "cargo/vendor/chrono-0.4.45"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327\", \"files\": {}}",+ "dest": "cargo/vendor/chrono-0.4.45",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cipher/cipher-0.4.4.crate",+ "sha256": "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad",+ "dest": "cargo/vendor/cipher-0.4.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad\", \"files\": {}}",+ "dest": "cargo/vendor/cipher-0.4.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/combine/combine-4.6.8.crate",+ "sha256": "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e",+ "dest": "cargo/vendor/combine-4.6.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e\", \"files\": {}}",+ "dest": "cargo/vendor/combine-4.6.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/compression-codecs/compression-codecs-0.4.41.crate",+ "sha256": "58a6d0db8759036a783bc7c3f7a07f8cef3bf9470eb1db3bc86e8bcd1c5d0fe8",+ "dest": "cargo/vendor/compression-codecs-0.4.41"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"58a6d0db8759036a783bc7c3f7a07f8cef3bf9470eb1db3bc86e8bcd1c5d0fe8\", \"files\": {}}",+ "dest": "cargo/vendor/compression-codecs-0.4.41",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/compression-core/compression-core-0.4.33.crate",+ "sha256": "6e8ccc4ea9f6acc32d102c0f6d471d11d913ad15f20c04de743374861fa1d414",+ "dest": "cargo/vendor/compression-core-0.4.33"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6e8ccc4ea9f6acc32d102c0f6d471d11d913ad15f20c04de743374861fa1d414\", \"files\": {}}",+ "dest": "cargo/vendor/compression-core-0.4.33",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/concurrent-queue/concurrent-queue-2.5.0.crate",+ "sha256": "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973",+ "dest": "cargo/vendor/concurrent-queue-2.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973\", \"files\": {}}",+ "dest": "cargo/vendor/concurrent-queue-2.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cookie/cookie-0.18.2.crate",+ "sha256": "1a373e3602691c3cdea496d2f0ee5935151e6168fe87739483c463db1b2f2f87",+ "dest": "cargo/vendor/cookie-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1a373e3602691c3cdea496d2f0ee5935151e6168fe87739483c463db1b2f2f87\", \"files\": {}}",+ "dest": "cargo/vendor/cookie-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cookie_store/cookie_store-0.21.1.crate",+ "sha256": "2eac901828f88a5241ee0600950ab981148a18f2f756900ffba1b125ca6a3ef9",+ "dest": "cargo/vendor/cookie_store-0.21.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2eac901828f88a5241ee0600950ab981148a18f2f756900ffba1b125ca6a3ef9\", \"files\": {}}",+ "dest": "cargo/vendor/cookie_store-0.21.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cookie_store/cookie_store-0.22.1.crate",+ "sha256": "15b2c103cf610ec6cae3da84a766285b42fd16aad564758459e6ecf128c75206",+ "dest": "cargo/vendor/cookie_store-0.22.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"15b2c103cf610ec6cae3da84a766285b42fd16aad564758459e6ecf128c75206\", \"files\": {}}",+ "dest": "cargo/vendor/cookie_store-0.22.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/core-foundation/core-foundation-0.9.4.crate",+ "sha256": "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f",+ "dest": "cargo/vendor/core-foundation-0.9.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f\", \"files\": {}}",+ "dest": "cargo/vendor/core-foundation-0.9.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/core-foundation/core-foundation-0.10.1.crate",+ "sha256": "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6",+ "dest": "cargo/vendor/core-foundation-0.10.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6\", \"files\": {}}",+ "dest": "cargo/vendor/core-foundation-0.10.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/core-foundation-sys/core-foundation-sys-0.8.7.crate",+ "sha256": "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b",+ "dest": "cargo/vendor/core-foundation-sys-0.8.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b\", \"files\": {}}",+ "dest": "cargo/vendor/core-foundation-sys-0.8.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/core-graphics/core-graphics-0.25.0.crate",+ "sha256": "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97",+ "dest": "cargo/vendor/core-graphics-0.25.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97\", \"files\": {}}",+ "dest": "cargo/vendor/core-graphics-0.25.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/core-graphics-types/core-graphics-types-0.2.0.crate",+ "sha256": "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb",+ "dest": "cargo/vendor/core-graphics-types-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb\", \"files\": {}}",+ "dest": "cargo/vendor/core-graphics-types-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cpufeatures/cpufeatures-0.2.17.crate",+ "sha256": "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280",+ "dest": "cargo/vendor/cpufeatures-0.2.17"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280\", \"files\": {}}",+ "dest": "cargo/vendor/cpufeatures-0.2.17",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cpufeatures/cpufeatures-0.3.1.crate",+ "sha256": "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566",+ "dest": "cargo/vendor/cpufeatures-0.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566\", \"files\": {}}",+ "dest": "cargo/vendor/cpufeatures-0.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/crc32fast/crc32fast-1.5.1.crate",+ "sha256": "8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550",+ "dest": "cargo/vendor/crc32fast-1.5.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550\", \"files\": {}}",+ "dest": "cargo/vendor/crc32fast-1.5.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/crossbeam-channel/crossbeam-channel-0.5.17.crate",+ "sha256": "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1",+ "dest": "cargo/vendor/crossbeam-channel-0.5.17"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1\", \"files\": {}}",+ "dest": "cargo/vendor/crossbeam-channel-0.5.17",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/crossbeam-utils/crossbeam-utils-0.8.23.crate",+ "sha256": "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6",+ "dest": "cargo/vendor/crossbeam-utils-0.8.23"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6\", \"files\": {}}",+ "dest": "cargo/vendor/crossbeam-utils-0.8.23",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/crypto-common/crypto-common-0.1.7.crate",+ "sha256": "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a",+ "dest": "cargo/vendor/crypto-common-0.1.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a\", \"files\": {}}",+ "dest": "cargo/vendor/crypto-common-0.1.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cssparser/cssparser-0.37.0.crate",+ "sha256": "8c9cdaae01d5ed7882b04d795e7f752f46ff52d2fa3b50a20d28c464510bba98",+ "dest": "cargo/vendor/cssparser-0.37.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8c9cdaae01d5ed7882b04d795e7f752f46ff52d2fa3b50a20d28c464510bba98\", \"files\": {}}",+ "dest": "cargo/vendor/cssparser-0.37.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/cssparser-macros/cssparser-macros-0.7.1.crate",+ "sha256": "d045de693cb712d0b22c6a64be5b953f67b3ce00ab5ad3dd5d8b441886ab8e1a",+ "dest": "cargo/vendor/cssparser-macros-0.7.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d045de693cb712d0b22c6a64be5b953f67b3ce00ab5ad3dd5d8b441886ab8e1a\", \"files\": {}}",+ "dest": "cargo/vendor/cssparser-macros-0.7.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ctor/ctor-1.0.13.crate",+ "sha256": "914a755b7c2d4af2bdcff7ce1739e2db9a1b81a9b07123d8015786ae03c0980d",+ "dest": "cargo/vendor/ctor-1.0.13"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"914a755b7c2d4af2bdcff7ce1739e2db9a1b81a9b07123d8015786ae03c0980d\", \"files\": {}}",+ "dest": "cargo/vendor/ctor-1.0.13",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/darling/darling-0.24.1.crate",+ "sha256": "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec",+ "dest": "cargo/vendor/darling-0.24.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec\", \"files\": {}}",+ "dest": "cargo/vendor/darling-0.24.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/darling_core/darling_core-0.24.1.crate",+ "sha256": "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff",+ "dest": "cargo/vendor/darling_core-0.24.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff\", \"files\": {}}",+ "dest": "cargo/vendor/darling_core-0.24.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/darling_macro/darling_macro-0.24.1.crate",+ "sha256": "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785",+ "dest": "cargo/vendor/darling_macro-0.24.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785\", \"files\": {}}",+ "dest": "cargo/vendor/darling_macro-0.24.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dbus/dbus-0.9.12.crate",+ "sha256": "3ab69f03cc8c4340c9c8e315114e1658e6775a9b16a04357973aa21cec22b32e",+ "dest": "cargo/vendor/dbus-0.9.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3ab69f03cc8c4340c9c8e315114e1658e6775a9b16a04357973aa21cec22b32e\", \"files\": {}}",+ "dest": "cargo/vendor/dbus-0.9.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dbus-secret-service/dbus-secret-service-4.1.0.crate",+ "sha256": "708b509edf7889e53d7efb0ffadd994cc6c2345ccb62f55cfd6b0682165e4fa6",+ "dest": "cargo/vendor/dbus-secret-service-4.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"708b509edf7889e53d7efb0ffadd994cc6c2345ccb62f55cfd6b0682165e4fa6\", \"files\": {}}",+ "dest": "cargo/vendor/dbus-secret-service-4.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/deadpool/deadpool-0.12.3.crate",+ "sha256": "0be2b1d1d6ec8d846f05e137292d0b89133caf95ef33695424c09568bdd39b1b",+ "dest": "cargo/vendor/deadpool-0.12.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0be2b1d1d6ec8d846f05e137292d0b89133caf95ef33695424c09568bdd39b1b\", \"files\": {}}",+ "dest": "cargo/vendor/deadpool-0.12.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/deadpool-runtime/deadpool-runtime-0.1.4.crate",+ "sha256": "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b",+ "dest": "cargo/vendor/deadpool-runtime-0.1.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b\", \"files\": {}}",+ "dest": "cargo/vendor/deadpool-runtime-0.1.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/defmt/defmt-1.1.1.crate",+ "sha256": "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1",+ "dest": "cargo/vendor/defmt-1.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1\", \"files\": {}}",+ "dest": "cargo/vendor/defmt-1.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/defmt-macros/defmt-macros-1.1.1.crate",+ "sha256": "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8",+ "dest": "cargo/vendor/defmt-macros-1.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8\", \"files\": {}}",+ "dest": "cargo/vendor/defmt-macros-1.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/defmt-parser/defmt-parser-1.0.0.crate",+ "sha256": "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e",+ "dest": "cargo/vendor/defmt-parser-1.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e\", \"files\": {}}",+ "dest": "cargo/vendor/defmt-parser-1.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/deranged/deranged-0.5.8.crate",+ "sha256": "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c",+ "dest": "cargo/vendor/deranged-0.5.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c\", \"files\": {}}",+ "dest": "cargo/vendor/deranged-0.5.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/derive_more/derive_more-2.1.1.crate",+ "sha256": "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134",+ "dest": "cargo/vendor/derive_more-2.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134\", \"files\": {}}",+ "dest": "cargo/vendor/derive_more-2.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/derive_more-impl/derive_more-impl-2.1.1.crate",+ "sha256": "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb",+ "dest": "cargo/vendor/derive_more-impl-2.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb\", \"files\": {}}",+ "dest": "cargo/vendor/derive_more-impl-2.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/digest/digest-0.10.7.crate",+ "sha256": "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292",+ "dest": "cargo/vendor/digest-0.10.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292\", \"files\": {}}",+ "dest": "cargo/vendor/digest-0.10.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dirs/dirs-7.0.0.crate",+ "sha256": "8d57d423b3c82e89b9a24ca3091fee61f456a26edbd28d26c65906f4bc1dcd8f",+ "dest": "cargo/vendor/dirs-7.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8d57d423b3c82e89b9a24ca3091fee61f456a26edbd28d26c65906f4bc1dcd8f\", \"files\": {}}",+ "dest": "cargo/vendor/dirs-7.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dirs-sys/dirs-sys-0.5.0.crate",+ "sha256": "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab",+ "dest": "cargo/vendor/dirs-sys-0.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab\", \"files\": {}}",+ "dest": "cargo/vendor/dirs-sys-0.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dispatch2/dispatch2-0.3.1.crate",+ "sha256": "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38",+ "dest": "cargo/vendor/dispatch2-0.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38\", \"files\": {}}",+ "dest": "cargo/vendor/dispatch2-0.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/displaydoc/displaydoc-0.2.7.crate",+ "sha256": "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8",+ "dest": "cargo/vendor/displaydoc-0.2.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8\", \"files\": {}}",+ "dest": "cargo/vendor/displaydoc-0.2.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dlopen2/dlopen2-0.8.2.crate",+ "sha256": "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4",+ "dest": "cargo/vendor/dlopen2-0.8.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4\", \"files\": {}}",+ "dest": "cargo/vendor/dlopen2-0.8.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dlopen2_derive/dlopen2_derive-0.4.3.crate",+ "sha256": "0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f",+ "dest": "cargo/vendor/dlopen2_derive-0.4.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f\", \"files\": {}}",+ "dest": "cargo/vendor/dlopen2_derive-0.4.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/document-features/document-features-0.2.12.crate",+ "sha256": "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61",+ "dest": "cargo/vendor/document-features-0.2.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61\", \"files\": {}}",+ "dest": "cargo/vendor/document-features-0.2.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dom_query/dom_query-0.28.0.crate",+ "sha256": "fac5fca71e65e94cc718a6e2af65d6e0f9c6027751c2aa562fbb5087fda639bc",+ "dest": "cargo/vendor/dom_query-0.28.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fac5fca71e65e94cc718a6e2af65d6e0f9c6027751c2aa562fbb5087fda639bc\", \"files\": {}}",+ "dest": "cargo/vendor/dom_query-0.28.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dpi/dpi-0.1.2.crate",+ "sha256": "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76",+ "dest": "cargo/vendor/dpi-0.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76\", \"files\": {}}",+ "dest": "cargo/vendor/dpi-0.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dtoa/dtoa-1.0.11.crate",+ "sha256": "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590",+ "dest": "cargo/vendor/dtoa-1.0.11"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590\", \"files\": {}}",+ "dest": "cargo/vendor/dtoa-1.0.11",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dtoa-short/dtoa-short-0.3.5.crate",+ "sha256": "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87",+ "dest": "cargo/vendor/dtoa-short-0.3.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87\", \"files\": {}}",+ "dest": "cargo/vendor/dtoa-short-0.3.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dunce/dunce-1.0.5.crate",+ "sha256": "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813",+ "dest": "cargo/vendor/dunce-1.0.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813\", \"files\": {}}",+ "dest": "cargo/vendor/dunce-1.0.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/dyn-clone/dyn-clone-1.0.20.crate",+ "sha256": "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555",+ "dest": "cargo/vendor/dyn-clone-1.0.20"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555\", \"files\": {}}",+ "dest": "cargo/vendor/dyn-clone-1.0.20",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/either/either-1.19.0.crate",+ "sha256": "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be",+ "dest": "cargo/vendor/either-1.19.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be\", \"files\": {}}",+ "dest": "cargo/vendor/either-1.19.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/embed-resource/embed-resource-3.0.11.crate",+ "sha256": "fbfdaacccebec3b28e4866b8973543c7647797db5ada1bdab552e48fe665fbbd",+ "dest": "cargo/vendor/embed-resource-3.0.11"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fbfdaacccebec3b28e4866b8973543c7647797db5ada1bdab552e48fe665fbbd\", \"files\": {}}",+ "dest": "cargo/vendor/embed-resource-3.0.11",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/embed_plist/embed_plist-1.2.2.crate",+ "sha256": "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7",+ "dest": "cargo/vendor/embed_plist-1.2.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7\", \"files\": {}}",+ "dest": "cargo/vendor/embed_plist-1.2.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/endi/endi-1.1.1.crate",+ "sha256": "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099",+ "dest": "cargo/vendor/endi-1.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099\", \"files\": {}}",+ "dest": "cargo/vendor/endi-1.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/enumflags2/enumflags2-0.7.12.crate",+ "sha256": "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef",+ "dest": "cargo/vendor/enumflags2-0.7.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef\", \"files\": {}}",+ "dest": "cargo/vendor/enumflags2-0.7.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/enumflags2_derive/enumflags2_derive-0.7.12.crate",+ "sha256": "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827",+ "dest": "cargo/vendor/enumflags2_derive-0.7.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827\", \"files\": {}}",+ "dest": "cargo/vendor/enumflags2_derive-0.7.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/enumn/enumn-0.1.14.crate",+ "sha256": "2f9ed6b3789237c8a0c1c505af1c7eb2c560df6186f01b098c3a1064ea532f38",+ "dest": "cargo/vendor/enumn-0.1.14"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2f9ed6b3789237c8a0c1c505af1c7eb2c560df6186f01b098c3a1064ea532f38\", \"files\": {}}",+ "dest": "cargo/vendor/enumn-0.1.14",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/equivalent/equivalent-1.0.2.crate",+ "sha256": "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f",+ "dest": "cargo/vendor/equivalent-1.0.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f\", \"files\": {}}",+ "dest": "cargo/vendor/equivalent-1.0.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/erased-serde/erased-serde-0.4.10.crate",+ "sha256": "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec",+ "dest": "cargo/vendor/erased-serde-0.4.10"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec\", \"files\": {}}",+ "dest": "cargo/vendor/erased-serde-0.4.10",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/errno/errno-0.3.14.crate",+ "sha256": "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb",+ "dest": "cargo/vendor/errno-0.3.14"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb\", \"files\": {}}",+ "dest": "cargo/vendor/errno-0.3.14",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/event-listener/event-listener-5.4.2.crate",+ "sha256": "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2",+ "dest": "cargo/vendor/event-listener-5.4.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2\", \"files\": {}}",+ "dest": "cargo/vendor/event-listener-5.4.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/event-listener-strategy/event-listener-strategy-0.5.4.crate",+ "sha256": "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93",+ "dest": "cargo/vendor/event-listener-strategy-0.5.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93\", \"files\": {}}",+ "dest": "cargo/vendor/event-listener-strategy-0.5.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/fallible-iterator/fallible-iterator-0.3.0.crate",+ "sha256": "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649",+ "dest": "cargo/vendor/fallible-iterator-0.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649\", \"files\": {}}",+ "dest": "cargo/vendor/fallible-iterator-0.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/fallible-streaming-iterator/fallible-streaming-iterator-0.1.9.crate",+ "sha256": "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a",+ "dest": "cargo/vendor/fallible-streaming-iterator-0.1.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a\", \"files\": {}}",+ "dest": "cargo/vendor/fallible-streaming-iterator-0.1.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/fast_image_resize/fast_image_resize-6.1.0.crate",+ "sha256": "e9c50201dc184ba6553da1695aac20a042efffbe2d84542cee31917c86c3ab1e",+ "dest": "cargo/vendor/fast_image_resize-6.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e9c50201dc184ba6553da1695aac20a042efffbe2d84542cee31917c86c3ab1e\", \"files\": {}}",+ "dest": "cargo/vendor/fast_image_resize-6.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/fastrand/fastrand-2.5.0.crate",+ "sha256": "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223",+ "dest": "cargo/vendor/fastrand-2.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223\", \"files\": {}}",+ "dest": "cargo/vendor/fastrand-2.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/fdeflate/fdeflate-0.3.7.crate",+ "sha256": "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c",+ "dest": "cargo/vendor/fdeflate-0.3.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c\", \"files\": {}}",+ "dest": "cargo/vendor/fdeflate-0.3.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/field-offset/field-offset-0.3.6.crate",+ "sha256": "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f",+ "dest": "cargo/vendor/field-offset-0.3.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f\", \"files\": {}}",+ "dest": "cargo/vendor/field-offset-0.3.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/find-msvc-tools/find-msvc-tools-0.1.12.crate",+ "sha256": "3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d",+ "dest": "cargo/vendor/find-msvc-tools-0.1.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d\", \"files\": {}}",+ "dest": "cargo/vendor/find-msvc-tools-0.1.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/flate2/flate2-1.1.10.crate",+ "sha256": "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb",+ "dest": "cargo/vendor/flate2-1.1.10"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb\", \"files\": {}}",+ "dest": "cargo/vendor/flate2-1.1.10",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/fnv/fnv-1.0.7.crate",+ "sha256": "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1",+ "dest": "cargo/vendor/fnv-1.0.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1\", \"files\": {}}",+ "dest": "cargo/vendor/fnv-1.0.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/foldhash/foldhash-0.2.0.crate",+ "sha256": "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb",+ "dest": "cargo/vendor/foldhash-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb\", \"files\": {}}",+ "dest": "cargo/vendor/foldhash-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/foreign-types/foreign-types-0.5.0.crate",+ "sha256": "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965",+ "dest": "cargo/vendor/foreign-types-0.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965\", \"files\": {}}",+ "dest": "cargo/vendor/foreign-types-0.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/foreign-types-macros/foreign-types-macros-0.2.4.crate",+ "sha256": "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225",+ "dest": "cargo/vendor/foreign-types-macros-0.2.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225\", \"files\": {}}",+ "dest": "cargo/vendor/foreign-types-macros-0.2.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/foreign-types-shared/foreign-types-shared-0.3.1.crate",+ "sha256": "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b",+ "dest": "cargo/vendor/foreign-types-shared-0.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b\", \"files\": {}}",+ "dest": "cargo/vendor/foreign-types-shared-0.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/form_urlencoded/form_urlencoded-1.2.2.crate",+ "sha256": "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf",+ "dest": "cargo/vendor/form_urlencoded-1.2.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf\", \"files\": {}}",+ "dest": "cargo/vendor/form_urlencoded-1.2.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/four-cc/four-cc-0.4.0.crate",+ "sha256": "795cbfc56d419a7ce47ccbb7504dd9a5b7c484c083c356e797de08bd988d9629",+ "dest": "cargo/vendor/four-cc-0.4.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"795cbfc56d419a7ce47ccbb7504dd9a5b7c484c083c356e797de08bd988d9629\", \"files\": {}}",+ "dest": "cargo/vendor/four-cc-0.4.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/fuser/fuser-0.18.0.crate",+ "sha256": "b82b6597d216503555ead6b358f341ef748869bf5c6fbae6a0cb9dd231baecfd",+ "dest": "cargo/vendor/fuser-0.18.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b82b6597d216503555ead6b358f341ef748869bf5c6fbae6a0cb9dd231baecfd\", \"files\": {}}",+ "dest": "cargo/vendor/fuser-0.18.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures/futures-0.3.34.crate",+ "sha256": "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3",+ "dest": "cargo/vendor/futures-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3\", \"files\": {}}",+ "dest": "cargo/vendor/futures-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-channel/futures-channel-0.3.34.crate",+ "sha256": "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4",+ "dest": "cargo/vendor/futures-channel-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4\", \"files\": {}}",+ "dest": "cargo/vendor/futures-channel-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-core/futures-core-0.3.34.crate",+ "sha256": "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e",+ "dest": "cargo/vendor/futures-core-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e\", \"files\": {}}",+ "dest": "cargo/vendor/futures-core-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-executor/futures-executor-0.3.34.crate",+ "sha256": "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432",+ "dest": "cargo/vendor/futures-executor-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432\", \"files\": {}}",+ "dest": "cargo/vendor/futures-executor-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-io/futures-io-0.3.34.crate",+ "sha256": "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed",+ "dest": "cargo/vendor/futures-io-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed\", \"files\": {}}",+ "dest": "cargo/vendor/futures-io-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-lite/futures-lite-2.6.1.crate",+ "sha256": "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad",+ "dest": "cargo/vendor/futures-lite-2.6.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad\", \"files\": {}}",+ "dest": "cargo/vendor/futures-lite-2.6.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-macro/futures-macro-0.3.34.crate",+ "sha256": "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44",+ "dest": "cargo/vendor/futures-macro-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44\", \"files\": {}}",+ "dest": "cargo/vendor/futures-macro-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-sink/futures-sink-0.3.34.crate",+ "sha256": "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d",+ "dest": "cargo/vendor/futures-sink-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d\", \"files\": {}}",+ "dest": "cargo/vendor/futures-sink-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-task/futures-task-0.3.34.crate",+ "sha256": "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd",+ "dest": "cargo/vendor/futures-task-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd\", \"files\": {}}",+ "dest": "cargo/vendor/futures-task-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/futures-util/futures-util-0.3.34.crate",+ "sha256": "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc",+ "dest": "cargo/vendor/futures-util-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc\", \"files\": {}}",+ "dest": "cargo/vendor/futures-util-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gdk/gdk-0.18.2.crate",+ "sha256": "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691",+ "dest": "cargo/vendor/gdk-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691\", \"files\": {}}",+ "dest": "cargo/vendor/gdk-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gdk-pixbuf/gdk-pixbuf-0.18.5.crate",+ "sha256": "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec",+ "dest": "cargo/vendor/gdk-pixbuf-0.18.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec\", \"files\": {}}",+ "dest": "cargo/vendor/gdk-pixbuf-0.18.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gdk-pixbuf-sys/gdk-pixbuf-sys-0.18.0.crate",+ "sha256": "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7",+ "dest": "cargo/vendor/gdk-pixbuf-sys-0.18.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7\", \"files\": {}}",+ "dest": "cargo/vendor/gdk-pixbuf-sys-0.18.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gdk-sys/gdk-sys-0.18.2.crate",+ "sha256": "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7",+ "dest": "cargo/vendor/gdk-sys-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7\", \"files\": {}}",+ "dest": "cargo/vendor/gdk-sys-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gdkwayland-sys/gdkwayland-sys-0.18.2.crate",+ "sha256": "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69",+ "dest": "cargo/vendor/gdkwayland-sys-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69\", \"files\": {}}",+ "dest": "cargo/vendor/gdkwayland-sys-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gdkx11/gdkx11-0.18.2.crate",+ "sha256": "3caa00e14351bebbc8183b3c36690327eb77c49abc2268dd4bd36b856db3fbfe",+ "dest": "cargo/vendor/gdkx11-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3caa00e14351bebbc8183b3c36690327eb77c49abc2268dd4bd36b856db3fbfe\", \"files\": {}}",+ "dest": "cargo/vendor/gdkx11-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gdkx11-sys/gdkx11-sys-0.18.2.crate",+ "sha256": "6e2e7445fe01ac26f11601db260dd8608fe172514eb63b3b5e261ea6b0f4428d",+ "dest": "cargo/vendor/gdkx11-sys-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6e2e7445fe01ac26f11601db260dd8608fe172514eb63b3b5e261ea6b0f4428d\", \"files\": {}}",+ "dest": "cargo/vendor/gdkx11-sys-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/generic-array/generic-array-0.14.7.crate",+ "sha256": "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a",+ "dest": "cargo/vendor/generic-array-0.14.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a\", \"files\": {}}",+ "dest": "cargo/vendor/generic-array-0.14.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/getrandom/getrandom-0.2.17.crate",+ "sha256": "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0",+ "dest": "cargo/vendor/getrandom-0.2.17"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0\", \"files\": {}}",+ "dest": "cargo/vendor/getrandom-0.2.17",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/getrandom/getrandom-0.3.4.crate",+ "sha256": "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd",+ "dest": "cargo/vendor/getrandom-0.3.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd\", \"files\": {}}",+ "dest": "cargo/vendor/getrandom-0.3.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/getrandom/getrandom-0.4.3.crate",+ "sha256": "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099",+ "dest": "cargo/vendor/getrandom-0.4.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099\", \"files\": {}}",+ "dest": "cargo/vendor/getrandom-0.4.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gio/gio-0.18.4.crate",+ "sha256": "d4fc8f532f87b79cbc51a79748f16a6828fb784be93145a322fa14d06d354c73",+ "dest": "cargo/vendor/gio-0.18.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d4fc8f532f87b79cbc51a79748f16a6828fb784be93145a322fa14d06d354c73\", \"files\": {}}",+ "dest": "cargo/vendor/gio-0.18.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gio-sys/gio-sys-0.18.1.crate",+ "sha256": "37566df850baf5e4cb0dfb78af2e4b9898d817ed9263d1090a2df958c64737d2",+ "dest": "cargo/vendor/gio-sys-0.18.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"37566df850baf5e4cb0dfb78af2e4b9898d817ed9263d1090a2df958c64737d2\", \"files\": {}}",+ "dest": "cargo/vendor/gio-sys-0.18.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gio-sys/gio-sys-0.22.9.crate",+ "sha256": "6c28739f914c15b87a9856000bed9cbd5b3a8afbca5e982d9a299e1601422cb5",+ "dest": "cargo/vendor/gio-sys-0.22.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6c28739f914c15b87a9856000bed9cbd5b3a8afbca5e982d9a299e1601422cb5\", \"files\": {}}",+ "dest": "cargo/vendor/gio-sys-0.22.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/glib/glib-0.18.5.crate",+ "sha256": "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5",+ "dest": "cargo/vendor/glib-0.18.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5\", \"files\": {}}",+ "dest": "cargo/vendor/glib-0.18.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/glib/glib-0.22.10.crate",+ "sha256": "e4cf9e5bd8713f1990a92c422998826e0fb34824277b46bc59757373483c6694",+ "dest": "cargo/vendor/glib-0.22.10"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e4cf9e5bd8713f1990a92c422998826e0fb34824277b46bc59757373483c6694\", \"files\": {}}",+ "dest": "cargo/vendor/glib-0.22.10",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/glib-macros/glib-macros-0.18.5.crate",+ "sha256": "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc",+ "dest": "cargo/vendor/glib-macros-0.18.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc\", \"files\": {}}",+ "dest": "cargo/vendor/glib-macros-0.18.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/glib-macros/glib-macros-0.22.9.crate",+ "sha256": "c9597c68fa7bdf4154a3079642cd21c4dccac0b0bdd2897d82861523bf91e7b9",+ "dest": "cargo/vendor/glib-macros-0.22.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c9597c68fa7bdf4154a3079642cd21c4dccac0b0bdd2897d82861523bf91e7b9\", \"files\": {}}",+ "dest": "cargo/vendor/glib-macros-0.22.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/glib-sys/glib-sys-0.18.1.crate",+ "sha256": "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898",+ "dest": "cargo/vendor/glib-sys-0.18.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898\", \"files\": {}}",+ "dest": "cargo/vendor/glib-sys-0.18.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/glib-sys/glib-sys-0.22.9.crate",+ "sha256": "99b38907e67e40dec9b60f858bcada952598719cb512a13eb13d6cdcd16f8295",+ "dest": "cargo/vendor/glib-sys-0.22.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"99b38907e67e40dec9b60f858bcada952598719cb512a13eb13d6cdcd16f8295\", \"files\": {}}",+ "dest": "cargo/vendor/glib-sys-0.22.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/glob/glob-0.3.4.crate",+ "sha256": "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b",+ "dest": "cargo/vendor/glob-0.3.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b\", \"files\": {}}",+ "dest": "cargo/vendor/glob-0.3.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gobject-sys/gobject-sys-0.18.0.crate",+ "sha256": "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44",+ "dest": "cargo/vendor/gobject-sys-0.18.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44\", \"files\": {}}",+ "dest": "cargo/vendor/gobject-sys-0.18.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gobject-sys/gobject-sys-0.22.9.crate",+ "sha256": "07595c9ba696bd9819cb6a8df39f08078f3dd679508fe052dd558492c2053834",+ "dest": "cargo/vendor/gobject-sys-0.22.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"07595c9ba696bd9819cb6a8df39f08078f3dd679508fe052dd558492c2053834\", \"files\": {}}",+ "dest": "cargo/vendor/gobject-sys-0.22.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer/gstreamer-0.25.4.crate",+ "sha256": "f4237e2066a25ecb7e54be6c066409e30615920265b9799b8d560ef8ac9857c6",+ "dest": "cargo/vendor/gstreamer-0.25.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f4237e2066a25ecb7e54be6c066409e30615920265b9799b8d560ef8ac9857c6\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-0.25.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer-app/gstreamer-app-0.25.2.crate",+ "sha256": "97f8ae9238c2352398dcc084de28df3f7099af216ac6c160b52318d23f25c010",+ "dest": "cargo/vendor/gstreamer-app-0.25.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"97f8ae9238c2352398dcc084de28df3f7099af216ac6c160b52318d23f25c010\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-app-0.25.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer-app-sys/gstreamer-app-sys-0.25.4.crate",+ "sha256": "0798b8aef6694341d40bb81edc759f8979b896b59f9f0f45d8cfa3bb7bf2e743",+ "dest": "cargo/vendor/gstreamer-app-sys-0.25.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0798b8aef6694341d40bb81edc759f8979b896b59f9f0f45d8cfa3bb7bf2e743\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-app-sys-0.25.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer-base/gstreamer-base-0.25.4.crate",+ "sha256": "17cbd8f59586a369c40d4b0d2f3a61cf9e9287b3cf5503cdcd8e7c5faa99265e",+ "dest": "cargo/vendor/gstreamer-base-0.25.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"17cbd8f59586a369c40d4b0d2f3a61cf9e9287b3cf5503cdcd8e7c5faa99265e\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-base-0.25.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer-base-sys/gstreamer-base-sys-0.25.4.crate",+ "sha256": "3b05f77bfd76b5afee6b29c27dae19eaf5018b5cf8d0d17520f3de44c6385c32",+ "dest": "cargo/vendor/gstreamer-base-sys-0.25.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3b05f77bfd76b5afee6b29c27dae19eaf5018b5cf8d0d17520f3de44c6385c32\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-base-sys-0.25.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer-sys/gstreamer-sys-0.25.4.crate",+ "sha256": "436d9532847489a8285d57b8c3670762c12a18f777fdc2ab159b52e0e6f521b9",+ "dest": "cargo/vendor/gstreamer-sys-0.25.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"436d9532847489a8285d57b8c3670762c12a18f777fdc2ab159b52e0e6f521b9\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-sys-0.25.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer-video/gstreamer-video-0.25.4.crate",+ "sha256": "ffe4d77b2a5e679973d9c6b6c052da8cda86b83f5c268872f8691fde693fde84",+ "dest": "cargo/vendor/gstreamer-video-0.25.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ffe4d77b2a5e679973d9c6b6c052da8cda86b83f5c268872f8691fde693fde84\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-video-0.25.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gstreamer-video-sys/gstreamer-video-sys-0.25.4.crate",+ "sha256": "ef455da22edca97ac9299d682b868227f3d9217b303748ce0161b31ae82dc106",+ "dest": "cargo/vendor/gstreamer-video-sys-0.25.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ef455da22edca97ac9299d682b868227f3d9217b303748ce0161b31ae82dc106\", \"files\": {}}",+ "dest": "cargo/vendor/gstreamer-video-sys-0.25.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gtk/gtk-0.18.2.crate",+ "sha256": "fd56fb197bfc42bd5d2751f4f017d44ff59fbb58140c6b49f9b3b2bdab08506a",+ "dest": "cargo/vendor/gtk-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fd56fb197bfc42bd5d2751f4f017d44ff59fbb58140c6b49f9b3b2bdab08506a\", \"files\": {}}",+ "dest": "cargo/vendor/gtk-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gtk-sys/gtk-sys-0.18.2.crate",+ "sha256": "8f29a1c21c59553eb7dd40e918be54dccd60c52b049b75119d5d96ce6b624414",+ "dest": "cargo/vendor/gtk-sys-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8f29a1c21c59553eb7dd40e918be54dccd60c52b049b75119d5d96ce6b624414\", \"files\": {}}",+ "dest": "cargo/vendor/gtk-sys-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/gtk3-macros/gtk3-macros-0.18.2.crate",+ "sha256": "52ff3c5b21f14f0736fed6dcfc0bfb4225ebf5725f3c0209edeec181e4d73e9d",+ "dest": "cargo/vendor/gtk3-macros-0.18.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"52ff3c5b21f14f0736fed6dcfc0bfb4225ebf5725f3c0209edeec181e4d73e9d\", \"files\": {}}",+ "dest": "cargo/vendor/gtk3-macros-0.18.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/h2/h2-0.4.19.crate",+ "sha256": "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16",+ "dest": "cargo/vendor/h2-0.4.19"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16\", \"files\": {}}",+ "dest": "cargo/vendor/h2-0.4.19",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hashbrown/hashbrown-0.12.3.crate",+ "sha256": "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888",+ "dest": "cargo/vendor/hashbrown-0.12.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888\", \"files\": {}}",+ "dest": "cargo/vendor/hashbrown-0.12.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hashbrown/hashbrown-0.14.5.crate",+ "sha256": "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1",+ "dest": "cargo/vendor/hashbrown-0.14.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1\", \"files\": {}}",+ "dest": "cargo/vendor/hashbrown-0.14.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hashbrown/hashbrown-0.17.1.crate",+ "sha256": "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a",+ "dest": "cargo/vendor/hashbrown-0.17.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a\", \"files\": {}}",+ "dest": "cargo/vendor/hashbrown-0.17.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hashlink/hashlink-0.9.1.crate",+ "sha256": "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af",+ "dest": "cargo/vendor/hashlink-0.9.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af\", \"files\": {}}",+ "dest": "cargo/vendor/hashlink-0.9.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/heck/heck-0.4.1.crate",+ "sha256": "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8",+ "dest": "cargo/vendor/heck-0.4.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8\", \"files\": {}}",+ "dest": "cargo/vendor/heck-0.4.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/heck/heck-0.5.0.crate",+ "sha256": "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea",+ "dest": "cargo/vendor/heck-0.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea\", \"files\": {}}",+ "dest": "cargo/vendor/heck-0.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hermit-abi/hermit-abi-0.5.3.crate",+ "sha256": "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284",+ "dest": "cargo/vendor/hermit-abi-0.5.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284\", \"files\": {}}",+ "dest": "cargo/vendor/hermit-abi-0.5.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hex/hex-0.4.3.crate",+ "sha256": "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70",+ "dest": "cargo/vendor/hex-0.4.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70\", \"files\": {}}",+ "dest": "cargo/vendor/hex-0.4.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hkdf/hkdf-0.12.4.crate",+ "sha256": "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7",+ "dest": "cargo/vendor/hkdf-0.12.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7\", \"files\": {}}",+ "dest": "cargo/vendor/hkdf-0.12.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hmac/hmac-0.12.1.crate",+ "sha256": "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e",+ "dest": "cargo/vendor/hmac-0.12.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e\", \"files\": {}}",+ "dest": "cargo/vendor/hmac-0.12.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/html5ever/html5ever-0.39.0.crate",+ "sha256": "46a1761807faccc9a19e86944bbf40610014066306f96edcdedc2fb714bcb7b8",+ "dest": "cargo/vendor/html5ever-0.39.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"46a1761807faccc9a19e86944bbf40610014066306f96edcdedc2fb714bcb7b8\", \"files\": {}}",+ "dest": "cargo/vendor/html5ever-0.39.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/http/http-1.5.0.crate",+ "sha256": "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0",+ "dest": "cargo/vendor/http-1.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0\", \"files\": {}}",+ "dest": "cargo/vendor/http-1.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/http-body/http-body-1.1.0.crate",+ "sha256": "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c",+ "dest": "cargo/vendor/http-body-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c\", \"files\": {}}",+ "dest": "cargo/vendor/http-body-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/http-body-util/http-body-util-0.1.5.crate",+ "sha256": "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c",+ "dest": "cargo/vendor/http-body-util-0.1.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c\", \"files\": {}}",+ "dest": "cargo/vendor/http-body-util-0.1.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/httparse/httparse-1.10.1.crate",+ "sha256": "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87",+ "dest": "cargo/vendor/httparse-1.10.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87\", \"files\": {}}",+ "dest": "cargo/vendor/httparse-1.10.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/httpdate/httpdate-1.0.3.crate",+ "sha256": "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9",+ "dest": "cargo/vendor/httpdate-1.0.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9\", \"files\": {}}",+ "dest": "cargo/vendor/httpdate-1.0.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hyper/hyper-1.11.1.crate",+ "sha256": "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43",+ "dest": "cargo/vendor/hyper-1.11.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43\", \"files\": {}}",+ "dest": "cargo/vendor/hyper-1.11.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hyper-rustls/hyper-rustls-0.27.9.crate",+ "sha256": "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f",+ "dest": "cargo/vendor/hyper-rustls-0.27.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f\", \"files\": {}}",+ "dest": "cargo/vendor/hyper-rustls-0.27.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/hyper-util/hyper-util-0.1.20.crate",+ "sha256": "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0",+ "dest": "cargo/vendor/hyper-util-0.1.20"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0\", \"files\": {}}",+ "dest": "cargo/vendor/hyper-util-0.1.20",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/iana-time-zone/iana-time-zone-0.1.65.crate",+ "sha256": "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470",+ "dest": "cargo/vendor/iana-time-zone-0.1.65"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470\", \"files\": {}}",+ "dest": "cargo/vendor/iana-time-zone-0.1.65",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/iana-time-zone-haiku/iana-time-zone-haiku-0.1.2.crate",+ "sha256": "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f",+ "dest": "cargo/vendor/iana-time-zone-haiku-0.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f\", \"files\": {}}",+ "dest": "cargo/vendor/iana-time-zone-haiku-0.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ico/ico-0.6.0.crate",+ "sha256": "d75e94d66081e4d8dcd098bd8dc5254800fea14a26389b298410158d834de167",+ "dest": "cargo/vendor/ico-0.6.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d75e94d66081e4d8dcd098bd8dc5254800fea14a26389b298410158d834de167\", \"files\": {}}",+ "dest": "cargo/vendor/ico-0.6.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/icu_collections/icu_collections-2.3.0.crate",+ "sha256": "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513",+ "dest": "cargo/vendor/icu_collections-2.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513\", \"files\": {}}",+ "dest": "cargo/vendor/icu_collections-2.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/icu_locale_core/icu_locale_core-2.3.0.crate",+ "sha256": "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb",+ "dest": "cargo/vendor/icu_locale_core-2.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb\", \"files\": {}}",+ "dest": "cargo/vendor/icu_locale_core-2.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/icu_normalizer/icu_normalizer-2.3.0.crate",+ "sha256": "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f",+ "dest": "cargo/vendor/icu_normalizer-2.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f\", \"files\": {}}",+ "dest": "cargo/vendor/icu_normalizer-2.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/icu_normalizer_data/icu_normalizer_data-2.3.0.crate",+ "sha256": "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0",+ "dest": "cargo/vendor/icu_normalizer_data-2.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0\", \"files\": {}}",+ "dest": "cargo/vendor/icu_normalizer_data-2.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/icu_properties/icu_properties-2.3.0.crate",+ "sha256": "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148",+ "dest": "cargo/vendor/icu_properties-2.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148\", \"files\": {}}",+ "dest": "cargo/vendor/icu_properties-2.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/icu_properties_data/icu_properties_data-2.3.0.crate",+ "sha256": "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa",+ "dest": "cargo/vendor/icu_properties_data-2.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa\", \"files\": {}}",+ "dest": "cargo/vendor/icu_properties_data-2.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/icu_provider/icu_provider-2.3.1.crate",+ "sha256": "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73",+ "dest": "cargo/vendor/icu_provider-2.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73\", \"files\": {}}",+ "dest": "cargo/vendor/icu_provider-2.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ident_case/ident_case-1.0.1.crate",+ "sha256": "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39",+ "dest": "cargo/vendor/ident_case-1.0.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39\", \"files\": {}}",+ "dest": "cargo/vendor/ident_case-1.0.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/idna/idna-1.1.0.crate",+ "sha256": "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de",+ "dest": "cargo/vendor/idna-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de\", \"files\": {}}",+ "dest": "cargo/vendor/idna-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/idna_adapter/idna_adapter-1.2.2.crate",+ "sha256": "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714",+ "dest": "cargo/vendor/idna_adapter-1.2.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714\", \"files\": {}}",+ "dest": "cargo/vendor/idna_adapter-1.2.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/image/image-0.25.10.crate",+ "sha256": "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104",+ "dest": "cargo/vendor/image-0.25.10"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104\", \"files\": {}}",+ "dest": "cargo/vendor/image-0.25.10",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/indexmap/indexmap-1.9.3.crate",+ "sha256": "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99",+ "dest": "cargo/vendor/indexmap-1.9.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99\", \"files\": {}}",+ "dest": "cargo/vendor/indexmap-1.9.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/indexmap/indexmap-2.14.2.crate",+ "sha256": "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855",+ "dest": "cargo/vendor/indexmap-2.14.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855\", \"files\": {}}",+ "dest": "cargo/vendor/indexmap-2.14.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/infer/infer-0.22.0.crate",+ "sha256": "f4200d433cbd5178df7797c9c2e75b348b728e39631cf14520d1e2fc424201f4",+ "dest": "cargo/vendor/infer-0.22.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f4200d433cbd5178df7797c9c2e75b348b728e39631cf14520d1e2fc424201f4\", \"files\": {}}",+ "dest": "cargo/vendor/infer-0.22.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/inout/inout-0.1.4.crate",+ "sha256": "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01",+ "dest": "cargo/vendor/inout-0.1.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01\", \"files\": {}}",+ "dest": "cargo/vendor/inout-0.1.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ipnet/ipnet-2.12.2.crate",+ "sha256": "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0",+ "dest": "cargo/vendor/ipnet-2.12.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0\", \"files\": {}}",+ "dest": "cargo/vendor/ipnet-2.12.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/is-docker/is-docker-0.2.0.crate",+ "sha256": "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3",+ "dest": "cargo/vendor/is-docker-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3\", \"files\": {}}",+ "dest": "cargo/vendor/is-docker-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/is-wsl/is-wsl-0.4.0.crate",+ "sha256": "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5",+ "dest": "cargo/vendor/is-wsl-0.4.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5\", \"files\": {}}",+ "dest": "cargo/vendor/is-wsl-0.4.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/itertools/itertools-0.15.0.crate",+ "sha256": "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc",+ "dest": "cargo/vendor/itertools-0.15.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc\", \"files\": {}}",+ "dest": "cargo/vendor/itertools-0.15.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/itoa/itoa-1.0.18.crate",+ "sha256": "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682",+ "dest": "cargo/vendor/itoa-1.0.18"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682\", \"files\": {}}",+ "dest": "cargo/vendor/itoa-1.0.18",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/javascriptcore-rs/javascriptcore-rs-1.1.2.crate",+ "sha256": "ca5671e9ffce8ffba57afc24070e906da7fc4b1ba66f2cabebf61bf2ea257fcc",+ "dest": "cargo/vendor/javascriptcore-rs-1.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ca5671e9ffce8ffba57afc24070e906da7fc4b1ba66f2cabebf61bf2ea257fcc\", \"files\": {}}",+ "dest": "cargo/vendor/javascriptcore-rs-1.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/javascriptcore-rs-sys/javascriptcore-rs-sys-1.1.1.crate",+ "sha256": "af1be78d14ffa4b75b66df31840478fef72b51f8c2465d4ca7c194da9f7a5124",+ "dest": "cargo/vendor/javascriptcore-rs-sys-1.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"af1be78d14ffa4b75b66df31840478fef72b51f8c2465d4ca7c194da9f7a5124\", \"files\": {}}",+ "dest": "cargo/vendor/javascriptcore-rs-sys-1.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jiff/jiff-0.2.37.crate",+ "sha256": "0ab1baf72f08796de0260609515130699b890ac25f30e610ad894bc5856cafdb",+ "dest": "cargo/vendor/jiff-0.2.37"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0ab1baf72f08796de0260609515130699b890ac25f30e610ad894bc5856cafdb\", \"files\": {}}",+ "dest": "cargo/vendor/jiff-0.2.37",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jiff-core/jiff-core-0.1.1.crate",+ "sha256": "5e52fe76043ccecc9005d2305ebaadf7d7fc0cc89ca6baa10a94d6bc68c7128c",+ "dest": "cargo/vendor/jiff-core-0.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5e52fe76043ccecc9005d2305ebaadf7d7fc0cc89ca6baa10a94d6bc68c7128c\", \"files\": {}}",+ "dest": "cargo/vendor/jiff-core-0.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jiff-static/jiff-static-0.2.37.crate",+ "sha256": "378268a1116ad67ae6228701118ac9f491d78fda38a40a1f1a9e1348de6f7212",+ "dest": "cargo/vendor/jiff-static-0.2.37"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"378268a1116ad67ae6228701118ac9f491d78fda38a40a1f1a9e1348de6f7212\", \"files\": {}}",+ "dest": "cargo/vendor/jiff-static-0.2.37",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jiff-tzdb/jiff-tzdb-0.1.8.crate",+ "sha256": "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e",+ "dest": "cargo/vendor/jiff-tzdb-0.1.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e\", \"files\": {}}",+ "dest": "cargo/vendor/jiff-tzdb-0.1.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jiff-tzdb-platform/jiff-tzdb-platform-0.1.3.crate",+ "sha256": "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8",+ "dest": "cargo/vendor/jiff-tzdb-platform-0.1.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8\", \"files\": {}}",+ "dest": "cargo/vendor/jiff-tzdb-platform-0.1.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jni/jni-0.21.1.crate",+ "sha256": "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97",+ "dest": "cargo/vendor/jni-0.21.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97\", \"files\": {}}",+ "dest": "cargo/vendor/jni-0.21.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jni-sys/jni-sys-0.3.1.crate",+ "sha256": "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258",+ "dest": "cargo/vendor/jni-sys-0.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258\", \"files\": {}}",+ "dest": "cargo/vendor/jni-sys-0.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jni-sys/jni-sys-0.4.1.crate",+ "sha256": "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2",+ "dest": "cargo/vendor/jni-sys-0.4.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2\", \"files\": {}}",+ "dest": "cargo/vendor/jni-sys-0.4.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jni-sys-macros/jni-sys-macros-0.4.1.crate",+ "sha256": "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264",+ "dest": "cargo/vendor/jni-sys-macros-0.4.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264\", \"files\": {}}",+ "dest": "cargo/vendor/jni-sys-macros-0.4.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/js-sys/js-sys-0.3.105.crate",+ "sha256": "ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e",+ "dest": "cargo/vendor/js-sys-0.3.105"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e\", \"files\": {}}",+ "dest": "cargo/vendor/js-sys-0.3.105",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/json-patch/json-patch-4.2.0.crate",+ "sha256": "7421438de105a0827e44fadd05377727847d717c80ce29a229f85fd04c427b72",+ "dest": "cargo/vendor/json-patch-4.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7421438de105a0827e44fadd05377727847d717c80ce29a229f85fd04c427b72\", \"files\": {}}",+ "dest": "cargo/vendor/json-patch-4.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/jsonptr/jsonptr-0.7.1.crate",+ "sha256": "a5a3cc660ba5d72bce0b3bb295bf20847ccbb40fd423f3f05b61273672e561fe",+ "dest": "cargo/vendor/jsonptr-0.7.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a5a3cc660ba5d72bce0b3bb295bf20847ccbb40fd423f3f05b61273672e561fe\", \"files\": {}}",+ "dest": "cargo/vendor/jsonptr-0.7.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/keyboard-types/keyboard-types-0.8.3.crate",+ "sha256": "0fbe853b403ae61a04233030ae8a79d94975281ed9770a1f9e246732b534b28d",+ "dest": "cargo/vendor/keyboard-types-0.8.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0fbe853b403ae61a04233030ae8a79d94975281ed9770a1f9e246732b534b28d\", \"files\": {}}",+ "dest": "cargo/vendor/keyboard-types-0.8.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/keyring/keyring-3.6.3.crate",+ "sha256": "eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c",+ "dest": "cargo/vendor/keyring-3.6.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c\", \"files\": {}}",+ "dest": "cargo/vendor/keyring-3.6.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/kstring/kstring-2.0.5.crate",+ "sha256": "7a09b82a7f771ed02dc0dd9b27130a0fa5499fa15ed3027116c1e5e4e591bd9e",+ "dest": "cargo/vendor/kstring-2.0.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7a09b82a7f771ed02dc0dd9b27130a0fa5499fa15ed3027116c1e5e4e591bd9e\", \"files\": {}}",+ "dest": "cargo/vendor/kstring-2.0.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/lazy_static/lazy_static-1.5.0.crate",+ "sha256": "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe",+ "dest": "cargo/vendor/lazy_static-1.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe\", \"files\": {}}",+ "dest": "cargo/vendor/lazy_static-1.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libappindicator/libappindicator-0.9.0.crate",+ "sha256": "03589b9607c868cc7ae54c0b2a22c8dc03dd41692d48f2d7df73615c6a95dc0a",+ "dest": "cargo/vendor/libappindicator-0.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"03589b9607c868cc7ae54c0b2a22c8dc03dd41692d48f2d7df73615c6a95dc0a\", \"files\": {}}",+ "dest": "cargo/vendor/libappindicator-0.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libappindicator-sys/libappindicator-sys-0.9.0.crate",+ "sha256": "6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf",+ "dest": "cargo/vendor/libappindicator-sys-0.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf\", \"files\": {}}",+ "dest": "cargo/vendor/libappindicator-sys-0.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libc/libc-0.2.189.crate",+ "sha256": "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2",+ "dest": "cargo/vendor/libc-0.2.189"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2\", \"files\": {}}",+ "dest": "cargo/vendor/libc-0.2.189",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libdbus-sys/libdbus-sys-0.2.7.crate",+ "sha256": "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043",+ "dest": "cargo/vendor/libdbus-sys-0.2.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043\", \"files\": {}}",+ "dest": "cargo/vendor/libdbus-sys-0.2.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libheif-rs/libheif-rs-3.0.0.crate",+ "sha256": "eeba013228b7f744e2ede32bbc4ea9056a9a27910e2ff61fdb146f94ed89f7ea",+ "dest": "cargo/vendor/libheif-rs-3.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"eeba013228b7f744e2ede32bbc4ea9056a9a27910e2ff61fdb146f94ed89f7ea\", \"files\": {}}",+ "dest": "cargo/vendor/libheif-rs-3.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libheif-sys/libheif-sys-5.3.1+1.23.1.crate",+ "sha256": "f554864c5f34c7f285ff6acdcadb64bcc2a3de1609e9135cec702c5edc703864",+ "dest": "cargo/vendor/libheif-sys-5.3.1+1.23.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f554864c5f34c7f285ff6acdcadb64bcc2a3de1609e9135cec702c5edc703864\", \"files\": {}}",+ "dest": "cargo/vendor/libheif-sys-5.3.1+1.23.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libloading/libloading-0.7.4.crate",+ "sha256": "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f",+ "dest": "cargo/vendor/libloading-0.7.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f\", \"files\": {}}",+ "dest": "cargo/vendor/libloading-0.7.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libredox/libredox-0.1.24.crate",+ "sha256": "6480ccc157a1389bb2e4891b24751b0f798ba640d22386f23143fbcc89da195a",+ "dest": "cargo/vendor/libredox-0.1.24"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6480ccc157a1389bb2e4891b24751b0f798ba640d22386f23143fbcc89da195a\", \"files\": {}}",+ "dest": "cargo/vendor/libredox-0.1.24",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/libsqlite3-sys/libsqlite3-sys-0.30.1.crate",+ "sha256": "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149",+ "dest": "cargo/vendor/libsqlite3-sys-0.30.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149\", \"files\": {}}",+ "dest": "cargo/vendor/libsqlite3-sys-0.30.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/linux-raw-sys/linux-raw-sys-0.12.1.crate",+ "sha256": "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53",+ "dest": "cargo/vendor/linux-raw-sys-0.12.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53\", \"files\": {}}",+ "dest": "cargo/vendor/linux-raw-sys-0.12.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/litemap/litemap-0.8.3.crate",+ "sha256": "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae",+ "dest": "cargo/vendor/litemap-0.8.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae\", \"files\": {}}",+ "dest": "cargo/vendor/litemap-0.8.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/litrs/litrs-1.0.0.crate",+ "sha256": "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092",+ "dest": "cargo/vendor/litrs-1.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092\", \"files\": {}}",+ "dest": "cargo/vendor/litrs-1.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/lock_api/lock_api-0.4.14.crate",+ "sha256": "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965",+ "dest": "cargo/vendor/lock_api-0.4.14"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965\", \"files\": {}}",+ "dest": "cargo/vendor/lock_api-0.4.14",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/log/log-0.4.34.crate",+ "sha256": "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6",+ "dest": "cargo/vendor/log-0.4.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6\", \"files\": {}}",+ "dest": "cargo/vendor/log-0.4.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/lru-slab/lru-slab-0.1.2.crate",+ "sha256": "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154",+ "dest": "cargo/vendor/lru-slab-0.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154\", \"files\": {}}",+ "dest": "cargo/vendor/lru-slab-0.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/mac-notification-sys/mac-notification-sys-0.6.15.crate",+ "sha256": "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca",+ "dest": "cargo/vendor/mac-notification-sys-0.6.15"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca\", \"files\": {}}",+ "dest": "cargo/vendor/mac-notification-sys-0.6.15",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/markup5ever/markup5ever-0.39.0.crate",+ "sha256": "7122d987ec5f704ee56f6e5b41a7d93722e9aae27ae07cafa4036c4d3f9757de",+ "dest": "cargo/vendor/markup5ever-0.39.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7122d987ec5f704ee56f6e5b41a7d93722e9aae27ae07cafa4036c4d3f9757de\", \"files\": {}}",+ "dest": "cargo/vendor/markup5ever-0.39.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/md-5/md-5-0.10.6.crate",+ "sha256": "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf",+ "dest": "cargo/vendor/md-5-0.10.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf\", \"files\": {}}",+ "dest": "cargo/vendor/md-5-0.10.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/memchr/memchr-2.8.3.crate",+ "sha256": "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98",+ "dest": "cargo/vendor/memchr-2.8.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98\", \"files\": {}}",+ "dest": "cargo/vendor/memchr-2.8.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/memoffset/memoffset-0.9.1.crate",+ "sha256": "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a",+ "dest": "cargo/vendor/memoffset-0.9.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a\", \"files\": {}}",+ "dest": "cargo/vendor/memoffset-0.9.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/mime/mime-0.3.17.crate",+ "sha256": "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a",+ "dest": "cargo/vendor/mime-0.3.17"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a\", \"files\": {}}",+ "dest": "cargo/vendor/mime-0.3.17",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/mime_guess/mime_guess-2.0.5.crate",+ "sha256": "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e",+ "dest": "cargo/vendor/mime_guess-2.0.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e\", \"files\": {}}",+ "dest": "cargo/vendor/mime_guess-2.0.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/miniz_oxide/miniz_oxide-0.8.9.crate",+ "sha256": "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316",+ "dest": "cargo/vendor/miniz_oxide-0.8.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316\", \"files\": {}}",+ "dest": "cargo/vendor/miniz_oxide-0.8.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/miniz_oxide/miniz_oxide-0.9.1.crate",+ "sha256": "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c",+ "dest": "cargo/vendor/miniz_oxide-0.9.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c\", \"files\": {}}",+ "dest": "cargo/vendor/miniz_oxide-0.9.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/mio/mio-1.2.3.crate",+ "sha256": "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8",+ "dest": "cargo/vendor/mio-1.2.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8\", \"files\": {}}",+ "dest": "cargo/vendor/mio-1.2.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/moxcms/moxcms-0.8.1.crate",+ "sha256": "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b",+ "dest": "cargo/vendor/moxcms-0.8.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b\", \"files\": {}}",+ "dest": "cargo/vendor/moxcms-0.8.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/muda/muda-0.20.0.crate",+ "sha256": "cca139e57da4383727f189e43e66e84fa372347027fc996f9f1a007ec0a37996",+ "dest": "cargo/vendor/muda-0.20.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cca139e57da4383727f189e43e66e84fa372347027fc996f9f1a007ec0a37996\", \"files\": {}}",+ "dest": "cargo/vendor/muda-0.20.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/muldiv/muldiv-1.0.1.crate",+ "sha256": "956787520e75e9bd233246045d19f42fb73242759cc57fba9611d940ae96d4b0",+ "dest": "cargo/vendor/muldiv-1.0.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"956787520e75e9bd233246045d19f42fb73242759cc57fba9611d940ae96d4b0\", \"files\": {}}",+ "dest": "cargo/vendor/muldiv-1.0.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ndk/ndk-0.9.0.crate",+ "sha256": "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4",+ "dest": "cargo/vendor/ndk-0.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4\", \"files\": {}}",+ "dest": "cargo/vendor/ndk-0.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ndk-context/ndk-context-0.1.1.crate",+ "sha256": "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b",+ "dest": "cargo/vendor/ndk-context-0.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b\", \"files\": {}}",+ "dest": "cargo/vendor/ndk-context-0.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ndk-sys/ndk-sys-0.6.0+11769913.crate",+ "sha256": "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873",+ "dest": "cargo/vendor/ndk-sys-0.6.0+11769913"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873\", \"files\": {}}",+ "dest": "cargo/vendor/ndk-sys-0.6.0+11769913",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/new_debug_unreachable/new_debug_unreachable-1.0.6.crate",+ "sha256": "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086",+ "dest": "cargo/vendor/new_debug_unreachable-1.0.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086\", \"files\": {}}",+ "dest": "cargo/vendor/new_debug_unreachable-1.0.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/nix/nix-0.29.0.crate",+ "sha256": "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46",+ "dest": "cargo/vendor/nix-0.29.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46\", \"files\": {}}",+ "dest": "cargo/vendor/nix-0.29.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/nix/nix-0.31.3.crate",+ "sha256": "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d",+ "dest": "cargo/vendor/nix-0.31.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d\", \"files\": {}}",+ "dest": "cargo/vendor/nix-0.31.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/notify-rust/notify-rust-4.18.1.crate",+ "sha256": "fe430c879247371c47fdedd328ad4e301e6b30b533c5fd5db1c06d75253d0e46",+ "dest": "cargo/vendor/notify-rust-4.18.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fe430c879247371c47fdedd328ad4e301e6b30b533c5fd5db1c06d75253d0e46\", \"files\": {}}",+ "dest": "cargo/vendor/notify-rust-4.18.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num/num-0.4.3.crate",+ "sha256": "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23",+ "dest": "cargo/vendor/num-0.4.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23\", \"files\": {}}",+ "dest": "cargo/vendor/num-0.4.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num-bigint/num-bigint-0.4.8.crate",+ "sha256": "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367",+ "dest": "cargo/vendor/num-bigint-0.4.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367\", \"files\": {}}",+ "dest": "cargo/vendor/num-bigint-0.4.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num-complex/num-complex-0.4.6.crate",+ "sha256": "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495",+ "dest": "cargo/vendor/num-complex-0.4.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495\", \"files\": {}}",+ "dest": "cargo/vendor/num-complex-0.4.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num-conv/num-conv-0.2.2.crate",+ "sha256": "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441",+ "dest": "cargo/vendor/num-conv-0.2.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441\", \"files\": {}}",+ "dest": "cargo/vendor/num-conv-0.2.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num-integer/num-integer-0.1.47.crate",+ "sha256": "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b",+ "dest": "cargo/vendor/num-integer-0.1.47"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b\", \"files\": {}}",+ "dest": "cargo/vendor/num-integer-0.1.47",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num-iter/num-iter-0.1.46.crate",+ "sha256": "c92800bd69a1eac91786bcfe9da64a897eb72911b8dc3095decbd07429e8048b",+ "dest": "cargo/vendor/num-iter-0.1.46"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c92800bd69a1eac91786bcfe9da64a897eb72911b8dc3095decbd07429e8048b\", \"files\": {}}",+ "dest": "cargo/vendor/num-iter-0.1.46",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num-rational/num-rational-0.4.2.crate",+ "sha256": "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824",+ "dest": "cargo/vendor/num-rational-0.4.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824\", \"files\": {}}",+ "dest": "cargo/vendor/num-rational-0.4.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num-traits/num-traits-0.2.19.crate",+ "sha256": "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841",+ "dest": "cargo/vendor/num-traits-0.2.19"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841\", \"files\": {}}",+ "dest": "cargo/vendor/num-traits-0.2.19",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num_cpus/num_cpus-1.17.0.crate",+ "sha256": "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b",+ "dest": "cargo/vendor/num_cpus-1.17.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b\", \"files\": {}}",+ "dest": "cargo/vendor/num_cpus-1.17.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num_enum/num_enum-0.7.6.crate",+ "sha256": "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26",+ "dest": "cargo/vendor/num_enum-0.7.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26\", \"files\": {}}",+ "dest": "cargo/vendor/num_enum-0.7.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/num_enum_derive/num_enum_derive-0.7.6.crate",+ "sha256": "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8",+ "dest": "cargo/vendor/num_enum_derive-0.7.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8\", \"files\": {}}",+ "dest": "cargo/vendor/num_enum_derive-0.7.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2/objc2-0.6.4.crate",+ "sha256": "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f",+ "dest": "cargo/vendor/objc2-0.6.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-0.6.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-app-kit/objc2-app-kit-0.3.2.crate",+ "sha256": "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c",+ "dest": "cargo/vendor/objc2-app-kit-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-app-kit-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-cloud-kit/objc2-cloud-kit-0.3.2.crate",+ "sha256": "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c",+ "dest": "cargo/vendor/objc2-cloud-kit-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-cloud-kit-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-core-data/objc2-core-data-0.3.2.crate",+ "sha256": "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa",+ "dest": "cargo/vendor/objc2-core-data-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-core-data-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-core-foundation/objc2-core-foundation-0.3.2.crate",+ "sha256": "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536",+ "dest": "cargo/vendor/objc2-core-foundation-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-core-foundation-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-core-graphics/objc2-core-graphics-0.3.2.crate",+ "sha256": "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807",+ "dest": "cargo/vendor/objc2-core-graphics-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-core-graphics-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-core-image/objc2-core-image-0.3.2.crate",+ "sha256": "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006",+ "dest": "cargo/vendor/objc2-core-image-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-core-image-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-core-location/objc2-core-location-0.3.2.crate",+ "sha256": "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009",+ "dest": "cargo/vendor/objc2-core-location-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-core-location-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-core-text/objc2-core-text-0.3.2.crate",+ "sha256": "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d",+ "dest": "cargo/vendor/objc2-core-text-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-core-text-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-encode/objc2-encode-4.1.0.crate",+ "sha256": "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33",+ "dest": "cargo/vendor/objc2-encode-4.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-encode-4.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-exception-helper/objc2-exception-helper-0.1.1.crate",+ "sha256": "c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a",+ "dest": "cargo/vendor/objc2-exception-helper-0.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-exception-helper-0.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-foundation/objc2-foundation-0.3.2.crate",+ "sha256": "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272",+ "dest": "cargo/vendor/objc2-foundation-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-foundation-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-io-surface/objc2-io-surface-0.3.2.crate",+ "sha256": "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d",+ "dest": "cargo/vendor/objc2-io-surface-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-io-surface-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-quartz-core/objc2-quartz-core-0.3.2.crate",+ "sha256": "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f",+ "dest": "cargo/vendor/objc2-quartz-core-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-quartz-core-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-ui-kit/objc2-ui-kit-0.3.2.crate",+ "sha256": "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22",+ "dest": "cargo/vendor/objc2-ui-kit-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-ui-kit-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-user-notifications/objc2-user-notifications-0.3.2.crate",+ "sha256": "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e",+ "dest": "cargo/vendor/objc2-user-notifications-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-user-notifications-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/objc2-web-kit/objc2-web-kit-0.3.2.crate",+ "sha256": "b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f",+ "dest": "cargo/vendor/objc2-web-kit-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f\", \"files\": {}}",+ "dest": "cargo/vendor/objc2-web-kit-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/once_cell/once_cell-1.21.4.crate",+ "sha256": "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50",+ "dest": "cargo/vendor/once_cell-1.21.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50\", \"files\": {}}",+ "dest": "cargo/vendor/once_cell-1.21.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/open/open-5.4.4.crate",+ "sha256": "aa576c76302b7b808eecc68061e67336c47833ef9d22caa74dda10fa9675eebc",+ "dest": "cargo/vendor/open-5.4.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"aa576c76302b7b808eecc68061e67336c47833ef9d22caa74dda10fa9675eebc\", \"files\": {}}",+ "dest": "cargo/vendor/open-5.4.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/option-ext/option-ext-0.2.0.crate",+ "sha256": "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d",+ "dest": "cargo/vendor/option-ext-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d\", \"files\": {}}",+ "dest": "cargo/vendor/option-ext-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/option-operations/option-operations-0.6.1.crate",+ "sha256": "aca39cf52b03268400c16eeb9b56382ea3c3353409309b63f5c8f0b1faf42754",+ "dest": "cargo/vendor/option-operations-0.6.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"aca39cf52b03268400c16eeb9b56382ea3c3353409309b63f5c8f0b1faf42754\", \"files\": {}}",+ "dest": "cargo/vendor/option-operations-0.6.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ordered-stream/ordered-stream-0.2.0.crate",+ "sha256": "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50",+ "dest": "cargo/vendor/ordered-stream-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50\", \"files\": {}}",+ "dest": "cargo/vendor/ordered-stream-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/page_size/page_size-0.6.0.crate",+ "sha256": "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da",+ "dest": "cargo/vendor/page_size-0.6.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da\", \"files\": {}}",+ "dest": "cargo/vendor/page_size-0.6.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/pango/pango-0.18.3.crate",+ "sha256": "7ca27ec1eb0457ab26f3036ea52229edbdb74dee1edd29063f5b9b010e7ebee4",+ "dest": "cargo/vendor/pango-0.18.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7ca27ec1eb0457ab26f3036ea52229edbdb74dee1edd29063f5b9b010e7ebee4\", \"files\": {}}",+ "dest": "cargo/vendor/pango-0.18.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/pango-sys/pango-sys-0.18.0.crate",+ "sha256": "436737e391a843e5933d6d9aa102cb126d501e815b83601365a948a518555dc5",+ "dest": "cargo/vendor/pango-sys-0.18.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"436737e391a843e5933d6d9aa102cb126d501e815b83601365a948a518555dc5\", \"files\": {}}",+ "dest": "cargo/vendor/pango-sys-0.18.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/parking/parking-2.2.1.crate",+ "sha256": "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba",+ "dest": "cargo/vendor/parking-2.2.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba\", \"files\": {}}",+ "dest": "cargo/vendor/parking-2.2.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/parking_lot/parking_lot-0.12.5.crate",+ "sha256": "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a",+ "dest": "cargo/vendor/parking_lot-0.12.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a\", \"files\": {}}",+ "dest": "cargo/vendor/parking_lot-0.12.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/parking_lot_core/parking_lot_core-0.9.12.crate",+ "sha256": "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1",+ "dest": "cargo/vendor/parking_lot_core-0.9.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1\", \"files\": {}}",+ "dest": "cargo/vendor/parking_lot_core-0.9.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/pastey/pastey-0.2.3.crate",+ "sha256": "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4",+ "dest": "cargo/vendor/pastey-0.2.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4\", \"files\": {}}",+ "dest": "cargo/vendor/pastey-0.2.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/pbkdf2/pbkdf2-0.12.2.crate",+ "sha256": "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2",+ "dest": "cargo/vendor/pbkdf2-0.12.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2\", \"files\": {}}",+ "dest": "cargo/vendor/pbkdf2-0.12.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/percent-encoding/percent-encoding-2.3.2.crate",+ "sha256": "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220",+ "dest": "cargo/vendor/percent-encoding-2.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220\", \"files\": {}}",+ "dest": "cargo/vendor/percent-encoding-2.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/phf/phf-0.13.1.crate",+ "sha256": "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf",+ "dest": "cargo/vendor/phf-0.13.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf\", \"files\": {}}",+ "dest": "cargo/vendor/phf-0.13.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/phf_codegen/phf_codegen-0.13.1.crate",+ "sha256": "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1",+ "dest": "cargo/vendor/phf_codegen-0.13.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1\", \"files\": {}}",+ "dest": "cargo/vendor/phf_codegen-0.13.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/phf_generator/phf_generator-0.13.1.crate",+ "sha256": "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737",+ "dest": "cargo/vendor/phf_generator-0.13.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737\", \"files\": {}}",+ "dest": "cargo/vendor/phf_generator-0.13.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/phf_macros/phf_macros-0.13.1.crate",+ "sha256": "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef",+ "dest": "cargo/vendor/phf_macros-0.13.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef\", \"files\": {}}",+ "dest": "cargo/vendor/phf_macros-0.13.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/phf_shared/phf_shared-0.13.1.crate",+ "sha256": "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266",+ "dest": "cargo/vendor/phf_shared-0.13.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266\", \"files\": {}}",+ "dest": "cargo/vendor/phf_shared-0.13.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/pin-project-lite/pin-project-lite-0.2.17.crate",+ "sha256": "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd",+ "dest": "cargo/vendor/pin-project-lite-0.2.17"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd\", \"files\": {}}",+ "dest": "cargo/vendor/pin-project-lite-0.2.17",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/piper/piper-0.2.5.crate",+ "sha256": "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1",+ "dest": "cargo/vendor/piper-0.2.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1\", \"files\": {}}",+ "dest": "cargo/vendor/piper-0.2.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/pkg-config/pkg-config-0.3.34.crate",+ "sha256": "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548",+ "dest": "cargo/vendor/pkg-config-0.3.34"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548\", \"files\": {}}",+ "dest": "cargo/vendor/pkg-config-0.3.34",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/plist/plist-1.10.1.crate",+ "sha256": "2896bade328c13f7042a297ea5ac5b0951f6cf989dea5f32c2fd98da398195cb",+ "dest": "cargo/vendor/plist-1.10.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2896bade328c13f7042a297ea5ac5b0951f6cf989dea5f32c2fd98da398195cb\", \"files\": {}}",+ "dest": "cargo/vendor/plist-1.10.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/png/png-0.17.16.crate",+ "sha256": "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526",+ "dest": "cargo/vendor/png-0.17.16"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526\", \"files\": {}}",+ "dest": "cargo/vendor/png-0.17.16",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/png/png-0.18.1.crate",+ "sha256": "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61",+ "dest": "cargo/vendor/png-0.18.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61\", \"files\": {}}",+ "dest": "cargo/vendor/png-0.18.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/polling/polling-3.11.0.crate",+ "sha256": "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218",+ "dest": "cargo/vendor/polling-3.11.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218\", \"files\": {}}",+ "dest": "cargo/vendor/polling-3.11.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/portable-atomic/portable-atomic-1.15.0.crate",+ "sha256": "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85",+ "dest": "cargo/vendor/portable-atomic-1.15.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85\", \"files\": {}}",+ "dest": "cargo/vendor/portable-atomic-1.15.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/portable-atomic-util/portable-atomic-util-0.2.8.crate",+ "sha256": "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715",+ "dest": "cargo/vendor/portable-atomic-util-0.2.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715\", \"files\": {}}",+ "dest": "cargo/vendor/portable-atomic-util-0.2.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/potential_utf/potential_utf-0.1.6.crate",+ "sha256": "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661",+ "dest": "cargo/vendor/potential_utf-0.1.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661\", \"files\": {}}",+ "dest": "cargo/vendor/potential_utf-0.1.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/powerfmt/powerfmt-0.2.0.crate",+ "sha256": "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391",+ "dest": "cargo/vendor/powerfmt-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391\", \"files\": {}}",+ "dest": "cargo/vendor/powerfmt-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ppv-lite86/ppv-lite86-0.2.21.crate",+ "sha256": "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9",+ "dest": "cargo/vendor/ppv-lite86-0.2.21"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9\", \"files\": {}}",+ "dest": "cargo/vendor/ppv-lite86-0.2.21",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/precomputed-hash/precomputed-hash-0.1.1.crate",+ "sha256": "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c",+ "dest": "cargo/vendor/precomputed-hash-0.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c\", \"files\": {}}",+ "dest": "cargo/vendor/precomputed-hash-0.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/proc-macro-crate/proc-macro-crate-1.3.1.crate",+ "sha256": "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919",+ "dest": "cargo/vendor/proc-macro-crate-1.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919\", \"files\": {}}",+ "dest": "cargo/vendor/proc-macro-crate-1.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/proc-macro-crate/proc-macro-crate-2.0.2.crate",+ "sha256": "b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24",+ "dest": "cargo/vendor/proc-macro-crate-2.0.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24\", \"files\": {}}",+ "dest": "cargo/vendor/proc-macro-crate-2.0.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/proc-macro-crate/proc-macro-crate-3.5.0.crate",+ "sha256": "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f",+ "dest": "cargo/vendor/proc-macro-crate-3.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f\", \"files\": {}}",+ "dest": "cargo/vendor/proc-macro-crate-3.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/proc-macro-error/proc-macro-error-1.0.4.crate",+ "sha256": "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c",+ "dest": "cargo/vendor/proc-macro-error-1.0.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c\", \"files\": {}}",+ "dest": "cargo/vendor/proc-macro-error-1.0.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/proc-macro-error-attr/proc-macro-error-attr-1.0.4.crate",+ "sha256": "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869",+ "dest": "cargo/vendor/proc-macro-error-attr-1.0.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869\", \"files\": {}}",+ "dest": "cargo/vendor/proc-macro-error-attr-1.0.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/proc-macro2/proc-macro2-1.0.107.crate",+ "sha256": "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9",+ "dest": "cargo/vendor/proc-macro2-1.0.107"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9\", \"files\": {}}",+ "dest": "cargo/vendor/proc-macro2-1.0.107",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/psl-types/psl-types-2.0.11.crate",+ "sha256": "33cb294fe86a74cbcf50d4445b37da762029549ebeea341421c7c70370f86cac",+ "dest": "cargo/vendor/psl-types-2.0.11"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"33cb294fe86a74cbcf50d4445b37da762029549ebeea341421c7c70370f86cac\", \"files\": {}}",+ "dest": "cargo/vendor/psl-types-2.0.11",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/publicsuffix/publicsuffix-2.3.0.crate",+ "sha256": "6f42ea446cab60335f76979ec15e12619a2165b5ae2c12166bef27d283a9fadf",+ "dest": "cargo/vendor/publicsuffix-2.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6f42ea446cab60335f76979ec15e12619a2165b5ae2c12166bef27d283a9fadf\", \"files\": {}}",+ "dest": "cargo/vendor/publicsuffix-2.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/pxfm/pxfm-0.1.30.crate",+ "sha256": "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea",+ "dest": "cargo/vendor/pxfm-0.1.30"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea\", \"files\": {}}",+ "dest": "cargo/vendor/pxfm-0.1.30",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/quick-xml/quick-xml-0.42.0.crate",+ "sha256": "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b",+ "dest": "cargo/vendor/quick-xml-0.42.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b\", \"files\": {}}",+ "dest": "cargo/vendor/quick-xml-0.42.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/quinn/quinn-0.11.11.crate",+ "sha256": "0c1a41e437b6bbd489372cd4971de128e85c855f56c57f283d20ff016cf7c0a8",+ "dest": "cargo/vendor/quinn-0.11.11"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0c1a41e437b6bbd489372cd4971de128e85c855f56c57f283d20ff016cf7c0a8\", \"files\": {}}",+ "dest": "cargo/vendor/quinn-0.11.11",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/quinn-proto/quinn-proto-0.11.17.crate",+ "sha256": "04759210543be93709136e28212294a659ef5001836ff4eab4d663e4529bba83",+ "dest": "cargo/vendor/quinn-proto-0.11.17"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"04759210543be93709136e28212294a659ef5001836ff4eab4d663e4529bba83\", \"files\": {}}",+ "dest": "cargo/vendor/quinn-proto-0.11.17",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/quinn-udp/quinn-udp-0.5.15.crate",+ "sha256": "35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694",+ "dest": "cargo/vendor/quinn-udp-0.5.15"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694\", \"files\": {}}",+ "dest": "cargo/vendor/quinn-udp-0.5.15",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/quote/quote-1.0.47.crate",+ "sha256": "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001",+ "dest": "cargo/vendor/quote-1.0.47"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001\", \"files\": {}}",+ "dest": "cargo/vendor/quote-1.0.47",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/r-efi/r-efi-5.3.0.crate",+ "sha256": "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f",+ "dest": "cargo/vendor/r-efi-5.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f\", \"files\": {}}",+ "dest": "cargo/vendor/r-efi-5.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/r-efi/r-efi-6.0.0.crate",+ "sha256": "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf",+ "dest": "cargo/vendor/r-efi-6.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf\", \"files\": {}}",+ "dest": "cargo/vendor/r-efi-6.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand/rand-0.8.8.crate",+ "sha256": "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c",+ "dest": "cargo/vendor/rand-0.8.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c\", \"files\": {}}",+ "dest": "cargo/vendor/rand-0.8.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand/rand-0.9.5.crate",+ "sha256": "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41",+ "dest": "cargo/vendor/rand-0.9.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41\", \"files\": {}}",+ "dest": "cargo/vendor/rand-0.9.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand/rand-0.10.2.crate",+ "sha256": "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80",+ "dest": "cargo/vendor/rand-0.10.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80\", \"files\": {}}",+ "dest": "cargo/vendor/rand-0.10.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand_chacha/rand_chacha-0.3.1.crate",+ "sha256": "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88",+ "dest": "cargo/vendor/rand_chacha-0.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88\", \"files\": {}}",+ "dest": "cargo/vendor/rand_chacha-0.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand_chacha/rand_chacha-0.9.0.crate",+ "sha256": "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb",+ "dest": "cargo/vendor/rand_chacha-0.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb\", \"files\": {}}",+ "dest": "cargo/vendor/rand_chacha-0.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand_core/rand_core-0.6.4.crate",+ "sha256": "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c",+ "dest": "cargo/vendor/rand_core-0.6.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c\", \"files\": {}}",+ "dest": "cargo/vendor/rand_core-0.6.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand_core/rand_core-0.9.5.crate",+ "sha256": "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c",+ "dest": "cargo/vendor/rand_core-0.9.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c\", \"files\": {}}",+ "dest": "cargo/vendor/rand_core-0.9.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand_core/rand_core-0.10.1.crate",+ "sha256": "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69",+ "dest": "cargo/vendor/rand_core-0.10.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69\", \"files\": {}}",+ "dest": "cargo/vendor/rand_core-0.10.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rand_pcg/rand_pcg-0.10.2.crate",+ "sha256": "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a",+ "dest": "cargo/vendor/rand_pcg-0.10.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a\", \"files\": {}}",+ "dest": "cargo/vendor/rand_pcg-0.10.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/raw-window-handle/raw-window-handle-0.6.2.crate",+ "sha256": "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539",+ "dest": "cargo/vendor/raw-window-handle-0.6.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539\", \"files\": {}}",+ "dest": "cargo/vendor/raw-window-handle-0.6.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/redox_syscall/redox_syscall-0.5.18.crate",+ "sha256": "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d",+ "dest": "cargo/vendor/redox_syscall-0.5.18"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d\", \"files\": {}}",+ "dest": "cargo/vendor/redox_syscall-0.5.18",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/redox_users/redox_users-0.5.2.crate",+ "sha256": "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac",+ "dest": "cargo/vendor/redox_users-0.5.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac\", \"files\": {}}",+ "dest": "cargo/vendor/redox_users-0.5.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ref-cast/ref-cast-1.0.27.crate",+ "sha256": "7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3",+ "dest": "cargo/vendor/ref-cast-1.0.27"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3\", \"files\": {}}",+ "dest": "cargo/vendor/ref-cast-1.0.27",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ref-cast-impl/ref-cast-impl-1.0.27.crate",+ "sha256": "92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a",+ "dest": "cargo/vendor/ref-cast-impl-1.0.27"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a\", \"files\": {}}",+ "dest": "cargo/vendor/ref-cast-impl-1.0.27",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/regex/regex-1.13.1.crate",+ "sha256": "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d",+ "dest": "cargo/vendor/regex-1.13.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d\", \"files\": {}}",+ "dest": "cargo/vendor/regex-1.13.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/regex-automata/regex-automata-0.4.18.crate",+ "sha256": "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2",+ "dest": "cargo/vendor/regex-automata-0.4.18"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2\", \"files\": {}}",+ "dest": "cargo/vendor/regex-automata-0.4.18",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/regex-syntax/regex-syntax-0.8.11.crate",+ "sha256": "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4",+ "dest": "cargo/vendor/regex-syntax-0.8.11"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4\", \"files\": {}}",+ "dest": "cargo/vendor/regex-syntax-0.8.11",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/reqwest/reqwest-0.12.28.crate",+ "sha256": "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147",+ "dest": "cargo/vendor/reqwest-0.12.28"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147\", \"files\": {}}",+ "dest": "cargo/vendor/reqwest-0.12.28",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/reqwest/reqwest-0.13.5.crate",+ "sha256": "16a1cfa75cc186dd73d5818e510e042e40927bccc9c236b061cea97e1eb08029",+ "dest": "cargo/vendor/reqwest-0.13.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"16a1cfa75cc186dd73d5818e510e042e40927bccc9c236b061cea97e1eb08029\", \"files\": {}}",+ "dest": "cargo/vendor/reqwest-0.13.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/reqwest_cookie_store/reqwest_cookie_store-0.8.2.crate",+ "sha256": "2314c325724fea278d44c13a525ebf60074e33c05f13b4345c076eb65b2446b3",+ "dest": "cargo/vendor/reqwest_cookie_store-0.8.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2314c325724fea278d44c13a525ebf60074e33c05f13b4345c076eb65b2446b3\", \"files\": {}}",+ "dest": "cargo/vendor/reqwest_cookie_store-0.8.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rfd/rfd-0.16.0.crate",+ "sha256": "a15ad77d9e70a92437d8f74c35d99b4e4691128df018833e99f90bcd36152672",+ "dest": "cargo/vendor/rfd-0.16.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a15ad77d9e70a92437d8f74c35d99b4e4691128df018833e99f90bcd36152672\", \"files\": {}}",+ "dest": "cargo/vendor/rfd-0.16.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ring/ring-0.17.14.crate",+ "sha256": "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7",+ "dest": "cargo/vendor/ring-0.17.14"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7\", \"files\": {}}",+ "dest": "cargo/vendor/ring-0.17.14",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rpassword/rpassword-7.5.4.crate",+ "sha256": "2da316a15f47e3d053de9cb2c439650bd8fa4aaeb9365f2e5f27f492ff73c196",+ "dest": "cargo/vendor/rpassword-7.5.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2da316a15f47e3d053de9cb2c439650bd8fa4aaeb9365f2e5f27f492ff73c196\", \"files\": {}}",+ "dest": "cargo/vendor/rpassword-7.5.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rtoolbox/rtoolbox-0.0.6.crate",+ "sha256": "9a1efe12a1469752d0e6ff5ebec0b6ef4924cc5c4c71046b0ec730040535819d",+ "dest": "cargo/vendor/rtoolbox-0.0.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9a1efe12a1469752d0e6ff5ebec0b6ef4924cc5c4c71046b0ec730040535819d\", \"files\": {}}",+ "dest": "cargo/vendor/rtoolbox-0.0.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rusqlite/rusqlite-0.32.1.crate",+ "sha256": "7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e",+ "dest": "cargo/vendor/rusqlite-0.32.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e\", \"files\": {}}",+ "dest": "cargo/vendor/rusqlite-0.32.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rustc-hash/rustc-hash-2.1.3.crate",+ "sha256": "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d",+ "dest": "cargo/vendor/rustc-hash-2.1.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d\", \"files\": {}}",+ "dest": "cargo/vendor/rustc-hash-2.1.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rustc_version/rustc_version-0.4.1.crate",+ "sha256": "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92",+ "dest": "cargo/vendor/rustc_version-0.4.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92\", \"files\": {}}",+ "dest": "cargo/vendor/rustc_version-0.4.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rustix/rustix-1.1.4.crate",+ "sha256": "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190",+ "dest": "cargo/vendor/rustix-1.1.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190\", \"files\": {}}",+ "dest": "cargo/vendor/rustix-1.1.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rustls/rustls-0.23.44.crate",+ "sha256": "6725596c3f2c3a0aef021139e145d4eafe314a6623e4680ca83852b2c67ab2ba",+ "dest": "cargo/vendor/rustls-0.23.44"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6725596c3f2c3a0aef021139e145d4eafe314a6623e4680ca83852b2c67ab2ba\", \"files\": {}}",+ "dest": "cargo/vendor/rustls-0.23.44",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rustls-pki-types/rustls-pki-types-1.15.1.crate",+ "sha256": "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96",+ "dest": "cargo/vendor/rustls-pki-types-1.15.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96\", \"files\": {}}",+ "dest": "cargo/vendor/rustls-pki-types-1.15.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rustls-webpki/rustls-webpki-0.103.15.crate",+ "sha256": "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2",+ "dest": "cargo/vendor/rustls-webpki-0.103.15"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2\", \"files\": {}}",+ "dest": "cargo/vendor/rustls-webpki-0.103.15",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/rustversion/rustversion-1.0.23.crate",+ "sha256": "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f",+ "dest": "cargo/vendor/rustversion-1.0.23"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f\", \"files\": {}}",+ "dest": "cargo/vendor/rustversion-1.0.23",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/ryu/ryu-1.0.23.crate",+ "sha256": "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f",+ "dest": "cargo/vendor/ryu-1.0.23"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f\", \"files\": {}}",+ "dest": "cargo/vendor/ryu-1.0.23",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/same-file/same-file-1.0.6.crate",+ "sha256": "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502",+ "dest": "cargo/vendor/same-file-1.0.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502\", \"files\": {}}",+ "dest": "cargo/vendor/same-file-1.0.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/schemars/schemars-0.8.22.crate",+ "sha256": "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615",+ "dest": "cargo/vendor/schemars-0.8.22"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615\", \"files\": {}}",+ "dest": "cargo/vendor/schemars-0.8.22",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/schemars/schemars-0.9.0.crate",+ "sha256": "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f",+ "dest": "cargo/vendor/schemars-0.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f\", \"files\": {}}",+ "dest": "cargo/vendor/schemars-0.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/schemars/schemars-1.2.2.crate",+ "sha256": "687274d293b6cdc6e73e0fee520bf2049650090d7164f87672d212a3c530cf4a",+ "dest": "cargo/vendor/schemars-1.2.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"687274d293b6cdc6e73e0fee520bf2049650090d7164f87672d212a3c530cf4a\", \"files\": {}}",+ "dest": "cargo/vendor/schemars-1.2.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/schemars_derive/schemars_derive-0.8.22.crate",+ "sha256": "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d",+ "dest": "cargo/vendor/schemars_derive-0.8.22"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d\", \"files\": {}}",+ "dest": "cargo/vendor/schemars_derive-0.8.22",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/scopeguard/scopeguard-1.2.0.crate",+ "sha256": "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49",+ "dest": "cargo/vendor/scopeguard-1.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49\", \"files\": {}}",+ "dest": "cargo/vendor/scopeguard-1.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/secret-service/secret-service-4.0.0.crate",+ "sha256": "e4d35ad99a181be0a60ffcbe85d680d98f87bdc4d7644ade319b87076b9dbfd4",+ "dest": "cargo/vendor/secret-service-4.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e4d35ad99a181be0a60ffcbe85d680d98f87bdc4d7644ade319b87076b9dbfd4\", \"files\": {}}",+ "dest": "cargo/vendor/secret-service-4.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/security-framework/security-framework-2.11.1.crate",+ "sha256": "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02",+ "dest": "cargo/vendor/security-framework-2.11.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02\", \"files\": {}}",+ "dest": "cargo/vendor/security-framework-2.11.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/security-framework/security-framework-3.7.0.crate",+ "sha256": "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d",+ "dest": "cargo/vendor/security-framework-3.7.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d\", \"files\": {}}",+ "dest": "cargo/vendor/security-framework-3.7.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/security-framework-sys/security-framework-sys-2.17.0.crate",+ "sha256": "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3",+ "dest": "cargo/vendor/security-framework-sys-2.17.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3\", \"files\": {}}",+ "dest": "cargo/vendor/security-framework-sys-2.17.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/selectors/selectors-0.38.0.crate",+ "sha256": "8adfa1c298912827b8a28b223b3b874357397ae706e6190acd9bf28cee99114d",+ "dest": "cargo/vendor/selectors-0.38.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8adfa1c298912827b8a28b223b3b874357397ae706e6190acd9bf28cee99114d\", \"files\": {}}",+ "dest": "cargo/vendor/selectors-0.38.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/semver/semver-1.0.28.crate",+ "sha256": "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd",+ "dest": "cargo/vendor/semver-1.0.28"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd\", \"files\": {}}",+ "dest": "cargo/vendor/semver-1.0.28",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde/serde-1.0.229.crate",+ "sha256": "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba",+ "dest": "cargo/vendor/serde-1.0.229"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba\", \"files\": {}}",+ "dest": "cargo/vendor/serde-1.0.229",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde-untagged/serde-untagged-0.1.9.crate",+ "sha256": "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058",+ "dest": "cargo/vendor/serde-untagged-0.1.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058\", \"files\": {}}",+ "dest": "cargo/vendor/serde-untagged-0.1.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_core/serde_core-1.0.229.crate",+ "sha256": "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48",+ "dest": "cargo/vendor/serde_core-1.0.229"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48\", \"files\": {}}",+ "dest": "cargo/vendor/serde_core-1.0.229",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_derive/serde_derive-1.0.229.crate",+ "sha256": "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348",+ "dest": "cargo/vendor/serde_derive-1.0.229"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348\", \"files\": {}}",+ "dest": "cargo/vendor/serde_derive-1.0.229",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_derive_internals/serde_derive_internals-0.29.1.crate",+ "sha256": "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711",+ "dest": "cargo/vendor/serde_derive_internals-0.29.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711\", \"files\": {}}",+ "dest": "cargo/vendor/serde_derive_internals-0.29.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_json/serde_json-1.0.151.crate",+ "sha256": "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14",+ "dest": "cargo/vendor/serde_json-1.0.151"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14\", \"files\": {}}",+ "dest": "cargo/vendor/serde_json-1.0.151",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_repr/serde_repr-0.1.21.crate",+ "sha256": "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906",+ "dest": "cargo/vendor/serde_repr-0.1.21"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906\", \"files\": {}}",+ "dest": "cargo/vendor/serde_repr-0.1.21",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_spanned/serde_spanned-0.6.9.crate",+ "sha256": "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3",+ "dest": "cargo/vendor/serde_spanned-0.6.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3\", \"files\": {}}",+ "dest": "cargo/vendor/serde_spanned-0.6.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_spanned/serde_spanned-1.1.1.crate",+ "sha256": "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26",+ "dest": "cargo/vendor/serde_spanned-1.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26\", \"files\": {}}",+ "dest": "cargo/vendor/serde_spanned-1.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_urlencoded/serde_urlencoded-0.7.1.crate",+ "sha256": "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd",+ "dest": "cargo/vendor/serde_urlencoded-0.7.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd\", \"files\": {}}",+ "dest": "cargo/vendor/serde_urlencoded-0.7.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_with/serde_with-3.23.0.crate",+ "sha256": "935177bb8c0cd8ca1a4e6d1a2ac8988bea69cab4f9d3a31311e012ad27868ea4",+ "dest": "cargo/vendor/serde_with-3.23.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"935177bb8c0cd8ca1a4e6d1a2ac8988bea69cab4f9d3a31311e012ad27868ea4\", \"files\": {}}",+ "dest": "cargo/vendor/serde_with-3.23.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serde_with_macros/serde_with_macros-3.23.0.crate",+ "sha256": "1d607aa01a3cb0ad757d6fd216136910db3c97b102fe686585689615a02dbcdc",+ "dest": "cargo/vendor/serde_with_macros-3.23.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1d607aa01a3cb0ad757d6fd216136910db3c97b102fe686585689615a02dbcdc\", \"files\": {}}",+ "dest": "cargo/vendor/serde_with_macros-3.23.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serialize-to-javascript/serialize-to-javascript-0.1.2.crate",+ "sha256": "04f3666a07a197cdb77cdf306c32be9b7f598d7060d50cfd4d5aa04bfd92f6c5",+ "dest": "cargo/vendor/serialize-to-javascript-0.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"04f3666a07a197cdb77cdf306c32be9b7f598d7060d50cfd4d5aa04bfd92f6c5\", \"files\": {}}",+ "dest": "cargo/vendor/serialize-to-javascript-0.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/serialize-to-javascript-impl/serialize-to-javascript-impl-0.1.2.crate",+ "sha256": "772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d",+ "dest": "cargo/vendor/serialize-to-javascript-impl-0.1.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d\", \"files\": {}}",+ "dest": "cargo/vendor/serialize-to-javascript-impl-0.1.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/servo_arc/servo_arc-0.4.3.crate",+ "sha256": "170fb83ab34de17dc69aa7c67482b22218ddb85da56546f9bd6b929e32a05930",+ "dest": "cargo/vendor/servo_arc-0.4.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"170fb83ab34de17dc69aa7c67482b22218ddb85da56546f9bd6b929e32a05930\", \"files\": {}}",+ "dest": "cargo/vendor/servo_arc-0.4.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/sha1/sha1-0.10.6.crate",+ "sha256": "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba",+ "dest": "cargo/vendor/sha1-0.10.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba\", \"files\": {}}",+ "dest": "cargo/vendor/sha1-0.10.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/sha2/sha2-0.10.9.crate",+ "sha256": "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283",+ "dest": "cargo/vendor/sha2-0.10.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283\", \"files\": {}}",+ "dest": "cargo/vendor/sha2-0.10.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/shlex/shlex-2.0.1.crate",+ "sha256": "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba",+ "dest": "cargo/vendor/shlex-2.0.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba\", \"files\": {}}",+ "dest": "cargo/vendor/shlex-2.0.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/signal-hook-registry/signal-hook-registry-1.4.8.crate",+ "sha256": "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b",+ "dest": "cargo/vendor/signal-hook-registry-1.4.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b\", \"files\": {}}",+ "dest": "cargo/vendor/signal-hook-registry-1.4.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/simd-adler32/simd-adler32-0.3.10.crate",+ "sha256": "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea",+ "dest": "cargo/vendor/simd-adler32-0.3.10"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea\", \"files\": {}}",+ "dest": "cargo/vendor/simd-adler32-0.3.10",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/siphasher/siphasher-1.0.3.crate",+ "sha256": "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649",+ "dest": "cargo/vendor/siphasher-1.0.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649\", \"files\": {}}",+ "dest": "cargo/vendor/siphasher-1.0.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/slab/slab-0.4.12.crate",+ "sha256": "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5",+ "dest": "cargo/vendor/slab-0.4.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5\", \"files\": {}}",+ "dest": "cargo/vendor/slab-0.4.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/smallvec/smallvec-1.16.1.crate",+ "sha256": "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891",+ "dest": "cargo/vendor/smallvec-1.16.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891\", \"files\": {}}",+ "dest": "cargo/vendor/smallvec-1.16.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/socket2/socket2-0.6.5.crate",+ "sha256": "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4",+ "dest": "cargo/vendor/socket2-0.6.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4\", \"files\": {}}",+ "dest": "cargo/vendor/socket2-0.6.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/softbuffer/softbuffer-0.4.8.crate",+ "sha256": "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3",+ "dest": "cargo/vendor/softbuffer-0.4.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3\", \"files\": {}}",+ "dest": "cargo/vendor/softbuffer-0.4.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/soup3/soup3-0.5.0.crate",+ "sha256": "471f924a40f31251afc77450e781cb26d55c0b650842efafc9c6cbd2f7cc4f9f",+ "dest": "cargo/vendor/soup3-0.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"471f924a40f31251afc77450e781cb26d55c0b650842efafc9c6cbd2f7cc4f9f\", \"files\": {}}",+ "dest": "cargo/vendor/soup3-0.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/soup3-sys/soup3-sys-0.5.0.crate",+ "sha256": "7ebe8950a680a12f24f15ebe1bf70db7af98ad242d9db43596ad3108aab86c27",+ "dest": "cargo/vendor/soup3-sys-0.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7ebe8950a680a12f24f15ebe1bf70db7af98ad242d9db43596ad3108aab86c27\", \"files\": {}}",+ "dest": "cargo/vendor/soup3-sys-0.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/stable_deref_trait/stable_deref_trait-1.2.1.crate",+ "sha256": "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596",+ "dest": "cargo/vendor/stable_deref_trait-1.2.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596\", \"files\": {}}",+ "dest": "cargo/vendor/stable_deref_trait-1.2.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/static_assertions/static_assertions-1.1.0.crate",+ "sha256": "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f",+ "dest": "cargo/vendor/static_assertions-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f\", \"files\": {}}",+ "dest": "cargo/vendor/static_assertions-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/static_vcruntime/static_vcruntime-3.0.0.crate",+ "sha256": "ff7589a1859b09232522bb9edf076ca7fcf14ded96685d3fa629db73023ffbb7",+ "dest": "cargo/vendor/static_vcruntime-3.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ff7589a1859b09232522bb9edf076ca7fcf14ded96685d3fa629db73023ffbb7\", \"files\": {}}",+ "dest": "cargo/vendor/static_vcruntime-3.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/string_cache/string_cache-0.9.0.crate",+ "sha256": "a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901",+ "dest": "cargo/vendor/string_cache-0.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901\", \"files\": {}}",+ "dest": "cargo/vendor/string_cache-0.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/string_cache_codegen/string_cache_codegen-0.6.1.crate",+ "sha256": "585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69",+ "dest": "cargo/vendor/string_cache_codegen-0.6.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69\", \"files\": {}}",+ "dest": "cargo/vendor/string_cache_codegen-0.6.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/strsim/strsim-0.11.1.crate",+ "sha256": "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f",+ "dest": "cargo/vendor/strsim-0.11.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f\", \"files\": {}}",+ "dest": "cargo/vendor/strsim-0.11.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/subtle/subtle-2.6.1.crate",+ "sha256": "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292",+ "dest": "cargo/vendor/subtle-2.6.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292\", \"files\": {}}",+ "dest": "cargo/vendor/subtle-2.6.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/swift-rs/swift-rs-1.0.9.crate",+ "sha256": "cefd87076fd385308ee4aff597256c902f1fbb4d031de1558efc12f8ffefadd9",+ "dest": "cargo/vendor/swift-rs-1.0.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cefd87076fd385308ee4aff597256c902f1fbb4d031de1558efc12f8ffefadd9\", \"files\": {}}",+ "dest": "cargo/vendor/swift-rs-1.0.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/syn/syn-1.0.109.crate",+ "sha256": "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237",+ "dest": "cargo/vendor/syn-1.0.109"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237\", \"files\": {}}",+ "dest": "cargo/vendor/syn-1.0.109",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/syn/syn-2.0.119.crate",+ "sha256": "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297",+ "dest": "cargo/vendor/syn-2.0.119"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297\", \"files\": {}}",+ "dest": "cargo/vendor/syn-2.0.119",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/syn/syn-3.0.5.crate",+ "sha256": "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9",+ "dest": "cargo/vendor/syn-3.0.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9\", \"files\": {}}",+ "dest": "cargo/vendor/syn-3.0.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/sync_wrapper/sync_wrapper-1.0.2.crate",+ "sha256": "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263",+ "dest": "cargo/vendor/sync_wrapper-1.0.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263\", \"files\": {}}",+ "dest": "cargo/vendor/sync_wrapper-1.0.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/synstructure/synstructure-0.13.2.crate",+ "sha256": "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2",+ "dest": "cargo/vendor/synstructure-0.13.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2\", \"files\": {}}",+ "dest": "cargo/vendor/synstructure-0.13.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/system-deps/system-deps-6.2.2.crate",+ "sha256": "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349",+ "dest": "cargo/vendor/system-deps-6.2.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349\", \"files\": {}}",+ "dest": "cargo/vendor/system-deps-6.2.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/system-deps/system-deps-8.0.0.crate",+ "sha256": "83779a5c956bcb6ba627a4ecf0a9d7625db47d7537e0892d97f712ac995648a3",+ "dest": "cargo/vendor/system-deps-8.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"83779a5c956bcb6ba627a4ecf0a9d7625db47d7537e0892d97f712ac995648a3\", \"files\": {}}",+ "dest": "cargo/vendor/system-deps-8.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/system-deps/system-deps-9.0.0.crate",+ "sha256": "8a0dae2cbca1f0ff93795713cfe0a4c02f760e3c0b8ae2ab4ec4045808ff429f",+ "dest": "cargo/vendor/system-deps-9.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8a0dae2cbca1f0ff93795713cfe0a4c02f760e3c0b8ae2ab4ec4045808ff429f\", \"files\": {}}",+ "dest": "cargo/vendor/system-deps-9.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tao/tao-0.37.1.crate",+ "sha256": "f37f381f4e048e6cdf038b5705f8cf14ad108279d46eb968140a7b291aba9400",+ "dest": "cargo/vendor/tao-0.37.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f37f381f4e048e6cdf038b5705f8cf14ad108279d46eb968140a7b291aba9400\", \"files\": {}}",+ "dest": "cargo/vendor/tao-0.37.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tao-macros/tao-macros-0.1.4.crate",+ "sha256": "5f7eeb6d99155545da6150a1795945f16ac9c178deb2a5f2e74d776107bd5849",+ "dest": "cargo/vendor/tao-macros-0.1.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5f7eeb6d99155545da6150a1795945f16ac9c178deb2a5f2e74d776107bd5849\", \"files\": {}}",+ "dest": "cargo/vendor/tao-macros-0.1.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/target-lexicon/target-lexicon-0.12.16.crate",+ "sha256": "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1",+ "dest": "cargo/vendor/target-lexicon-0.12.16"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1\", \"files\": {}}",+ "dest": "cargo/vendor/target-lexicon-0.12.16",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/target-lexicon/target-lexicon-0.13.5.crate",+ "sha256": "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca",+ "dest": "cargo/vendor/target-lexicon-0.13.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca\", \"files\": {}}",+ "dest": "cargo/vendor/target-lexicon-0.13.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri/tauri-2.12.5.crate",+ "sha256": "5fb0244332cfb9cee7e2a568bf5da29a36ed8fdbd717f6f47a66b6b7b358c072",+ "dest": "cargo/vendor/tauri-2.12.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5fb0244332cfb9cee7e2a568bf5da29a36ed8fdbd717f6f47a66b6b7b358c072\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-2.12.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-build/tauri-build-2.7.4.crate",+ "sha256": "adddb0e648752aaac5da9c3c3c6a68e1e87cab55e3b757b18a9441ef8c3ac614",+ "dest": "cargo/vendor/tauri-build-2.7.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"adddb0e648752aaac5da9c3c3c6a68e1e87cab55e3b757b18a9441ef8c3ac614\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-build-2.7.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-codegen/tauri-codegen-2.7.4.crate",+ "sha256": "fb37631cf71dab5e8ab55e1bdd701e18a52653d90b78e71d0e5598b1e0a61316",+ "dest": "cargo/vendor/tauri-codegen-2.7.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fb37631cf71dab5e8ab55e1bdd701e18a52653d90b78e71d0e5598b1e0a61316\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-codegen-2.7.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-macros/tauri-macros-2.7.4.crate",+ "sha256": "0cc38db58854c10fb5f91a887ed8bf82d3239bb92b5d8db86eda09e96d9963d1",+ "dest": "cargo/vendor/tauri-macros-2.7.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0cc38db58854c10fb5f91a887ed8bf82d3239bb92b5d8db86eda09e96d9963d1\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-macros-2.7.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-plugin/tauri-plugin-2.7.2.crate",+ "sha256": "67fb21a77e8f94e8beb3325e583102488659365af0a3948b7ea244c5b779c291",+ "dest": "cargo/vendor/tauri-plugin-2.7.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"67fb21a77e8f94e8beb3325e583102488659365af0a3948b7ea244c5b779c291\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-plugin-2.7.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-plugin-dialog/tauri-plugin-dialog-2.7.3.crate",+ "sha256": "61854a36651aa48381e5e209f69a01273b77f3f9f91f0c430b1b98d33bd47229",+ "dest": "cargo/vendor/tauri-plugin-dialog-2.7.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"61854a36651aa48381e5e209f69a01273b77f3f9f91f0c430b1b98d33bd47229\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-plugin-dialog-2.7.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-plugin-fs/tauri-plugin-fs-2.5.2.crate",+ "sha256": "de22eef34fd78c0da050e748710edd50bf127e651d02ea1b2bfada1523cc5c51",+ "dest": "cargo/vendor/tauri-plugin-fs-2.5.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"de22eef34fd78c0da050e748710edd50bf127e651d02ea1b2bfada1523cc5c51\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-plugin-fs-2.5.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-plugin-opener/tauri-plugin-opener-2.5.5.crate",+ "sha256": "60d60366174b745b4ef5824b8bbc1c457fd08f0ce101ff643c0a49181a9f4e91",+ "dest": "cargo/vendor/tauri-plugin-opener-2.5.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"60d60366174b745b4ef5824b8bbc1c457fd08f0ce101ff643c0a49181a9f4e91\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-plugin-opener-2.5.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-plugin-single-instance/tauri-plugin-single-instance-2.4.5.crate",+ "sha256": "db817fe9295e19b7d8357e900af31edb93703dd9fb6de524b007b47b6afc63b0",+ "dest": "cargo/vendor/tauri-plugin-single-instance-2.4.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"db817fe9295e19b7d8357e900af31edb93703dd9fb6de524b007b47b6afc63b0\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-plugin-single-instance-2.4.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-plugin-window-state/tauri-plugin-window-state-2.5.0.crate",+ "sha256": "5d6815cab7b212f9cfe16a9d79d8d22f9e14159e4a9460f7dec1467167a008e3",+ "dest": "cargo/vendor/tauri-plugin-window-state-2.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5d6815cab7b212f9cfe16a9d79d8d22f9e14159e4a9460f7dec1467167a008e3\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-plugin-window-state-2.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-runtime/tauri-runtime-2.12.2.crate",+ "sha256": "7c55766d99cea69055904d1735b93c2049302b2e09effd462120deb5581d78e9",+ "dest": "cargo/vendor/tauri-runtime-2.12.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7c55766d99cea69055904d1735b93c2049302b2e09effd462120deb5581d78e9\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-runtime-2.12.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-runtime-wry/tauri-runtime-wry-2.12.3.crate",+ "sha256": "e1aa9d8b7a120f879f44fdc1053f7b7dbf416bf0bbc6a72b714dec46b782b52f",+ "dest": "cargo/vendor/tauri-runtime-wry-2.12.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e1aa9d8b7a120f879f44fdc1053f7b7dbf416bf0bbc6a72b714dec46b782b52f\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-runtime-wry-2.12.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-utils/tauri-utils-2.10.2.crate",+ "sha256": "362ab21cd4cc713f2a02b1a9b5688198b1541cfb6907c4281e9190e0f0ef4aa3",+ "dest": "cargo/vendor/tauri-utils-2.10.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"362ab21cd4cc713f2a02b1a9b5688198b1541cfb6907c4281e9190e0f0ef4aa3\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-utils-2.10.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-winres/tauri-winres-0.3.6.crate",+ "sha256": "cc65d45c68858bfe420dd29e834b5d15dbecf8a07a8a16cf4d532c7b1f69d4b6",+ "dest": "cargo/vendor/tauri-winres-0.3.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cc65d45c68858bfe420dd29e834b5d15dbecf8a07a8a16cf4d532c7b1f69d4b6\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-winres-0.3.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tauri-winrt-notification/tauri-winrt-notification-0.8.1.crate",+ "sha256": "f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36",+ "dest": "cargo/vendor/tauri-winrt-notification-0.8.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36\", \"files\": {}}",+ "dest": "cargo/vendor/tauri-winrt-notification-0.8.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tempfile/tempfile-3.27.0.crate",+ "sha256": "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd",+ "dest": "cargo/vendor/tempfile-3.27.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd\", \"files\": {}}",+ "dest": "cargo/vendor/tempfile-3.27.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tendril/tendril-0.5.1.crate",+ "sha256": "5fed54709c5b3a53d09bb1c113ea4f5ceafd1e772ddcb0030a82e1d56c087b08",+ "dest": "cargo/vendor/tendril-0.5.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5fed54709c5b3a53d09bb1c113ea4f5ceafd1e772ddcb0030a82e1d56c087b08\", \"files\": {}}",+ "dest": "cargo/vendor/tendril-0.5.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/thiserror/thiserror-1.0.69.crate",+ "sha256": "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52",+ "dest": "cargo/vendor/thiserror-1.0.69"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52\", \"files\": {}}",+ "dest": "cargo/vendor/thiserror-1.0.69",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/thiserror/thiserror-2.0.20.crate",+ "sha256": "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f",+ "dest": "cargo/vendor/thiserror-2.0.20"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f\", \"files\": {}}",+ "dest": "cargo/vendor/thiserror-2.0.20",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/thiserror-impl/thiserror-impl-1.0.69.crate",+ "sha256": "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1",+ "dest": "cargo/vendor/thiserror-impl-1.0.69"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1\", \"files\": {}}",+ "dest": "cargo/vendor/thiserror-impl-1.0.69",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/thiserror-impl/thiserror-impl-2.0.20.crate",+ "sha256": "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af",+ "dest": "cargo/vendor/thiserror-impl-2.0.20"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af\", \"files\": {}}",+ "dest": "cargo/vendor/thiserror-impl-2.0.20",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/time/time-0.3.55.crate",+ "sha256": "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134",+ "dest": "cargo/vendor/time-0.3.55"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134\", \"files\": {}}",+ "dest": "cargo/vendor/time-0.3.55",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/time-core/time-core-0.1.9.crate",+ "sha256": "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109",+ "dest": "cargo/vendor/time-core-0.1.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109\", \"files\": {}}",+ "dest": "cargo/vendor/time-core-0.1.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/time-macros/time-macros-0.2.32.crate",+ "sha256": "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85",+ "dest": "cargo/vendor/time-macros-0.2.32"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85\", \"files\": {}}",+ "dest": "cargo/vendor/time-macros-0.2.32",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tinystr/tinystr-0.8.4.crate",+ "sha256": "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643",+ "dest": "cargo/vendor/tinystr-0.8.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643\", \"files\": {}}",+ "dest": "cargo/vendor/tinystr-0.8.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tinyvec/tinyvec-1.13.2.crate",+ "sha256": "4cf0ded5c4e56918d8f8a339e1bb67d038d3bc6d144ac407904015ba2e4cde9b",+ "dest": "cargo/vendor/tinyvec-1.13.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4cf0ded5c4e56918d8f8a339e1bb67d038d3bc6d144ac407904015ba2e4cde9b\", \"files\": {}}",+ "dest": "cargo/vendor/tinyvec-1.13.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tinyvec_macros/tinyvec_macros-0.1.1.crate",+ "sha256": "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20",+ "dest": "cargo/vendor/tinyvec_macros-0.1.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20\", \"files\": {}}",+ "dest": "cargo/vendor/tinyvec_macros-0.1.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tokio/tokio-1.53.1.crate",+ "sha256": "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed",+ "dest": "cargo/vendor/tokio-1.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed\", \"files\": {}}",+ "dest": "cargo/vendor/tokio-1.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tokio-macros/tokio-macros-2.7.2.crate",+ "sha256": "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e",+ "dest": "cargo/vendor/tokio-macros-2.7.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e\", \"files\": {}}",+ "dest": "cargo/vendor/tokio-macros-2.7.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tokio-rustls/tokio-rustls-0.26.5.crate",+ "sha256": "b0c85f2c3ef0b1cd58b36682f4b17aaa995f0e5db534d85692b4903abce21f67",+ "dest": "cargo/vendor/tokio-rustls-0.26.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b0c85f2c3ef0b1cd58b36682f4b17aaa995f0e5db534d85692b4903abce21f67\", \"files\": {}}",+ "dest": "cargo/vendor/tokio-rustls-0.26.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tokio-util/tokio-util-0.7.19.crate",+ "sha256": "494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52",+ "dest": "cargo/vendor/tokio-util-0.7.19"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52\", \"files\": {}}",+ "dest": "cargo/vendor/tokio-util-0.7.19",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml/toml-0.8.2.crate",+ "sha256": "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d",+ "dest": "cargo/vendor/toml-0.8.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d\", \"files\": {}}",+ "dest": "cargo/vendor/toml-0.8.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml/toml-1.1.6+spec-1.1.0.crate",+ "sha256": "920602543f0911ab71da12c50d59701da54c196d1a2bf5cb4b75667f137a406a",+ "dest": "cargo/vendor/toml-1.1.6+spec-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"920602543f0911ab71da12c50d59701da54c196d1a2bf5cb4b75667f137a406a\", \"files\": {}}",+ "dest": "cargo/vendor/toml-1.1.6+spec-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml_datetime/toml_datetime-0.6.3.crate",+ "sha256": "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b",+ "dest": "cargo/vendor/toml_datetime-0.6.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b\", \"files\": {}}",+ "dest": "cargo/vendor/toml_datetime-0.6.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml_datetime/toml_datetime-1.1.1+spec-1.1.0.crate",+ "sha256": "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7",+ "dest": "cargo/vendor/toml_datetime-1.1.1+spec-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7\", \"files\": {}}",+ "dest": "cargo/vendor/toml_datetime-1.1.1+spec-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml_edit/toml_edit-0.19.15.crate",+ "sha256": "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421",+ "dest": "cargo/vendor/toml_edit-0.19.15"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421\", \"files\": {}}",+ "dest": "cargo/vendor/toml_edit-0.19.15",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml_edit/toml_edit-0.20.2.crate",+ "sha256": "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338",+ "dest": "cargo/vendor/toml_edit-0.20.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338\", \"files\": {}}",+ "dest": "cargo/vendor/toml_edit-0.20.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml_edit/toml_edit-0.25.15+spec-1.1.0.crate",+ "sha256": "1340ea94a5856333492c9064b02c778b191dd2c853778d9609debdcdfea3a614",+ "dest": "cargo/vendor/toml_edit-0.25.15+spec-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1340ea94a5856333492c9064b02c778b191dd2c853778d9609debdcdfea3a614\", \"files\": {}}",+ "dest": "cargo/vendor/toml_edit-0.25.15+spec-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml_parser/toml_parser-1.1.3+spec-1.1.0.crate",+ "sha256": "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56",+ "dest": "cargo/vendor/toml_parser-1.1.3+spec-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56\", \"files\": {}}",+ "dest": "cargo/vendor/toml_parser-1.1.3+spec-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/toml_writer/toml_writer-1.1.2+spec-1.1.0.crate",+ "sha256": "7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2",+ "dest": "cargo/vendor/toml_writer-1.1.2+spec-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2\", \"files\": {}}",+ "dest": "cargo/vendor/toml_writer-1.1.2+spec-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tower/tower-0.5.3.crate",+ "sha256": "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4",+ "dest": "cargo/vendor/tower-0.5.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4\", \"files\": {}}",+ "dest": "cargo/vendor/tower-0.5.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tower-http/tower-http-0.6.11.crate",+ "sha256": "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840",+ "dest": "cargo/vendor/tower-http-0.6.11"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840\", \"files\": {}}",+ "dest": "cargo/vendor/tower-http-0.6.11",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tower-layer/tower-layer-0.3.3.crate",+ "sha256": "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e",+ "dest": "cargo/vendor/tower-layer-0.3.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e\", \"files\": {}}",+ "dest": "cargo/vendor/tower-layer-0.3.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tower-service/tower-service-0.3.3.crate",+ "sha256": "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3",+ "dest": "cargo/vendor/tower-service-0.3.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3\", \"files\": {}}",+ "dest": "cargo/vendor/tower-service-0.3.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tracing/tracing-0.1.44.crate",+ "sha256": "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100",+ "dest": "cargo/vendor/tracing-0.1.44"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100\", \"files\": {}}",+ "dest": "cargo/vendor/tracing-0.1.44",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tracing-attributes/tracing-attributes-0.1.31.crate",+ "sha256": "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da",+ "dest": "cargo/vendor/tracing-attributes-0.1.31"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da\", \"files\": {}}",+ "dest": "cargo/vendor/tracing-attributes-0.1.31",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tracing-core/tracing-core-0.1.36.crate",+ "sha256": "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a",+ "dest": "cargo/vendor/tracing-core-0.1.36"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a\", \"files\": {}}",+ "dest": "cargo/vendor/tracing-core-0.1.36",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/tray-icon/tray-icon-0.25.1.crate",+ "sha256": "b2b9c52859a94554803ccd4a24b98f74148ebc73b90676d783f3490b1bff9d72",+ "dest": "cargo/vendor/tray-icon-0.25.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b2b9c52859a94554803ccd4a24b98f74148ebc73b90676d783f3490b1bff9d72\", \"files\": {}}",+ "dest": "cargo/vendor/tray-icon-0.25.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/try-lock/try-lock-0.2.5.crate",+ "sha256": "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b",+ "dest": "cargo/vendor/try-lock-0.2.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b\", \"files\": {}}",+ "dest": "cargo/vendor/try-lock-0.2.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/typeid/typeid-1.0.3.crate",+ "sha256": "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c",+ "dest": "cargo/vendor/typeid-1.0.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c\", \"files\": {}}",+ "dest": "cargo/vendor/typeid-1.0.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/typenum/typenum-1.20.1.crate",+ "sha256": "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20",+ "dest": "cargo/vendor/typenum-1.20.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20\", \"files\": {}}",+ "dest": "cargo/vendor/typenum-1.20.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/uds_windows/uds_windows-1.2.1.crate",+ "sha256": "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e",+ "dest": "cargo/vendor/uds_windows-1.2.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e\", \"files\": {}}",+ "dest": "cargo/vendor/uds_windows-1.2.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/unicase/unicase-2.9.0.crate",+ "sha256": "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142",+ "dest": "cargo/vendor/unicase-2.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142\", \"files\": {}}",+ "dest": "cargo/vendor/unicase-2.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/unicode-ident/unicode-ident-1.0.24.crate",+ "sha256": "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75",+ "dest": "cargo/vendor/unicode-ident-1.0.24"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75\", \"files\": {}}",+ "dest": "cargo/vendor/unicode-ident-1.0.24",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/unicode-segmentation/unicode-segmentation-1.13.3.crate",+ "sha256": "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8",+ "dest": "cargo/vendor/unicode-segmentation-1.13.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8\", \"files\": {}}",+ "dest": "cargo/vendor/unicode-segmentation-1.13.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/untrusted/untrusted-0.9.0.crate",+ "sha256": "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1",+ "dest": "cargo/vendor/untrusted-0.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1\", \"files\": {}}",+ "dest": "cargo/vendor/untrusted-0.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/url/url-2.5.8.crate",+ "sha256": "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed",+ "dest": "cargo/vendor/url-2.5.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed\", \"files\": {}}",+ "dest": "cargo/vendor/url-2.5.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/urlpattern/urlpattern-0.6.0.crate",+ "sha256": "df16f50ef4cc145211879a3867ba757076b25dfee812040dcb0658bd9ae7904b",+ "dest": "cargo/vendor/urlpattern-0.6.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"df16f50ef4cc145211879a3867ba757076b25dfee812040dcb0658bd9ae7904b\", \"files\": {}}",+ "dest": "cargo/vendor/urlpattern-0.6.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/utf8_iter/utf8_iter-1.0.4.crate",+ "sha256": "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be",+ "dest": "cargo/vendor/utf8_iter-1.0.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be\", \"files\": {}}",+ "dest": "cargo/vendor/utf8_iter-1.0.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/uuid/uuid-1.26.1.crate",+ "sha256": "2ef6dac1e96601b4fb3acccccff2139741fcb757cb9a36089bf5be91cfb285ce",+ "dest": "cargo/vendor/uuid-1.26.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2ef6dac1e96601b4fb3acccccff2139741fcb757cb9a36089bf5be91cfb285ce\", \"files\": {}}",+ "dest": "cargo/vendor/uuid-1.26.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/vcpkg/vcpkg-0.2.15.crate",+ "sha256": "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426",+ "dest": "cargo/vendor/vcpkg-0.2.15"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426\", \"files\": {}}",+ "dest": "cargo/vendor/vcpkg-0.2.15",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/version-compare/version-compare-0.2.1.crate",+ "sha256": "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e",+ "dest": "cargo/vendor/version-compare-0.2.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e\", \"files\": {}}",+ "dest": "cargo/vendor/version-compare-0.2.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/version_check/version_check-0.9.5.crate",+ "sha256": "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a",+ "dest": "cargo/vendor/version_check-0.9.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a\", \"files\": {}}",+ "dest": "cargo/vendor/version_check-0.9.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/vswhom/vswhom-0.1.0.crate",+ "sha256": "be979b7f07507105799e854203b470ff7c78a1639e330a58f183b5fea574608b",+ "dest": "cargo/vendor/vswhom-0.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"be979b7f07507105799e854203b470ff7c78a1639e330a58f183b5fea574608b\", \"files\": {}}",+ "dest": "cargo/vendor/vswhom-0.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/vswhom-sys/vswhom-sys-0.1.3.crate",+ "sha256": "fb067e4cbd1ff067d1df46c9194b5de0e98efd2810bbc95c5d5e5f25a3231150",+ "dest": "cargo/vendor/vswhom-sys-0.1.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fb067e4cbd1ff067d1df46c9194b5de0e98efd2810bbc95c5d5e5f25a3231150\", \"files\": {}}",+ "dest": "cargo/vendor/vswhom-sys-0.1.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/walkdir/walkdir-2.5.0.crate",+ "sha256": "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b",+ "dest": "cargo/vendor/walkdir-2.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b\", \"files\": {}}",+ "dest": "cargo/vendor/walkdir-2.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/want/want-0.3.1.crate",+ "sha256": "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e",+ "dest": "cargo/vendor/want-0.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e\", \"files\": {}}",+ "dest": "cargo/vendor/want-0.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasi/wasi-0.11.1+wasi-snapshot-preview1.crate",+ "sha256": "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b",+ "dest": "cargo/vendor/wasi-0.11.1+wasi-snapshot-preview1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b\", \"files\": {}}",+ "dest": "cargo/vendor/wasi-0.11.1+wasi-snapshot-preview1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasip2/wasip2-1.0.4+wasi-0.2.12.crate",+ "sha256": "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487",+ "dest": "cargo/vendor/wasip2-1.0.4+wasi-0.2.12"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487\", \"files\": {}}",+ "dest": "cargo/vendor/wasip2-1.0.4+wasi-0.2.12",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasm-bindgen/wasm-bindgen-0.2.128.crate",+ "sha256": "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf",+ "dest": "cargo/vendor/wasm-bindgen-0.2.128"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf\", \"files\": {}}",+ "dest": "cargo/vendor/wasm-bindgen-0.2.128",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasm-bindgen-futures/wasm-bindgen-futures-0.4.78.crate",+ "sha256": "6ef4c5d3d2cdf5c54f4231181768f5510842e350db025faf1f7163b1030ed928",+ "dest": "cargo/vendor/wasm-bindgen-futures-0.4.78"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6ef4c5d3d2cdf5c54f4231181768f5510842e350db025faf1f7163b1030ed928\", \"files\": {}}",+ "dest": "cargo/vendor/wasm-bindgen-futures-0.4.78",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasm-bindgen-macro/wasm-bindgen-macro-0.2.128.crate",+ "sha256": "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed",+ "dest": "cargo/vendor/wasm-bindgen-macro-0.2.128"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed\", \"files\": {}}",+ "dest": "cargo/vendor/wasm-bindgen-macro-0.2.128",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasm-bindgen-macro-support/wasm-bindgen-macro-support-0.2.128.crate",+ "sha256": "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a",+ "dest": "cargo/vendor/wasm-bindgen-macro-support-0.2.128"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a\", \"files\": {}}",+ "dest": "cargo/vendor/wasm-bindgen-macro-support-0.2.128",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasm-bindgen-shared/wasm-bindgen-shared-0.2.128.crate",+ "sha256": "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e",+ "dest": "cargo/vendor/wasm-bindgen-shared-0.2.128"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e\", \"files\": {}}",+ "dest": "cargo/vendor/wasm-bindgen-shared-0.2.128",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasm-streams/wasm-streams-0.4.2.crate",+ "sha256": "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65",+ "dest": "cargo/vendor/wasm-streams-0.4.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65\", \"files\": {}}",+ "dest": "cargo/vendor/wasm-streams-0.4.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wasm-streams/wasm-streams-0.5.0.crate",+ "sha256": "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb",+ "dest": "cargo/vendor/wasm-streams-0.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb\", \"files\": {}}",+ "dest": "cargo/vendor/wasm-streams-0.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/web-sys/web-sys-0.3.105.crate",+ "sha256": "9fbddc4a036f00ec4f18c83445bd3115cb306a91da554919a099d9222fe4a7f8",+ "dest": "cargo/vendor/web-sys-0.3.105"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9fbddc4a036f00ec4f18c83445bd3115cb306a91da554919a099d9222fe4a7f8\", \"files\": {}}",+ "dest": "cargo/vendor/web-sys-0.3.105",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/web-time/web-time-1.1.0.crate",+ "sha256": "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb",+ "dest": "cargo/vendor/web-time-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb\", \"files\": {}}",+ "dest": "cargo/vendor/web-time-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/web_atoms/web_atoms-0.2.6.crate",+ "sha256": "ba8b815c1b593dc0baf78dd0f4fc8fdb2de53198fb1163738093e9a311c33fb3",+ "dest": "cargo/vendor/web_atoms-0.2.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ba8b815c1b593dc0baf78dd0f4fc8fdb2de53198fb1163738093e9a311c33fb3\", \"files\": {}}",+ "dest": "cargo/vendor/web_atoms-0.2.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/webkit2gtk/webkit2gtk-2.0.2.crate",+ "sha256": "a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793",+ "dest": "cargo/vendor/webkit2gtk-2.0.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793\", \"files\": {}}",+ "dest": "cargo/vendor/webkit2gtk-2.0.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/webkit2gtk-sys/webkit2gtk-sys-2.0.2.crate",+ "sha256": "916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5",+ "dest": "cargo/vendor/webkit2gtk-sys-2.0.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5\", \"files\": {}}",+ "dest": "cargo/vendor/webkit2gtk-sys-2.0.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/webpki-roots/webpki-roots-1.0.9.crate",+ "sha256": "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a",+ "dest": "cargo/vendor/webpki-roots-1.0.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a\", \"files\": {}}",+ "dest": "cargo/vendor/webpki-roots-1.0.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/webview2-com/webview2-com-0.39.1.crate",+ "sha256": "3f89fca7a704cee10dcb3654c1dbb8941d1783132f1917358af75bec37a7d7e6",+ "dest": "cargo/vendor/webview2-com-0.39.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3f89fca7a704cee10dcb3654c1dbb8941d1783132f1917358af75bec37a7d7e6\", \"files\": {}}",+ "dest": "cargo/vendor/webview2-com-0.39.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/webview2-com-macros/webview2-com-macros-0.8.1.crate",+ "sha256": "67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54",+ "dest": "cargo/vendor/webview2-com-macros-0.8.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54\", \"files\": {}}",+ "dest": "cargo/vendor/webview2-com-macros-0.8.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/webview2-com-sys/webview2-com-sys-0.39.1.crate",+ "sha256": "b3a07132775117d6065853d9d1178157b8c90e228de47129d6bce2c7edebedfb",+ "dest": "cargo/vendor/webview2-com-sys-0.39.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b3a07132775117d6065853d9d1178157b8c90e228de47129d6bce2c7edebedfb\", \"files\": {}}",+ "dest": "cargo/vendor/webview2-com-sys-0.39.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/winapi/winapi-0.3.9.crate",+ "sha256": "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419",+ "dest": "cargo/vendor/winapi-0.3.9"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419\", \"files\": {}}",+ "dest": "cargo/vendor/winapi-0.3.9",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/winapi-i686-pc-windows-gnu/winapi-i686-pc-windows-gnu-0.4.0.crate",+ "sha256": "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6",+ "dest": "cargo/vendor/winapi-i686-pc-windows-gnu-0.4.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6\", \"files\": {}}",+ "dest": "cargo/vendor/winapi-i686-pc-windows-gnu-0.4.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/winapi-util/winapi-util-0.1.11.crate",+ "sha256": "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22",+ "dest": "cargo/vendor/winapi-util-0.1.11"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22\", \"files\": {}}",+ "dest": "cargo/vendor/winapi-util-0.1.11",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/winapi-x86_64-pc-windows-gnu/winapi-x86_64-pc-windows-gnu-0.4.0.crate",+ "sha256": "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f",+ "dest": "cargo/vendor/winapi-x86_64-pc-windows-gnu-0.4.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f\", \"files\": {}}",+ "dest": "cargo/vendor/winapi-x86_64-pc-windows-gnu-0.4.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/window-vibrancy/window-vibrancy-0.8.1.crate",+ "sha256": "111e51caca442cafd9bab396628ac4d814880eaea4e63dfd76a12e9f342b5580",+ "dest": "cargo/vendor/window-vibrancy-0.8.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"111e51caca442cafd9bab396628ac4d814880eaea4e63dfd76a12e9f342b5580\", \"files\": {}}",+ "dest": "cargo/vendor/window-vibrancy-0.8.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows/windows-0.61.3.crate",+ "sha256": "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893",+ "dest": "cargo/vendor/windows-0.61.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893\", \"files\": {}}",+ "dest": "cargo/vendor/windows-0.61.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows/windows-0.62.2.crate",+ "sha256": "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580",+ "dest": "cargo/vendor/windows-0.62.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580\", \"files\": {}}",+ "dest": "cargo/vendor/windows-0.62.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-collections/windows-collections-0.2.0.crate",+ "sha256": "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8",+ "dest": "cargo/vendor/windows-collections-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8\", \"files\": {}}",+ "dest": "cargo/vendor/windows-collections-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-collections/windows-collections-0.3.2.crate",+ "sha256": "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610",+ "dest": "cargo/vendor/windows-collections-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610\", \"files\": {}}",+ "dest": "cargo/vendor/windows-collections-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-core/windows-core-0.61.2.crate",+ "sha256": "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3",+ "dest": "cargo/vendor/windows-core-0.61.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3\", \"files\": {}}",+ "dest": "cargo/vendor/windows-core-0.61.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-core/windows-core-0.62.2.crate",+ "sha256": "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb",+ "dest": "cargo/vendor/windows-core-0.62.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb\", \"files\": {}}",+ "dest": "cargo/vendor/windows-core-0.62.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-future/windows-future-0.2.1.crate",+ "sha256": "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e",+ "dest": "cargo/vendor/windows-future-0.2.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e\", \"files\": {}}",+ "dest": "cargo/vendor/windows-future-0.2.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-future/windows-future-0.3.2.crate",+ "sha256": "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb",+ "dest": "cargo/vendor/windows-future-0.3.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb\", \"files\": {}}",+ "dest": "cargo/vendor/windows-future-0.3.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-implement/windows-implement-0.60.2.crate",+ "sha256": "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf",+ "dest": "cargo/vendor/windows-implement-0.60.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf\", \"files\": {}}",+ "dest": "cargo/vendor/windows-implement-0.60.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-interface/windows-interface-0.59.3.crate",+ "sha256": "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358",+ "dest": "cargo/vendor/windows-interface-0.59.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358\", \"files\": {}}",+ "dest": "cargo/vendor/windows-interface-0.59.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-link/windows-link-0.1.3.crate",+ "sha256": "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a",+ "dest": "cargo/vendor/windows-link-0.1.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a\", \"files\": {}}",+ "dest": "cargo/vendor/windows-link-0.1.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-link/windows-link-0.2.1.crate",+ "sha256": "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5",+ "dest": "cargo/vendor/windows-link-0.2.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5\", \"files\": {}}",+ "dest": "cargo/vendor/windows-link-0.2.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-numerics/windows-numerics-0.2.0.crate",+ "sha256": "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1",+ "dest": "cargo/vendor/windows-numerics-0.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1\", \"files\": {}}",+ "dest": "cargo/vendor/windows-numerics-0.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-numerics/windows-numerics-0.3.1.crate",+ "sha256": "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26",+ "dest": "cargo/vendor/windows-numerics-0.3.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26\", \"files\": {}}",+ "dest": "cargo/vendor/windows-numerics-0.3.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-result/windows-result-0.3.4.crate",+ "sha256": "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6",+ "dest": "cargo/vendor/windows-result-0.3.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6\", \"files\": {}}",+ "dest": "cargo/vendor/windows-result-0.3.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-result/windows-result-0.4.1.crate",+ "sha256": "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5",+ "dest": "cargo/vendor/windows-result-0.4.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5\", \"files\": {}}",+ "dest": "cargo/vendor/windows-result-0.4.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-strings/windows-strings-0.4.2.crate",+ "sha256": "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57",+ "dest": "cargo/vendor/windows-strings-0.4.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57\", \"files\": {}}",+ "dest": "cargo/vendor/windows-strings-0.4.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-strings/windows-strings-0.5.1.crate",+ "sha256": "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091",+ "dest": "cargo/vendor/windows-strings-0.5.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091\", \"files\": {}}",+ "dest": "cargo/vendor/windows-strings-0.5.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-sys/windows-sys-0.45.0.crate",+ "sha256": "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0",+ "dest": "cargo/vendor/windows-sys-0.45.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0\", \"files\": {}}",+ "dest": "cargo/vendor/windows-sys-0.45.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-sys/windows-sys-0.52.0.crate",+ "sha256": "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d",+ "dest": "cargo/vendor/windows-sys-0.52.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d\", \"files\": {}}",+ "dest": "cargo/vendor/windows-sys-0.52.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-sys/windows-sys-0.59.0.crate",+ "sha256": "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b",+ "dest": "cargo/vendor/windows-sys-0.59.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b\", \"files\": {}}",+ "dest": "cargo/vendor/windows-sys-0.59.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-sys/windows-sys-0.60.2.crate",+ "sha256": "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb",+ "dest": "cargo/vendor/windows-sys-0.60.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb\", \"files\": {}}",+ "dest": "cargo/vendor/windows-sys-0.60.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-sys/windows-sys-0.61.2.crate",+ "sha256": "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc",+ "dest": "cargo/vendor/windows-sys-0.61.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc\", \"files\": {}}",+ "dest": "cargo/vendor/windows-sys-0.61.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-targets/windows-targets-0.42.2.crate",+ "sha256": "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071",+ "dest": "cargo/vendor/windows-targets-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071\", \"files\": {}}",+ "dest": "cargo/vendor/windows-targets-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-targets/windows-targets-0.52.6.crate",+ "sha256": "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973",+ "dest": "cargo/vendor/windows-targets-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973\", \"files\": {}}",+ "dest": "cargo/vendor/windows-targets-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-targets/windows-targets-0.53.5.crate",+ "sha256": "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3",+ "dest": "cargo/vendor/windows-targets-0.53.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3\", \"files\": {}}",+ "dest": "cargo/vendor/windows-targets-0.53.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-threading/windows-threading-0.1.0.crate",+ "sha256": "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6",+ "dest": "cargo/vendor/windows-threading-0.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6\", \"files\": {}}",+ "dest": "cargo/vendor/windows-threading-0.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-threading/windows-threading-0.2.1.crate",+ "sha256": "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37",+ "dest": "cargo/vendor/windows-threading-0.2.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37\", \"files\": {}}",+ "dest": "cargo/vendor/windows-threading-0.2.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows-version/windows-version-0.1.7.crate",+ "sha256": "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631",+ "dest": "cargo/vendor/windows-version-0.1.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631\", \"files\": {}}",+ "dest": "cargo/vendor/windows-version-0.1.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_aarch64_gnullvm/windows_aarch64_gnullvm-0.42.2.crate",+ "sha256": "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8",+ "dest": "cargo/vendor/windows_aarch64_gnullvm-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8\", \"files\": {}}",+ "dest": "cargo/vendor/windows_aarch64_gnullvm-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_aarch64_gnullvm/windows_aarch64_gnullvm-0.52.6.crate",+ "sha256": "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3",+ "dest": "cargo/vendor/windows_aarch64_gnullvm-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3\", \"files\": {}}",+ "dest": "cargo/vendor/windows_aarch64_gnullvm-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_aarch64_gnullvm/windows_aarch64_gnullvm-0.53.1.crate",+ "sha256": "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53",+ "dest": "cargo/vendor/windows_aarch64_gnullvm-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53\", \"files\": {}}",+ "dest": "cargo/vendor/windows_aarch64_gnullvm-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_aarch64_msvc/windows_aarch64_msvc-0.42.2.crate",+ "sha256": "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43",+ "dest": "cargo/vendor/windows_aarch64_msvc-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43\", \"files\": {}}",+ "dest": "cargo/vendor/windows_aarch64_msvc-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_aarch64_msvc/windows_aarch64_msvc-0.52.6.crate",+ "sha256": "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469",+ "dest": "cargo/vendor/windows_aarch64_msvc-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469\", \"files\": {}}",+ "dest": "cargo/vendor/windows_aarch64_msvc-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_aarch64_msvc/windows_aarch64_msvc-0.53.1.crate",+ "sha256": "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006",+ "dest": "cargo/vendor/windows_aarch64_msvc-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006\", \"files\": {}}",+ "dest": "cargo/vendor/windows_aarch64_msvc-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_gnu/windows_i686_gnu-0.42.2.crate",+ "sha256": "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f",+ "dest": "cargo/vendor/windows_i686_gnu-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_gnu-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_gnu/windows_i686_gnu-0.52.6.crate",+ "sha256": "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b",+ "dest": "cargo/vendor/windows_i686_gnu-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_gnu-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_gnu/windows_i686_gnu-0.53.1.crate",+ "sha256": "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3",+ "dest": "cargo/vendor/windows_i686_gnu-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_gnu-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_gnullvm/windows_i686_gnullvm-0.52.6.crate",+ "sha256": "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66",+ "dest": "cargo/vendor/windows_i686_gnullvm-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_gnullvm-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_gnullvm/windows_i686_gnullvm-0.53.1.crate",+ "sha256": "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c",+ "dest": "cargo/vendor/windows_i686_gnullvm-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_gnullvm-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_msvc/windows_i686_msvc-0.42.2.crate",+ "sha256": "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060",+ "dest": "cargo/vendor/windows_i686_msvc-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_msvc-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_msvc/windows_i686_msvc-0.52.6.crate",+ "sha256": "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66",+ "dest": "cargo/vendor/windows_i686_msvc-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_msvc-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_i686_msvc/windows_i686_msvc-0.53.1.crate",+ "sha256": "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2",+ "dest": "cargo/vendor/windows_i686_msvc-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2\", \"files\": {}}",+ "dest": "cargo/vendor/windows_i686_msvc-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_gnu/windows_x86_64_gnu-0.42.2.crate",+ "sha256": "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36",+ "dest": "cargo/vendor/windows_x86_64_gnu-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_gnu-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_gnu/windows_x86_64_gnu-0.52.6.crate",+ "sha256": "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78",+ "dest": "cargo/vendor/windows_x86_64_gnu-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_gnu-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_gnu/windows_x86_64_gnu-0.53.1.crate",+ "sha256": "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499",+ "dest": "cargo/vendor/windows_x86_64_gnu-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_gnu-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_gnullvm/windows_x86_64_gnullvm-0.42.2.crate",+ "sha256": "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3",+ "dest": "cargo/vendor/windows_x86_64_gnullvm-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_gnullvm-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_gnullvm/windows_x86_64_gnullvm-0.52.6.crate",+ "sha256": "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d",+ "dest": "cargo/vendor/windows_x86_64_gnullvm-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_gnullvm-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_gnullvm/windows_x86_64_gnullvm-0.53.1.crate",+ "sha256": "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1",+ "dest": "cargo/vendor/windows_x86_64_gnullvm-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_gnullvm-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_msvc/windows_x86_64_msvc-0.42.2.crate",+ "sha256": "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0",+ "dest": "cargo/vendor/windows_x86_64_msvc-0.42.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_msvc-0.42.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_msvc/windows_x86_64_msvc-0.52.6.crate",+ "sha256": "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec",+ "dest": "cargo/vendor/windows_x86_64_msvc-0.52.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_msvc-0.52.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/windows_x86_64_msvc/windows_x86_64_msvc-0.53.1.crate",+ "sha256": "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650",+ "dest": "cargo/vendor/windows_x86_64_msvc-0.53.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650\", \"files\": {}}",+ "dest": "cargo/vendor/windows_x86_64_msvc-0.53.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/winnow/winnow-0.5.40.crate",+ "sha256": "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876",+ "dest": "cargo/vendor/winnow-0.5.40"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876\", \"files\": {}}",+ "dest": "cargo/vendor/winnow-0.5.40",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/winnow/winnow-1.0.4.crate",+ "sha256": "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81",+ "dest": "cargo/vendor/winnow-1.0.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81\", \"files\": {}}",+ "dest": "cargo/vendor/winnow-1.0.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/winreg/winreg-0.55.0.crate",+ "sha256": "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97",+ "dest": "cargo/vendor/winreg-0.55.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97\", \"files\": {}}",+ "dest": "cargo/vendor/winreg-0.55.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wiremock/wiremock-0.6.5.crate",+ "sha256": "08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031",+ "dest": "cargo/vendor/wiremock-0.6.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031\", \"files\": {}}",+ "dest": "cargo/vendor/wiremock-0.6.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wit-bindgen/wit-bindgen-0.57.1.crate",+ "sha256": "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e",+ "dest": "cargo/vendor/wit-bindgen-0.57.1"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e\", \"files\": {}}",+ "dest": "cargo/vendor/wit-bindgen-0.57.1",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/writeable/writeable-0.6.4.crate",+ "sha256": "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc",+ "dest": "cargo/vendor/writeable-0.6.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc\", \"files\": {}}",+ "dest": "cargo/vendor/writeable-0.6.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/wry/wry-0.57.0.crate",+ "sha256": "a819957a01b3119af85e638a38d242af76dbc87d130dca67bfd0441072e21ff0",+ "dest": "cargo/vendor/wry-0.57.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"a819957a01b3119af85e638a38d242af76dbc87d130dca67bfd0441072e21ff0\", \"files\": {}}",+ "dest": "cargo/vendor/wry-0.57.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/x11/x11-2.21.0.crate",+ "sha256": "502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e",+ "dest": "cargo/vendor/x11-2.21.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e\", \"files\": {}}",+ "dest": "cargo/vendor/x11-2.21.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/x11-dl/x11-dl-2.21.0.crate",+ "sha256": "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f",+ "dest": "cargo/vendor/x11-dl-2.21.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f\", \"files\": {}}",+ "dest": "cargo/vendor/x11-dl-2.21.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/xdg-home/xdg-home-1.3.0.crate",+ "sha256": "ec1cdab258fb55c0da61328dc52c8764709b249011b2cad0454c72f0bf10a1f6",+ "dest": "cargo/vendor/xdg-home-1.3.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"ec1cdab258fb55c0da61328dc52c8764709b249011b2cad0454c72f0bf10a1f6\", \"files\": {}}",+ "dest": "cargo/vendor/xdg-home-1.3.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/yoke/yoke-0.8.3.crate",+ "sha256": "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5",+ "dest": "cargo/vendor/yoke-0.8.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5\", \"files\": {}}",+ "dest": "cargo/vendor/yoke-0.8.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/yoke-derive/yoke-derive-0.8.2.crate",+ "sha256": "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e",+ "dest": "cargo/vendor/yoke-derive-0.8.2"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e\", \"files\": {}}",+ "dest": "cargo/vendor/yoke-derive-0.8.2",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zbus/zbus-4.4.0.crate",+ "sha256": "bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725",+ "dest": "cargo/vendor/zbus-4.4.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725\", \"files\": {}}",+ "dest": "cargo/vendor/zbus-4.4.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zbus/zbus-5.19.0.crate",+ "sha256": "5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907",+ "dest": "cargo/vendor/zbus-5.19.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907\", \"files\": {}}",+ "dest": "cargo/vendor/zbus-5.19.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zbus_macros/zbus_macros-4.4.0.crate",+ "sha256": "267db9407081e90bbfa46d841d3cbc60f59c0351838c4bc65199ecd79ab1983e",+ "dest": "cargo/vendor/zbus_macros-4.4.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"267db9407081e90bbfa46d841d3cbc60f59c0351838c4bc65199ecd79ab1983e\", \"files\": {}}",+ "dest": "cargo/vendor/zbus_macros-4.4.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zbus_macros/zbus_macros-5.19.0.crate",+ "sha256": "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40",+ "dest": "cargo/vendor/zbus_macros-5.19.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40\", \"files\": {}}",+ "dest": "cargo/vendor/zbus_macros-5.19.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zbus_names/zbus_names-3.0.0.crate",+ "sha256": "4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c",+ "dest": "cargo/vendor/zbus_names-3.0.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c\", \"files\": {}}",+ "dest": "cargo/vendor/zbus_names-3.0.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zbus_names/zbus_names-4.3.4.crate",+ "sha256": "d8bf88b4a3ff53e883001e0e0115b297a9d53c31b9c1edd2bfdd853e3428624e",+ "dest": "cargo/vendor/zbus_names-4.3.4"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d8bf88b4a3ff53e883001e0e0115b297a9d53c31b9c1edd2bfdd853e3428624e\", \"files\": {}}",+ "dest": "cargo/vendor/zbus_names-4.3.4",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zcheapstr/zcheapstr-1.1.0.crate",+ "sha256": "d1afec51604565183aeb5c54c20aeab286120d4e4460f7f76e3e8bb8c0d99473",+ "dest": "cargo/vendor/zcheapstr-1.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d1afec51604565183aeb5c54c20aeab286120d4e4460f7f76e3e8bb8c0d99473\", \"files\": {}}",+ "dest": "cargo/vendor/zcheapstr-1.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zerocopy/zerocopy-0.8.57.crate",+ "sha256": "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873",+ "dest": "cargo/vendor/zerocopy-0.8.57"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873\", \"files\": {}}",+ "dest": "cargo/vendor/zerocopy-0.8.57",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zerocopy-derive/zerocopy-derive-0.8.57.crate",+ "sha256": "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc",+ "dest": "cargo/vendor/zerocopy-derive-0.8.57"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc\", \"files\": {}}",+ "dest": "cargo/vendor/zerocopy-derive-0.8.57",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zerofrom/zerofrom-0.1.8.crate",+ "sha256": "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272",+ "dest": "cargo/vendor/zerofrom-0.1.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272\", \"files\": {}}",+ "dest": "cargo/vendor/zerofrom-0.1.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zerofrom-derive/zerofrom-derive-0.1.7.crate",+ "sha256": "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1",+ "dest": "cargo/vendor/zerofrom-derive-0.1.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1\", \"files\": {}}",+ "dest": "cargo/vendor/zerofrom-derive-0.1.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zeroize/zeroize-1.9.0.crate",+ "sha256": "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e",+ "dest": "cargo/vendor/zeroize-1.9.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e\", \"files\": {}}",+ "dest": "cargo/vendor/zeroize-1.9.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zeroize_derive/zeroize_derive-1.5.0.crate",+ "sha256": "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328",+ "dest": "cargo/vendor/zeroize_derive-1.5.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328\", \"files\": {}}",+ "dest": "cargo/vendor/zeroize_derive-1.5.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zerotrie/zerotrie-0.2.5.crate",+ "sha256": "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f",+ "dest": "cargo/vendor/zerotrie-0.2.5"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f\", \"files\": {}}",+ "dest": "cargo/vendor/zerotrie-0.2.5",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zerovec/zerovec-0.11.8.crate",+ "sha256": "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8",+ "dest": "cargo/vendor/zerovec-0.11.8"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8\", \"files\": {}}",+ "dest": "cargo/vendor/zerovec-0.11.8",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zerovec-derive/zerovec-derive-0.11.6.crate",+ "sha256": "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da",+ "dest": "cargo/vendor/zerovec-derive-0.11.6"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da\", \"files\": {}}",+ "dest": "cargo/vendor/zerovec-derive-0.11.6",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zlib-rs/zlib-rs-0.6.7.crate",+ "sha256": "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12",+ "dest": "cargo/vendor/zlib-rs-0.6.7"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12\", \"files\": {}}",+ "dest": "cargo/vendor/zlib-rs-0.6.7",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zmij/zmij-1.0.23.crate",+ "sha256": "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b",+ "dest": "cargo/vendor/zmij-1.0.23"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b\", \"files\": {}}",+ "dest": "cargo/vendor/zmij-1.0.23",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zune-core/zune-core-0.5.3.crate",+ "sha256": "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b",+ "dest": "cargo/vendor/zune-core-0.5.3"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b\", \"files\": {}}",+ "dest": "cargo/vendor/zune-core-0.5.3",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zune-jpeg/zune-jpeg-0.5.15.crate",+ "sha256": "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296",+ "dest": "cargo/vendor/zune-jpeg-0.5.15"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296\", \"files\": {}}",+ "dest": "cargo/vendor/zune-jpeg-0.5.15",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zvariant/zvariant-4.2.0.crate",+ "sha256": "2084290ab9a1c471c38fc524945837734fbf124487e105daec2bb57fd48c81fe",+ "dest": "cargo/vendor/zvariant-4.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"2084290ab9a1c471c38fc524945837734fbf124487e105daec2bb57fd48c81fe\", \"files\": {}}",+ "dest": "cargo/vendor/zvariant-4.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zvariant/zvariant-5.15.0.crate",+ "sha256": "c1d34c27cc6cdd1f458427519dd6b8612f7b7e3f7b9a0b2355d041dda9869147",+ "dest": "cargo/vendor/zvariant-5.15.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c1d34c27cc6cdd1f458427519dd6b8612f7b7e3f7b9a0b2355d041dda9869147\", \"files\": {}}",+ "dest": "cargo/vendor/zvariant-5.15.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zvariant_derive/zvariant_derive-4.2.0.crate",+ "sha256": "73e2ba546bda683a90652bac4a279bc146adad1386f25379cf73200d2002c449",+ "dest": "cargo/vendor/zvariant_derive-4.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"73e2ba546bda683a90652bac4a279bc146adad1386f25379cf73200d2002c449\", \"files\": {}}",+ "dest": "cargo/vendor/zvariant_derive-4.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zvariant_derive/zvariant_derive-5.15.0.crate",+ "sha256": "864155e69b4352db0c7f374917bf45d1e0c8d17659c8b3dbf9795f3673f8c497",+ "dest": "cargo/vendor/zvariant_derive-5.15.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"864155e69b4352db0c7f374917bf45d1e0c8d17659c8b3dbf9795f3673f8c497\", \"files\": {}}",+ "dest": "cargo/vendor/zvariant_derive-5.15.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zvariant_utils/zvariant_utils-2.1.0.crate",+ "sha256": "c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340",+ "dest": "cargo/vendor/zvariant_utils-2.1.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340\", \"files\": {}}",+ "dest": "cargo/vendor/zvariant_utils-2.1.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "archive",+ "archive-type": "tar-gzip",+ "url": "https://static.crates.io/crates/zvariant_utils/zvariant_utils-4.2.0.crate",+ "sha256": "bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3",+ "dest": "cargo/vendor/zvariant_utils-4.2.0"+ },+ {+ "type": "inline",+ "contents": "{\"package\": \"bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3\", \"files\": {}}",+ "dest": "cargo/vendor/zvariant_utils-4.2.0",+ "dest-filename": ".cargo-checksum.json"+ },+ {+ "type": "inline",+ "contents": "[source.vendored-sources]\ndirectory = \"cargo/vendor\"\n\n[source.crates-io]\nreplace-with = \"vendored-sources\"\n",+ "dest": "cargo",+ "dest-filename": "config"+ }+]\ No newline at end of filediff --git a/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.desktop b/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.desktopnew file mode 100644index 0000000..78fd348--- /dev/null+++ b/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.desktop@@ -0,0 +1,46 @@+[Desktop Entry]+Type=Application+Name=Pomander+GenericName=iCloud Client+Comment=Your iCloud, on this computer+Exec=pomander %U+Icon=io.github.yashwanthkamireddi.Pomander+Terminal=false+Categories=Office;Calendar;ContactManagement;+Keywords=iCloud;calendar;reminders;notes;contacts;sync;+MimeType=text/calendar;text/vcard;text/x-vcard;+StartupNotify=true+StartupWMClass=io.github.yashwanthkamireddi.Pomander+Actions=new-reminder;new-note;notes;reminders;calendar;contacts;drive;photos;++[Desktop Action new-reminder]+Name=New Reminder+Exec=pomander --new reminder++[Desktop Action new-note]+Name=New Note+Exec=pomander --new note++[Desktop Action notes]+Name=Notes+Exec=pomander --app notes++[Desktop Action reminders]+Name=Reminders+Exec=pomander --app reminders++[Desktop Action calendar]+Name=Calendar+Exec=pomander --app calendar++[Desktop Action contacts]+Name=Contacts+Exec=pomander --app contacts++[Desktop Action drive]+Name=Drive+Exec=pomander --app drive++[Desktop Action photos]+Name=Photos+Exec=pomander --app photosdiff --git a/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.metainfo.xml b/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.metainfo.xmlnew file mode 100644index 0000000..663f9b2--- /dev/null+++ b/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.metainfo.xml@@ -0,0 +1,92 @@+<?xml version="1.0" encoding="UTF-8"?>+<!--+ The Flatpak copy of packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xml (that one+ names the .deb's launcher, Pomander.desktop). Keep the two in step. Flathub requires this+ file; GNOME Software and+ KDE Discover read it to build the page someone decides from.++ Every claim here has to be one the app can keep. The disclaimer is not boilerplate: this+ talks to iCloud through interfaces Apple has not published, and somebody installing it is+ entitled to know that before they type their Apple ID.+-->+<component type="desktop-application">+ <id>io.github.yashwanthkamireddi.Pomander</id>+ <metadata_license>CC0-1.0</metadata_license>+ <project_license>GPL-3.0-only</project_license>++ <name>Pomander</name>+ <summary>Your iCloud, on this computer</summary>++ <description>+ <p>+ Pomander keeps your iCloud calendar, reminders, notes, contacts and Drive on your own+ machine. Everything opens straight away and works without a connection, and what you+ change here reaches your other devices.+ </p>+ <p>+ You sign in once with your Apple ID and stay signed in. Nothing is stored on anybody+ else's server: there is no Pomander account and no Pomander service, and your credentials+ never leave this computer.+ </p>+ <p>+ Pomander is an independent project. It is not made by, endorsed by, or affiliated with+ Apple, and it reaches iCloud through interfaces Apple has not published, which means+ they can change without warning. Services that Apple encrypts end to end — Health,+ Messages, Keychain and others — cannot be read by any client and are shown as+ unavailable rather than quietly left out.+ </p>+ </description>++ <launchable type="desktop-id">io.github.yashwanthkamireddi.Pomander.desktop</launchable>++ <categories>+ <category>Utility</category>+ <category>Office</category>+ </categories>++ <keywords>+ <keyword>iCloud</keyword>+ <keyword>calendar</keyword>+ <keyword>reminders</keyword>+ <keyword>notes</keyword>+ <keyword>contacts</keyword>+ <keyword>sync</keyword>+ </keywords>++ <provides>+ <mediatype>text/calendar</mediatype>+ <mediatype>text/vcard</mediatype>+ <mediatype>text/x-vcard</mediatype>+ <binary>pomander</binary>+ </provides>++ <content_rating type="oars-1.1"/>++ <url type="homepage">https://github.com/YashwanthKamireddi/Pomander</url>+ <url type="vcs-browser">https://github.com/YashwanthKamireddi/Pomander</url>+ <url type="bugtracker">https://github.com/YashwanthKamireddi/Pomander/issues</url>++ <developer id="io.github.yashwanthkamireddi">+ <name>Yashwanth Kamireddi</name>+ </developer>++ <requires>+ <internet>first-run</internet>+ </requires>++ <recommends>+ <control>keyboard</control>+ <control>pointing</control>+ </recommends>++ <releases>+ <release version="0.1.0" date="2026-09-14">+ <description>+ <p>+ Calendar, Reminders, Notes, Contacts and iCloud Drive, all readable and writable,+ kept in step with your other devices.+ </p>+ </description>+ </release>+ </releases>+</component>diff --git a/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.yml b/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.ymlnew file mode 100644index 0000000..8b0b470--- /dev/null+++ b/packaging/flatpak/io.github.yashwanthkamireddi.Pomander.yml@@ -0,0 +1,142 @@+# Pomander as a Flatpak, for Flathub.+#+# NOT YET BUILT: the development machine has no flatpak-builder, so this manifest has never run.+# packaging/flatpak/README.md lists what was checked, what was not, and the open questions.+#+# The Tauri identifier (src-tauri/tauri.conf.json) is this app ID, so the window's Wayland app+# ID, the per-app windows (<id>.Notes, …) and the single-instance D-Bus name+# (<id>.SingleInstance, which the sandbox may own by default) all agree with it.+#+# Runtime: GNOME 51, the current stable. Checked 2026-10-21 against gnome-build-meta: branch+# gnome-51, tags 51.0 (2026-09-16) and 51.1 (2026-10-18); it is built on freedesktop-sdk 26.08.+# Its gnome-51 elements ship webkit2gtk-4.1, gtk3, libsecret, libnotify, GStreamer and libheif+# (via freedesktop-sdk), so none of those are bundled here.+#+# HEIC: the runtime's libheif is built with plugin loading and no HEVC decoder of its own; the+# libde265 plugin comes from org.freedesktop.Platform.codecs-extra, an extension the runtime+# downloads automatically (it is declared without no-autodownload in the GNOME 51 platform+# metadata). That HEIC actually decodes in the sandbox is unverified — see the README.+# Checked 2026-10-21: freedesktop-sdk release/26.08 lists components/libheif.bst in platform.bst,+# built -DWITH_LIBDE265=OFF, confirming the above. So there is no libheif module here.+#+# FUSE: no fuse3 module either. fuser is built with default-features = false, its pure-Rust mount+# path, which links no libfuse; it needs only /dev/fuse and a fusermount3 at run time, and the+# FUSE folders are switched off in this package anyway (see finish-args).+app-id: io.github.yashwanthkamireddi.Pomander+runtime: org.gnome.Platform+runtime-version: '51'+sdk: org.gnome.Sdk+sdk-extensions:+ # Both exist with a branch/26.08, the freedesktop-sdk under GNOME 51 (checked 2026-10-21).+ - org.freedesktop.Sdk.Extension.rust-stable+ - org.freedesktop.Sdk.Extension.node24+command: pomander++finish-args:+ # iCloud.+ - --share=network+ # The window: Wayland first, X11 only where there is no Wayland.+ - --socket=wayland+ - --socket=fallback-x11+ - --share=ipc+ - --device=dri+ # The Apple ID session is kept in the Secret Service keyring (keyring crate, Secret Service+ # over D-Bus). Without this the app starts but cannot stay signed in.+ - --talk-name=org.freedesktop.secrets+ # Reminder alerts (notify-rust, org.freedesktop.Notifications over D-Bus).+ - --talk-name=org.freedesktop.Notifications+ # The tray icon (libayatana-appindicator, StatusNotifierItem).+ - --talk-name=org.kde.StatusNotifierWatcher+ # Files saved from Drive and Photos land in ~/Downloads: the app writes there directly+ # (main.rs, photos.rs: download_dir()), not through the file-chooser portal, so without this+ # every "save" fails inside the sandbox. Narrow and routinely accepted on Flathub; remove it+ # once saving goes through the portal.+ - --filesystem=xdg-download++ # Deliberately NOT granted (README, "Permissions left out"):+ #+ # Drive and Photos as folders (FUSE). Mounting needs /dev/fuse (--device=all) and a working+ # fusermount3, which cannot be setuid inside the sandbox; in practice that means reaching+ # out to the host (flatpak-spawn --host, i.e. --talk-name=org.freedesktop.Flatpak), a full+ # sandbox escape Flathub will question. Off; the folders are unavailable in the Flatpak.+ # - --device=all+ #+ # Waking on resume from sleep (alerts.rs listens for logind's PrepareForSleep). Without it+ # the app falls back to its ten-minute ceiling, which it already handles.+ # - --system-talk-name=org.freedesktop.login1++modules:+ # The tray. libayatana-appindicator is not in the GNOME runtime; Flathub's shared module+ # builds it. Clone flathub/shared-modules here first (README, "Build locally"); in the+ # Flathub repository it is a git submodule at this path.+ - shared-modules/libayatana-appindicator/libayatana-appindicator-gtk3.json++ - name: pomander+ buildsystem: simple+ build-options:+ append-path: /usr/lib/sdk/rust-stable/bin:/usr/lib/sdk/node24/bin+ env:+ # Offline: every crate and npm package comes from the generated sources below.+ CARGO_HOME: /run/build/pomander/cargo+ CARGO_NET_OFFLINE: 'true'+ XDG_CACHE_HOME: /run/build/pomander/flatpak-node/cache+ npm_config_cache: /run/build/pomander/flatpak-node/npm-cache+ npm_config_offline: 'true'+ # esbuild's binary, placed by node-sources.json for the build architecture.+ ESBUILD_BINARY_PATH: /run/build/pomander/flatpak-node/cache/esbuild/bin/esbuild-current+ build-commands:+ # The frontend into dist/, which tauri::generate_context! embeds at compile time.+ - npm ci --offline --no-audit --no-fund+ - npm run build+ # The app. tauri/custom-protocol is what `tauri build` turns on: without it the binary+ # is a dev build (cfg(dev)) — dev CSP and dev behaviour in a release package.+ - cargo --offline build --release --locked -p quince-app --features tauri/custom-protocol+ - install -Dm755 target/release/quince-app ${FLATPAK_DEST}/bin/pomander++ # The main launcher entry and the metainfo: written for this app ID, kept beside this+ # manifest (packaging/flatpak/), and added as file sources below.+ - desktop-file-validate ${FLATPAK_ID}.desktop+ - install -Dm644 ${FLATPAK_ID}.desktop ${FLATPAK_DEST}/share/applications/${FLATPAK_ID}.desktop++ # The six per-app entries, already named under this app ID (Flatpak exports only desktop+ # files whose names start with it). Exec stays `pomander --app …`; flatpak rewrites it to+ # `flatpak run --command=pomander io.github.yashwanthkamireddi.Pomander --app …` when it+ # exports the file.+ - |+ for entry in packaging/apps/${FLATPAK_ID}.*.desktop; do+ desktop-file-validate "$entry"+ install -Dm644 "$entry" "${FLATPAK_DEST}/share/applications/${entry##*/}"+ done+ test "$(ls ${FLATPAK_DEST}/share/applications/${FLATPAK_ID}.*.desktop | wc -l)" -eq 7++ - install -Dm644 ${FLATPAK_ID}.metainfo.xml ${FLATPAK_DEST}/share/metainfo/${FLATPAK_ID}.metainfo.xml++ # Icons: the vector original, and the rendered sizes.+ - install -Dm644 src-tauri/icons/icon.svg ${FLATPAK_DEST}/share/icons/hicolor/scalable/apps/${FLATPAK_ID}.svg+ - install -Dm644 src-tauri/icons/32x32.png ${FLATPAK_DEST}/share/icons/hicolor/32x32/apps/${FLATPAK_ID}.png+ - install -Dm644 src-tauri/icons/64x64.png ${FLATPAK_DEST}/share/icons/hicolor/64x64/apps/${FLATPAK_ID}.png+ - install -Dm644 src-tauri/icons/128x128.png ${FLATPAK_DEST}/share/icons/hicolor/128x128/apps/${FLATPAK_ID}.png+ - install -Dm644 src-tauri/icons/[email protected] ${FLATPAK_DEST}/share/icons/hicolor/256x256/apps/${FLATPAK_ID}.png+ - install -Dm644 src-tauri/icons/icon.png ${FLATPAK_DEST}/share/icons/hicolor/512x512/apps/${FLATPAK_ID}.png++ - install -Dm644 LICENSE ${FLATPAK_DEST}/share/licenses/${FLATPAK_ID}/LICENSE+ sources:+ # LOCAL BUILDS: the repository two levels up, at its committed HEAD — only committed+ # files are copied, so target/, node_modules/ and anything untracked never enter the+ # build. Commit before building; set `branch:` to build another branch.+ #+ # FLATHUB: replace with the public repository at a release tag, e.g.+ # - type: git+ # url: https://github.com/YashwanthKamireddi/Pomander.git+ # tag: v0.1.0+ # commit: <full sha of that tag>+ - type: git+ path: ../..+ # Not part of the git checkout, so they work before packaging/flatpak/ is committed.+ - type: file+ path: io.github.yashwanthkamireddi.Pomander.desktop+ - type: file+ path: io.github.yashwanthkamireddi.Pomander.metainfo.xml+ # Regenerate both whenever Cargo.lock or package-lock.json changes (README).+ - cargo-sources.json+ - node-sources.jsondiff --git a/packaging/flatpak/node-sources.json b/packaging/flatpak/node-sources.jsonnew file mode 100644index 0000000..f15e404--- /dev/null+++ b/packaging/flatpak/node-sources.json@@ -0,0 +1,2058 @@+[+ {+ "type": "archive",+ "url": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",+ "strip-components": 1,+ "sha512": "94f0c6c82d493c3a2ef2419ccb06346082f35a58619d18dda1fdd495ca2a6264bd125f35f0b2df2497373d75e0647ac70802acfd9d92799b4326be4cae4c6d3b",+ "dest": "flatpak-node/cache/esbuild/.package/@esbuild/[email protected]",+ "only-arches": [+ "arm"+ ]+ },+ {+ "type": "archive",+ "url": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",+ "strip-components": 1,+ "sha512": "f1bc17edaf05821220aeea5cc5be1a5266032e9f295f4eab1a1e47a834fb6c1fbc45d7a596cea61efac51c75b624038f6546e78d4a4a4cb83a102cb3bdab3601",+ "dest": "flatpak-node/cache/esbuild/.package/@esbuild/[email protected]",+ "only-arches": [+ "aarch64"+ ]+ },+ {+ "type": "archive",+ "url": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",+ "strip-components": 1,+ "sha512": "d32f4aadd5676cc336fef1bc29f5346f285437e1050a7cbdfbc836d36818a924953289dbb027cb8d43beac2722ee933458112dcfea0afcf2301e4cf193285aac",+ "dest": "flatpak-node/cache/esbuild/.package/@esbuild/[email protected]",+ "only-arches": [+ "i386"+ ]+ },+ {+ "type": "archive",+ "url": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",+ "strip-components": 1,+ "sha512": "baa64c4cbaffcd1fde7788c81a7c122e468798f8ce8c9be79ba4d5562b406b4f122d2f59d1533cc08471ee059b241e7f279e18b883089c3aae5b262f40b66483",+ "dest": "flatpak-node/cache/esbuild/.package/@esbuild/[email protected]",+ "only-arches": [+ "x86_64"+ ]+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@axe-core/playwright/-/playwright-4.13.0.tgz",+ "sha512": "e982f1fa4c57bb918971e1b8a33160fb7ddad84313763630586968277b1bf4ab5ae69a7e64d4b9deec4656883925eb4863cb3ef8fe54aed5fe72b8bebb454056",+ "dest-filename": "f1fa4c57bb918971e1b8a33160fb7ddad84313763630586968277b1bf4ab5ae69a7e64d4b9deec4656883925eb4863cb3ef8fe54aed5fe72b8bebb454056",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e9/82"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",+ "sha512": "02ea7b69439fa5b01483644e38937a230e5ff43301973bb4988926fe66a52d014dfd84203b8f300a3d0ac5adec10726f3d5160eec891faa4489f05dddaa8502b",+ "dest-filename": "7b69439fa5b01483644e38937a230e5ff43301973bb4988926fe66a52d014dfd84203b8f300a3d0ac5adec10726f3d5160eec891faa4489f05dddaa8502b",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/02/ea"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",+ "sha512": "968713910c8abf0204801cd5ae7f3af7779b73dec5d94f191e36d7c035c9e459f64c2a4dc1394a71a28b91d1e8a7973f89c38513baaded0f490b986728d6ba1a",+ "dest-filename": "13910c8abf0204801cd5ae7f3af7779b73dec5d94f191e36d7c035c9e459f64c2a4dc1394a71a28b91d1e8a7973f89c38513baaded0f490b986728d6ba1a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/96/87"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",+ "sha512": "4601c10afb636ce2b681748d04d22436811cf6aa1512d6aede18fc804a8a42e2f71d90226ca6ab585108dcb7e6e8460a90b6a53a1f1e4ab8fd6fe721f47fd504",+ "dest-filename": "c10afb636ce2b681748d04d22436811cf6aa1512d6aede18fc804a8a42e2f71d90226ca6ab585108dcb7e6e8460a90b6a53a1f1e4ab8fd6fe721f47fd504",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/46/01"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz",+ "sha512": "8196dea6c761dd60ed8192962febd33e1ef52d206b9bf638fd00d905509c61f99e4c412ea0e630952cbe1b54ad7c983efd9cb9e74bbfdd30136e6eea0db6ccb6",+ "dest-filename": "dea6c761dd60ed8192962febd33e1ef52d206b9bf638fd00d905509c61f99e4c412ea0e630952cbe1b54ad7c983efd9cb9e74bbfdd30136e6eea0db6ccb6",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/81/96"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",+ "sha512": "c1e9ba59a063e0d69561574d84b3cf55a7044ba649f8a0417d2913303dd86716cfdeb9b70e2f39b4953996369436168eca7b7e023d31aee858bb3401b7c9fbd6",+ "dest-filename": "ba59a063e0d69561574d84b3cf55a7044ba649f8a0417d2913303dd86716cfdeb9b70e2f39b4953996369436168eca7b7e023d31aee858bb3401b7c9fbd6",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/c1/e9"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",+ "sha512": "de7415500b6f90a1fdcda85f5a0c3de8973fb853a68c0084d64433f3613696a5a61c1823cdb365b02db69ee4137da86659e42d4eae6743fe0d9ddd80d708f8cc",+ "dest-filename": "15500b6f90a1fdcda85f5a0c3de8973fb853a68c0084d64433f3613696a5a61c1823cdb365b02db69ee4137da86659e42d4eae6743fe0d9ddd80d708f8cc",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/de/74"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",+ "sha512": "7a31f0ad0418726f719d38af4a19f62033a5233227377e005ec92fabd42272f0ad133ab5573725bbfb4a17c26ad4283c246d862fafc49a382c093ee55dea44de",+ "dest-filename": "f0ad0418726f719d38af4a19f62033a5233227377e005ec92fabd42272f0ad133ab5573725bbfb4a17c26ad4283c246d862fafc49a382c093ee55dea44de",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/7a/31"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",+ "sha512": "50f5154b25db3a1eb6eca8822064128305b319e04a2e4689f4f24476b9e0230312cf12d1e234b8f9fd5fd636fb57305b83c9c52da628b6f54f1424ea76b99302",+ "dest-filename": "154b25db3a1eb6eca8822064128305b319e04a2e4689f4f24476b9e0230312cf12d1e234b8f9fd5fd636fb57305b83c9c52da628b6f54f1424ea76b99302",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/50/f5"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",+ "sha512": "1bbb0762280f635ee83b94985a77c3ff4313070551efcd52fc923ae377bf26151881581613feb54a85b7347f4a5942b22aae4b561de7a627fdf5692dea3f3a27",+ "dest-filename": "0762280f635ee83b94985a77c3ff4313070551efcd52fc923ae377bf26151881581613feb54a85b7347f4a5942b22aae4b561de7a627fdf5692dea3f3a27",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/1b/bb"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",+ "sha512": "3dbe628cfad9f3d1831fcdb6dcbe143fc8ba400a56c6cd3845b3d02537960d5d3f91e476137e8c78a9f2afa2d899452fa91448f88bfced2b85d56e84ac837363",+ "dest-filename": "628cfad9f3d1831fcdb6dcbe143fc8ba400a56c6cd3845b3d02537960d5d3f91e476137e8c78a9f2afa2d899452fa91448f88bfced2b85d56e84ac837363",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/3d/be"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",+ "sha512": "a9e8711a4463e7987f7dff0431a27e71887268a947231a980e7ebcdb0403ed1369f54ba3390b07a20dae4b4af6bf3af8a56fac5dff7435e79aca370d697ddf16",+ "dest-filename": "711a4463e7987f7dff0431a27e71887268a947231a980e7ebcdb0403ed1369f54ba3390b07a20dae4b4af6bf3af8a56fac5dff7435e79aca370d697ddf16",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a9/e8"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",+ "sha512": "37d644aeb0fec96e607820ed06a9cea31991f3eb4d2a21aec4a943a6e2717ecaa96b674571ec5ace218013faa81cb8830eb79534cba9c46992a0d972bec03783",+ "dest-filename": "44aeb0fec96e607820ed06a9cea31991f3eb4d2a21aec4a943a6e2717ecaa96b674571ec5ace218013faa81cb8830eb79534cba9c46992a0d972bec03783",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/37/d6"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",+ "sha512": "d64da500644c7c74dcc2e35870235499a51f7e642ff0a58c7e1da225451e465c25c07e0574d1bb99f3c8d7434f7cb1c9153844e13cabe26bfb9133593a23ee06",+ "dest-filename": "a500644c7c74dcc2e35870235499a51f7e642ff0a58c7e1da225451e465c25c07e0574d1bb99f3c8d7434f7cb1c9153844e13cabe26bfb9133593a23ee06",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/d6/4d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz",+ "sha512": "13c953018341d4a5be147f95189b993358a8031d84ea8565bd0151adfe4ff19666b222576000fdbd3155ef2c84511373821d5d16a319b8eead53070045ba8508",+ "dest-filename": "53018341d4a5be147f95189b993358a8031d84ea8565bd0151adfe4ff19666b222576000fdbd3155ef2c84511373821d5d16a319b8eead53070045ba8508",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/13/c9"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz",+ "sha512": "4cbd2131cf71cf2f3a543df59d48b0cdde68b5101cc843dcb1e802c6894ed0fbdc5ee1f5bf490409efd42339d816286992f539c20fe3938bf44d31057e6e777f",+ "dest-filename": "2131cf71cf2f3a543df59d48b0cdde68b5101cc843dcb1e802c6894ed0fbdc5ee1f5bf490409efd42339d816286992f539c20fe3938bf44d31057e6e777f",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/4c/bd"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz",+ "sha512": "d3a2322b4f47df08b87066e10c1c29e60506a3420ab6761af2dc9389ea618ab3c22ba7dba1b54689730c239ccb43868a1183f7c19dc0ad4e38a3ef0a32b486fd",+ "dest-filename": "322b4f47df08b87066e10c1c29e60506a3420ab6761af2dc9389ea618ab3c22ba7dba1b54689730c239ccb43868a1183f7c19dc0ad4e38a3ef0a32b486fd",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/d3/a2"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",+ "sha512": "a6eabe19fdf9a08db815e375d4b92851016abfdbb035e5a9c57662fc98b7ad1228280cca9f145a67e1a48f4bca4bd6428931127e783537d2f23b25efa3e9be1a",+ "dest-filename": "be19fdf9a08db815e375d4b92851016abfdbb035e5a9c57662fc98b7ad1228280cca9f145a67e1a48f4bca4bd6428931127e783537d2f23b25efa3e9be1a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a6/ea"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz",+ "sha512": "239cfb1f76dfff8d64b6c3552eda4dd3001adf7e8792a20743906e3cb1214e4b758d54b266978d288cd38045a69718dd83cd51d0881409c684f8e93736fadf66",+ "dest-filename": "fb1f76dfff8d64b6c3552eda4dd3001adf7e8792a20743906e3cb1214e4b758d54b266978d288cd38045a69718dd83cd51d0881409c684f8e93736fadf66",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/23/9c"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",+ "sha512": "563d6317770f7f183b3807e823b42754a2e820b966d8917da67547ad7f2ac7b0073226164fe343000ee30a194d8114b85932dcfdf0f59572e63e2c65ba3fb71a",+ "dest-filename": "6317770f7f183b3807e823b42754a2e820b966d8917da67547ad7f2ac7b0073226164fe343000ee30a194d8114b85932dcfdf0f59572e63e2c65ba3fb71a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/56/3d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",+ "sha512": "1e19b077a0889d9dddc29b864c5f1f246eb2a169ac4e813ebd8803e27cad655c5cbb5ba51e9510440075509f3e375026dcccf8fb1381ca84284997f80fe0a990",+ "dest-filename": "b077a0889d9dddc29b864c5f1f246eb2a169ac4e813ebd8803e27cad655c5cbb5ba51e9510440075509f3e375026dcccf8fb1381ca84284997f80fe0a990",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/1e/19"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",+ "sha512": "549fac2af340fc613b09c69c73d0a16bb6e94bc9f2cd5bf48dd560c0d0da478803302ff64d345cdf7229f2aacd61472990e1d44f9399d1b51c34d55943d44b96",+ "dest-filename": "ac2af340fc613b09c69c73d0a16bb6e94bc9f2cd5bf48dd560c0d0da478803302ff64d345cdf7229f2aacd61472990e1d44f9399d1b51c34d55943d44b96",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/54/9f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",+ "sha512": "e800262c6ef3c03d59d79f6308a3ef03165de32fd54ced15929ad8cbedcdd85b49f3e0505855d4f8ec40448c00e3a739b5d0fd4ac28667fd6872a052fe000a1e",+ "dest-filename": "262c6ef3c03d59d79f6308a3ef03165de32fd54ced15929ad8cbedcdd85b49f3e0505855d4f8ec40448c00e3a739b5d0fd4ac28667fd6872a052fe000a1e",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e8/00"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",+ "sha512": "e636dbfb68610c7c79a61611d81cbc193584ce7e88f54a91d752b07f6da229b36962bb26441d7c697ffd8af73971a6dc522013ff033e60867a486f503ba6bc92",+ "dest-filename": "dbfb68610c7c79a61611d81cbc193584ce7e88f54a91d752b07f6da229b36962bb26441d7c697ffd8af73971a6dc522013ff033e60867a486f503ba6bc92",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e6/36"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",+ "sha512": "377ce5fa5c470a27e022570c50fe74d7a11291e4232e3ffde7d471c4d608b61220f82407227ba316e5de59b58c8274e8e1ca795d51ea14f9a9caef49eb90b562",+ "dest-filename": "e5fa5c470a27e022570c50fe74d7a11291e4232e3ffde7d471c4d608b61220f82407227ba316e5de59b58c8274e8e1ca795d51ea14f9a9caef49eb90b562",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/37/7c"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",+ "sha512": "1d0f646b82b1db5a875f0b654d455b2893809e61b58a95e17564e635788fccf7d62a95ea01255c59d9dfd9b9cbef7c208cdac55c06b7c98bc149df69cdf108a4",+ "dest-filename": "646b82b1db5a875f0b654d455b2893809e61b58a95e17564e635788fccf7d62a95ea01255c59d9dfd9b9cbef7c208cdac55c06b7c98bc149df69cdf108a4",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/1d/0f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",+ "sha512": "800d01c7be7dfbb26f7b4dcad52d2f90ebb92e0ffce5da2edc4b1e38651eb3c7e554e1b16e10c387f8996a87a4d7563c9adc8a3c6177bcff178679031009b37a",+ "dest-filename": "01c7be7dfbb26f7b4dcad52d2f90ebb92e0ffce5da2edc4b1e38651eb3c7e554e1b16e10c387f8996a87a4d7563c9adc8a3c6177bcff178679031009b37a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/80/0d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",+ "sha512": "4c66cedba630db1b07cf1b5b5451845c1147d054403fb82d70f13b3f9c8fef01b2edc5cada83bb4723a12f934b8aa4e5061e3b5e1988517b867225c4a9815f05",+ "dest-filename": "cedba630db1b07cf1b5b5451845c1147d054403fb82d70f13b3f9c8fef01b2edc5cada83bb4723a12f934b8aa4e5061e3b5e1988517b867225c4a9815f05",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/4c/66"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",+ "sha512": "94f0c6c82d493c3a2ef2419ccb06346082f35a58619d18dda1fdd495ca2a6264bd125f35f0b2df2497373d75e0647ac70802acfd9d92799b4326be4cae4c6d3b",+ "dest-filename": "c6c82d493c3a2ef2419ccb06346082f35a58619d18dda1fdd495ca2a6264bd125f35f0b2df2497373d75e0647ac70802acfd9d92799b4326be4cae4c6d3b",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/94/f0"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",+ "sha512": "f1bc17edaf05821220aeea5cc5be1a5266032e9f295f4eab1a1e47a834fb6c1fbc45d7a596cea61efac51c75b624038f6546e78d4a4a4cb83a102cb3bdab3601",+ "dest-filename": "17edaf05821220aeea5cc5be1a5266032e9f295f4eab1a1e47a834fb6c1fbc45d7a596cea61efac51c75b624038f6546e78d4a4a4cb83a102cb3bdab3601",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/f1/bc"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",+ "sha512": "d32f4aadd5676cc336fef1bc29f5346f285437e1050a7cbdfbc836d36818a924953289dbb027cb8d43beac2722ee933458112dcfea0afcf2301e4cf193285aac",+ "dest-filename": "4aadd5676cc336fef1bc29f5346f285437e1050a7cbdfbc836d36818a924953289dbb027cb8d43beac2722ee933458112dcfea0afcf2301e4cf193285aac",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/d3/2f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",+ "sha512": "87ffff2ebe5af6b89bfefd461aa5d51b38cbe1332f553bfeb350cfa3141dcfb97f018bfa2c34b1748c33c64acf5b8dfca145e20edc0cd74a3d3e6c12ffa67436",+ "dest-filename": "ff2ebe5af6b89bfefd461aa5d51b38cbe1332f553bfeb350cfa3141dcfb97f018bfa2c34b1748c33c64acf5b8dfca145e20edc0cd74a3d3e6c12ffa67436",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/87/ff"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",+ "sha512": "8b246b3353f3cbd1853032ec5e7d621d49b5f2784a9cd316b1c8e6a78fa1a5a7dc663aebd966d3fff776d316869635c30581ea45c97c1e7c5b5fab9a03f78657",+ "dest-filename": "6b3353f3cbd1853032ec5e7d621d49b5f2784a9cd316b1c8e6a78fa1a5a7dc663aebd966d3fff776d316869635c30581ea45c97c1e7c5b5fab9a03f78657",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/8b/24"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",+ "sha512": "f6678cfe5457c4c8b93d252a117442b558c46411b007b3ff0f8c93f141bf9b021dcded9a578568e94e600f7f91b281d72a41c27d2c592b3983b2c565463d5040",+ "dest-filename": "8cfe5457c4c8b93d252a117442b558c46411b007b3ff0f8c93f141bf9b021dcded9a578568e94e600f7f91b281d72a41c27d2c592b3983b2c565463d5040",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/f6/67"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",+ "sha512": "66beca478860294a560306f57f7a39ca04f4e0ccea56b18419718b9e3d796100c912b62efc11a0fb09859480ce749a743e607494bbf1148397660151add8d1d3",+ "dest-filename": "ca478860294a560306f57f7a39ca04f4e0ccea56b18419718b9e3d796100c912b62efc11a0fb09859480ce749a743e607494bbf1148397660151add8d1d3",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/66/be"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",+ "sha512": "32c2a770e7204cdbddb6221273f8d9b3f65ff1dd1c97fb77818597f09f6e6c19d53b0964eb9508104be004e4538a58e5a085a70732ece2a8733e425c8ad23322",+ "dest-filename": "a770e7204cdbddb6221273f8d9b3f65ff1dd1c97fb77818597f09f6e6c19d53b0964eb9508104be004e4538a58e5a085a70732ece2a8733e425c8ad23322",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/32/c2"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",+ "sha512": "baa64c4cbaffcd1fde7788c81a7c122e468798f8ce8c9be79ba4d5562b406b4f122d2f59d1533cc08471ee059b241e7f279e18b883089c3aae5b262f40b66483",+ "dest-filename": "4c4cbaffcd1fde7788c81a7c122e468798f8ce8c9be79ba4d5562b406b4f122d2f59d1533cc08471ee059b241e7f279e18b883089c3aae5b262f40b66483",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/ba/a6"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",+ "sha512": "c57c1c4eae0685133b27d03c1afe5ba1a9c78516bf43d28b5667325c709368ce3029f2295a475788ca20fcab27c73274035fa70fece879cbb3a8f9824720468e",+ "dest-filename": "1c4eae0685133b27d03c1afe5ba1a9c78516bf43d28b5667325c709368ce3029f2295a475788ca20fcab27c73274035fa70fece879cbb3a8f9824720468e",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/c5/7c"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",+ "sha512": "2dde694e5ccfcb763019e7383ae1e1d5a095091bce5dd1fc0e04637c3cbfa2e995a2f9ae4b359f9d2260f95b5a901f429b483134ef41cd6923ea6b4ed4531791",+ "dest-filename": "694e5ccfcb763019e7383ae1e1d5a095091bce5dd1fc0e04637c3cbfa2e995a2f9ae4b359f9d2260f95b5a901f429b483134ef41cd6923ea6b4ed4531791",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/2d/de"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",+ "sha512": "7c5f7a4fa2ac068fe991023de74140454f5aa463534a5646b2fd6364102570b2f530b8cb34858f0648f93654b3f1a03360a83e78daa49eb509db8401c9b791e4",+ "dest-filename": "7a4fa2ac068fe991023de74140454f5aa463534a5646b2fd6364102570b2f530b8cb34858f0648f93654b3f1a03360a83e78daa49eb509db8401c9b791e4",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/7c/5f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",+ "sha512": "319c975246478d0c54bf32bbacdf032774919ab56b91ef19c91bac1e53fe92ec2a4dc7d62f2a8c384dec49c3cfc9e21737f9832487c65ef70ca8281829e92843",+ "dest-filename": "975246478d0c54bf32bbacdf032774919ab56b91ef19c91bac1e53fe92ec2a4dc7d62f2a8c384dec49c3cfc9e21737f9832487c65ef70ca8281829e92843",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/31/9c"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",+ "sha512": "ae6d185aca94491ae39dc497180ed9bfbf0d6e7c385cbebf773af6d1ccab41fed999172ca2fa5c4417610f8dcdba4df2ed72285b63b1315bf0b91be4f577404a",+ "dest-filename": "185aca94491ae39dc497180ed9bfbf0d6e7c385cbebf773af6d1ccab41fed999172ca2fa5c4417610f8dcdba4df2ed72285b63b1315bf0b91be4f577404a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/ae/6d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",+ "sha512": "df0192083cae4c7414cedd2757b6e8703cbbdabda5237dd02f78240cd1a4a1ddb612c625d38b0c7f4a8b6fc96e34a4ce9a017f7831033f9045370a01287e38d7",+ "dest-filename": "92083cae4c7414cedd2757b6e8703cbbdabda5237dd02f78240cd1a4a1ddb612c625d38b0c7f4a8b6fc96e34a4ce9a017f7831033f9045370a01287e38d7",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/df/01"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",+ "sha512": "acc98baeeafae00efe0ca9674aec2a51d44ac9ddd413ba0f2599a7963a84a6d7ac28cf30c7d27c831e6ed3ef4fab47d0416f2fa9e29e6f035775f3b23fef01b2",+ "dest-filename": "8baeeafae00efe0ca9674aec2a51d44ac9ddd413ba0f2599a7963a84a6d7ac28cf30c7d27c831e6ed3ef4fab47d0416f2fa9e29e6f035775f3b23fef01b2",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/ac/c9"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",+ "sha512": "1e4aa79a606809b0b0c5428a34f062c62583182a50195b2b41f26854660b3d3e355d617c947b84e4de9685589ada7e28e502b9338b58af6d7cdbb7cd862e1bc9",+ "dest-filename": "a79a606809b0b0c5428a34f062c62583182a50195b2b41f26854660b3d3e355d617c947b84e4de9685589ada7e28e502b9338b58af6d7cdbb7cd862e1bc9",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/1e/4a"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",+ "sha512": "6a5242d2e099a5316b48bd020838dc8257815cf9c2ac40214c120ba5e029eccfce160a2ab407ad7c1cd7d31334d0c52c5553e956394fb8c6d112a9d90976939c",+ "dest-filename": "42d2e099a5316b48bd020838dc8257815cf9c2ac40214c120ba5e029eccfce160a2ab407ad7c1cd7d31334d0c52c5553e956394fb8c6d112a9d90976939c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/6a/52"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",+ "sha512": "da492dffb9e227a32010fc45d1b61d43a7ad65a03e7d0bc370b29c921cb5c8840ecdaa0a8c10634a3eb7fda2d58d8137aa146de5dbccfae5327c283a50a0816c",+ "dest-filename": "2dffb9e227a32010fc45d1b61d43a7ad65a03e7d0bc370b29c921cb5c8840ecdaa0a8c10634a3eb7fda2d58d8137aa146de5dbccfae5327c283a50a0816c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/da/49"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",+ "sha512": "2c8f6effe95a606e03b354c3292256d983eb22571560ec22d9f502eb1078de5b9e0a383157895f7ce0990ad605887e9334e5feb50297c7ded3e082876e1c8711",+ "dest-filename": "6effe95a606e03b354c3292256d983eb22571560ec22d9f502eb1078de5b9e0a383157895f7ce0990ad605887e9334e5feb50297c7ded3e082876e1c8711",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/2c/8f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",+ "sha512": "6d12128022233f6d3fb5b5923d63048b9e1054f45913192e0fd9492fe508c542adc15240f305b54eb6f58ccb354455e8d42053359ff98690bd42f98a59da292b",+ "dest-filename": "128022233f6d3fb5b5923d63048b9e1054f45913192e0fd9492fe508c542adc15240f305b54eb6f58ccb354455e8d42053359ff98690bd42f98a59da292b",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/6d/12"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz",+ "sha512": "4fb8dffb9ce0b191f0349e25bd0eff69ecdbca4d27357fb32555a998703b558b04c7b6bbaabe5183921bb4916a920cdee58dacaeeab545463c43cdfb39dee217",+ "dest-filename": "dffb9ce0b191f0349e25bd0eff69ecdbca4d27357fb32555a998703b558b04c7b6bbaabe5183921bb4916a920cdee58dacaeeab545463c43cdfb39dee217",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/4f/b8"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",+ "sha512": "cf3351f9275048327373c8e869e3fc410a0242bf0db98c76748232b65d507811191c9f6e5ba85e6ecad881bcfc849c1441aa374d608cb667d5f0dbb5b7038b03",+ "dest-filename": "51f9275048327373c8e869e3fc410a0242bf0db98c76748232b65d507811191c9f6e5ba85e6ecad881bcfc849c1441aa374d608cb667d5f0dbb5b7038b03",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/cf/33"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",+ "sha512": "a135c42216b84acb97753038232b248f4929771db255776177be5cdafdf11ab1c57d532c6e14cf654fe730f2f8b162a8e290479b76ae70b6aa1a517af7a753c9",+ "dest-filename": "c42216b84acb97753038232b248f4929771db255776177be5cdafdf11ab1c57d532c6e14cf654fe730f2f8b162a8e290479b76ae70b6aa1a517af7a753c9",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a1/35"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",+ "sha512": "f9dd05e0c28c09b795509c06f7ab90e12800ce764d4aaf7723757ef4d1c0e0ea6fa86f26442a4674a98af25fdd974da1d820831f05b616a8a59d3c837009ea8c",+ "dest-filename": "05e0c28c09b795509c06f7ab90e12800ce764d4aaf7723757ef4d1c0e0ea6fa86f26442a4674a98af25fdd974da1d820831f05b616a8a59d3c837009ea8c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/f9/dd"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.2.tgz",+ "sha512": "5dae910e859afa13625fa3e0b258e51fa5bbe5168e371df2e8f5656cb8641165be19a3d0ddd3f98306cbfdeac0cd01d6c24bd6e54c5d0f997ced0c7614043fe0",+ "dest-filename": "910e859afa13625fa3e0b258e51fa5bbe5168e371df2e8f5656cb8641165be19a3d0ddd3f98306cbfdeac0cd01d6c24bd6e54c5d0f997ced0c7614043fe0",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/5d/ae"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.2.tgz",+ "sha512": "bcd012c6c82131f439b3ebf73eba6725dfabc8bff6ea5c4209a188fac0c9ed5ce61e261722bad596db0385a6b0c4b33559ca0c536a1895b3c72da610b41ce172",+ "dest-filename": "12c6c82131f439b3ebf73eba6725dfabc8bff6ea5c4209a188fac0c9ed5ce61e261722bad596db0385a6b0c4b33559ca0c536a1895b3c72da610b41ce172",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/bc/d0"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.2.tgz",+ "sha512": "d1d5838e696ba590208cf0ff68fcd40e1056f003cb4630278b96ceaccefac228999be13e29331528d840cda4c1a21cfc5323b67ca340974f9fca06ded8765738",+ "dest-filename": "838e696ba590208cf0ff68fcd40e1056f003cb4630278b96ceaccefac228999be13e29331528d840cda4c1a21cfc5323b67ca340974f9fca06ded8765738",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/d1/d5"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.2.tgz",+ "sha512": "379f2e92d730ce4dfea93e0a1c4b8d748c57d4dd35456ae47d5a2697af4401b49a3432feb1b3552f1d91325e10776de5a40d1f80fbf28798476f8c1e0f958a9a",+ "dest-filename": "2e92d730ce4dfea93e0a1c4b8d748c57d4dd35456ae47d5a2697af4401b49a3432feb1b3552f1d91325e10776de5a40d1f80fbf28798476f8c1e0f958a9a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/37/9f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.2.tgz",+ "sha512": "1d6176cc7f04029dac716469b763c67ba8941b3ef38b4e30697b1d46bdf36f80d60a4d88988a39159bb48e3983e779cffc3192be75b47bbff54e808d66cda567",+ "dest-filename": "76cc7f04029dac716469b763c67ba8941b3ef38b4e30697b1d46bdf36f80d60a4d88988a39159bb48e3983e779cffc3192be75b47bbff54e808d66cda567",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/1d/61"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.2.tgz",+ "sha512": "324bdcc07327ccf48c39013007ac079cbce673e853f0119ce5b5bf3219a38e0c77c1b8fa5419e5738ed7b0aef8903d0af4c8a415f5e942acb3e0d5176945bad8",+ "dest-filename": "dcc07327ccf48c39013007ac079cbce673e853f0119ce5b5bf3219a38e0c77c1b8fa5419e5738ed7b0aef8903d0af4c8a415f5e942acb3e0d5176945bad8",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/32/4b"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.2.tgz",+ "sha512": "c5ed5b08a3c968ab03d2d7dded16fa6c67d4a20253a4a6d3104b61b1f75bee14df4d13495504dd8ab69b431d28e844556dafec9a433bdb4b28318fb4427ae549",+ "dest-filename": "5b08a3c968ab03d2d7dded16fa6c67d4a20253a4a6d3104b61b1f75bee14df4d13495504dd8ab69b431d28e844556dafec9a433bdb4b28318fb4427ae549",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/c5/ed"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.2.tgz",+ "sha512": "c8e33b2dd2b4a7a824ebe43bef7384c2d96c8a44f54cbdf232662c4ed4650d13e16b9bd5d830b9c7b2ea4560ebe9fddc49834c295ab1cdf7d7bfc8afc4d04815",+ "dest-filename": "3b2dd2b4a7a824ebe43bef7384c2d96c8a44f54cbdf232662c4ed4650d13e16b9bd5d830b9c7b2ea4560ebe9fddc49834c295ab1cdf7d7bfc8afc4d04815",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/c8/e3"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.2.tgz",+ "sha512": "aa25ae2495770f26c0d887f3bd18a678a5c6ac6b953efd73a1b498ff6e8a9cfdc76d5d1570d6f7102ce0bed6ef177c6348c91ca28a2ee870125d9b8b7639e1a5",+ "dest-filename": "ae2495770f26c0d887f3bd18a678a5c6ac6b953efd73a1b498ff6e8a9cfdc76d5d1570d6f7102ce0bed6ef177c6348c91ca28a2ee870125d9b8b7639e1a5",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/aa/25"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.2.tgz",+ "sha512": "6a4719aae473098fcaa54a1900c06119fee88b82e65ead41cd103908f002deb9147f6f18fec0185778d22fe24a77b73013216f4791b45d567481a31e74ffbad0",+ "dest-filename": "19aae473098fcaa54a1900c06119fee88b82e65ead41cd103908f002deb9147f6f18fec0185778d22fe24a77b73013216f4791b45d567481a31e74ffbad0",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/6a/47"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.2.tgz",+ "sha512": "7cdc181eb3f2632c5ab8fcd7fdca58c3c67b2d0a69f83180d0a0a8b30034695141a6674c8a5f5782307c577372eb8221bbbf7bf8629cb89aa7b0e2849a8afb7c",+ "dest-filename": "181eb3f2632c5ab8fcd7fdca58c3c67b2d0a69f83180d0a0a8b30034695141a6674c8a5f5782307c577372eb8221bbbf7bf8629cb89aa7b0e2849a8afb7c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/7c/dc"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.2.tgz",+ "sha512": "5dfbec83347b0d9a9111db2decad4c8f78a5494339c4b00725c20c0c53ca7714ecf6ae551ce4fc68c03e6baf377ea06eec3425f3e49df470ac4182fc10c63da8",+ "dest-filename": "ec83347b0d9a9111db2decad4c8f78a5494339c4b00725c20c0c53ca7714ecf6ae551ce4fc68c03e6baf377ea06eec3425f3e49df470ac4182fc10c63da8",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/5d/fb"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.2.tgz",+ "sha512": "3e9ee055982010595b72eced6b2fbf5348151bd4b55c087c8bb23545efe1b5b033a38dcfe701d91f0ea94f2ce8b484aa94aa21a21f51a487e73b3dd16de98ad7",+ "dest-filename": "e055982010595b72eced6b2fbf5348151bd4b55c087c8bb23545efe1b5b033a38dcfe701d91f0ea94f2ce8b484aa94aa21a21f51a487e73b3dd16de98ad7",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/3e/9e"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.2.tgz",+ "sha512": "ce480bdb17dfea2eeee616aefe6e8519e4bc81190b11d80bc39db658699d59694b77d6ed98d9774bcd267048ed1aafa4be051e910dfe04e60b2cb70f952d8b20",+ "dest-filename": "0bdb17dfea2eeee616aefe6e8519e4bc81190b11d80bc39db658699d59694b77d6ed98d9774bcd267048ed1aafa4be051e910dfe04e60b2cb70f952d8b20",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/ce/48"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.2.tgz",+ "sha512": "a8e85e2689ab91509b6c7149ecbdc9f7b72785fa202aa82e010a61bf6ebedd9b004081752f5f5bf9d02b97ffecf2b8c91c92f3f5bcb293233c3413f89e649ad6",+ "dest-filename": "5e2689ab91509b6c7149ecbdc9f7b72785fa202aa82e010a61bf6ebedd9b004081752f5f5bf9d02b97ffecf2b8c91c92f3f5bcb293233c3413f89e649ad6",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a8/e8"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.2.tgz",+ "sha512": "5e5c4b0f9e304211f715c88280ca1fc41c36ecdcd47bcd7c8091f8d74a96bdce35513d1915c831563c97e7f10af0c3d3ba98de556a8de68cbef69080f66a9f08",+ "dest-filename": "4b0f9e304211f715c88280ca1fc41c36ecdcd47bcd7c8091f8d74a96bdce35513d1915c831563c97e7f10af0c3d3ba98de556a8de68cbef69080f66a9f08",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/5e/5c"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.2.tgz",+ "sha512": "bddaf259e45bd9b2c965fd05bff5bcb1eea7bec1ded8f9130b157499e85e2b79d013e1bdd150897247b9d4c8b2d72411b1f9b6baa2328d73aee30994cdb4ed91",+ "dest-filename": "f259e45bd9b2c965fd05bff5bcb1eea7bec1ded8f9130b157499e85e2b79d013e1bdd150897247b9d4c8b2d72411b1f9b6baa2328d73aee30994cdb4ed91",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/bd/da"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.2.tgz",+ "sha512": "6dcab6876a642a61f6a68e1c655f155b33b894be34493caefe72e816960c429f42dad09535375c56ff3a3304ac9f70f9b351417b64f2d5ab6abd50144cc8a636",+ "dest-filename": "b6876a642a61f6a68e1c655f155b33b894be34493caefe72e816960c429f42dad09535375c56ff3a3304ac9f70f9b351417b64f2d5ab6abd50144cc8a636",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/6d/ca"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.2.tgz",+ "sha512": "106a28e4331531191321df1fb930daa31565479653b0a50b51ecd18ddf600b0e5e798f838c2bc3a5900e94d52f28f197fbbad2d515b1ea3fb23a934fc7471481",+ "dest-filename": "28e4331531191321df1fb930daa31565479653b0a50b51ecd18ddf600b0e5e798f838c2bc3a5900e94d52f28f197fbbad2d515b1ea3fb23a934fc7471481",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/10/6a"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.2.tgz",+ "sha512": "304ae5d7693b0451d91b54c8f5017fde5492640473abd2a0372fc58e7a8530292ff8de11492ce85020398769aa1d7e0ca31dd669354a6e5cb3850d7345bd99b9",+ "dest-filename": "e5d7693b0451d91b54c8f5017fde5492640473abd2a0372fc58e7a8530292ff8de11492ce85020398769aa1d7e0ca31dd669354a6e5cb3850d7345bd99b9",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/30/4a"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.2.tgz",+ "sha512": "20bb3c934ed6878a743ec358e3060b11a5d928c3a9561ac6e500c1d321e11a1bb339f0e59f21cdeac7e52f8125fcca543f5cbcb98da5519aefe28052ea94d3de",+ "dest-filename": "3c934ed6878a743ec358e3060b11a5d928c3a9561ac6e500c1d321e11a1bb339f0e59f21cdeac7e52f8125fcca543f5cbcb98da5519aefe28052ea94d3de",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/20/bb"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.2.tgz",+ "sha512": "84a801de7cff4ca0f75afefc5c4b325f342c363be13879b02904ef5c00c63b253f7080a56433bb0eca2081b7662433c6a7957cd2d03755fbfad4f68a4cb1f72c",+ "dest-filename": "01de7cff4ca0f75afefc5c4b325f342c363be13879b02904ef5c00c63b253f7080a56433bb0eca2081b7662433c6a7957cd2d03755fbfad4f68a4cb1f72c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/84/a8"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.2.tgz",+ "sha512": "4f8c1fd66b9d203c4df10fc25880490b5bb981051cfabe663ef970a126c8bcd9325533f64c015ea1b126b2de4043880cc80cf8b1207255da130dfbd39862bff2",+ "dest-filename": "1fd66b9d203c4df10fc25880490b5bb981051cfabe663ef970a126c8bcd9325533f64c015ea1b126b2de4043880cc80cf8b1207255da130dfbd39862bff2",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/4f/8c"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.2.tgz",+ "sha512": "b42dc863baa8683f4b977ffc589427e3d8f95767ff36e23d4b8d4d384da233930fb37b0f22f3a4553a0b733ffb073e29c85ecf4afaedc2ef08fe952b18e49e71",+ "dest-filename": "c863baa8683f4b977ffc589427e3d8f95767ff36e23d4b8d4d384da233930fb37b0f22f3a4553a0b733ffb073e29c85ecf4afaedc2ef08fe952b18e49e71",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/b4/2d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.2.tgz",+ "sha512": "e8d1e793f2b77aad99158714d57f20ebbb3da8825108e4d3f768302cc541a74f1d076baebb0235fd0fde9a9ccbd817ebd9fd9644b255c29a7dd1199a710c8593",+ "dest-filename": "e793f2b77aad99158714d57f20ebbb3da8825108e4d3f768302cc541a74f1d076baebb0235fd0fde9a9ccbd817ebd9fd9644b255c29a7dd1199a710c8593",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e8/d1"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/api/-/api-2.11.1.tgz",+ "sha512": "33614fb98343da6fb087985f5bd66949dc4c3dd109a2f3c15b0a07266c14a72b1360d1da3a4545378d7d9bf2b42c88236ffeca536bc182c51ea495ae8100af00",+ "dest-filename": "4fb98343da6fb087985f5bd66949dc4c3dd109a2f3c15b0a07266c14a72b1360d1da3a4545378d7d9bf2b42c88236ffeca536bc182c51ea495ae8100af00",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/33/61"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-darwin-arm64/-/cli-darwin-arm64-2.11.4.tgz",+ "sha512": "d6bc8e177661a59fe77a61d5e73570050073f630c62a628fbd63c00ce85cf378a0d0fe1b31cda2111e0d6c2eabf6c8de219e91550e20dd164862f7b385c9784d",+ "dest-filename": "8e177661a59fe77a61d5e73570050073f630c62a628fbd63c00ce85cf378a0d0fe1b31cda2111e0d6c2eabf6c8de219e91550e20dd164862f7b385c9784d",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/d6/bc"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-darwin-x64/-/cli-darwin-x64-2.11.4.tgz",+ "sha512": "b85b0640001fbb2cf593fc862e69167e406580a02a65fc6a94798b5b1f35414dbb44959f99b347088abc4fcc357be542965788b99523a4759fa04e04dc32e8dc",+ "dest-filename": "0640001fbb2cf593fc862e69167e406580a02a65fc6a94798b5b1f35414dbb44959f99b347088abc4fcc357be542965788b99523a4759fa04e04dc32e8dc",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/b8/5b"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm-gnueabihf/-/cli-linux-arm-gnueabihf-2.11.4.tgz",+ "sha512": "21a1d99f909d04bdb5a149a3895392d5cb70e88a753b4a63a7bd05c0e5a6633d66c967b4498f7a6488f61587fba53d26f1b23687f86bb3965b1175e1e38fcc91",+ "dest-filename": "d99f909d04bdb5a149a3895392d5cb70e88a753b4a63a7bd05c0e5a6633d66c967b4498f7a6488f61587fba53d26f1b23687f86bb3965b1175e1e38fcc91",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/21/a1"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-gnu/-/cli-linux-arm64-gnu-2.11.4.tgz",+ "sha512": "378d7fba44d155ee974ae513112b8574678e5b68bb93adad2beea01cae4a779feae513efbe2d7d19a58054f3dbf6ef791d21a64c2852a2505fcf29d4b2cb0568",+ "dest-filename": "7fba44d155ee974ae513112b8574678e5b68bb93adad2beea01cae4a779feae513efbe2d7d19a58054f3dbf6ef791d21a64c2852a2505fcf29d4b2cb0568",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/37/8d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.11.4.tgz",+ "sha512": "bf6efb5274ff7c1eb8c407d2ae82f93772a6ded2e6bc04d6a89270ff0448fa0ea8f8791e0f4b25c84ee03a136cd4c6e3138d51edb40e4f1315a0bddaa265099b",+ "dest-filename": "fb5274ff7c1eb8c407d2ae82f93772a6ded2e6bc04d6a89270ff0448fa0ea8f8791e0f4b25c84ee03a136cd4c6e3138d51edb40e4f1315a0bddaa265099b",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/bf/6e"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-linux-riscv64-gnu/-/cli-linux-riscv64-gnu-2.11.4.tgz",+ "sha512": "aaa80d910daed72647c63871b196b152d4435bc748a88626df7af1fe6cf042fd127d8f71d41fa2ada8fcbd67858978e349556110c7a95d23adb354ea3f3bd735",+ "dest-filename": "0d910daed72647c63871b196b152d4435bc748a88626df7af1fe6cf042fd127d8f71d41fa2ada8fcbd67858978e349556110c7a95d23adb354ea3f3bd735",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/aa/a8"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-linux-x64-gnu/-/cli-linux-x64-gnu-2.11.4.tgz",+ "sha512": "d9544d5a5f3814e1f49b682288390eda1d105e570c25e5fecc90e9239903210031eacfa0785defe3c1780d77c97b3e064bf15da031a73e7c350b689819b43b6d",+ "dest-filename": "4d5a5f3814e1f49b682288390eda1d105e570c25e5fecc90e9239903210031eacfa0785defe3c1780d77c97b3e064bf15da031a73e7c350b689819b43b6d",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/d9/54"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-linux-x64-musl/-/cli-linux-x64-musl-2.11.4.tgz",+ "sha512": "a3d1b2858a2bfe773bc5aae6c0313791adaccee5b7bae6735e31d687ae10f185f902d4a0c5d424156ceb6383bc2a21ad54dbc5048d781f7438f508f94ce20ffc",+ "dest-filename": "b2858a2bfe773bc5aae6c0313791adaccee5b7bae6735e31d687ae10f185f902d4a0c5d424156ceb6383bc2a21ad54dbc5048d781f7438f508f94ce20ffc",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a3/d1"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-win32-arm64-msvc/-/cli-win32-arm64-msvc-2.11.4.tgz",+ "sha512": "95de4485be7df26d15918cb29513cd78216c05efe49b48f18ace8a80ca65dc8198e88fe2d51c105ced3923502c5d45ced960ba02f07f2f0e2a4dffdab22b8489",+ "dest-filename": "4485be7df26d15918cb29513cd78216c05efe49b48f18ace8a80ca65dc8198e88fe2d51c105ced3923502c5d45ced960ba02f07f2f0e2a4dffdab22b8489",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/95/de"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-win32-ia32-msvc/-/cli-win32-ia32-msvc-2.11.4.tgz",+ "sha512": "d761f18b45d7fc7e551713bf6c68079055a19a5f5532010ebbd0a2763782793350d65e9fa5495b8868123fb08b2373c5b56f7f15f6de1e2799fa4c962b91fb08",+ "dest-filename": "f18b45d7fc7e551713bf6c68079055a19a5f5532010ebbd0a2763782793350d65e9fa5495b8868123fb08b2373c5b56f7f15f6de1e2799fa4c962b91fb08",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/d7/61"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli-win32-x64-msvc/-/cli-win32-x64-msvc-2.11.4.tgz",+ "sha512": "faf0e2a81214e5d3084a0ff036f5f7b05f991df809189e53d0070ef841cd5d5f461801be3f97f3a1d9435c3dd074a091819c4ca029b93cfbe3dc1a8b36306d87",+ "dest-filename": "e2a81214e5d3084a0ff036f5f7b05f991df809189e53d0070ef841cd5d5f461801be3f97f3a1d9435c3dd074a091819c4ca029b93cfbe3dc1a8b36306d87",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/fa/f0"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/cli/-/cli-2.11.4.tgz",+ "sha512": "47cc46b4ca70c9eb5ac12aa6f6460eb8c984aa48546ef714cbc9f468d5c8c689652812c4494bb97f8171fbae218004989b51fe8d25aaea3096eb3a939c7ea1a9",+ "dest-filename": "46b4ca70c9eb5ac12aa6f6460eb8c984aa48546ef714cbc9f468d5c8c689652812c4494bb97f8171fbae218004989b51fe8d25aaea3096eb3a939c7ea1a9",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/47/cc"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@tauri-apps/plugin-dialog/-/plugin-dialog-2.7.3.tgz",+ "sha512": "091804fbb4cfe2dbeaf4c8c153a7f4e0d2d3148a9530b287937840aa5862974d2780af40093ad73c7de81e928c3eba3120ba1d77762306829b330488e0811c7c",+ "dest-filename": "04fbb4cfe2dbeaf4c8c153a7f4e0d2d3148a9530b287937840aa5862974d2780af40093ad73c7de81e928c3eba3120ba1d77762306829b330488e0811c7c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/09/18"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",+ "sha512": "aa8429ad9bf3e70405270303a9eb1e4575afdeba8cbe18296d715f5725a16f1f57e3b3ce200ea2ffe75779f12664aa0080e69375a22035232a30853ad72472cc",+ "dest-filename": "29ad9bf3e70405270303a9eb1e4575afdeba8cbe18296d715f5725a16f1f57e3b3ce200ea2ffe75779f12664aa0080e69375a22035232a30853ad72472cc",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/aa/84"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",+ "sha512": "b9f15dd978bdd8e0153d8b32f8fe27eff53b7baf1f7b1d3e11ef20486f4a5fb7a8d3ce025a2438b1dc64b6f765d1b38fba95ed5493d8d7dce4e84c16a9443c96",+ "dest-filename": "5dd978bdd8e0153d8b32f8fe27eff53b7baf1f7b1d3e11ef20486f4a5fb7a8d3ce025a2438b1dc64b6f765d1b38fba95ed5493d8d7dce4e84c16a9443c96",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/b9/f1"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",+ "sha512": "87f354692c86e44cb1048a7c611c68e1131edbfa9082fca8c11c1533385884108e35b5bc3d4b20e2590532b86066151ee73dcbdcc88b0eebf227f09a3dad80f0",+ "dest-filename": "54692c86e44cb1048a7c611c68e1131edbfa9082fca8c11c1533385884108e35b5bc3d4b20e2590532b86066151ee73dcbdcc88b0eebf227f09a3dad80f0",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/87/f3"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",+ "sha512": "f0fbdc5dfef48130d9060b7da6dc49f1e9417818dc2ce01c3ada0efe63c98ed8e2d7e09d19b1e09bbee89b51abb0fc6c884fae5c8a4d48aeb8518688c105dde1",+ "dest-filename": "dc5dfef48130d9060b7da6dc49f1e9417818dc2ce01c3ada0efe63c98ed8e2d7e09d19b1e09bbee89b51abb0fc6c884fae5c8a4d48aeb8518688c105dde1",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/f0/fb"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",+ "sha512": "1a174f832d5e978fc898fd395f4e54c38730dbf33ddc10949a712f599352b650b310a304e05924f98a680393a21cd426a12ec269f6fc5dadcfc9af26d50af37a",+ "dest-filename": "4f832d5e978fc898fd395f4e54c38730dbf33ddc10949a712f599352b650b310a304e05924f98a680393a21cd426a12ec269f6fc5dadcfc9af26d50af37a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/1a/17"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",+ "sha512": "17a6c4c9a995f632860050449a54277ac44f18e42a4b6f94c22d049b5e717a73b11da7f686fe8bf180959f7acf74f24e8897cf8829cb211cafc156aa318dcc23",+ "dest-filename": "c4c9a995f632860050449a54277ac44f18e42a4b6f94c22d049b5e717a73b11da7f686fe8bf180959f7acf74f24e8897cf8829cb211cafc156aa318dcc23",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/17/a6"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",+ "sha512": "3047b751ea043585455f3a17116b2f72983a66f96b14d94e43b10eb2f848dc27c05f0ccf7cef10c2ec5de349dea6c60aab2c954274dd11fbfaf2af75c8b70aad",+ "dest-filename": "b751ea043585455f3a17116b2f72983a66f96b14d94e43b10eb2f848dc27c05f0ccf7cef10c2ec5de349dea6c60aab2c954274dd11fbfaf2af75c8b70aad",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/30/47"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@types/react/-/react-18.3.31.tgz",+ "sha512": "bdf12aa574efc13f75ca19b075fa2e4ad3768522b04efc91b3caa92df003cababf9310f0d2164ced693d520d4510b8fc8486f2f92ffe910092445177da7bf643",+ "dest-filename": "2aa574efc13f75ca19b075fa2e4ad3768522b04efc91b3caa92df003cababf9310f0d2164ced693d520d4510b8fc8486f2f92ffe910092445177da7bf643",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/bd/f1"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",+ "sha512": "814bbd8707d6bef1030419a0b40a30402a23c19989e6670b9f76ae7de0ac8ad8a3b37f9fd8db2b3ed94058847a38f8aa96397de8654251b2ded07caa22955aa0",+ "dest-filename": "bd8707d6bef1030419a0b40a30402a23c19989e6670b9f76ae7de0ac8ad8a3b37f9fd8db2b3ed94058847a38f8aa96397de8654251b2ded07caa22955aa0",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/81/4b"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/axe-core/-/axe-core-4.13.0.tgz",+ "sha512": "5331adf3383b372f1d8db60c871976cee11ebd56bbaf68098d86392f0af5c4cefe5d4da777a0a421615355c0886c03fadef4b3ef535a572cae4a4f651ca732d0",+ "dest-filename": "adf3383b372f1d8db60c871976cee11ebd56bbaf68098d86392f0af5c4cefe5d4da777a0a421615355c0886c03fadef4b3ef535a572cae4a4f651ca732d0",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/53/31"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.22.tgz",+ "sha512": "a56738c39d5f04577b99abf8dffcca442f9123a7f8c9fcd0a1595fbc4f1d10278fc9f927d5bccba74d458f440009cc826721618843320f6a9271f2915a05a26c",+ "dest-filename": "38c39d5f04577b99abf8dffcca442f9123a7f8c9fcd0a1595fbc4f1d10278fc9f927d5bccba74d458f440009cc826721618843320f6a9271f2915a05a26c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a5/67"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.9.tgz",+ "sha512": "1166b339b945614be519971f1a13d43e6621de78a45310556fecbd309ba7e5fde1062f35d97fbc312413ba32c1b602b771fe757c959b59f3a3c9e3bde7877e12",+ "dest-filename": "b339b945614be519971f1a13d43e6621de78a45310556fecbd309ba7e5fde1062f35d97fbc312413ba32c1b602b771fe757c959b59f3a3c9e3bde7877e12",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/11/66"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz",+ "sha512": "4c84d03d491acfe69593918be8d84e77093568468d4d20cfb06156ad3ba1286b634c5ef48cbfce86dd96e1ceab5d47b97eeec87b5f5521a8405c720889658d7a",+ "dest-filename": "d03d491acfe69593918be8d84e77093568468d4d20cfb06156ad3ba1286b634c5ef48cbfce86dd96e1ceab5d47b97eeec87b5f5521a8405c720889658d7a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/4c/84"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",+ "sha512": "2afa78e7d1eb576144275080b22d4abbe318de46ac1f5f53172913cf6c5698c7aae9b936354dd75ef7c9f90eb59b4c64b56c2dfb51d261fdc966c4e6b3769126",+ "dest-filename": "78e7d1eb576144275080b22d4abbe318de46ac1f5f53172913cf6c5698c7aae9b936354dd75ef7c9f90eb59b4c64b56c2dfb51d261fdc966c4e6b3769126",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/2a/fa"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",+ "sha512": "cf51c629c632db103c00641fc2b9f43c0cbe3c1ed7fc64a3dd45495bda8aca7e37c566be825e675e6538aaa2cc4735952c50bc2aeb145fc4ffd240a2398a4021",+ "dest-filename": "c629c632db103c00641fc2b9f43c0cbe3c1ed7fc64a3dd45495bda8aca7e37c566be825e675e6538aaa2cc4735952c50bc2aeb145fc4ffd240a2398a4021",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/cf/51"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",+ "sha512": "446c305a7c10be455f6af295b76d8518bc3ec5849dcc04709b4aeee83853540dee994e6165cdbc57790ee2cb6062bcab4e52e9baf808f468a28e5b408cd6dca8",+ "dest-filename": "305a7c10be455f6af295b76d8518bc3ec5849dcc04709b4aeee83853540dee994e6165cdbc57790ee2cb6062bcab4e52e9baf808f468a28e5b408cd6dca8",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/44/6c"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.427.tgz",+ "sha512": "9f5e336f715db02859d813686ea34700931c3f789f16fe296a8c762ef0ab7d501072a1a24944606c997e3df3291d508d1644ad9cd73e45156d3c14d55b93c383",+ "dest-filename": "336f715db02859d813686ea34700931c3f789f16fe296a8c762ef0ab7d501072a1a24944606c997e3df3291d508d1644ad9cd73e45156d3c14d55b93c383",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/9f/5e"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",+ "sha512": "6db3c1618aed65b92de8eb3a1624cb093171beae2db7724a6a5975bd1c2c840ddf755cedb0b01ab45699a1b864042f3f06b3deb686b4a24b18a0a5e81b8af226",+ "dest-filename": "c1618aed65b92de8eb3a1624cb093171beae2db7724a6a5975bd1c2c840ddf755cedb0b01ab45699a1b864042f3f06b3deb686b4a24b18a0a5e81b8af226",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/6d/b3"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",+ "sha512": "5948f6aa5c5a42d3b883a3eae5cdbd193716183c9df22b4bf334e58a98040b3dc97ac02288e2a8b5df0953aa2d0773c00a01bac64254c9585ba0c4be6e37bf8c",+ "dest-filename": "f6aa5c5a42d3b883a3eae5cdbd193716183c9df22b4bf334e58a98040b3dc97ac02288e2a8b5df0953aa2d0773c00a01bac64254c9585ba0c4be6e37bf8c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/59/48"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",+ "sha512": "b486d8b596ee70eb340511aa3c992c84951874bf920c7edd54cf208f2f84469dd60148cb105244fb4da46a7c87b708d63a7c2b298062c0098cd29e242c90275e",+ "dest-filename": "d8b596ee70eb340511aa3c992c84951874bf920c7edd54cf208f2f84469dd60148cb105244fb4da46a7c87b708d63a7c2b298062c0098cd29e242c90275e",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/b4/86"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",+ "sha512": "e71a037d7f9f2fb7da0139da82658fa5b16dc21fd1efb5a630caaa1c64bae42defbc1d181eb805f81d58999df8e35b4c8f99fade4d36d765cda09c339617df43",+ "dest-filename": "037d7f9f2fb7da0139da82658fa5b16dc21fd1efb5a630caaa1c64bae42defbc1d181eb805f81d58999df8e35b4c8f99fade4d36d765cda09c339617df43",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e7/1a"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",+ "sha512": "de137b35ab2462f3032d0639e609d6dcd43e99eb0401ea53aa583e5446e3ef3cea10c055361cdc19861ea85a3f4e5633e9e42215ca751dcb0264efa71a04bcce",+ "dest-filename": "7b35ab2462f3032d0639e609d6dcd43e99eb0401ea53aa583e5446e3ef3cea10c055361cdc19861ea85a3f4e5633e9e42215ca751dcb0264efa71a04bcce",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/de/13"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",+ "sha512": "45d2547e5704ddc5332a232a420b02bb4e853eef5474824ed1b7986cf84737893a6a9809b627dca02b53f5b7313a9601b690f690233a49bce0e026aeb16fcf29",+ "dest-filename": "547e5704ddc5332a232a420b02bb4e853eef5474824ed1b7986cf84737893a6a9809b627dca02b53f5b7313a9601b690f690233a49bce0e026aeb16fcf29",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/45/d2"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",+ "sha512": "fec33774ed853b35e3290849ba8d10d7bdf07f628ea3cb7823cbc7cba945f69a14a7b6ca4f4fcd1c4f1f3d7db73f07e19f291faa70b6c51c4e9d5c395ee18868",+ "dest-filename": "3774ed853b35e3290849ba8d10d7bdf07f628ea3cb7823cbc7cba945f69a14a7b6ca4f4fcd1c4f1f3d7db73f07e19f291faa70b6c51c4e9d5c395ee18868",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/fe/c3"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",+ "sha512": "5e63967bb7b21d81f5e1c2dd54fa3283e18e1f7ad85fef8aa73af2949c125bdf2ddcd93e53c5ce97c15628e830b7375bf255c67facd8c035337873167f16acca",+ "dest-filename": "967bb7b21d81f5e1c2dd54fa3283e18e1f7ad85fef8aa73af2949c125bdf2ddcd93e53c5ce97c15628e830b7375bf255c67facd8c035337873167f16acca",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/5e/63"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",+ "sha512": "972bb13c6aff59f86b95e9b608bfd472751cd7372a280226043cee918ed8e45ff242235d928ebe7d12debe5c351e03324b0edfeb5d54218e34f04b71452a0add",+ "dest-filename": "b13c6aff59f86b95e9b608bfd472751cd7372a280226043cee918ed8e45ff242235d928ebe7d12debe5c351e03324b0edfeb5d54218e34f04b71452a0add",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/97/2b"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",+ "sha512": "2a9340450037230bfe8d3034bad51555bae1f8996baf516fd1ee7a186cc014e5cdedd93f16f89a0d6f0b1e62b9d8395c1f858fda7ea023cbcdd5a7ac045828f7",+ "dest-filename": "40450037230bfe8d3034bad51555bae1f8996baf516fd1ee7a186cc014e5cdedd93f16f89a0d6f0b1e62b9d8395c1f858fda7ea023cbcdd5a7ac045828f7",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/2a/93"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.48.0.tgz",+ "sha512": "474088298fdf5e20bacbdc510400e0b0af955b6a7fa5c4c938c84b65fd53fae1bebc952fc94474da718e8262080bb30f92234ae0ec7c4039dba85f2b25858f65",+ "dest-filename": "88298fdf5e20bacbdc510400e0b0af955b6a7fa5c4c938c84b65fd53fae1bebc952fc94474da718e8262080bb30f92234ae0ec7c4039dba85f2b25858f65",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/47/40"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",+ "sha512": "e85973b9b4cb646dc9d9afcd542025784863ceae68c601f268253dc985ef70bb2fa1568726afece715c8ebf5d73fab73ed1f7100eb479d23bfb57b45dd645394",+ "dest-filename": "73b9b4cb646dc9d9afcd542025784863ceae68c601f268253dc985ef70bb2fa1568726afece715c8ebf5d73fab73ed1f7100eb479d23bfb57b45dd645394",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e8/59"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz",+ "sha512": "636b54372e28bb0eadab9a0348a7906063b286450184d39c195ff4d8a0beea477d7831aa75977efa68cc8880e296b058be3127098bd5b6cb870ae3fea2449fba",+ "dest-filename": "54372e28bb0eadab9a0348a7906063b286450184d39c195ff4d8a0beea477d7831aa75977efa68cc8880e296b058be3127098bd5b6cb870ae3fea2449fba",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/63/6b"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.55.tgz",+ "sha512": "988ac4fc2c3dcbef40bba752e6f0ca0e14336bd62f1bac3e66b4ba5fe67303bc855bfb2801e6aea6ce10ce7d5b2fa839155cbc5ad3fbf7ed23f36a0f21ba918d",+ "dest-filename": "c4fc2c3dcbef40bba752e6f0ca0e14336bd62f1bac3e66b4ba5fe67303bc855bfb2801e6aea6ce10ce7d5b2fa839155cbc5ad3fbf7ed23f36a0f21ba918d",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/98/8a"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/orderedmap/-/orderedmap-2.1.1.tgz",+ "sha512": "4ef016c62d270ded63febb4c7167088fde3e15f7ba9fbce1a30df7878d122b19ac9a8cece9dcff7be11a8f299fa0570777bb31367f321ccf3cdfdba2c4c395ea",+ "dest-filename": "16c62d270ded63febb4c7167088fde3e15f7ba9fbce1a30df7878d122b19ac9a8cece9dcff7be11a8f299fa0570777bb31367f321ccf3cdfdba2c4c395ea",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/4e/f0"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",+ "sha512": "c5c787dac9e1b5be4cf658aa0ec984c39ea57b7efa993664117fe311bfd1c4d1727a036e97b78db250973fd1438ff2dcbb45fc284c8c71e3f69eda5a1eb0c454",+ "dest-filename": "87dac9e1b5be4cf658aa0ec984c39ea57b7efa993664117fe311bfd1c4d1727a036e97b78db250973fd1438ff2dcbb45fc284c8c71e3f69eda5a1eb0c454",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/c5/c7"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",+ "sha512": "a9c26ef3c436216a89b030f9dbd24a31dc069bf76f2275b81ef427470887f49b62849bf318eb1c0ed1c4df1d6904a794393cac43c91598b9c9da426eef285c18",+ "dest-filename": "6ef3c436216a89b030f9dbd24a31dc069bf76f2275b81ef427470887f49b62849bf318eb1c0ed1c4df1d6904a794393cac43c91598b9c9da426eef285c18",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a9/c2"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.63.0.tgz",+ "sha512": "ad80ac045fcce478d4721e766dbb5538d1058efe97bbcb26f21ef674d951e5bcc81357ef0bf6f182ca7392349f53e3307843263ccf0a25e6c6ea79f2c68e660a",+ "dest-filename": "ac045fcce478d4721e766dbb5538d1058efe97bbcb26f21ef674d951e5bcc81357ef0bf6f182ca7392349f53e3307843263ccf0a25e6c6ea79f2c68e660a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/ad/80"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/playwright/-/playwright-1.63.0.tgz",+ "sha512": "fbbce204b89d4b835a34276de7b4940d3fb062699de5f9a241e8d489cfe46fe62c61208fc8e384f6c79bccc8cd990aec9cda4326a778587bd5ffc95f29f50352",+ "dest-filename": "e204b89d4b835a34276de7b4940d3fb062699de5f9a241e8d489cfe46fe62c61208fc8e384f6c79bccc8cd990aec9cda4326a778587bd5ffc95f29f50352",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/fb/bc"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz",+ "sha512": "451bb3a83b6de58f61deabb3e615a12be4cf9ec995b3a5b0494e8b90931e6381ecb54103b984c6f1425275ac0c4739b302d57e284a06f0ddd0836a8bcb9bccfc",+ "dest-filename": "b3a83b6de58f61deabb3e615a12be4cf9ec995b3a5b0494e8b90931e6381ecb54103b984c6f1425275ac0c4739b302d57e284a06f0ddd0836a8bcb9bccfc",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/45/1b"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/prosemirror-commands/-/prosemirror-commands-1.7.2.tgz",+ "sha512": "aba43ab33c6a76ef5777a11c74ab2a5e086ee6741d653a41e10f72774e1645ceff8edefaddefeb4fad0ec21d0bd46618f93e3aa39ac3fbd944377e9d652e37b7",+ "dest-filename": "3ab33c6a76ef5777a11c74ab2a5e086ee6741d653a41e10f72774e1645ceff8edefaddefeb4fad0ec21d0bd46618f93e3aa39ac3fbd944377e9d652e37b7",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/ab/a4"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/prosemirror-history/-/prosemirror-history-1.5.1.tgz",+ "sha512": "a279709ea2af82d160eacad93a60ce021940cb51481d0a4e131391c9b5f44be0ef25ea44e6d3c02eb07d8867adff6b2aaaaade9529c1d743a888e26a02fbb60c",+ "dest-filename": "709ea2af82d160eacad93a60ce021940cb51481d0a4e131391c9b5f44be0ef25ea44e6d3c02eb07d8867adff6b2aaaaade9529c1d743a888e26a02fbb60c",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a2/79"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/prosemirror-keymap/-/prosemirror-keymap-1.2.3.tgz",+ "sha512": "e07b9c465a622ddd483d041736a7a8f35046b6463c022e6c98784a5bd8e33ca45cdb0408c64b20ec7975b5323621f4f607f2e05fa6df62f5f1129265eda2982b",+ "dest-filename": "9c465a622ddd483d041736a7a8f35046b6463c022e6c98784a5bd8e33ca45cdb0408c64b20ec7975b5323621f4f607f2e05fa6df62f5f1129265eda2982b",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e0/7b"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/prosemirror-model/-/prosemirror-model-1.25.12.tgz",+ "sha512": "51eda04e65cc6bb121a4b3610bb27e878fb2903f216b5d8aeabad914528a247045a2b7c84adc39809e99adfd66aaa01af4d9a9984078c29f5b2a60387945635a",+ "dest-filename": "a04e65cc6bb121a4b3610bb27e878fb2903f216b5d8aeabad914528a247045a2b7c84adc39809e99adfd66aaa01af4d9a9984078c29f5b2a60387945635a",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/51/ed"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/prosemirror-state/-/prosemirror-state-1.4.4.tgz",+ "sha512": "ea38981c7d822066c27e7c5d1db5d9d7683248563f7f3fee959137df71ba6cfa8867817e4d7a3d89f891f3a9c01e95a77e836339bde8e444a2ec9f14cf58d71f",+ "dest-filename": "981c7d822066c27e7c5d1db5d9d7683248563f7f3fee959137df71ba6cfa8867817e4d7a3d89f891f3a9c01e95a77e836339bde8e444a2ec9f14cf58d71f",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/ea/38"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/prosemirror-transform/-/prosemirror-transform-1.12.2.tgz",+ "sha512": "3c4fda6341c4638cdccef9aaae29609142bf59abad174721bccaa498cfe2379fda3c7bf0ac259a4198d2e82219a7e2bce18aef3c5aab2fe600aeb7c95fcc57ee",+ "dest-filename": "da6341c4638cdccef9aaae29609142bf59abad174721bccaa498cfe2379fda3c7bf0ac259a4198d2e82219a7e2bce18aef3c5aab2fe600aeb7c95fcc57ee",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/3c/4f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/prosemirror-view/-/prosemirror-view-1.42.6.tgz",+ "sha512": "de0db97fa84a5766c1c68de9b87dc47185a69953521f489698db0c553eecba00d2a40d36e6382938b6ab7035abdfd49dccf8d831a898b5174db5789a94f4a311",+ "dest-filename": "b97fa84a5766c1c68de9b87dc47185a69953521f489698db0c553eecba00d2a40d36e6382938b6ab7035abdfd49dccf8d831a898b5174db5789a94f4a311",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/de/0d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",+ "sha512": "e66e2740aa7ead945bd3d2cd1f9f463380714e1f76e75ff295b2886e97bb4e91b17c9fbd92fe812e42c15c88e3b296e06e720136a948db7b519d3593d2c9d423",+ "dest-filename": "2740aa7ead945bd3d2cd1f9f463380714e1f76e75ff295b2886e97bb4e91b17c9fbd92fe812e42c15c88e3b296e06e720136a948db7b519d3593d2c9d423",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/e6/6e"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",+ "sha512": "cfa17b2bd6d5f3911fb1e442a766f3ae9c90d06930d6e2e809e97d5c15563e0fd38d18fde12909cd44c67ce6b86ecee226f056b501b45aaef09c8d2ccb0dc405",+ "dest-filename": "7b2bd6d5f3911fb1e442a766f3ae9c90d06930d6e2e809e97d5c15563e0fd38d18fde12909cd44c67ce6b86ecee226f056b501b45aaef09c8d2ccb0dc405",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/cf/a1"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",+ "sha512": "c12fa1020252851d0a844bcf240adfb8f54dd7e1f3d6dd18ea7e632eb1906e46f8bab80f13fd11bdefb590c075bffa16807826e1621c57e8bb176a53563fb689",+ "dest-filename": "a1020252851d0a844bcf240adfb8f54dd7e1f3d6dd18ea7e632eb1906e46f8bab80f13fd11bdefb590c075bffa16807826e1621c57e8bb176a53563fb689",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/c1/2f"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/rollup/-/rollup-4.63.2.tgz",+ "sha512": "9797b292c578b4f063ea527211adfb63320e092395ee5919cc41d47698d665bb43ef04dc1589846174a09b96d3e2f57e7592dbf6b046d56f4644e386e0d4b813",+ "dest-filename": "b292c578b4f063ea527211adfb63320e092395ee5919cc41d47698d665bb43ef04dc1589846174a09b96d3e2f57e7592dbf6b046d56f4644e386e0d4b813",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/97/97"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/rope-sequence/-/rope-sequence-1.3.4.tgz",+ "sha512": "513e440ded9cbb613fe8ee22814af93d216cdb79efbee9227161f1e869ce3e51c08a261bccdb824500ae89474725072a29a94b2a5ad82678d8d32486b173505d",+ "dest-filename": "440ded9cbb613fe8ee22814af93d216cdb79efbee9227161f1e869ce3e51c08a261bccdb824500ae89474725072a29a94b2a5ad82678d8d32486b173505d",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/51/3e"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",+ "sha512": "50e4a1b0fc33ecdacc52a851eadd215a315dbaf3b36edbfbb680c7d7f848adf44d2030679c159dd02c094c6bd3a67815966c0609d3fdfd997fb55ac3a9cb98cd",+ "dest-filename": "a1b0fc33ecdacc52a851eadd215a315dbaf3b36edbfbb680c7d7f848adf44d2030679c159dd02c094c6bd3a67815966c0609d3fdfd997fb55ac3a9cb98cd",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/50/e4"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",+ "sha512": "051ed5bc30951cefaadb10445ac9314ba0c9135a919dbec3c7352ba206fbd425a849f89c07162c88019df8a9749a6abf329ac6f7202b464cab4314cee978cccc",+ "dest-filename": "d5bc30951cefaadb10445ac9314ba0c9135a919dbec3c7352ba206fbd425a849f89c07162c88019df8a9749a6abf329ac6f7202b464cab4314cee978cccc",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/05/1e"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",+ "sha512": "51758c2a12cec1529bef6f0852d40f5f17d853ebac7726ed52b2bff2e184f0240cbeb84ea70bf30c1c23d108522fb31073bbc8b084811bc550f3e203431a5f40",+ "dest-filename": "8c2a12cec1529bef6f0852d40f5f17d853ebac7726ed52b2bff2e184f0240cbeb84ea70bf30c1c23d108522fb31073bbc8b084811bc550f3e203431a5f40",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/51/75"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",+ "sha512": "c1747f758a5ca8a99f5a911d66388a24ec023459dd0f40cc9eb5bf7188d51adb449017d581c2c51e836b963e3b9a339589cf72c8dbbae5a96c805e0d4324dada",+ "dest-filename": "7f758a5ca8a99f5a911d66388a24ec023459dd0f40cc9eb5bf7188d51adb449017d581c2c51e836b963e3b9a339589cf72c8dbbae5a96c805e0d4324dada",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/c1/74"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",+ "sha512": "8e5d6f6733c38a72ebf5e52ddc9feded5e8580d130f508ef04f772b33f4a7d00c3e357d0ac2d98e2f290762694a454f86d795bd511e12e9a7cc2d9ba3394e04b",+ "dest-filename": "6f6733c38a72ebf5e52ddc9feded5e8580d130f508ef04f772b33f4a7d00c3e357d0ac2d98e2f290762694a454f86d795bd511e12e9a7cc2d9ba3394e04b",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/8e/5d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz",+ "sha512": "a49dac61ac104b447f588f76f068f91a53e14c6cdb31e96ad3ee0836d49834357d12b289717eb18c65a4a06fd59c1ddda549b4d3300b6aa92b503efba4ee530d",+ "dest-filename": "ac61ac104b447f588f76f068f91a53e14c6cdb31e96ad3ee0836d49834357d12b289717eb18c65a4a06fd59c1ddda549b4d3300b6aa92b503efba4ee530d",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/a4/9d"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz",+ "sha512": "3532a57108e500aecc950a326fa2e06aa1dcf2cb28fe9572509616330b378e0db5b93270fcb75da8814f70fa8fe8fce981b21c672288f39b051381c1ad00c0f0",+ "dest-filename": "a57108e500aecc950a326fa2e06aa1dcf2cb28fe9572509616330b378e0db5b93270fcb75da8814f70fa8fe8fce981b21c672288f39b051381c1ad00c0f0",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/35/32"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",+ "sha512": "769a2306136c08d37b4fcd939bb936e80e86f4c2f7364843b27c3d9ff7a8c52465541078084b4843f29308b2361707f76ad6925d1858164422dd29671703ef3d",+ "dest-filename": "2306136c08d37b4fcd939bb936e80e86f4c2f7364843b27c3d9ff7a8c52465541078084b4843f29308b2361707f76ad6925d1858164422dd29671703ef3d",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/76/9a"+ },+ {+ "type": "file",+ "url": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",+ "sha512": "6b850641a58f1f9f663975189c01b67b09dc412e22e05e374efdc9a0033eb365430264bd36c2bc1a90cc2eb0873e4b054fb8772ba4cea14367da96fb4685f1e2",+ "dest-filename": "0641a58f1f9f663975189c01b67b09dc412e22e05e374efdc9a0033eb365430264bd36c2bc1a90cc2eb0873e4b054fb8772ba4cea14367da96fb4685f1e2",+ "dest": "flatpak-node/npm-cache/_cacache/content-v2/sha512/6b/85"+ },+ {+ "type": "inline",+ "contents": "01471f711f0f1d908ad78510b49ad16923bfcb0e\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.2.tgz\", \"integrity\": \"sha512-Xa6RDoWa+hNiX6PgsljlH6W75RaONx3y6PVlbLhkEWW+GaPQ3dP5gwbL/erAzQHWwkvW5UxdD5l87Qx2FAQ/4A==\", \"time\": 0, \"size\": 841596, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "df642187bd5cf0e36f853b5d243035ea856adacd0bc409c3de58dd3a23f0",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/95/23"+ },+ {+ "type": "inline",+ "contents": "0327dcda608a0fabe8a4796c9768c79aa5dad397\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz\", \"integrity\": \"sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==\", \"time\": 0, \"size\": 1089001, \"metadata\": {\"url\": \"https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "4244544732d3e784c8fd360e0ea256a943488c53a834da3d0ddf3e83af9b",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/6f/9f"+ },+ {+ "type": "inline",+ "contents": "0476275047f95d2c5254e407cf9434a6006c5bde\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz\", \"integrity\": \"sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==\", \"time\": 0, \"size\": 4085066, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a17f4c5fd9e43f2384c59e71dee766e3c1bee846b41ac8d9615f9e794b2f",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/b1/9c"+ },+ {+ "type": "inline",+ "contents": "05dadd5594b4d3947d4b4c5faddad274a1da2dad\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz\", \"integrity\": \"sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==\", \"time\": 0, \"size\": 4381813, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "182867011e50d0dcbb38e87fd1510d6c86f4d931411ca48830535435ab2a",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/df/fc"+ },+ {+ "type": "inline",+ "contents": "07e6917dcb72e05c83133ce453a7b7a0a1148e06\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/playwright/-/playwright-1.63.0.tgz\", \"integrity\": \"sha512-+7ziBLidS4NaNCdt57SUDT+wYmmd5fmiQejUic/kb+YsYSCPyOOE9sebzMjNmQrsnNpDJqd4WHvV/8lfKfUDUg==\", \"time\": 0, \"size\": 899597, \"metadata\": {\"url\": \"https://registry.npmjs.org/playwright/-/playwright-1.63.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "4141a806114780ff5d840a8d5befb8d37b7be6b42ea079170653f237d826",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/29/d6"+ },+ {+ "type": "inline",+ "contents": "0ba3cb9bd95c8d680a641290c1ccad31396133ba\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz\", \"integrity\": \"sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==\", \"time\": 0, \"size\": 4191694, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "0a6cbb402537b494b7bb9bb630de92170ca50c5105974007aed8c0aef4e0",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/82/39"+ },+ {+ "type": "inline",+ "contents": "0c9ab681ea37c0c6b8c920b6e774ff76e3ac0ab1\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz\", \"integrity\": \"sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==\", \"time\": 0, \"size\": 192830, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "4d855dd8d61c847d498c12ebf5b56c4b2c52a793ccb85a93ef8f4050f6f7",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/55/4b"+ },+ {+ "type": "inline",+ "contents": "0ce49e83c20bd547c0652072a16e0c2f72523e58\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.11.4.tgz\", \"integrity\": \"sha512-v277UnT/fB64xAfSroL5N3Km3tLmvATWqJJw/wRI+g6o+HkeD0slyE7gOhNs1MbjE41R7bQOTxMVoL3aomUJmw==\", \"time\": 0, \"size\": 8220872, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "079c7a01fbc5dbe9d3ffe126f3cd9aa3867083592fbfee9de635cfba2212",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/2b/15"+ },+ {+ "type": "inline",+ "contents": "0e59844e5b609f7c714da16cd1eecb9b256d1782\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz\", \"integrity\": \"sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==\", \"time\": 0, \"size\": 2842, \"metadata\": {\"url\": \"https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "452a94b385f28d524a6fd9178863fe32cc70bc3d94033a3dda9c91b2e128",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/27/ef"+ },+ {+ "type": "inline",+ "contents": "0eda031ff89c7bc6c7cb38dba929c9931593996b\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/prosemirror-model/-/prosemirror-model-1.25.12.tgz\", \"integrity\": \"sha512-Ue2gTmXMa7EhpLNhC7J+h4+ykD8ha12K6rrZFFKKJHBForfIStw5gJ6Zrf1mqqAa9NmpmEB4wp9bKmA4eUVjWg==\", \"time\": 0, \"size\": 130134, \"metadata\": {\"url\": \"https://registry.npmjs.org/prosemirror-model/-/prosemirror-model-1.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "4bd8c2b7e3d6107933e831030adc0dfca71ec2f7ee5162639476527daa8a",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/2b/17"+ },+ {+ "type": "inline",+ "contents": "0fc8a0375f35ad9613c665d950bdbdc793abb895\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/prosemirror-state/-/prosemirror-state-1.4.4.tgz\", \"integrity\": \"sha512-6jiYHH2CIGbCfnxdHbXZ12gySFY/fz/ulZE333G6bPqIZ4F+TXo9ifiR86nAHpWnfoNjOb3o5ESi7J8Uz1jXHw==\", \"time\": 0, \"size\": 43710, \"metadata\": {\"url\": \"https://registry.npmjs.org/prosemirror-state/-/prosemirror-state-1.4.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "ea4170776998ad71f3b14bfb71d2300b9500d0296ea32f2e58fe5b2e4bda",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/c4/77"+ },+ {+ "type": "inline",+ "contents": "10de881b48133f91fb04e610fe56bf07811c692e\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz\", \"integrity\": \"sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==\", \"time\": 0, \"size\": 4016073, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "64ee02faafa864fc9ff7f3269adc233871f28b31d00ba64a4eeb90fbd1d4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/94/96"+ },+ {+ "type": "inline",+ "contents": "11b758212ff22c713fa53c29124ff87b79144d60\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/react/-/react-18.3.1.tgz\", \"integrity\": \"sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==\", \"time\": 0, \"size\": 81751, \"metadata\": {\"url\": \"https://registry.npmjs.org/react/-/react-18.3.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "434e6cce71a37629e1945f6d35d5e52c1e34aa88ef24d1915846c72775f1",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/73/e2"+ },+ {+ "type": "inline",+ "contents": "11f4c04984f32c2fbb3c26833e7ccd5000f01715\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz\", \"integrity\": \"sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==\", \"time\": 0, \"size\": 4050637, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "6846ba842e2aa77ef19352d864b56ecdc474f70d6ca855b8914298da2ab7",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/75/bc"+ },+ {+ "type": "inline",+ "contents": "128099c727246e4731bb37f79f252053a3cfdaa4\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz\", \"integrity\": \"sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==\", \"time\": 0, \"size\": 4172833, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "02f4332d8b2d5ff4e8046134a1ef129d4b028ea75c2ef66993942fb280ba",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8a/38"+ },+ {+ "type": "inline",+ "contents": "136da76d0c67c55e25926bd14f065ccd0da3a811\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz\", \"integrity\": \"sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==\", \"time\": 0, \"size\": 15961, \"metadata\": {\"url\": \"https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "ef30fa51cda1f7fec7431ff72e4dceadd4c8c12da056e18c4a3a6335cbf4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/21/1e"+ },+ {+ "type": "inline",+ "contents": "13fb80a7448a23cbe49306186fdb3aea1f176add\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz\", \"integrity\": \"sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==\", \"time\": 0, \"size\": 637261, \"metadata\": {\"url\": \"https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "7985bbc823a713b03e5b1603ef3bc7b4c896cba5e868961d3e30cf37885a",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d8/23"+ },+ {+ "type": "inline",+ "contents": "192b697613cb3703b79bcb88aa7fef7795e3519d\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.2.tgz\", \"integrity\": \"sha512-Pp7gVZggEFlbcuztay+/U0gVG9S1XAh8i7I1Re/htbAzo43P5wHZHw6pTyzotISqlKohoh9RpIfnOz3RbemK1w==\", \"time\": 0, \"size\": 983736, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "d6f48011a61a84a5531a4ce929f4db358f0e20756c71154ca6fb563f7463",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/31/17"+ },+ {+ "type": "inline",+ "contents": "197f173b8cf5d4b96ddc9384b9c65c25ba7e62ed\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz\", \"integrity\": \"sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==\", \"time\": 0, \"size\": 9998, \"metadata\": {\"url\": \"https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "3849f3c1fa39383ce61dfadb908796c9646f9a97f258c3ed9322170e28cb",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/18/70"+ },+ {+ "type": "inline",+ "contents": "1a2a7e484b6e1f091fe7b2918909d337b489e5af\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz\", \"integrity\": \"sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==\", \"time\": 0, \"size\": 4496, \"metadata\": {\"url\": \"https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "56d3868cdb645b2dd09110debc35e2e7b4e26d0210d08755dce2a8cd9ae8",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/27/26"+ },+ {+ "type": "inline",+ "contents": "1b3447d33678039f512fffcb3c64f00cc75f9361\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz\", \"integrity\": \"sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==\", \"time\": 0, \"size\": 3274088, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e7a67f77d13a6c181c7b9cb1bc65a3ce61743ea6d297be8160de439e6c82",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8a/5d"+ },+ {+ "type": "inline",+ "contents": "1d0032c36ab1f54e81663494d8e4335685f5800d\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz\", \"integrity\": \"sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==\", \"time\": 0, \"size\": 4390621, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a04b0bcabfea96702fbdde43a0116edf8a184eddd2e2d51fdc2f26378e04",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/b2/ea"+ },+ {+ "type": "inline",+ "contents": "1d60404b3281c92034abd12e57aa0af0e64aa315\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz\", \"integrity\": \"sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==\", \"time\": 0, \"size\": 22808, \"metadata\": {\"url\": \"https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "c98f1cdf494d5afde6448966f8b5b9ae83d1b42c6702670e15e8a7f68552",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/49/61"+ },+ {+ "type": "inline",+ "contents": "1d6d28077422f44d90cae8ca22393a3999e64ebf\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-darwin-x64/-/cli-darwin-x64-2.11.4.tgz\", \"integrity\": \"sha512-uFsGQAAfuyz1k/yGLmkWfkBlgKAqZfxqlHmLWx81QU27RJWfmbNHCIq8T8w1e+VClleIuZUjpHWfoE4E3DLo3A==\", \"time\": 0, \"size\": 8209507, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-darwin-x64/-/cli-darwin-x64-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "1eeecf3038738a02ba20d00311720bbee6d6aefbfc24bd9dde80ae054305",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/e4/e7"+ },+ {+ "type": "inline",+ "contents": "1f8d17c601697db6ef28ead8257c57074dea3636\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz\", \"integrity\": \"sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==\", \"time\": 0, \"size\": 3689, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "24fd04498d836720ed69690ea3560e29c949549e12a1cc96ead68284d80b",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/ae/54"+ },+ {+ "type": "inline",+ "contents": "20950692a925e698f389e7985fed7fe82d399bbf\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz\", \"integrity\": \"sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==\", \"time\": 0, \"size\": 4034702, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "65820aac6465cf81b24af603f813b53974b7d42f4b27764460f4ff90a93f",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/28/d9"+ },+ {+ "type": "inline",+ "contents": "221fd2838f2a743956193d6105df1624f3fa8a72\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/prosemirror-view/-/prosemirror-view-1.42.6.tgz\", \"integrity\": \"sha512-3g25f6hKV2bBxo3puH3EcYWmmVNSH0iWmNsMVT7sugDSpA025jgpOLarcDWr39SdzPjYMaiYtRdNtXialPSjEQ==\", \"time\": 0, \"size\": 228272, \"metadata\": {\"url\": \"https://registry.npmjs.org/prosemirror-view/-/prosemirror-view-1.42.6.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "843e1afab3c12e594fea3dbb06aea86f1e5a5b7712c64b42b56eafbf4bc4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/ff/1a"+ },+ {+ "type": "inline",+ "contents": "25b00e15983a2b4e76658be3607ba0226a41c393\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-linux-riscv64-gnu/-/cli-linux-riscv64-gnu-2.11.4.tgz\", \"integrity\": \"sha512-qqgNkQ2u1yZHxjhxsZaxUtRDW8dIqIYm33rx/mzwQv0SfY9x1B+iraj8vWeFiXjjSVVhEMepXSOts1TqPzvXNQ==\", \"time\": 0, \"size\": 8359622, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-linux-riscv64-gnu/-/cli-linux-riscv64-gnu-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "2d12c0167e91be884155cce9cd629a1fb933d860b1a26da6bba61be728ea",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/44/42"+ },+ {+ "type": "inline",+ "contents": "2e8b159d666eeafde57a0af8bed1da03757d39a2\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.2.tgz\", \"integrity\": \"sha512-0dWDjmlrpZAgjPD/aPzUDhBW8APLRjAni5bOrM76wiiZm+E+KTMVKNhAzaTBohz8UyO2fKNAl0+fygbe2HZXOA==\", \"time\": 0, \"size\": 837878, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "6672542f2fedc141ad9405cbc0ccc28bf4775bd426fd6980952a872ded0b",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8d/73"+ },+ {+ "type": "inline",+ "contents": "2fa98ec2bce7fb361ddda6e92e72376a513662d3\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.2.tgz\", \"integrity\": \"sha512-T4wf1mudIDxN8Q/CWIBJC1u5gQUc+r5mPvlwoSbIvNkyVTP2TAFeobEmst5AQ4gMyAz4sSByVdoTDfvTmGK/8g==\", \"time\": 0, \"size\": 864245, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "f73ce9205dec6a45f9501fd38df15fad196445b9d35b6cf4088fbd12ddec",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/9c/6b"+ },+ {+ "type": "inline",+ "contents": "308a5c220421238ebd711dba9cda4777427e2f43\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.2.tgz\", \"integrity\": \"sha512-vNASxsghMfQ5s+v3PrpnJd+ryL/26lxCCaGI+sDJ7VzmHiYXIrrVltsDhaawxLM1WcoMU2oYlbPHLaYQtBzhcg==\", \"time\": 0, \"size\": 884773, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "b9d4f0fa0b420450f9f66757e18d15ac42936b26e40901d24f0773a73e77",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/f7/f9"+ },+ {+ "type": "inline",+ "contents": "310106862dc0319e26546094cd2baa8514d7fa83\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz\", \"integrity\": \"sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==\", \"time\": 0, \"size\": 4226978, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "ed029cc0fe8b4a43312fe4636a65137e9f980779075b2a2ab75216af78bc",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/9a/74"+ },+ {+ "type": "inline",+ "contents": "314d58eb5517fc811ef60be4dafdd7b4563d9364\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz\", \"integrity\": \"sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==\", \"time\": 0, \"size\": 4042485, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "62a07b2dbe5d75af14173476956fa1714b84a1c44cef8dd14e9755e23277",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/1f/da"+ },+ {+ "type": "inline",+ "contents": "33472096995f66d0af8f98c8d7210ed50105f0cc\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz\", \"integrity\": \"sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==\", \"time\": 0, \"size\": 30947, \"metadata\": {\"url\": \"https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "6835fd850598b0b7dbaef8fc840fefd706389ce90f80a76360d9b40032d8",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/16/92"+ },+ {+ "type": "inline",+ "contents": "35f5e967b70002d9f106f55ea57f9c621603d973\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz\", \"integrity\": \"sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==\", \"time\": 0, \"size\": 4377468, \"metadata\": {\"url\": \"https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "cff74a8452b6159ec5df4cd310e05e05bfaa99de31da7de4b5a7a7a849d9",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/6a/b2"+ },+ {+ "type": "inline",+ "contents": "37d927b18b16c07ae78853e3f5898dba7fed1825\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-gnu/-/cli-linux-arm64-gnu-2.11.4.tgz\", \"integrity\": \"sha512-N41/ukTRVe6XSuUTESuFdGeOW2i7k62tK+6gHK5Kd5/q5RPvvi19GaWAVPPb9u95HSGmTChSolBfzynUsssFaA==\", \"time\": 0, \"size\": 8219048, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-gnu/-/cli-linux-arm64-gnu-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e06fb8348bfcb56726aa59f59cd35f8628227f7f487b9ed07f3ab750eedd",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/56/23"+ },+ {+ "type": "inline",+ "contents": "37e6faddac83e2d1d16e2e1fe14cec1b3107fcdf\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli/-/cli-2.11.4.tgz\", \"integrity\": \"sha512-R8xGtMpwyetawSqm9kYOuMmEqkhUbvcUy8n0aNXIxollKBLESUu5f4Fx+64hgASYm1H+jSWq6jCW6zqTnH6hqQ==\", \"time\": 0, \"size\": 85772, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli/-/cli-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "68d9070230fc842af5d6eef2a9eea489888a6b78f42e89bd22f128f6bc28",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/77/34"+ },+ {+ "type": "inline",+ "contents": "3a83feab7c65560e54a648e6c76452d9dfd7d672\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@axe-core/playwright/-/playwright-4.13.0.tgz\", \"integrity\": \"sha512-6YLx+kxXu5GJceG4ozFg+33a2EMTdjYwWGloJ3sb9Kta5pp+ZNS53uxGVog5JetIY8s++P5UrtX+cri+u0VAVg==\", \"time\": 0, \"size\": 11953, \"metadata\": {\"url\": \"https://registry.npmjs.org/@axe-core/playwright/-/playwright-4.13.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "3a5a367aa1dda1dec11cfd6d6bc36e92bddba2918cf413e626a005a33189",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d4/e4"+ },+ {+ "type": "inline",+ "contents": "3c4aa7c0b80799e0607272ad1e2c57c4c66f348a\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/plugin-dialog/-/plugin-dialog-2.7.3.tgz\", \"integrity\": \"sha512-CRgE+7TP4tvq9MjBU6f04NLTFIqVMLKHk3hAqlhil00ngK9ACTrXPH3oHpKMProxILodd3YjBoKbMwSI4IEcfA==\", \"time\": 0, \"size\": 6658, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/plugin-dialog/-/plugin-dialog-2.7.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "943be993497b348c7eef3babfb695d56209ef29c543b4f90a78991bd4d41",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/6e/2a"+ },+ {+ "type": "inline",+ "contents": "406077e4014d251290f355e2c3da0d55140e76d9\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz\", \"integrity\": \"sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==\", \"time\": 0, \"size\": 113664, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "1f762623db4b06a91bc30095cbf96aa9a8527cf43bb93f9d2f30a3585d5a",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/72/6d"+ },+ {+ "type": "inline",+ "contents": "49874de63f3bdfd637c16453fe8977a9eadfcc64\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz\", \"integrity\": \"sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==\", \"time\": 0, \"size\": 3009, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "9ddc9f878c52039554fd9be6ee3852f10163225591207069618d4544e7b8",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/4d/f4"+ },+ {+ "type": "inline",+ "contents": "4a127e6ac7af313c73fc6f5deac39cd4465b54b3\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.2.tgz\", \"integrity\": \"sha512-XlxLD54wQhH3FciCgMofxBw27NzUe818gJH410qWvc41UT0ZFcgxVjyX5/EK8MPTupjeVWqN5oy+9pCA9mqfCA==\", \"time\": 0, \"size\": 915558, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "63ad1fff022b57ccf8aa80c1ff2441cd0473b11eaf88de36dc0a621e1a28",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/bb/91"+ },+ {+ "type": "inline",+ "contents": "4f5de37149940548a5c72d73a4a16e6a8a3c2c4a\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz\", \"integrity\": \"sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==\", \"time\": 0, \"size\": 30747, \"metadata\": {\"url\": \"https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "be954aca6e8bac59ed3f9aeedddfb27aff4451daf808e122d86491a37f77",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/f6/44"+ },+ {+ "type": "inline",+ "contents": "5064f08188cd3692ed070e85bfea3026cea53bb7\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.427.tgz\", \"integrity\": \"sha512-n14zb3FdsChZ2BNobqNHAJMcP3ifFv4paox2LvCrfVAQcqGiSURgbJl+PfMpHVCNFkStnNc+RRVtPBTVW5PDgw==\", \"time\": 0, \"size\": 35164, \"metadata\": {\"url\": \"https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.427.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "19a8da920d85f8d30f7dd8aa1fabceb11c9d4fb8d231cfba28d3e67609c5",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/89/5f"+ },+ {+ "type": "inline",+ "contents": "5086e224838db00ffda8ac0df22f9c7a07ba9245\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/prosemirror-keymap/-/prosemirror-keymap-1.2.3.tgz\", \"integrity\": \"sha512-4HucRlpiLd1IPQQXNqeo81BGtkY8Ai5smHhKW9jjPKRc2wQIxksg7Hl1tTI2IfT2B/LgX6bfYvXxEpJl7aKYKw==\", \"time\": 0, \"size\": 7470, \"metadata\": {\"url\": \"https://registry.npmjs.org/prosemirror-keymap/-/prosemirror-keymap-1.2.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "2a77113104e4f8359bb52ee1939186c68156418dd9a5a428ad9e0c5726c4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/7e/07"+ },+ {+ "type": "inline",+ "contents": "52063d107f8e763c7db1583c5ed71592db21a25c\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz\", \"integrity\": \"sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==\", \"time\": 0, \"size\": 4068, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "064ac66040d7820a41b4342f9685c2ed6b4556989cc76cf89118dd265f79",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/1e/59"+ },+ {+ "type": "inline",+ "contents": "5217cc9f5646d7240aa97f8862ab008c57a8440a\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz\", \"integrity\": \"sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==\", \"time\": 0, \"size\": 2970, \"metadata\": {\"url\": \"https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a70839f3c418571c203f6d6273aba0f11b9abe30f22a2df95f92d82aedac",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/60/60"+ },+ {+ "type": "inline",+ "contents": "52636b5b5e0a385c568790ce93256340839d69bd\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz\", \"integrity\": \"sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==\", \"time\": 0, \"size\": 6658, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "67ce826ee436322a29f15679f982de17704f76557ffb3d73d932a4944c7c",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/62/1f"+ },+ {+ "type": "inline",+ "contents": "52af01ff9770dd9883e901d51c5450bb9043e8a5\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz\", \"integrity\": \"sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==\", \"time\": 0, \"size\": 5930, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "7b95e0dedcb8078233a6c78e446ab86eeb34fe91750c0e4ce90602a1e1eb",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8b/93"+ },+ {+ "type": "inline",+ "contents": "548a36821d0ea31013dfe1b87f82c6299f1fd656\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz\", \"integrity\": \"sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==\", \"time\": 0, \"size\": 439060, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "67b6cb3b440f334679b300b3eb6611e1f87ad7dfaffa813d4077c45163df",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/4d/d5"+ },+ {+ "type": "inline",+ "contents": "574fabd6aa29f3c2c2ebfa74a405dca65453609e\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/orderedmap/-/orderedmap-2.1.1.tgz\", \"integrity\": \"sha512-TvAWxi0nDe1j/rtMcWcIj94+Ffe6n7zhow33h40SKxmsmozs6dz/e+EajymfoFcHd7sxNn8yHM8839uixMOV6g==\", \"time\": 0, \"size\": 3308, \"metadata\": {\"url\": \"https://registry.npmjs.org/orderedmap/-/orderedmap-2.1.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "863e6f3ff678c39a10b4b2306bc0a5c4bc1ee5d76440d1407754e1337933",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a7/04"+ },+ {+ "type": "inline",+ "contents": "57f6a42901b009e39f7e78df2bdd5d9501bd1b22\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz\", \"integrity\": \"sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==\", \"time\": 0, \"size\": 4030831, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "d149a613e66bcc63bb3067cd3aa700f17aafe9d40f757d1e38c2f9bdf549",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/47/09"+ },+ {+ "type": "inline",+ "contents": "584fdbfc948a0ed41a1674df22893f558aae2667\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.2.tgz\", \"integrity\": \"sha512-zkgL2xff6i7u5hau/m6FGeS8gRkLEdgLw522WGmdWWlLd9btmNl3S80mcEjtGq+kvgUekQ3+BOYLLLcPlS2LIA==\", \"time\": 0, \"size\": 1001211, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "d03422109e5e51e421bd78e3aecffaea010849dead9b910b3f50f00b0a44",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/77/04"+ },+ {+ "type": "inline",+ "contents": "5895a7360ed1ef38ff4c79f2549c093b3a20c64b\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz\", \"integrity\": \"sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==\", \"time\": 0, \"size\": 188848, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "d15a104a0944c809e757c0151fec03c18e6bfd3d1700acc26735df43e79f",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8d/18"+ },+ {+ "type": "inline",+ "contents": "59c9e50e387d0dd1e8141e3371932d65ae75fba2\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz\", \"integrity\": \"sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==\", \"time\": 0, \"size\": 9742, \"metadata\": {\"url\": \"https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "7bd13a4fbca4723a579cab6019efcd5e03ff32581fd276a8f79738dc7a68",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/b0/18"+ },+ {+ "type": "inline",+ "contents": "5bd2f0ccf86f9503abdc01505c4952fad25cc5b5\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/playwright-core/-/playwright-core-1.63.0.tgz\", \"integrity\": \"sha512-rYCsBF/M5HjUch52bbtVONEFjv6Xu8sm8h72dNlR5bzIE1fvC/bxgspzkjSfU+MweEMmPM8KJebG6nnyxo5mCg==\", \"time\": 0, \"size\": 3123044, \"metadata\": {\"url\": \"https://registry.npmjs.org/playwright-core/-/playwright-core-1.63.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "89399654dbb1fa3f402061f654a3d769313065329842008bc4e378840ee2",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/f2/27"+ },+ {+ "type": "inline",+ "contents": "5c3f3b531cdf843f1c51fb05ac076312b63f6793\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz\", \"integrity\": \"sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==\", \"time\": 0, \"size\": 7349, \"metadata\": {\"url\": \"https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "187b89c53e1962773f0ae13e020357b58665412f5615c5fa61b6ad710cad",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/b0/74"+ },+ {+ "type": "inline",+ "contents": "5ce903a8862e03b6f85b4a4e9475bd631d07f783\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.2.tgz\", \"integrity\": \"sha512-MkvcwHMnzPSMOQEwB6wHnLzmc+hT8BGc5bW/Mhmjjgx3wbj6VBnlc47XsK74kD0K9MikFfXpQqyz4NUXaUW62A==\", \"time\": 0, \"size\": 830638, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "611c7d354d65a1b2e01af26536d7f146d18f86486f04cc50b57e029e7f0c",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/0d/ba"+ },+ {+ "type": "inline",+ "contents": "5e85ffc5795d332bf03dce2e3f2e72208d4147be\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.2.tgz\", \"integrity\": \"sha512-qiWuJJV3DybA2IfzvRimeKXGrGuVPv1zobSY/26KnP3HbV0VcNb3ECzgvtbvF3xjSMkcooou6HASXZuLdjnhpQ==\", \"time\": 0, \"size\": 869991, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "6ea8a29384bb7659fadf8be2ed428464e417346ee5279933c458d7e37760",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/26/ad"+ },+ {+ "type": "inline",+ "contents": "5e868d20935f88cfef3a4c29735fd7f5396bc06b\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/prosemirror-history/-/prosemirror-history-1.5.1.tgz\", \"integrity\": \"sha512-onlwnqKvgtFg6srZOmDOAhlAy1FIHQpOExORybX0S+DvJepE5tPALrB9iGet/2sqqqrelSnB10OoiOJqAvu2DA==\", \"time\": 0, \"size\": 17722, \"metadata\": {\"url\": \"https://registry.npmjs.org/prosemirror-history/-/prosemirror-history-1.5.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "96c56183f0cecd655d6b614645b4fc8b2928c0e86b0e3125ab56988ff592",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/83/86"+ },+ {+ "type": "inline",+ "contents": "5f8c598edd49d1c1c8583786b127a1f969de19be\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.22.tgz\", \"integrity\": \"sha512-pWc4w51fBFd7mav43/zKRC+RI6f4yfzQoVlfvE8dECePyfkn1bzLp01Fj0QACcyCZyFhiEMyD2qScfKRWgWibA==\", \"time\": 0, \"size\": 41601, \"metadata\": {\"url\": \"https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.22.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "fa51424e831e5008b89268e6964b64707d882047fbc5a117c95e641c414d",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/2a/0f"+ },+ {+ "type": "inline",+ "contents": "616e31aa0a4002e4bb0577a828d5396750822486\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/rope-sequence/-/rope-sequence-1.3.4.tgz\", \"integrity\": \"sha512-UT5EDe2cu2E/6O4igUr5PSFs23nvvukicWHx6GnOPlHAiiYbzNuCRQCuiUdHJQcqKalLKlrYJnjY0ySGsXNQXQ==\", \"time\": 0, \"size\": 5305, \"metadata\": {\"url\": \"https://registry.npmjs.org/rope-sequence/-/rope-sequence-1.3.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "6384accf902e3124c40684749909d0748099863f8b1a8c5ec4273802d0fc",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/09/3d"+ },+ {+ "type": "inline",+ "contents": "64b4b70f062015a2d5343146c2b35f2ecbb75433\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.2.tgz\", \"integrity\": \"sha512-6NHnk/K3eq2ZFYcU1X8g67s9qIJRCOTT92gwLMVBp08dB2uuuwI1/Q/empzL2Bfr2f2WRLJVwpp90RmacQyFkw==\", \"time\": 0, \"size\": 1019064, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "0f6a7d24c5bb244e70f906a03e3c7d51bd600e9e56af31709dc1848213c9",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/16/be"+ },+ {+ "type": "inline",+ "contents": "6532e766fa4e1797341bc49436e188c66112c083\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.2.tgz\", \"integrity\": \"sha512-ILs8k07Wh4p0PsNY4wYLEaXZKMOpVhrG5QDB0yHhGhuzOfDlnyHN6sflL4El/MpUP1y8uY2lUZrv4oBS6pTT3g==\", \"time\": 0, \"size\": 836297, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "6344cddbcad7726d453c6cadc2d96005f5fde7559b1f97980ce471419080",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/dd/17"+ },+ {+ "type": "inline",+ "contents": "661296d656a2b98a9c931ccc8bedd4831271e8e8\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz\", \"integrity\": \"sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==\", \"time\": 0, \"size\": 4221048, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "257e9e9cdea2311ca53b50aeebea80051199d50c6afad46837602fedbade",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/04/6a"+ },+ {+ "type": "inline",+ "contents": "679fe75d3e795283d34bc42e5490fd2cb9c85a6c\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz\", \"integrity\": \"sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==\", \"time\": 0, \"size\": 14245, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "91ca587de8f2a43a792968c4c652e025455b6bd2ed604f4514936043cd55",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/42/98"+ },+ {+ "type": "inline",+ "contents": "68078507e1ae3261a69077e6f76fbdbb92703f17\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-linux-arm-gnueabihf/-/cli-linux-arm-gnueabihf-2.11.4.tgz\", \"integrity\": \"sha512-IaHZn5CdBL21oUmjiVOS1ctw6Ip1O0pjp70FwOWmYz1myWe0SY96ZIj2FYf7pT0m8bI2h/hrs5ZbEXXh44/MkQ==\", \"time\": 0, \"size\": 8353316, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-linux-arm-gnueabihf/-/cli-linux-arm-gnueabihf-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "688a47a4f051fafbd149ec615b05f0a56000c538833bd92192ed53681f4e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/80/72"+ },+ {+ "type": "inline",+ "contents": "69b285c6d8c8f6fabdddabddd248e20e1bba9708\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.2.tgz\", \"integrity\": \"sha512-qOheJomrkVCbbHFJ7L3J97cnhfogKqguAQphv26+3ZsAQIF1L19b+dArl//s8rjJHJLz9byykyM8NBP4nmSa1g==\", \"time\": 0, \"size\": 955969, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e7f92d7d47a15a3dbe305683069c6c5d2d5c5a7d66975945babd9f7e8258",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/52/1b"+ },+ {+ "type": "inline",+ "contents": "69bec1c0a43107710fc364757395af84597659cc\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz\", \"integrity\": \"sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==\", \"time\": 0, \"size\": 3274064, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "77748f537b92c5fa05c05e3c7f27237d341a97d0c4c0d3ed19fe3b5a76d4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/47/44"+ },+ {+ "type": "inline",+ "contents": "69fdcf77eafdbf266be8117803072063570ad335\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.2.tgz\", \"integrity\": \"sha512-yOM7LdK0p6gk6+Q773OEwtlsikT1TL3yMmYsTtRlDRPha5vV2DC5x7LqRWDr6f3cSYNMKVqxzffXv8ivxNBIFQ==\", \"time\": 0, \"size\": 934752, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "b79d781f0e69fa1eff6e0af6fdf7e382e719a2f13733def84d11b07892a4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d0/29"+ },+ {+ "type": "inline",+ "contents": "6b8c0807ef1ccab8a1e558c2b0b311a343d6404a\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-linux-x64-gnu/-/cli-linux-x64-gnu-2.11.4.tgz\", \"integrity\": \"sha512-2VRNWl84FOH0m2giiDkO2h0QXlcMJeX+zJDpI5kDIQAx6s+geF3v48F4DXfJez4GS/FdoDGnPnw1C2iYGbQ7bQ==\", \"time\": 0, \"size\": 8677404, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-linux-x64-gnu/-/cli-linux-x64-gnu-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "3f139e48814e4cec221f8f0df9a459cc5b8a2e1b426e5cbd2f30ce3658d9",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/ab/1f"+ },+ {+ "type": "inline",+ "contents": "6bb4ab8d46ee60de733d7ac685ed70078bc59b19\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz\", \"integrity\": \"sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==\", \"time\": 0, \"size\": 5694, \"metadata\": {\"url\": \"https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "965254bb7c9f56ca8c69a03e0c766c531ec4a3569f36fcb057a88eeb26ab",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/bc/eb"+ },+ {+ "type": "inline",+ "contents": "6c76c711b39b8c26cee5b912919f5f8f4d03f390\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz\", \"integrity\": \"sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==\", \"time\": 0, \"size\": 168479, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "b76c81c987c93bb0106da040b3ab5ecf81a25b7a26e02f465029ed4d6798",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/4b/f9"+ },+ {+ "type": "inline",+ "contents": "719ea523cc47269953393542ba84568bc220dac4\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz\", \"integrity\": \"sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==\", \"time\": 0, \"size\": 35340, \"metadata\": {\"url\": \"https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "1018bd2617c9bf8a0c2742b8d6db95d9995670b0e195cb06cfea9d61c009",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/69/e3"+ },+ {+ "type": "inline",+ "contents": "763581e9c630fa5d969e57574916c4fd2d975ea5\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/json5/-/json5-2.2.3.tgz\", \"integrity\": \"sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==\", \"time\": 0, \"size\": 50318, \"metadata\": {\"url\": \"https://registry.npmjs.org/json5/-/json5-2.2.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e89f8bf36bf4f4865512579b711f7cba1f7f3a4cc4d8b133abb9793b0ea9",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/2c/24"+ },+ {+ "type": "inline",+ "contents": "786aa2884a39f6ee594c2af39b0a45da145cc069\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz\", \"integrity\": \"sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==\", \"time\": 0, \"size\": 9622, \"metadata\": {\"url\": \"https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "58cbe482acb2f4e2b961dfc2cdd7143d35b8f091f18831fcdcf72dc7cd4f",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/0d/01"+ },+ {+ "type": "inline",+ "contents": "7961e5f9f00751572b580538b4cdf06106672d4d\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.2.tgz\", \"integrity\": \"sha512-MErl12k7BFHZG1TI9QF/3lSSZARzq9KgNy/FjnqFMCkv+N4RSSzoUCA5h2mqHX4Mox3WaTVKblyzhQ1zRb2ZuQ==\", \"time\": 0, \"size\": 904203, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "7287dba88f2c19e65847f7ce18379afe363e5aa95f23acf7fd948e24b20e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/74/cd"+ },+ {+ "type": "inline",+ "contents": "7a96398bcb23418943af4f6b2a22a767399e981b\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/debug/-/debug-4.4.3.tgz\", \"integrity\": \"sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==\", \"time\": 0, \"size\": 13449, \"metadata\": {\"url\": \"https://registry.npmjs.org/debug/-/debug-4.4.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e25f670d26bc26d1cb236efef449fc8718223fd484c4107ba797934cb10c",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/c9/1f"+ },+ {+ "type": "inline",+ "contents": "7ab8cd031a2cef69947ca7e56d1b8e8cf1b4dc33\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz\", \"integrity\": \"sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==\", \"time\": 0, \"size\": 3751, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "3c3d3bae96103eea0881228975bc730e8e1a86f3b47584173536f19d4b08",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/7a/eb"+ },+ {+ "type": "inline",+ "contents": "7b485fa15598e9f1e4ecfaef1b38a47d50da3e19\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.2.tgz\", \"integrity\": \"sha512-XfvsgzR7DZqREdst7K1Mj3ilSUM5xLAHJcIMDFPKdxTs9q5VHOT8aMA+a683fqBu7DQl8+Sd9HCsQYL8EMY9qA==\", \"time\": 0, \"size\": 893433, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "811a27f7e787653da78662b8c3369cb1dc44c5ddc7b8f7b9fd00f6cc0a87",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/7d/9f"+ },+ {+ "type": "inline",+ "contents": "7ceb30c8ac138670e59e18a8cb8bed712f85edf9\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz\", \"integrity\": \"sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg==\", \"time\": 0, \"size\": 323010, \"metadata\": {\"url\": \"https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "ceb9a3ca4ae375f3c18096f3c50edaca555b5351099882f66badd535bc38",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/b8/b1"+ },+ {+ "type": "inline",+ "contents": "84866b1f1d5b98b0703e9bda1b8ffc02b018ca8b\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz\", \"integrity\": \"sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==\", \"time\": 0, \"size\": 4424, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "5672834f1013134431fc8a076f0234611b6f557cbb3f79d1d17edd2e9172",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a6/eb"+ },+ {+ "type": "inline",+ "contents": "854060adf70aaae07fb43017b376a1e0b4fcf675\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.2.tgz\", \"integrity\": \"sha512-akcZquRzCY/KpUoZAMBhGf7oi4LmXq1BzRA5CPAC3rkUf28Y/sAYV3jSL+JKd7cwEyFvR5G0XVZ0gaMedP+60A==\", \"time\": 0, \"size\": 883682, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "2eebcb5c4ce04b20de30e5b74735dde9802fd0788942d98ebccb6e572748",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8e/c2"+ },+ {+ "type": "inline",+ "contents": "8c8eff166e34e35e7e230cbd4c12c4b7321988e6\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz\", \"integrity\": \"sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==\", \"time\": 0, \"size\": 18401, \"metadata\": {\"url\": \"https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "896209f48728e5c51546b3eee1a7f3ca0e3f1fd7a3ed03452a8c45bc6d6a",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/9d/ac"+ },+ {+ "type": "inline",+ "contents": "8fc7855095d039f2a76b3c417ff1c5bf1323a3cd\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz\", \"integrity\": \"sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==\", \"time\": 0, \"size\": 4087166, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "0a1f9a76f75287d17b060945e113589e60ea6b8aeb793165d74e4caa628e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d3/9f"+ },+ {+ "type": "inline",+ "contents": "912805456ee0fff3bbf2e21f6854da729a60e61c\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz\", \"integrity\": \"sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==\", \"time\": 0, \"size\": 5824, \"metadata\": {\"url\": \"https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "8c061789582f306e5cd49035ee51582e6495bd621f643d2451345dc3b3dc",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/90/53"+ },+ {+ "type": "inline",+ "contents": "9282db09db250156de09f12f35bd4a6946ac4f70\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/node-releases/-/node-releases-2.0.55.tgz\", \"integrity\": \"sha512-mIrE/Cw9y+9Au6dS5vDKDhQza9YvG6w+ZrS6X+ZzA7yFW/soAeaups4Qzn1bL6g5FVy8WtP79+0j82oPIbqRjQ==\", \"time\": 0, \"size\": 6071, \"metadata\": {\"url\": \"https://registry.npmjs.org/node-releases/-/node-releases-2.0.55.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "51746e787d4402622fc1a08d7b60e752ae5353910dd46f2ab1dfcbdc0600",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/2b/05"+ },+ {+ "type": "inline",+ "contents": "9acdbdc65ef996bf8d8ddef275e7fccd0b91a3fc\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz\", \"integrity\": \"sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==\", \"time\": 0, \"size\": 4229555, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "f0dedeee6b00068f272c7d5b85387baa746909855d7eadab5796c66c2668",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d3/f5"+ },+ {+ "type": "inline",+ "contents": "9bb7daff4835b52fe36b6d93b4303fa3b4326190\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz\", \"integrity\": \"sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==\", \"time\": 0, \"size\": 10384, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "5f2e04fe73aa013a02edf031459ca2412692ea65964115ebe84f8dd26f97",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/23/d7"+ },+ {+ "type": "inline",+ "contents": "9bd85894a0a173c9a11c0af148416a1b867c9b1d\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz\", \"integrity\": \"sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==\", \"time\": 0, \"size\": 37783, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "88b3b8aae31fcb4c8aee70663d7c1bdf72a065a32589977f261f7ec81b8d",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/9b/8c"+ },+ {+ "type": "inline",+ "contents": "9c8a850b9eef6b34ef0ed7687dee7ce92ac997b7\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/ms/-/ms-2.1.3.tgz\", \"integrity\": \"sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==\", \"time\": 0, \"size\": 2967, \"metadata\": {\"url\": \"https://registry.npmjs.org/ms/-/ms-2.1.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "bd8af8e4938b9fee217abddb09ce52db330434e323c828aeabe5bd909ae7",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/21/a7"+ },+ {+ "type": "inline",+ "contents": "9fa22a51ea578f6ef4b1fcc924f3183c3cf7ee45\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/api/-/api-2.11.1.tgz\", \"integrity\": \"sha512-M2FPuYND2m+wh5hfW9ZpSdxMPdEJovPBWwoHJmwUpysTYNHaOkVFN419m/K0LIgjb/7KU2vBgsUepJWugQCvAA==\", \"time\": 0, \"size\": 135672, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/api/-/api-2.11.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "eac0487d1bad8eb709e7ed72596a3c51344947d5996d3c6dcc9ca8e0d2cc",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/20/af"+ },+ {+ "type": "inline",+ "contents": "a1ad0bd89a6406cc846c3d2708d9fdb98424f1dd\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-darwin-arm64/-/cli-darwin-arm64-2.11.4.tgz\", \"integrity\": \"sha512-1ryOF3ZhpZ/nemHV5zVwBQBz9jDGKmKPvWPADOhc83ig0P4bMc2iER4NbC6r9sjeIZ6RVQ4g3RZIYvezhcl4TQ==\", \"time\": 0, \"size\": 7902237, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-darwin-arm64/-/cli-darwin-arm64-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "bda1b50b6eee0a5e0977f9e6fa9c076bd145a9a05ad28da2dae1d37a429c",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/3a/72"+ },+ {+ "type": "inline",+ "contents": "a32dba68d0346b8e06af9666833a38b916b4c70e\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/vite/-/vite-6.4.3.tgz\", \"integrity\": \"sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==\", \"time\": 0, \"size\": 632844, \"metadata\": {\"url\": \"https://registry.npmjs.org/vite/-/vite-6.4.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "383d157ff157e4a5900da1ea86d724b3121d1c8fdb51ac4e2abd10e67f52",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a8/dd"+ },+ {+ "type": "inline",+ "contents": "a3ffc521f3a3aa8792ed0671033bfefa02294b10\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz\", \"integrity\": \"sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==\", \"time\": 0, \"size\": 4484984, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "41923902cc27ec7d83b21d07756eb9d378e356ae9fd384620581f7168fd8",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/9d/43"+ },+ {+ "type": "inline",+ "contents": "a8bf0661d1ce53cd07333db99adc8e0b6830b257\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.2.tgz\", \"integrity\": \"sha512-EGoo5DMVMRkTId8fuTDaoxVlR5ZTsKULUezRjd9gCw5eeY+DjCvDpZAOlNUvKPGX+7rS1RWx6j+yOpNPx0cUgQ==\", \"time\": 0, \"size\": 943972, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "8c92cfb6c1efc04a8b4a8db349af258bf809b8e14fbec90b8ab57dffe1b4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/ce/a2"+ },+ {+ "type": "inline",+ "contents": "a901398ef2f2aa757c967c0852753f203e2539f0\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz\", \"integrity\": \"sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==\", \"time\": 0, \"size\": 3274073, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "538d647557aeae69a76fef6ac596f7722e584a26296f3ec389de88a11eb1",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8d/6f"+ },+ {+ "type": "inline",+ "contents": "a9330eef8afc077d03ef8a280ecfc09be5977408\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz\", \"integrity\": \"sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==\", \"time\": 0, \"size\": 301854, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "255526ac0589eb11dcc4f2c8ab30a85974521fd4921adfd05b04a6e92a1f",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d1/c5"+ },+ {+ "type": "inline",+ "contents": "ab93a47f9c735850818809abfd40b68e6ae46771\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz\", \"integrity\": \"sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==\", \"time\": 0, \"size\": 15915, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "1da406197170b616eda8e749f38787cc2f6a51a7cc273ecb5c757804513e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/ec/52"+ },+ {+ "type": "inline",+ "contents": "b056c31802ef4da4294b310706b8f7b7eb2d873a\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz\", \"integrity\": \"sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==\", \"time\": 0, \"size\": 4469597, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "9af4602db2fb84470e28597ffadeeda0e54ffd282c10fcca8ed4b9927e20",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/46/16"+ },+ {+ "type": "inline",+ "contents": "b0d19ef7d9472824d8f99263f768481ce4ac7555\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/browserslist/-/browserslist-4.28.9.tgz\", \"integrity\": \"sha512-EWazOblFYUvlGZcfGhPUPmYh3nikUxBVb+y9MJun5f3hBi812X+8MSQTujLBtgK3cf51fJWbWfOjyeO954d+Eg==\", \"time\": 0, \"size\": 18332, \"metadata\": {\"url\": \"https://registry.npmjs.org/browserslist/-/browserslist-4.28.9.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "8a275a027d6940de0dc63413bf974460556f6d97d1ba50c74b5d4842b524",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/35/d7"+ },+ {+ "type": "inline",+ "contents": "b123bae67d2d0e7a9ae1e69c459e5119c828cb58\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz\", \"integrity\": \"sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==\", \"time\": 0, \"size\": 4384, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "d5dd1776bc8b91a94cc71eb3a1e40a8d0e261a2123ce326bf670dde8c98b",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/3f/6b"+ },+ {+ "type": "inline",+ "contents": "b67db885f212ce7ef813b99c26bfc88182ec034d\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz\", \"integrity\": \"sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==\", \"time\": 0, \"size\": 17726, \"metadata\": {\"url\": \"https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "3aa5d94761ad382e1a1acc61203736494009e20422bce1dd1433666dd012",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d0/57"+ },+ {+ "type": "inline",+ "contents": "b71b4107dcf538594722aaa0406493613ea40dec\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-win32-arm64-msvc/-/cli-win32-arm64-msvc-2.11.4.tgz\", \"integrity\": \"sha512-ld5Ehb598m0VkYyylRPNeCFsBe/km0jxis6KgMpl3IGY6I/i1RwQXO05I1AsXUXO2WC6AvB/Lw4qTf/asiuEiQ==\", \"time\": 0, \"size\": 7275788, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-win32-arm64-msvc/-/cli-win32-arm64-msvc-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "9ba93d42655988e452e81713ddca3f52a369f812501cba3492f3cc67539f",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/3e/77"+ },+ {+ "type": "inline",+ "contents": "b7b2c53e78216e19ccd892db974a1382354d600e\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz\", \"integrity\": \"sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==\", \"time\": 0, \"size\": 4483, \"metadata\": {\"url\": \"https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "8e01e6bce59ac02f0d20fc97382749190cb73f6006f9526fc7fb1ec79dd4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/d1/26"+ },+ {+ "type": "inline",+ "contents": "ba844c0cec4b8209e0ce16c70e553c1625d074e8\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/prosemirror-transform/-/prosemirror-transform-1.12.2.tgz\", \"integrity\": \"sha512-PE/aY0HEY4zczvmqrilgkUK/WautF0chvMqkmM/iN5/aPHvwrCWaQZjS6CIZp+K84YrvPFqrL+YArrfJX8xX7g==\", \"time\": 0, \"size\": 75618, \"metadata\": {\"url\": \"https://registry.npmjs.org/prosemirror-transform/-/prosemirror-transform-1.12.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "80bc380809ae556b5af335866048b2abb1333a3998905743a5892428526d",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/c3/f3"+ },+ {+ "type": "inline",+ "contents": "bb7cbc2981f2d592d9d43e5c01ce82974268bffa\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/lucide-react/-/lucide-react-1.48.0.tgz\", \"integrity\": \"sha512-R0CIKY/fXiC6y9xRBADgsK+VW2p/pcTJOMhLZf1T+uG+vJUvyUR02nGOgmIIC7MPkiNK4Ox8QDnbqF8rJYWPZQ==\", \"time\": 0, \"size\": 3079026, \"metadata\": {\"url\": \"https://registry.npmjs.org/lucide-react/-/lucide-react-1.48.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "d08202ebda68858cdd1e226aa520733972be4794d86bcafeb9e8d0b71582",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a8/39"+ },+ {+ "type": "inline",+ "contents": "bca61143b45e94d18e44556cf413881fe8a8cc51\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz\", \"integrity\": \"sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==\", \"time\": 0, \"size\": 4952, \"metadata\": {\"url\": \"https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "656d08a513cf41cf02f0fcb0e63ba171f108175b3c711837ec0c0f93f955",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/0a/d0"+ },+ {+ "type": "inline",+ "contents": "bd31a0ef7e75acd83bfcb02cdc6df43a2fee5831\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/axe-core/-/axe-core-4.13.0.tgz\", \"integrity\": \"sha512-UzGt8zg7Ny8djbYMhxl2zuEevVa7r2gJjYY5Lwr1xM7+XU2nd6CkIWFTVcCIbAP63vSz71NaVyyuSk9lHKcy0A==\", \"time\": 0, \"size\": 627805, \"metadata\": {\"url\": \"https://registry.npmjs.org/axe-core/-/axe-core-4.13.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "440e26031a9d0945c7012e43ef22e74e7de628bede43e79e5804eb6aaf9b",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a4/6b"+ },+ {+ "type": "inline",+ "contents": "be24af5fe7f43c407c27b4c95eb5f64db3f99671\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz\", \"integrity\": \"sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==\", \"time\": 0, \"size\": 4024126, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "977ef981869ae74d2a1325b8b6da077057aa278a0fa70c4e362da415c02f",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/ae/c6"+ },+ {+ "type": "inline",+ "contents": "be4138fca42ff79ffbe5d869abe9f6b3a52d2259\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz\", \"integrity\": \"sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==\", \"time\": 0, \"size\": 17972, \"metadata\": {\"url\": \"https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "9672ccd5d1b968aaac0d946fa3edfb7bf457bbf9ea32c1949fbe55b875f4",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/bf/07"+ },+ {+ "type": "inline",+ "contents": "bf17bc9feca98e76e2167d1981a076e31663a7c6\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz\", \"integrity\": \"sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==\", \"time\": 0, \"size\": 9608, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "4022921afad2e38857eb774774f73ce1bd92b1c21069b7125dc7c7578551",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/26/d4"+ },+ {+ "type": "inline",+ "contents": "c12cf1946acc640a7848817425e81effa3f7f7d4\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.2.tgz\", \"integrity\": \"sha512-N58uktcwzk3+qT4KHEuNdIxX1N01RWrkfVoml69EAbSaNDL+sbNVLx2RMl4Qd23lpA0fgPvyh5hHb4weD5WKmg==\", \"time\": 0, \"size\": 905417, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "55300b82516d2d50eb45675b5a679c41d8d1317559552e370cb2edbaa14e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/39/99"+ },+ {+ "type": "inline",+ "contents": "c375a623b22500e0b5ad9180961e5bc8a1742f6b\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz\", \"integrity\": \"sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==\", \"time\": 0, \"size\": 10038, \"metadata\": {\"url\": \"https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "1394bfe3119ef9620ccb5d4eb6c4001ab70c64efb55f558a35ad46138686",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a4/96"+ },+ {+ "type": "inline",+ "contents": "c399f3acb41ffb7fda8f2958850f998c904cc000\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-linux-x64-musl/-/cli-linux-x64-musl-2.11.4.tgz\", \"integrity\": \"sha512-o9GyhYor/nc7xarmwDE3ka2szuW3uuZzXjHWh64Q8YX5AtSgxdQkFWzrY4O8KiGtVNvFBI14H3Q49Qj5TOIP/A==\", \"time\": 0, \"size\": 8652989, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-linux-x64-musl/-/cli-linux-x64-musl-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "6f897b82d2e32bc8116defc271239ee0911530767d7507d4476a90155a2b",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/1d/6a"+ },+ {+ "type": "inline",+ "contents": "c601090cd6c8b1839c4124219198a5715b7d8250\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/react/-/react-18.3.31.tgz\", \"integrity\": \"sha512-vfEqpXTvwT91yhmwdfouStN2hSKwTvyRs8qpLfADyrq/kxDw0hZM7Wk9Ug1FELj8hIby+S/+kQCSRFF32nv2Qw==\", \"time\": 0, \"size\": 80345, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/react/-/react-18.3.31.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "9af1f2c5216d57925681562e3a425fcaed71f790c8207dcdef380ef352f5",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a2/aa"+ },+ {+ "type": "inline",+ "contents": "c88e5ca7fd331d689af683865a1a9f5f80a6a905\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.2.tgz\", \"integrity\": \"sha512-xe1bCKPJaKsD0tfd7Rb6bGfUogJTpKbTEEthsfdb7hTfTRNJVQTdirabQx0o6ERVba/smkM720soMY+0QnrlSQ==\", \"time\": 0, \"size\": 925046, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "3c1362a422d0622a2ed4d5b4c2ae75bfc7cfdf63743e9dfcc73d7dda5402",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/02/f6"+ },+ {+ "type": "inline",+ "contents": "caab412a990e892c0a6f687d3ed1f2b4b8582fe4\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz\", \"integrity\": \"sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==\", \"time\": 0, \"size\": 24326, \"metadata\": {\"url\": \"https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e43ea27e40a4ebc3ba4102f20f3d6796415f2f1a4f9f0dfae93d933b0ad6",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/5e/ca"+ },+ {+ "type": "inline",+ "contents": "cc954bca09c6fd7efd6f6c54659e9fa736ae4f30\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz\", \"integrity\": \"sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==\", \"time\": 0, \"size\": 3733025, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "77d3e4706106af1d54d566124ea823ae6aa2adcc348b3af3e45c1183d0a9",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/04/be"+ },+ {+ "type": "inline",+ "contents": "d0b4a795af7c5a290d8cd62afe5c3391f43c53e1\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz\", \"integrity\": \"sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==\", \"time\": 0, \"size\": 4375063, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "3a58f2fa1297155c6d33db9cbaac6748e674fb1a81715fc000135460a5af",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/8c/8f"+ },+ {+ "type": "inline",+ "contents": "d2da1f6634ec7e4d39df4f509dc8b53fdcd3694a\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz\", \"integrity\": \"sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==\", \"time\": 0, \"size\": 2677, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "48011259d0e96d76bb6477a88e2828eb597909fd035b03109bd1f2cc4e3e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/e1/13"+ },+ {+ "type": "inline",+ "contents": "d31c9160378263d3bc01ee81e386c673303cf2d8\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz\", \"integrity\": \"sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==\", \"time\": 0, \"size\": 138324, \"metadata\": {\"url\": \"https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "97d2c6e5c772f993e1a5b5fdeae5e52c835ac89d689ba43dbe025d54d880",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/96/e8"+ },+ {+ "type": "inline",+ "contents": "d3dc889f6ad66f9291ecef25bad74664d27d0ca9\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz\", \"integrity\": \"sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==\", \"time\": 0, \"size\": 18157, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "c7fa8f4763ce45f543d6952e5a1787fcb67fff9e7372f0684fe68cfbe342",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/62/c6"+ },+ {+ "type": "inline",+ "contents": "d79faf5fb9569efa453f4f4d963806ab445c5bea\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz\", \"integrity\": \"sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==\", \"time\": 0, \"size\": 4296, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a8b30a439dfcf0b09abd5dce256cec215e5094780e39dae9291d68c45eea",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/14/60"+ },+ {+ "type": "inline",+ "contents": "d7af0dccbb92c22336f80fc25356846c3a282481\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz\", \"integrity\": \"sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==\", \"time\": 0, \"size\": 7873, \"metadata\": {\"url\": \"https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "43b89d1c15ce8a3c5d1add3132f3c3d0fc8ae221a195e331cb84d785ed88",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/aa/65"+ },+ {+ "type": "inline",+ "contents": "da2d8aede0915ae5081bf94bf73d3e6a5547798f\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz\", \"integrity\": \"sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==\", \"time\": 0, \"size\": 4395720, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "055de2b5a37d474abdd9bcefab350877b3dcac2b6a726fd8bc33dcc26d2c",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/61/8d"+ },+ {+ "type": "inline",+ "contents": "dc0568305d8879648fb68df061df8f9d78c10d75\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.2.tgz\", \"integrity\": \"sha512-vdryWeRb2bLJZf0Fv/W8se6nvsHe2PkTCxV0meheK3nQE+G90VCJcke51Miy1yQRsfm2uqIyjXOu4wmUzbTtkQ==\", \"time\": 0, \"size\": 979905, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "ee4a70d5cd05638e9d1f4ad3cc110cd103dc6cbf4c1e0dffc2d2d6c95200",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/08/d7"+ },+ {+ "type": "inline",+ "contents": "dec4fa36f7c4ab7cb0d2f0d60af0fb0f07fb1666\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz\", \"integrity\": \"sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==\", \"time\": 0, \"size\": 2625, \"metadata\": {\"url\": \"https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "c9aa1c46bf0c67511379e97bd07fca87532422f2506214f94db8861160d3",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/a1/5e"+ },+ {+ "type": "inline",+ "contents": "dfa846ad4aa6614e35653bcf542308eb4689c476\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz\", \"integrity\": \"sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==\", \"time\": 0, \"size\": 8383, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "4d94c6c25990732f631da05a710bc3d90594982ac55c4556c82cb1edbdad",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/c2/a3"+ },+ {+ "type": "inline",+ "contents": "e2989bc87628631e88c062866c4a7967f8869d80\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.2.tgz\", \"integrity\": \"sha512-tC3IY7qoaD9Ll3/8WJQn49j5V2f/NuI9S41NOE2iM5MPs3sPIvOkVToLcz/7Bz4pyF7PSvrtwu8I/pUrGOSecQ==\", \"time\": 0, \"size\": 916429, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a167de340e46a0848e4134ca5b6e7a993be1b6be8d7d7ae7520bef1fc58e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/2b/d4"+ },+ {+ "type": "inline",+ "contents": "e2f08f4f4bcc9d97ee09c72bf27c88b08526edae\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz\", \"integrity\": \"sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==\", \"time\": 0, \"size\": 4069529, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e0f3f7a8f2fa0d3754af24af4a9f525ebbe04b8deb711f248b33a0f5bfde",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/17/52"+ },+ {+ "type": "inline",+ "contents": "e33bf96ab44eee78243e23f1ec72a01652834a7c\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.2.tgz\", \"integrity\": \"sha512-HWF2zH8EAp2scWRpt2PGe6iUGz7zi04waXsdRr3zb4DWCk2ImIo5FZu0jjmD53nP/DGSvnW0e7/1ToCNZs2lZw==\", \"time\": 0, \"size\": 712437, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "7681c290c5a574c8ac74c54c2e880119f0f8d8a02fd5b1a48c3cb10b3448",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/95/46"+ },+ {+ "type": "inline",+ "contents": "e34c3b041b6295e2e74f4888f1fd7c9aa3a2efbf\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/rollup/-/rollup-4.63.2.tgz\", \"integrity\": \"sha512-l5eyksV4tPBj6lJyEa37YzIOCSOV7lkZzEHUdpjWZbtD7wTcFYmEYXSgm5bT4vV+dZLb9rBG1W9GROOG4NS4Ew==\", \"time\": 0, \"size\": 576183, \"metadata\": {\"url\": \"https://registry.npmjs.org/rollup/-/rollup-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "c5c2e0486c7fd0df3dd185f04809d5743ffa0d9355d71d03a7ac46c481ce",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/71/20"+ },+ {+ "type": "inline",+ "contents": "e60ac816b1777a89b4eabce95a8938dc5638468d\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz\", \"integrity\": \"sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==\", \"time\": 0, \"size\": 14864, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "72adca232a03beb43a8b72dac70aea04b97a0bf6b9fefbbe65e78ce2ab06",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/93/09"+ },+ {+ "type": "inline",+ "contents": "e8d8f2eca996b1ae589a41e91ac72725a979071a\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.2.tgz\", \"integrity\": \"sha512-fNwYHrPyYyxauPzX/cpYw8Z7LQpp+DGA0KCoswA0aVFBpmdMil9XgjB8V3Ny64Ihu797+GKcuJqnsOKEmor7fA==\", \"time\": 0, \"size\": 876017, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "4f2fe860526654aca1b27f42012a7006151979b74395a93b5890c64aec44",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/98/3c"+ },+ {+ "type": "inline",+ "contents": "e94ac98d04703b5c60d2f7504145453004556719\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.2.tgz\", \"integrity\": \"sha512-bcq2h2pkKmH2po4cZV8VWzO4lL40STyu/nLoFpYMQp9C2tCVNTdcVv86MwSsn3D5s1FBe2Ty1atqvVAUTMimNg==\", \"time\": 0, \"size\": 940781, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "b025ba83824f0c9eb91b71f97023a5fc2b1326100df5e8de3c1d97b72248",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/4f/54"+ },+ {+ "type": "inline",+ "contents": "eb2e7cc7c27b088084e6759b3be15c759f694a48\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz\", \"integrity\": \"sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==\", \"time\": 0, \"size\": 6542, \"metadata\": {\"url\": \"https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "df2b2137355548fc0e2edd8c75e03ade0d1036d9466886d3c4f7ea6248af",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/5a/48"+ },+ {+ "type": "inline",+ "contents": "eb95b36f3c3d5d8e48c8a5901a6414ae30de7e89\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-win32-x64-msvc/-/cli-win32-x64-msvc-2.11.4.tgz\", \"integrity\": \"sha512-+vDiqBIU5dMISg/wNvX3sF+ZHfgJGJ5T0AcO+EHNXV9GGAG+P5fzodlDXD3QdKCRgZxMoCm5PPvj3BqLNjBthw==\", \"time\": 0, \"size\": 7619200, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-win32-x64-msvc/-/cli-win32-x64-msvc-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "cada4d3cbc7229462cac850462b6f58c43ed5fce1b4efba3c58a8f7d75e1",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/15/bd"+ },+ {+ "type": "inline",+ "contents": "eeac7b5c68cdab35b1d644b5d64c9fac8e8a213e\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz\", \"integrity\": \"sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==\", \"time\": 0, \"size\": 14064, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a261187919d92768a88a7dd2d99815ee7f043463f14693e43ecf6ab9a13e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/79/2b"+ },+ {+ "type": "inline",+ "contents": "eed0435685500b468f822fcb809ad24a6b3840f3\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz\", \"integrity\": \"sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==\", \"time\": 0, \"size\": 6839, \"metadata\": {\"url\": \"https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "ec73cb10b2f32d6e39ab917041d3bb996ae7791a73f4dfdfe4d81b144894",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/5e/1e"+ },+ {+ "type": "inline",+ "contents": "f0cdd876a9e653a6e96e49c7eda9fc14c1f3b2ad\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.2.tgz\", \"integrity\": \"sha512-hKgB3nz/TKD3Wv78XEsyXzQsNjvhOHmwKQTvXADGOyU/cIClZDO7DsoggbdmJDPGp5V80tA3Vfv61PaKTLH3LA==\", \"time\": 0, \"size\": 889290, \"metadata\": {\"url\": \"https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "70156d44124c16587911623f1f1e38f184f86924bd476e00f831cf0e6cc0",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/20/48"+ },+ {+ "type": "inline",+ "contents": "f36b1016dd5b1627491067bd6601697ce1a9a873\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz\", \"integrity\": \"sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==\", \"time\": 0, \"size\": 4079682, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "419bef7fef31eafed33a2d9dbcde5e2220a980fb9265696660e9ef1a5997",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/53/1b"+ },+ {+ "type": "inline",+ "contents": "f391ea8b48e9043a5c249dd5e4464dd1417ac1a9\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/prosemirror-commands/-/prosemirror-commands-1.7.2.tgz\", \"integrity\": \"sha512-q6Q6szxqdu9Xd6EcdKsqXghu5nQdZTpB4Q9yd04WRc7/jt763e/rT60Owh0L1GYY+T46o5rD+9lEN36dZS43tw==\", \"time\": 0, \"size\": 30216, \"metadata\": {\"url\": \"https://registry.npmjs.org/prosemirror-commands/-/prosemirror-commands-1.7.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "729d1a1a654904791168f20d3ad79750c18cb3d0649458dd5f9f6abc4163",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/5e/5e"+ },+ {+ "type": "inline",+ "contents": "f602f50d86a013f1ed8937b139084ea43006ad39\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz\", \"integrity\": \"sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==\", \"time\": 0, \"size\": 7442, \"metadata\": {\"url\": \"https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "115303ea18a519131a06a54e40e89d11ac3d6417db6551daad7b909f4d80",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/29/da"+ },+ {+ "type": "inline",+ "contents": "fc1bdef33c1658d5896219662e97c9af32df6ce1\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz\", \"integrity\": \"sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==\", \"time\": 0, \"size\": 9704, \"metadata\": {\"url\": \"https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a45e494ca2e846d401646ceab55186fcfe87c4fa76d70a3850d08faf8949",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/45/74"+ },+ {+ "type": "inline",+ "contents": "fce5d36208723ffe246696fcd35e6b07e3899da3\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz\", \"integrity\": \"sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==\", \"time\": 0, \"size\": 4383334, \"metadata\": {\"url\": \"https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "ef123652a4af056bb998cde98140ffc4f44d882c75902e8a10c1d759c1da",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/5b/2b"+ },+ {+ "type": "inline",+ "contents": "fd81d7ed78a018d57d6d1911b059b8726077994e\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/semver/-/semver-6.3.1.tgz\", \"integrity\": \"sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==\", \"time\": 0, \"size\": 19093, \"metadata\": {\"url\": \"https://registry.npmjs.org/semver/-/semver-6.3.1.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "1e3daaea93f68bf9dcdd7e978b6dd8f43627145028c05ccc5d6187e7a25d",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/b9/bf"+ },+ {+ "type": "inline",+ "contents": "fe7ec1f17c15f7ecc769bcf7052b9014c34e91e5\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz\", \"integrity\": \"sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==\", \"time\": 0, \"size\": 14624, \"metadata\": {\"url\": \"https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "a2c7cee872051584ce9afbd7cd92701c7fe77cb8be37a304f4703459da8e",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/7c/01"+ },+ {+ "type": "inline",+ "contents": "ff1d66c8f6e7139c58e15776e4adbc8294e001be\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/@tauri-apps/cli-win32-ia32-msvc/-/cli-win32-ia32-msvc-2.11.4.tgz\", \"integrity\": \"sha512-12Hxi0XX/H5VFxO/bGgHkFWhml9VMgEOu9CidjeCeTNQ1l6fpUlbiGgSP7CLI3PFtW9/FfbeHieZ+kyWK5H7CA==\", \"time\": 0, \"size\": 7318138, \"metadata\": {\"url\": \"https://registry.npmjs.org/@tauri-apps/cli-win32-ia32-msvc/-/cli-win32-ia32-msvc-2.11.4.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "e1be3dcc84b02be66b1322506e994863a368bad7be66da8230428358795a",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/9f/6f"+ },+ {+ "type": "inline",+ "contents": "ffa89207688aa70f5a0f17e4d05734e451e9a6ff\t{\"key\": \"make-fetch-happen:request-cache:https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz\", \"integrity\": \"sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==\", \"time\": 0, \"size\": 52195, \"metadata\": {\"url\": \"https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz\", \"reqHeaders\": {}, \"resHeaders\": {}}}",+ "dest-filename": "aadf52099844232f97af818d4176e74a1daf76d86adbc7538e7f2c1e89e8",+ "dest": "flatpak-node/npm-cache/_cacache/index-v5/3f/d4"+ },+ {+ "type": "script",+ "commands": [+ "version=$(node --version | sed \"s/^v//\")",+ "nodedir=$(dirname \"$(dirname \"$(which node)\")\")",+ "mkdir -p \"flatpak-node/cache/node-gyp/$version\"",+ "ln -s \"$nodedir/include\" \"flatpak-node/cache/node-gyp/$version/include\"",+ "echo 11 > \"flatpak-node/cache/node-gyp/$version/installVersion\""+ ],+ "dest-filename": "setup_sdk_node_headers.sh",+ "dest": "flatpak-node"+ },+ {+ "type": "shell",+ "commands": [+ "bash flatpak-node/setup_sdk_node_headers.sh"+ ]+ },+ {+ "type": "shell",+ "commands": [+ "mkdir -p \"bin/@esbuild\"",+ "cp \".package/@esbuild/[email protected]/bin/esbuild\" \"bin/@esbuild/[email protected]\"",+ "ln -sf \"@esbuild/[email protected]\" \"bin/esbuild-current\""+ ],+ "dest": "flatpak-node/cache/esbuild",+ "only-arches": [+ "aarch64"+ ]+ },+ {+ "type": "shell",+ "commands": [+ "mkdir -p \"bin/@esbuild\"",+ "cp \".package/@esbuild/[email protected]/bin/esbuild\" \"bin/@esbuild/[email protected]\"",+ "ln -sf \"@esbuild/[email protected]\" \"bin/esbuild-current\""+ ],+ "dest": "flatpak-node/cache/esbuild",+ "only-arches": [+ "arm"+ ]+ },+ {+ "type": "shell",+ "commands": [+ "mkdir -p \"bin/@esbuild\"",+ "cp \".package/@esbuild/[email protected]/bin/esbuild\" \"bin/@esbuild/[email protected]\"",+ "ln -sf \"@esbuild/[email protected]\" \"bin/esbuild-current\""+ ],+ "dest": "flatpak-node/cache/esbuild",+ "only-arches": [+ "i386"+ ]+ },+ {+ "type": "shell",+ "commands": [+ "mkdir -p \"bin/@esbuild\"",+ "cp \".package/@esbuild/[email protected]/bin/esbuild\" \"bin/@esbuild/[email protected]\"",+ "ln -sf \"@esbuild/[email protected]\" \"bin/esbuild-current\""+ ],+ "dest": "flatpak-node/cache/esbuild",+ "only-arches": [+ "x86_64"+ ]+ }+]diff --git a/packaging/dev.quince.client.desktop.in b/packaging/io.github.yashwanthkamireddi.Pomander.desktop.insimilarity index 68%rename from packaging/dev.quince.client.desktop.inrename to packaging/io.github.yashwanthkamireddi.Pomander.desktop.inindex 4ac08bc..e911441 100644--- a/packaging/dev.quince.client.desktop.in+++ b/packaging/io.github.yashwanthkamireddi.Pomander.desktop.in@@ -1,6 +1,8 @@# The menu entry, with the names filled in by whatever is building the package — Tauri# substitutes these itself, and the Arch PKGBUILD fills them in with sed. One file, so the# entry cannot say one thing in a .deb and another in a .pkg.tar.zst.+# MimeType: calendar and contact files open in Pomander's import sheet (src-tauri/src/intake.rs);+# %U hands them over as file:// URIs, which intake reads.[Desktop Entry]Type=ApplicationName={{name}}@@ -11,9 +13,18 @@ Icon={{icon}}Terminal=falseCategories={{categories}}Keywords=iCloud;calendar;reminders;notes;contacts;sync;+MimeType=text/calendar;text/vcard;text/x-vcard;StartupNotify=trueStartupWMClass={{exec}}-Actions=notes;reminders;calendar;contacts;drive;photos;+Actions=new-reminder;new-note;notes;reminders;calendar;contacts;drive;photos;++[Desktop Action new-reminder]+Name=New Reminder+Exec={{exec}} --new reminder++[Desktop Action new-note]+Name=New Note+Exec={{exec}} --new note[Desktop Action notes]Name=Notesdiff --git a/packaging/dev.quince.client.metainfo.xml b/packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xmlsimilarity index 91%rename from packaging/dev.quince.client.metainfo.xmlrename to packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xmlindex cfd1b8e..dcf3588 100644--- a/packaging/dev.quince.client.metainfo.xml+++ b/packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xml@@ -8,7 +8,7 @@entitled to know that before they type their Apple ID.--><component type="desktop-application">- <id>dev.quince.client</id>+ <id>io.github.yashwanthkamireddi.Pomander</id><metadata_license>CC0-1.0</metadata_license><project_license>GPL-3.0-only</project_license>@@ -37,6 +37,12 @@<launchable type="desktop-id">Pomander.desktop</launchable>+ <provides>+ <mediatype>text/calendar</mediatype>+ <mediatype>text/vcard</mediatype>+ <mediatype>text/x-vcard</mediatype>+ </provides>+<categories><category>Utility</category><category>Office</category>@@ -56,7 +62,7 @@<url type="homepage">https://github.com/YashwanthKamireddi/quince</url><url type="bugtracker">https://github.com/YashwanthKamireddi/quince/issues</url>- <developer id="dev.quince">+ <developer id="io.github.yashwanthkamireddi"><name>Yashwanth Kamireddi</name></developer>diff --git a/probe/examples/calendar_count.rs b/probe/examples/calendar_count.rsnew file mode 100644index 0000000..94f2a32--- /dev/null+++ b/probe/examples/calendar_count.rs@@ -0,0 +1,29 @@+//! Read-only: how many calendars and events Apple holds in the window a sync keeps — counts only.+use anyhow::{anyhow, Result};+#[tokio::main]+async fn main() -> Result<()> {+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("calendar")+ .ok_or_else(|| anyhow!("no calendar"))?;+ let snap = quince_icloud::sync::fetch_calendar(+ client.http(),+ &root,+ client.service_params(),+ "2026-09-01",+ "2027-01-31",+ "Asia/Kolkata",+ )+ .await?;+ println!(+ "calendars={} events={}",+ snap.calendars.len(),+ snap.events.len()+ );+ Ok(())+}diff --git a/probe/examples/keyring_pipe.rs b/probe/examples/keyring_pipe.rsindex 024b3ce..8b10b89 100644--- a/probe/examples/keyring_pipe.rs+++ b/probe/examples/keyring_pipe.rs@@ -5,7 +5,7 @@ use anyhow::{anyhow, Result};use std::io::{Read, Write};fn main() -> Result<()> {- let entry = keyring::Entry::new("dev.quince.client", "session")?;+ let entry = keyring::Entry::new("io.github.yashwanthkamireddi.Pomander", "session")?;match std::env::args().nth(1).as_deref() {Some("get") => std::io::stdout().write_all(entry.get_password()?.as_bytes())?,Some("set") => {diff --git a/probe/examples/notes_attach_locked_shape.rs b/probe/examples/notes_attach_locked_shape.rsnew file mode 100644index 0000000..56f6ffe--- /dev/null+++ b/probe/examples/notes_attach_locked_shape.rs@@ -0,0 +1,326 @@+//! Read-only: the SHAPE of (a) password-protected notes and (b) phone-made picture+//! attachments — field names, CloudKit types, byte lengths, numbers. Never note text.+use anyhow::{anyhow, Result};+use base64::Engine;+use serde_json::Value;++fn b64len(v: &Value) -> String {+ v.as_str()+ .and_then(|s| base64::engine::general_purpose::STANDARD.decode(s).ok())+ .map_or("?".into(), |b| format!("{} bytes", b.len()))+}++fn name_shape(n: &str) -> String {+ let up = n+ .chars()+ .all(|c| c.is_ascii_uppercase() || c.is_ascii_digit() || c == '-');+ format!(+ "len {} {}{}",+ n.len(),+ if up { "UPPER/hex" } else { "mixed" },+ if n.matches('-').count() == 4 && n.len() == 36 {+ " (uuid)"+ } else {+ ""+ }+ )+}++/// Every field: name, type, and a non-revealing description of its value.+fn describe(r: &Value, safe_text: &[&str]) {+ println!(+ " recordType={} name: {}",+ r["recordType"],+ name_shape(r["recordName"].as_str().unwrap_or(""))+ );+ let mut top: Vec<&String> = r+ .as_object()+ .map(|o| o.keys().collect())+ .unwrap_or_default();+ top.sort();+ println!(" record keys: {top:?}");+ let Some(f) = r["fields"].as_object() else {+ return;+ };+ let mut keys: Vec<&String> = f.keys().collect();+ keys.sort();+ for k in keys {+ let t = f[k]["type"].as_str().unwrap_or("?");+ let v = &f[k]["value"];+ let d = match t {+ "ENCRYPTED_BYTES" | "BYTES" => {+ if safe_text.contains(&k.as_str()) {+ let raw = v+ .as_str()+ .and_then(|s| base64::engine::general_purpose::STANDARD.decode(s).ok())+ .unwrap_or_default();+ format!("{:?}", String::from_utf8_lossy(&raw))+ } else {+ b64len(v)+ }+ }+ "REFERENCE" => format!(+ "-> {} action={}",+ name_shape(v["recordName"].as_str().unwrap_or("")),+ v["action"]+ ),+ "REFERENCE_LIST" => format!("list of {}", v.as_array().map_or(0, Vec::len)),+ "ASSETID" => format!(+ "asset keys {:?} size {}",+ v.as_object()+ .map(|o| o.keys().cloned().collect::<Vec<_>>())+ .unwrap_or_default(),+ v["size"]+ ),+ "ASSETID_LIST" => format!("{} assets", v.as_array().map_or(0, Vec::len)),+ "STRING" => {+ if safe_text.contains(&k.as_str()) {+ format!("{v}")+ } else {+ format!("string {} chars", v.as_str().map_or(0, str::len))+ }+ }+ _ => format!("{v}"),+ };+ println!(" {k:<38} {t:<16} {d}");+ }+}++#[tokio::main]+async fn main() -> Result<()> {+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("ckdatabasews")+ .ok_or_else(|| anyhow!("no ck"))?;+ let (http, p) = (client.http().clone(), client.service_params());+ let zc = quince_icloud::cloudkit::ZoneClient::new(&http, &root, "com.apple.notes", p.clone());+ let walk = zc.all_records("Notes", None).await?;+ let recs = walk.records;+ let mut counts = std::collections::BTreeMap::<String, usize>::new();+ for r in &recs {+ *counts+ .entry(+ r["recordType"]+ .as_str()+ .unwrap_or("<tombstone>")+ .to_string(),+ )+ .or_default() += 1;+ }+ println!("record types: {counts:?}");++ // (a) locked notes+ let mut field_census = std::collections::BTreeMap::<String, usize>::new();+ for r in &recs {+ if let Some(o) = r["fields"].as_object() {+ for k in o.keys() {+ if k.contains("Crypto") || k.contains("Password") || k.contains("Hint") {+ *field_census+ .entry(format!("{}.{k}", r["recordType"].as_str().unwrap_or("?")))+ .or_default() += 1;+ }+ }+ }+ }+ println!("\ncrypto/password fields across zone: {field_census:?}");+ for r in recs+ .iter()+ .filter(|r| {+ r["recordType"]+ .as_str()+ .is_some_and(|t| t.starts_with("PasswordProtected"))+ })+ .take(2)+ {+ println!("\n== locked-related record");+ describe(r, &[]);+ }+ for r in recs+ .iter()+ .filter(|r| {+ r["fields"].get("CryptoSaltEncrypted").is_some()+ || r["fields"].get("CryptoIterationCount").is_some()+ })+ .take(2)+ {+ println!("\n== record carrying crypto fields");+ describe(r, &[]);+ }++ for r in recs.iter().filter(|r| r["recordType"] == "AccountData") {+ println!("\n== AccountData");+ describe(r, &[]);+ }+ let locked: Vec<String> = recs+ .iter()+ .filter(|r| r["recordType"] == "PasswordProtectedNote_UserSpecific")+ .filter_map(|r| {+ r["fields"]["Note"]["value"]["recordName"]+ .as_str()+ .map(String::from)+ })+ .collect();+ for n in &locked {+ let in_walk = recs+ .iter()+ .any(|r| r["recordName"].as_str() == Some(n.as_str()));+ println!("\n== locked note (in walk: {in_walk})");+ match zc.lookup_record("Notes", n).await? {+ Some(r) => describe(&r, &[]),+ None => println!(" lookup: not found"),+ }+ }+ for r in recs.iter().filter(|r| r["recordType"] == "AccountData") {+ let raw = r["fields"]["CryptoPassphraseVerifier"]["value"]+ .as_str()+ .and_then(|s| base64::engine::general_purpose::STANDARD.decode(s).ok())+ .unwrap_or_default();+ println!(+ "verifier head: {:?}",+ String::from_utf8_lossy(&raw[..raw.len().min(8)])+ );+ match plist::Value::from_reader(std::io::Cursor::new(&raw)) {+ Ok(v) => {+ fn shape(v: &plist::Value, pad: usize) {+ match v {+ plist::Value::Dictionary(d) => {+ for (k, x) in d {+ println!(+ "{}{k}: {}",+ " ".repeat(pad),+ match x {+ plist::Value::Integer(i) => format!("int {i:?}"),+ plist::Value::Data(b) => format!("data {}B", b.len()),+ plist::Value::String(s) => format!("string {}c", s.len()),+ plist::Value::Dictionary(_) | plist::Value::Array(_) =>+ "nested".into(),+ o => format!("{o:?}").chars().take(30).collect(),+ }+ );+ shape(x, pad + 2);+ }+ }+ plist::Value::Array(a) => {+ for x in a {+ shape(x, pad + 2)+ }+ }+ _ => {}+ }+ }+ shape(&v, 3);+ }+ Err(e) => println!(" not a plist: {e}"),+ }+ let raw = r["fields"]["MergeableDataEncrypted"]["value"]+ .as_str()+ .unwrap_or("");+ if let Some(b) = quince_icloud::ckdocument::debug_inflate(raw) {+ for l in quince_icloud::ckdocument::debug_tree(&b, 3)+ .iter()+ .filter(|l| !l.contains("text"))+ {+ println!(" md {l}");+ }+ }+ }+ let names = |t: &str| -> Vec<std::collections::BTreeSet<String>> {+ recs.iter()+ .filter(|r| r["recordType"] == "Attachment" && r["fields"]["UTI"]["value"] == t)+ .map(|r| r["fields"].as_object().unwrap().keys().cloned().collect())+ .collect()+ };+ for t in [+ "public.jpeg",+ "public.png",+ "public.json",+ "org.openxmlformats.spreadsheetml.sheet",+ ] {+ for set in names(t) {+ println!("{t}: {set:?}");+ }+ }+ if std::env::var("ONLY_LOCKED").is_ok() {+ return Ok(());+ }+ // (b) phone-made picture attachments+ let uti_of = |r: &Value| -> String {+ r["fields"]["UTIEncrypted"]["value"]+ .as_str()+ .and_then(|v| base64::engine::general_purpose::STANDARD.decode(v).ok())+ .map(|b| String::from_utf8_lossy(&b).into_owned())+ .or_else(|| r["fields"]["UTI"]["value"].as_str().map(String::from))+ .unwrap_or_default()+ };+ let mut utis = std::collections::BTreeMap::<String, usize>::new();+ for r in recs.iter().filter(|r| r["recordType"] == "Attachment") {+ *utis.entry(uti_of(r)).or_default() += 1;+ }+ println!("\nattachment UTIs: {utis:?}");+ let pics: Vec<&Value> = recs+ .iter()+ .filter(|r| {+ r["recordType"] == "Attachment"+ && matches!(+ uti_of(r).as_str(),+ "public.jpeg" | "public.heic" | "public.png"+ )+ })+ .take(6)+ .collect();+ for a in pics {+ println!(+ "\n== image Attachment parent={} chainParentKey? {} pluginFields={}",+ a["parent"]+ .as_object()+ .map(|o| format!("{:?}", o.keys().collect::<Vec<_>>()))+ .unwrap_or_default(),+ a.get("chainParentKey").is_some(),+ a["pluginFields"]+ );+ if let Some(pn) = a["parent"]["recordName"].as_str() {+ println!(+ " parent == Note ref? {}",+ Some(pn) == a["fields"]["Note"]["value"]["recordName"].as_str()+ );+ }+ describe(a, &["UTIEncrypted", "UTI"]);+ if let Some(m) = a["fields"]["Media"]["value"]["recordName"].as_str() {+ if let Some(media) = zc.lookup_record("Notes", m).await? {+ println!(+ " -- its Media; parent == attachment? {} parent==note? {}",+ media["parent"]["recordName"].as_str() == a["recordName"].as_str(),+ media["parent"]["recordName"].as_str()+ == a["fields"]["Note"]["value"]["recordName"].as_str()+ );+ describe(&media, &[]);+ }+ }+ // The run in its note that holds it.+ if let Some(n) = a["fields"]["Note"]["value"]["recordName"].as_str() {+ if let Some(note) = zc.lookup_record("Notes", n).await? {+ println!(" -- its Note's fields (shape)");+ describe(¬e, &[]);+ let id = a["recordName"].as_str().unwrap_or("");+ if let Some(doc) = note["fields"]["TextDataEncrypted"]["value"].as_str() {+ let raw = base64::engine::general_purpose::STANDARD.decode(doc)?;+ for run in quince_icloud::ckdocument::debug_attribute_runs(&raw) {+ if run.windows(id.len()).any(|w| w == id.as_bytes()) {+ println!(" -- attachment run tree:");+ for l in quince_icloud::ckdocument::debug_tree(&run, 4) {+ // ids/utis are strings; print only field shape lines+ println!(" {}", l.replace(id, "<ATTACHMENT-ID>"));+ }+ }+ }+ }+ }+ }+ }+ Ok(())+}diff --git a/probe/examples/notes_note_tables.rs b/probe/examples/notes_note_tables.rsnew file mode 100644index 0000000..a5322ff--- /dev/null+++ b/probe/examples/notes_note_tables.rs@@ -0,0 +1,54 @@+//! Read-only: one note's tables — each attachment's cells as Quince reads them, its record's+//! fields (encrypted ones as length and hash), and the raw document saved for diffing.+use anyhow::{anyhow, Result};+#[tokio::main]+async fn main() -> Result<()> {+ let note = std::env::args()+ .nth(1)+ .ok_or_else(|| anyhow!("note record name"))?;+ let out = std::env::args().nth(2).ok_or_else(|| anyhow!("dump dir"))?;+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("ckdatabasews")+ .ok_or_else(|| anyhow!("no ck"))?;+ let (http, p) = (client.http().clone(), client.service_params());+ let zc = quince_icloud::cloudkit::ZoneClient::new(&http, &root, "com.apple.notes", p);+ let walk = zc.all_records("Notes", None).await?;+ for r in walk.records.iter().filter(|r| {+ r["recordType"] == "Attachment"+ && r["fields"]["Note"]["value"]["recordName"] == note.as_str()+ }) {+ let name = r["recordName"].as_str().unwrap_or("x");+ println!("== attachment {name} tag={}", r["recordChangeTag"]);+ for (k, v) in r["fields"].as_object().into_iter().flatten() {+ let val = v["value"].to_string();+ println!(+ " {k}: {}",+ if val.len() > 90 {+ format!("<{} chars>", val.len())+ } else {+ val+ }+ );+ }+ if let Some(m) = r["fields"]["MergeableDataEncrypted"]["value"].as_str() {+ if let Some(raw) = quince_icloud::ckdocument::debug_inflate(m) {+ std::fs::write(format!("{out}/{name}.bin"), &raw).ok();+ }+ match quince_icloud::table::cells_from_base64(m) {+ Some(cells) => {+ for row in cells {+ println!(" | {}", row.join(" | "));+ }+ }+ None => println!(" (cells not readable)"),+ }+ }+ }+ Ok(())+}diff --git a/probe/examples/notes_reach_live.rs b/probe/examples/notes_reach_live.rsindex 12c7aec..6bfb576 100644--- a/probe/examples/notes_reach_live.rs+++ b/probe/examples/notes_reach_live.rs@@ -27,7 +27,7 @@ async fn main() -> Result<()> {let (http, p) = (client.http().clone(), client.service_params());let db = rusqlite::Connection::open_with_flags(std::path::PathBuf::from(std::env::var("HOME")?)- .join(".local/share/dev.quince.client/library.db"),+ .join(".local/share/io.github.yashwanthkamireddi.Pomander/library.db"),rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY,)?;let title = format!("Quince mount test {}", std::process::id());diff --git a/probe/examples/notes_table_replicas.rs b/probe/examples/notes_table_replicas.rsnew file mode 100644index 0000000..77016e5--- /dev/null+++ b/probe/examples/notes_table_replicas.rs@@ -0,0 +1,68 @@+//! Read-only: for one note and its table attachments, the base64 fields that name replicas+//! (`ReplicaIDToNotesVersionDataEncrypted`, `ReplicaIDToUserIDEncrypted`) and the table's+//! document, each saved raw (decoded, inflated where compressed) for diffing. Prints only+//! field names, sizes and record tags; no note text.+use anyhow::{anyhow, Result};+use base64::Engine;++fn save(out: &str, name: &str, field: &str, value: &str) {+ let Ok(raw) = base64::engine::general_purpose::STANDARD.decode(value.trim()) else {+ println!(" {field}: not base64");+ return;+ };+ let plain = quince_icloud::ckdocument::debug_inflate(value).unwrap_or_else(|| raw.clone());+ let path = format!("{out}/{name}.{field}.bin");+ std::fs::write(&path, &plain).ok();+ println!(+ " {field}: {} bytes raw, {} plain{} -> {path}",+ raw.len(),+ plain.len(),+ if raw.starts_with(&[0x1f, 0x8b]) {+ " (gzip)"+ } else {+ ""+ }+ );+}++#[tokio::main]+async fn main() -> Result<()> {+ let note = std::env::args()+ .nth(1)+ .ok_or_else(|| anyhow!("note record name"))?;+ let out = std::env::args().nth(2).ok_or_else(|| anyhow!("dump dir"))?;+ std::fs::create_dir_all(&out)?;+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("ckdatabasews")+ .ok_or_else(|| anyhow!("no ck"))?;+ let (http, p) = (client.http().clone(), client.service_params());+ let zc = quince_icloud::cloudkit::ZoneClient::new(&http, &root, "com.apple.notes", p);+ let walk = zc.all_records("Notes", None).await?;+ for r in walk.records.iter().filter(|r| {+ r["recordName"] == note.as_str()+ || (r["recordType"] == "Attachment"+ && r["fields"]["Note"]["value"]["recordName"] == note.as_str())+ }) {+ let name = r["recordName"].as_str().unwrap_or("x");+ println!(+ "== {} {name} tag={} modified={}",+ r["recordType"], r["recordChangeTag"], r["modified"]["timestamp"]+ );+ for field in [+ "ReplicaIDToNotesVersionDataEncrypted",+ "ReplicaIDToUserIDEncrypted",+ "MergeableDataEncrypted",+ ] {+ if let Some(v) = r["fields"][field]["value"].as_str() {+ save(&out, name, field, v);+ }+ }+ }+ Ok(())+}diff --git a/probe/examples/notes_table_writers.rs b/probe/examples/notes_table_writers.rsnew file mode 100644index 0000000..e7632c7--- /dev/null+++ b/probe/examples/notes_table_writers.rs@@ -0,0 +1,160 @@+//! Read-only: every table attachment on the account, by structure only — its document's+//! version vector (data field 1), its text writers (data field 7: uuid prefix and clocks),+//! its uuid count, and whether a given writer uuid appears. Tables naming that writer are+//! saved (inflated) to the dump dir for diffing. No cell text is printed.+//!+//! `notes_table_writers <writer-uuid> <dumpdir> [all]` — `all` saves every table, not only+//! those naming the writer.+use anyhow::{anyhow, Result};++fn varint(b: &[u8], mut at: usize) -> Option<(u64, usize)> {+ let mut v = 0u64;+ for s in 0..10 {+ let x = *b.get(at)?;+ at += 1;+ v |= u64::from(x & 0x7f) << (s * 7);+ if x & 0x80 == 0 {+ return Some((v, at));+ }+ }+ None+}++/// (field, Some(bytes) | None, int)+/// A message's fields: number, bytes when length-delimited, and value when a varint.+type Fields<'a> = Vec<(u64, Option<&'a [u8]>, u64)>;++fn fields(b: &[u8]) -> Option<Fields<'_>> {+ let mut out = Vec::new();+ let mut at = 0;+ while at < b.len() {+ let (k, n) = varint(b, at)?;+ at = n;+ match k & 7 {+ 0 => {+ let (v, n) = varint(b, at)?;+ at = n;+ out.push((k >> 3, None, v));+ }+ 2 => {+ let (l, n) = varint(b, at)?;+ let end = n.checked_add(usize::try_from(l).ok()?)?;+ out.push((k >> 3, Some(b.get(n..end)?), 0));+ at = end;+ }+ 1 => at += 8,+ 5 => at += 4,+ _ => return None,+ }+ }+ Some(out)+}++fn sub<'a>(fs: &[(u64, Option<&'a [u8]>, u64)], t: u64) -> Vec<&'a [u8]> {+ fs.iter().filter(|f| f.0 == t).filter_map(|f| f.1).collect()+}++fn ints(b: &[u8]) -> Vec<(u64, u64)> {+ fields(b)+ .unwrap_or_default()+ .iter()+ .filter(|f| f.1.is_none())+ .map(|f| (f.0, f.2))+ .collect()+}++#[tokio::main]+async fn main() -> Result<()> {+ let writer = std::env::args()+ .nth(1)+ .ok_or_else(|| anyhow!("writer uuid"))?;+ let out = std::env::args().nth(2).ok_or_else(|| anyhow!("dump dir"))?;+ std::fs::create_dir_all(&out)?;+ let me = *uuid::Uuid::parse_str(&writer)?.as_bytes();+ let all = std::env::args().nth(3).as_deref() == Some("all");+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("ckdatabasews")+ .ok_or_else(|| anyhow!("no ck"))?;+ let (http, p) = (client.http().clone(), client.service_params());+ let zc = quince_icloud::cloudkit::ZoneClient::new(&http, &root, "com.apple.notes", p);+ let walk = zc.all_records("Notes", None).await?;+ for r in walk.records.iter().filter(|r| {+ r["recordType"] == "Attachment" && r["fields"]["UTI"]["value"] == quince_icloud::table::UTI+ }) {+ let name = r["recordName"].as_str().unwrap_or("x");+ let note = r["fields"]["Note"]["value"]["recordName"]+ .as_str()+ .unwrap_or("?");+ let Some(raw) = r["fields"]["MergeableDataEncrypted"]["value"]+ .as_str()+ .and_then(quince_icloud::ckdocument::debug_inflate)+ else {+ continue;+ };+ let Some(top) = fields(&raw) else { continue };+ let mut lines = Vec::new();+ let mut mine = raw.windows(16).any(|w| w == me);+ for (vi, version) in sub(&top, 2).into_iter().enumerate() {+ let Some(vf) = fields(version) else { continue };+ for data in sub(&vf, 3) {+ let Some(df) = fields(data) else { continue };+ let vv: Vec<Vec<(u64, u64)>> = sub(&df, 1)+ .iter()+ .flat_map(|v| sub(&fields(v).unwrap_or_default(), 1))+ .map(ints)+ .collect();+ let uuids = sub(&df, 6);+ let mut writers = Vec::new();+ for w in sub(&df, 7)+ .iter()+ .flat_map(|v| sub(&fields(v).unwrap_or_default(), 1))+ {+ let wf = fields(w).unwrap_or_default();+ let id = sub(&wf, 1).first().map_or(String::new(), |u| {+ u.iter().take(4).map(|b| format!("{b:02x}")).collect()+ });+ let clocks: Vec<u64> = sub(&wf, 2)+ .iter()+ .flat_map(|c| ints(c))+ .map(|x| x.1)+ .collect();+ writers.push(format!("{id}{clocks:?}"));+ }+ let u0 = uuids.first().map_or(String::new(), |u| {+ u.iter().take(4).map(|b| format!("{b:02x}")).collect()+ });+ if uuids.contains(&&me[..]) {+ mine = true;+ }+ lines.push(format!(+ " v{vi}: data {}B vv={vv:?} f2={} uuids={} uuid0={u0} writers={writers:?}",+ data.len(),+ sub(&df, 2).len(),+ uuids.len()+ ));+ }+ }+ println!(+ "== {name} note={note} deleted={} mine={mine} top={:?} created={}@{} modified={}@{}",+ r["fields"]["Deleted"]["value"],+ ints(&raw),+ r["created"]["deviceID"],+ r["created"]["timestamp"],+ r["modified"]["deviceID"],+ r["modified"]["timestamp"],+ );+ for l in lines {+ println!("{l}");+ }+ if mine || all {+ std::fs::write(format!("{out}/{name}.bin"), &raw).ok();+ }+ }+ Ok(())+}diff --git a/probe/examples/notes_vs_library.rs b/probe/examples/notes_vs_library.rsindex 02ebd29..efec54c 100644--- a/probe/examples/notes_vs_library.rs+++ b/probe/examples/notes_vs_library.rs@@ -17,7 +17,7 @@ async fn main() -> Result<()> {let walk = zc.all_records("Notes", None).await?;let db = rusqlite::Connection::open_with_flags(std::path::PathBuf::from(std::env::var("HOME")?)- .join(".local/share/dev.quince.client/library.db"),+ .join(".local/share/io.github.yashwanthkamireddi.Pomander/library.db"),rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY,)?;let mut apple = std::collections::HashSet::new();diff --git a/probe/examples/reminders_detail_census.rs b/probe/examples/reminders_detail_census.rsnew file mode 100644index 0000000..33ef3dc--- /dev/null+++ b/probe/examples/reminders_detail_census.rs@@ -0,0 +1,40 @@+//! Live, READ-ONLY: walk the Reminders zone once and save every record to a file given as+//! the first argument, for offline study of record shapes (tags, URLs, smart lists, sections).+//! Writes nothing to iCloud. Prints only record-type counts — never titles.+use anyhow::{anyhow, Result};+#[tokio::main]+async fn main() -> Result<()> {+ let out = std::env::args()+ .nth(1)+ .ok_or_else(|| anyhow!("usage: <out.json>"))?;+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("ckdatabasews")+ .ok_or_else(|| anyhow!("no ckdatabasews"))?;+ let zc = quince_icloud::cloudkit::ZoneClient::new(+ client.http(),+ &root,+ "com.apple.reminders",+ client.service_params(),+ );+ let walk = zc.all_records("Reminders", None).await?;+ let mut counts = std::collections::BTreeMap::<String, usize>::new();+ for r in &walk.records {+ let t = r["recordType"]+ .as_str()+ .unwrap_or("(tombstone)")+ .to_string();+ *counts.entry(t).or_default() += 1;+ }+ println!("complete: {}", walk.complete);+ for (t, n) in counts {+ println!("{t}: {n}");+ }+ std::fs::write(&out, serde_json::to_vec(&walk.records)?)?;+ Ok(())+}diff --git a/probe/examples/reminders_details_read.rs b/probe/examples/reminders_details_read.rsnew file mode 100644index 0000000..83f9689--- /dev/null+++ b/probe/examples/reminders_details_read.rs@@ -0,0 +1,67 @@+//! Live, READ-ONLY: sync Reminders into a throwaway in-memory library and print what the+//! detail readers found — counts and kinds only, never titles or tag names.+use anyhow::{anyhow, Result};+#[tokio::main]+async fn main() -> Result<()> {+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("ckdatabasews")+ .ok_or_else(|| anyhow!("no ckdatabasews"))?;+ let mut lib = quince_core::Library::in_memory()?;+ let (lists, reminders, _) = quince_icloud::reminders::sync_cloudkit(+ client.http(),+ &root,+ client.service_params(),+ &mut lib,+ None,+ )+ .await?;+ println!("lists {lists}, reminders {reminders}");+ println!("tags on account: {}", lib.reminder_tags()?.len());+ let all: Vec<_> = lib+ .reminder_lists()?+ .into_iter()+ .flat_map(|l| lib.reminders_in(&l.guid, true).unwrap_or_default())+ .collect();+ let (mut alerts, mut urls, mut sectioned) = (0, 0, 0);+ let mut units = std::collections::BTreeMap::<(i64, i64), usize>::new();+ for r in &all {+ let d = lib.reminder_detail(&r.guid)?;+ alerts += usize::from(!d.early_alerts.is_empty());+ urls += usize::from(d.url.is_some());+ sectioned += usize::from(r.section_guid.is_some());+ for a in d.early_alerts {+ *units.entry((a.count, a.unit)).or_default() += 1;+ }+ }+ println!("reminders with an early alert: {alerts} {units:?}; with a link: {urls}; in a section: {sectioned}");+ println!(+ "early-alert account id known: {}",+ lib.early_alert_account()?.is_some()+ );+ let sections: usize = lib+ .reminder_lists()?+ .iter()+ .map(|l| lib.reminder_sections(&l.guid).map(|s| s.len()).unwrap_or(0))+ .sum();+ println!("live sections: {sections}");+ for s in lib.reminder_smart_lists()? {+ let filter = s+ .filter+ .as_deref()+ .map(quince_core::reminders::SmartFilter::decode);+ println!(+ "smart list kind={} pinned={} has_filter={} unknown={:?}",+ s.kind,+ s.pinned,+ filter.is_some(),+ filter.map(|f| f.unknown)+ );+ }+ Ok(())+}diff --git a/probe/examples/reminders_schema_probe.rs b/probe/examples/reminders_schema_probe.rsnew file mode 100644index 0000000..d63ed5f--- /dev/null+++ b/probe/examples/reminders_schema_probe.rs@@ -0,0 +1,88 @@+//! Live, READ-ONLY: ask CloudKit (records/query, which changes nothing) about record types and+//! fields this account holds no records of, by how it answers a filter on each field name.+//! Prints only Apple's error text and record counts.+use anyhow::{anyhow, Result};+use serde_json::json;+#[tokio::main]+async fn main() -> Result<()> {+ let dir = std::path::PathBuf::from(std::env::var("HOME")?).join(".local/share/quince-probe");+ let mut client = quince_auth::Client::new(&dir)?;+ if !client.resume().await? {+ return Err(anyhow!("no session"));+ }+ let root = client+ .session()+ .service_url("ckdatabasews")+ .ok_or_else(|| anyhow!("no ckdatabasews"))?;+ let zc = quince_icloud::cloudkit::ZoneClient::new(+ client.http(),+ &root,+ "com.apple.reminders",+ client.service_params(),+ );+ let probes: &[(&str, &str, serde_json::Value)] = &[+ ("Hashtag", "", json!(null)),+ ("Hashtag", "Name", json!({"value":"x","type":"STRING"})),+ ("Hashtag", "Type", json!({"value":0,"type":"NUMBER_INT64"})),+ (+ "Hashtag",+ "CreationDate",+ json!({"value":0,"type":"TIMESTAMP"}),+ ),+ (+ "Hashtag",+ "Deleted",+ json!({"value":0,"type":"NUMBER_INT64"}),+ ),+ (+ "Hashtag",+ "NoSuchFieldXyz",+ json!({"value":0,"type":"NUMBER_INT64"}),+ ),+ ("Attachment", "", json!(null)),+ ("Attachment", "URL", json!({"value":"x","type":"STRING"})),+ ("Attachment", "Type", json!({"value":"URL","type":"STRING"})),+ (+ "Attachment",+ "UTI",+ json!({"value":"public.url","type":"STRING"}),+ ),+ (+ "Attachment",+ "NoSuchFieldXyz",+ json!({"value":0,"type":"NUMBER_INT64"}),+ ),+ ("NoSuchTypeXyz", "", json!(null)),+ ("ListSection", "", json!(null)),+ ("SmartList", "", json!(null)),+ (+ "Reminder",+ "DueDateDeltaAlertsData",+ json!({"value":"eA==","type":"BYTES"}),+ ),+ ];+ let extra: Vec<String> = std::env::args().skip(1).collect();+ let owned: Vec<(String, String, serde_json::Value)> = if extra.is_empty() {+ probes+ .iter()+ .map(|(a, b, c)| (a.to_string(), b.to_string(), c.clone()))+ .collect()+ } else {+ extra+ .into_iter()+ .map(|t| (t, String::new(), json!(null)))+ .collect()+ };+ for (ty, f, v) in &owned {+ let q = if f.is_empty() {+ json!({"recordType": ty})+ } else {+ json!({"recordType": ty, "filterBy": [{"comparator":"EQUALS","fieldName": f, "fieldValue": v}]})+ };+ match zc.records_query("Reminders", q).await {+ Ok(r) => println!("{ty}.{f}: ok, {} records", r.len()),+ Err(e) => println!("{ty}.{f}: {e}"),+ }+ }+ Ok(())+}diff --git a/probe/examples/reminders_section_files.rs b/probe/examples/reminders_section_files.rsnew file mode 100644index 0000000..a545b1b--- /dev/null+++ b/probe/examples/reminders_section_files.rs@@ -0,0 +1,50 @@+//! Live, READ-ONLY: download every list's section-membership file (and SectionIDsOrdering if+//! any) from the zone dump made by `reminders_detail_census`, saving each beside the dump.+//! Writes nothing to iCloud. Prints only sizes and checksums.+use anyhow::{anyhow, Result};+use serde_json::Value;+#[tokio::main]+async fn main() -> Result<()> {+ let dump = std::env::args()+ .nth(1)+ .ok_or_else(|| anyhow!("usage: <zone.json>"))?;+ let out = std::path::Path::new(&dump)+ .parent()+ .unwrap()+ .join("memberships");+ std::fs::create_dir_all(&out)?;+ let records: Vec<Value> = serde_json::from_slice(&std::fs::read(&dump)?)?;+ let http = reqwest::Client::new();+ for (i, r) in records.iter().enumerate() {+ if r["recordType"] != "List" {+ continue;+ }+ for f in [+ "MembershipsOfRemindersInSectionsAsData",+ "SectionIDsOrderingAsData",+ ] {+ let Some(url) = r+ .pointer(&format!("/fields/{f}/value/downloadURL"))+ .and_then(Value::as_str)+ else {+ continue;+ };+ let bytes = http+ .get(url.replace("${f}", "file"))+ .send()+ .await?+ .bytes()+ .await?;+ let name = format!("{i}-{f}.bin");+ std::fs::write(out.join(&name), &bytes)?;+ let ck = r.pointer("/fields/MembershipsOfRemindersInSectionsChecksum/value");+ println!(+ "{name}: {} bytes, checksum field {:?}, asset {:?}",+ bytes.len(),+ ck,+ r.pointer(&format!("/fields/{f}/value/fileChecksum"))+ );+ }+ }+ Ok(())+}diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.tomlindex 1a67921..ba02324 100644--- a/src-tauri/Cargo.toml+++ b/src-tauri/Cargo.toml@@ -32,6 +32,10 @@ tauri-plugin-single-instance = "2"libc = "0.2"tauri-plugin-window-state = "2"+# Toasts with buttons on Windows (notify-rust sends none there): the same crate notify-rust uses.+[target.'cfg(windows)'.dependencies]+tauri-winrt-notification = "0.8"+[target.'cfg(target_os = "linux")'.dependencies]fuser = { version = "0.18", default-features = false }# A video's poster when Apple's is blank: one frame read with GStreamer, which WebKitGTKdiff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.jsonindex a16c08e..e57b889 100644--- a/src-tauri/capabilities/default.json+++ b/src-tauri/capabilities/default.json@@ -1,12 +1,17 @@{"$schema": "../gen/schemas/desktop-schema.json","identifier": "default",- "description": "Core window permissions for the Quince window.",+ "description": "What the window's own page may ask of Tauri itself, and no more: hearing the engine's events (and the webview's dropped files), the app's version for Settings, a window's title, and the system's open and save dialogs. Pomander's own commands are separate. These windows only ever load the app's bundled page (no remote URL is granted anything).","windows": [- "main"+ "main",+ "app-*",+ "capture"],"permissions": [- "core:default",+ "core:event:allow-listen",+ "core:event:allow-unlisten",+ "core:app:allow-version",+ "core:window:allow-set-title","dialog:allow-open","dialog:allow-save"]diff --git a/src-tauri/src/alerts.rs b/src-tauri/src/alerts.rsindex 7fa24e1..c85c757 100644--- a/src-tauri/src/alerts.rs+++ b/src-tauri/src/alerts.rs@@ -10,7 +10,6 @@use crate::{Auth, Data};use quince_core::alarms::DueAlarm;use std::time::Duration;-#[cfg(all(unix, not(target_os = "macos")))]use tauri::Emitter;use tauri::{AppHandle, Manager};use tokio::sync::Notify;@@ -27,7 +26,6 @@ const LONGEST_SLEEP: Duration = Duration::from_secs(10 * 60);const STILL_WORTH_SAYING: i64 = 6 * 60 * 60;/// Snooze, as the phone offers it.-#[cfg(all(unix, not(target_os = "macos")))]const SNOOZE: i64 = 60 * 60;/// The app's icon, carried in the binary so an alert shows it on any desktop. A notification@@ -37,6 +35,116 @@ const SNOOZE: i64 = 60 * 60;const ICON: &[u8] = include_bytes!("../icons/[email protected]");static ICON_PATH: std::sync::OnceLock<Option<String>> = std::sync::OnceLock::new();+/// What a press on a reminder's alert does — Linux's notification actions and Windows' toast+/// buttons alike: complete this occurrence, put it off an hour, or open it in Reminders.+fn answer(app: &AppHandle, due: &DueAlarm, due_then: Option<Option<i64>>, action: &str) {+ match action {+ "complete" => {+ let app = app.clone();+ let due = due.clone();+ tauri::async_runtime::block_on(async move {+ let auth = app.state::<Auth>();+ let data = app.state::<Data>();+ let now = data+ .0+ .lock()+ .await+ .reminder(&due.reminder_guid)+ .ok()+ .flatten();+ let same = now+ .as_ref()+ .is_some_and(|r| r.completed_at.is_none() && Some(r.due_at) == due_then);+ if !same {+ quiet!("an alert was answered after its reminder had moved on");+ } else if let Err(e) =+ crate::set_done(&auth, &data, &due.reminder_guid, &due.list_guid, true).await+ {+ quiet!("an alert's reminder could not be completed: {e}");+ }+ // Every open screen looks again, as after any pass.+ let report = crate::refresh::status(&data.0).await;+ app.emit(crate::SYNCED, &report).ok();+ });+ }+ "snooze" => {+ let app = app.clone();+ let guid = due.reminder_guid.clone();+ tauri::async_runtime::block_on(async move {+ let data = app.state::<Data>();+ let mut library = data.0.lock().await;+ library.snooze_reminder(&guid, now() + SNOOZE).ok();+ });+ changed();+ }+ "default" => {+ crate::show_window(app);+ app.emit(OPEN_REMINDER, &due.reminder_guid).ok();+ }+ _ => {}+ }+}++/// A plain notice from the app itself — not a reminder or an event — sent as Pomander, and+/// opening the window when clicked where the desktop allows it.+pub fn tell(app: &AppHandle, title: &str, body: &str) {+ let app = app.clone();+ let (title, body) = (title.to_string(), body.to_string());+ std::thread::spawn(move || {+ let mut notice = notify_rust::Notification::new();+ #[cfg(windows)]+ notice.app_id(&app.config().identifier);+ notice+ .appname("Pomander")+ .summary(&title)+ .body(&body)+ .icon(icon_path(&app).unwrap_or("quince"));+ #[cfg(all(unix, not(target_os = "macos")))]+ {+ notice+ .hint(notify_rust::Hint::DesktopEntry(+ app.config().identifier.clone(),+ ))+ .action("default", "Open");+ if let Ok(handle) = notice.show() {+ handle.wait_for_action(|action| {+ if action == "default" {+ crate::show_window(&app);+ }+ });+ }+ }+ #[cfg(not(all(unix, not(target_os = "macos"))))]+ notice.show().ok();+ });+}++/// An alert's sound, as the desktop's own sound theme has it ("alarm-clock-elapsed"). A+/// notification server that plays sounds is asked to play it; one that does not — Quickshell,+/// mako, dunst and others say no "sound" capability — leaves it to the app, as the spec says,+/// and it is played here through libcanberra, which keeps to the sound theme and to the+/// desktop's "event sounds" switch. Without this every alert on such a desktop was silent.+#[cfg(all(unix, not(target_os = "macos")))]+fn chime(alert: &mut notify_rust::Notification) {+ const SOUND: &str = "alarm-clock-elapsed";+ static SERVER_PLAYS: std::sync::OnceLock<bool> = std::sync::OnceLock::new();+ let server_plays = *SERVER_PLAYS.get_or_init(|| {+ notify_rust::get_capabilities().is_ok_and(|c| c.iter().any(|x| x == "sound"))+ });+ if server_plays {+ alert.hint(notify_rust::Hint::SoundName(SOUND.into()));+ return;+ }+ // Not waited on: an alert never stands behind its sound.+ std::process::Command::new("canberra-gtk-play")+ .args(["--id", SOUND, "--description", "Pomander alert"])+ .stdin(std::process::Stdio::null())+ .stdout(std::process::Stdio::null())+ .stderr(std::process::Stdio::null())+ .spawn()+ .ok();+}+fn icon_path(app: &AppHandle) -> Option<&'static str> {ICON_PATH.get_or_init(|| {@@ -52,7 +160,6 @@ fn icon_path(app: &AppHandle) -> Option<&'static str> {}/// Emitted to the window to open a reminder an alert was clicked for.-#[cfg(all(unix, not(target_os = "macos")))]pub const OPEN_REMINDER: &str = "quince://open-reminder";/// Tell the task to look again: the reminders or their alarms may have changed.@@ -168,39 +275,65 @@ fn show(app: AppHandle, due: DueAlarm) {.map(ToString::to_string).or_else(|| due.list_title.clone()).unwrap_or_default();- // The phone's choices on the alert are the freedesktop notification spec's actions. Windows- // and macOS take no buttons through this crate, so the alert says what is due and- // the reminder is completed or put off in the app.- #[cfg(not(all(unix, not(target_os = "macos"))))]+ // The occurrence this alert is for: a repeating reminder ticked since (here or on the+ // phone) has moved on, and a press on this alert must not move it on again.+ let due_then = {+ let app = app.clone();+ let guid = due.reminder_guid.clone();+ tauri::async_runtime::block_on(async move {+ let data = app.state::<Data>();+ let library = data.0.lock().await;+ library.reminder(&guid).ok().flatten().map(|r| r.due_at)+ })+ };+ // On Windows the phone's choices are the toast's own buttons, and the toast is sent as+ // the app the Start menu knows (the installer stamps its shortcut with this ID; without+ // it every alert came from "Windows PowerShell"), with Windows' reminder chime.+ #[cfg(windows)]{- notify_rust::Notification::new()- .appname("Pomander")- .summary(&due.title)- .body(&body)- .icon(icon_path(&app).unwrap_or("quince"))- .show()- .ok();+ use tauri_winrt_notification::{Duration as Shown, Scenario, Sound, Toast};+ let answering = app.clone();+ let due_answered = due.clone();+ let mut toast = Toast::new(&app.config().identifier)+ .title(&due.title)+ .text1(&body)+ .sound(Some(Sound::Reminder))+ .duration(Shown::Long)+ .scenario(Scenario::Reminder)+ .add_button("Mark as Completed", "complete")+ .add_button("Remind Me in 1 Hour", "snooze")+ .on_activated(move |action| {+ answer(+ &answering,+ &due_answered,+ due_then,+ action.as_deref().unwrap_or("default"),+ );+ Ok(())+ });+ if let Some(icon) = icon_path(&app) {+ toast = toast.icon(+ std::path::Path::new(icon),+ tauri_winrt_notification::IconCrop::Square,+ "Pomander",+ );+ }+ toast.show().ok();}#[cfg(all(unix, not(target_os = "macos")))]{- // The occurrence this alert is for: a repeating reminder ticked since (here or on the- // phone) has moved on, and a press on this alert must not move it on again.- let due_then = {- let app = app.clone();- let guid = due.reminder_guid.clone();- tauri::async_runtime::block_on(async move {- let data = app.state::<Data>();- let library = data.0.lock().await;- library.reminder(&guid).ok().flatten().map(|r| r.due_at)- })- };- let shown = notify_rust::Notification::new()+ let mut alert = notify_rust::Notification::new();+ chime(&mut alert);+ let shown = alert.appname("Pomander").summary(&due.title).body(&body).icon(icon_path(&app).unwrap_or("quince")).hint(notify_rust::Hint::Category("reminder".into()))- .hint(notify_rust::Hint::DesktopEntry("quince".into()))+ .hint(notify_rust::Hint::DesktopEntry(format!(+ "{}.Reminders",+ app.config().identifier+ ))).hint(notify_rust::Hint::Resident(true)).action("default", "Open").action("complete", "Mark as Completed")@@ -210,52 +343,7 @@ fn show(app: AppHandle, due: DueAlarm) {let Ok(handle) = shown else {return;};- handle.wait_for_action(|action| match action {- "complete" => {- let app = app.clone();- let due = due.clone();- tauri::async_runtime::block_on(async move {- let auth = app.state::<Auth>();- let data = app.state::<Data>();- let now = data- .0- .lock()- .await- .reminder(&due.reminder_guid)- .ok()- .flatten();- let same = now.as_ref().is_some_and(|r| {- r.completed_at.is_none() && Some(r.due_at) == due_then- });- if !same {- quiet!("an alert was answered after its reminder had moved on");- } else if let Err(e) =- crate::set_done(&auth, &data, &due.reminder_guid, &due.list_guid, true)- .await- {- quiet!("an alert's reminder could not be completed: {e}");- }- // Every open screen looks again, as after any pass.- let report = crate::refresh::status(&data.0).await;- app.emit(crate::SYNCED, &report).ok();- });- }- "snooze" => {- let app = app.clone();- let guid = due.reminder_guid.clone();- tauri::async_runtime::block_on(async move {- let data = app.state::<Data>();- let mut library = data.0.lock().await;- library.snooze_reminder(&guid, now() + SNOOZE).ok();- });- changed();- }- "default" => {- crate::show_window(&app);- app.emit(OPEN_REMINDER, &due.reminder_guid).ok();- }- _ => {}- });+ handle.wait_for_action(|action| answer(&app, &due, due_then, action));}});}@@ -374,7 +462,16 @@ fn show_event(app: AppHandle, event: quince_core::calendar::Event, minutes: i64)}#[cfg(not(all(unix, not(target_os = "macos"))))]{- notify_rust::Notification::new()+ let mut toast = notify_rust::Notification::new();+ // Windows names a toast's sender by the app ID it claims, matched to the Start+ // menu shortcut the installer stamps with the same ID; without it every alert+ // came from "Windows PowerShell".+ #[cfg(windows)]+ toast.app_id(&app.config().identifier);+ // Windows' own reminder chime; without a sound named the toast was silent.+ #[cfg(windows)]+ toast.sound_name("Reminder");+ toast.appname("Pomander").summary(&event.title).body(&body)@@ -384,13 +481,18 @@ fn show_event(app: AppHandle, event: quince_core::calendar::Event, minutes: i64)}#[cfg(all(unix, not(target_os = "macos")))]{- let shown = notify_rust::Notification::new()+ let mut alert = notify_rust::Notification::new();+ chime(&mut alert);+ let shown = alert.appname("Pomander").summary(&event.title).body(&body).icon(icon_path(&app).unwrap_or("quince")).hint(notify_rust::Hint::Category("calendar".into()))- .hint(notify_rust::Hint::DesktopEntry("quince".into()))+ .hint(notify_rust::Hint::DesktopEntry(format!(+ "{}.Calendar",+ app.config().identifier+ ))).action("default", "Open").show();if let Ok(handle) = shown {diff --git a/src-tauri/src/apps.rs b/src-tauri/src/apps.rsindex 7e0abf8..9685af1 100644--- a/src-tauri/src/apps.rs+++ b/src-tauri/src/apps.rs@@ -38,6 +38,90 @@ pub fn asked(args: &[String]) -> Option<&'static str> {.map(|(key, _)| *key)}+/// What a quick-capture launcher action asks for: `--new reminder` or `--new note` (or+/// `--new=note`).+pub fn new_asked(args: &[String]) -> Option<&'static str> {+ let named = args.iter().enumerate().find_map(|(i, a)| {+ a.strip_prefix("--new=")+ .map(ToString::to_string)+ .or_else(|| (a == "--new").then(|| args.get(i + 1).cloned()).flatten())+ })?;+ match named.as_str() {+ "reminder" => Some("reminder"),+ "note" => Some("note"),+ _ => None,+ }+}++/// The calendar and contact files a command line hands over — opened from a file manager,+/// as a path (`%F`, Windows) or a `file://` URI (`%U`) — made absolute against `cwd`, the+/// directory the launch came from. Only files of the kinds Pomander opens are taken; any+/// other argument is someone else's business.+pub fn files_asked(args: &[String], cwd: &std::path::Path) -> Vec<std::path::PathBuf> {+ let mut skip_next = false;+ let mut out = Vec::new();+ for a in args.iter().skip(1) {+ if std::mem::take(&mut skip_next) {+ continue;+ }+ if a == "--app" || a == "--new" {+ skip_next = true;+ continue;+ }+ if a.starts_with('-') {+ continue;+ }+ let path = match a.strip_prefix("file://") {+ Some(uri) => {+ // `file:///home/a/b.ics`, or `file://localhost/…`; on Windows `file:///C:/…`.+ let uri = uri.strip_prefix("localhost").unwrap_or(uri);+ let decoded = percent_decoded(uri);+ let decoded = if cfg!(windows) {+ decoded.trim_start_matches('/').to_string()+ } else {+ decoded+ };+ std::path::PathBuf::from(decoded)+ }+ None if a.contains("://") => continue,+ None => std::path::PathBuf::from(a),+ };+ let wanted = path.extension().and_then(|e| e.to_str()).is_some_and(|e| {+ matches!(+ e.to_ascii_lowercase().as_str(),+ "ics" | "ical" | "icalendar" | "vcf" | "vcard"+ )+ });+ if wanted {+ out.push(if path.is_absolute() {+ path+ } else {+ cwd.join(path)+ });+ }+ }+ out+}++/// `%20` and the rest of a URI's escapes turned back into the bytes they stand for.+fn percent_decoded(s: &str) -> String {+ let bytes = s.as_bytes();+ let mut out = Vec::with_capacity(bytes.len());+ let mut i = 0;+ while i < bytes.len() {+ if bytes[i] == b'%' && i + 2 < bytes.len() && s.is_char_boundary(i + 3) {+ if let Ok(b) = u8::from_str_radix(&s[i + 1..i + 3], 16) {+ out.push(b);+ i += 3;+ continue;+ }+ }+ out.push(bytes[i]);+ i += 1;+ }+ String::from_utf8_lossy(&out).into_owned()+}+fn label(key: &str) -> String {format!("app-{key}")}@@ -94,10 +178,56 @@ pub fn open(app: &AppHandle, key: &str) {});}+/// How long a closed app window is kept, put away, before its memory is given back.+const KEPT: std::time::Duration = std::time::Duration::from_secs(10 * 60);++/// When each put-away app window was closed: shown again, it is taken off the list, so a+/// window closed, reopened and closed again is kept the full while from its last close.+static PUT_AWAY: std::sync::Mutex<Vec<(String, std::time::Instant)>> =+ std::sync::Mutex::new(Vec::new());++/// A closed app window, kept hidden for a while and then closed for good if it was not opened+/// again meanwhile.+pub fn put_away(window: &tauri::Window) {+ let label = window.label().to_string();+ let at = std::time::Instant::now();+ {+ let mut list = PUT_AWAY+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ list.retain(|(l, _)| *l != label);+ list.push((label.clone(), at));+ }+ let app = window.app_handle().clone();+ tauri::async_runtime::spawn(async move {+ tokio::time::sleep(KEPT).await;+ let still = PUT_AWAY+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .iter()+ .any(|(l, t)| *l == label && *t == at);+ if still {+ PUT_AWAY+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .retain(|(l, _)| *l != label);+ if let Some(w) = app.get_webview_window(&label) {+ if !w.is_visible().unwrap_or(true) {+ w.destroy().ok();+ }+ }+ }+ });+}+/// An app's window put on screen, and — now that it is there — told its own app ID: GTK/// takes a window's app ID only once the window is shown (measured: set before, it was/// silently dropped and the window went on saying the program's name).pub fn show(window: &tauri::WebviewWindow) {+ PUT_AWAY+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .retain(|(l, _)| l != window.label());window.show().ok();window.set_focus().ok();#[cfg(target_os = "linux")]@@ -170,4 +300,43 @@ mod tests {assert_eq!(asked(&args(&["pomander", "--app", "mail"])), None);assert_eq!(asked(&args(&["pomander", "--app"])), None);}++ #[test]+ fn a_launcher_action_asks_for_a_quick_capture() {+ assert_eq!(+ new_asked(&args(&["pomander", "--new", "reminder"])),+ Some("reminder")+ );+ assert_eq!(new_asked(&args(&["pomander", "--new=note"])), Some("note"));+ assert_eq!(new_asked(&args(&["pomander", "--new", "event"])), None);+ assert_eq!(new_asked(&args(&["pomander", "--new"])), None);+ assert_eq!(new_asked(&args(&["pomander", "--app", "notes"])), None);+ }++ #[test]+ fn opened_files_are_taken_as_paths_or_uris() {+ let cwd = std::path::Path::new("/home/a/Downloads");+ let got = files_asked(+ &args(&[+ "pomander",+ "--app",+ "calendar",+ "invite.ics",+ "/tmp/Card.VCF",+ "file:///home/a/My%20Events.ics",+ "notes.txt",+ "https://example.com/x.ics",+ ]),+ cwd,+ );+ assert_eq!(+ got,+ vec![+ std::path::PathBuf::from("/home/a/Downloads/invite.ics"),+ std::path::PathBuf::from("/tmp/Card.VCF"),+ std::path::PathBuf::from("/home/a/My Events.ics"),+ ]+ );+ assert!(files_asked(&args(&["pomander", "--app", "x.ics"]), cwd).is_empty());+ }}diff --git a/src-tauri/src/contacts_cmds.rs b/src-tauri/src/contacts_cmds.rsnew file mode 100644index 0000000..27bf4e1--- /dev/null+++ b/src-tauri/src/contacts_cmds.rs@@ -0,0 +1,61 @@+//! Contacts commands: a card's postal addresses, part by part.++use crate::{Data, UiResult};+use quince_core::contacts::PostalAddress;+use quince_icloud::contacts::address::{self, AddressEdit};+use tauri::State;++/// One card's addresses, each part on its own, as the last pass (or edit) stored them.+#[tauri::command]+pub async fn contact_addresses(+ guid: String,+ data: State<'_, Data>,+) -> UiResult<Vec<PostalAddress>> {+ let library = data.0.lock().await;+ library.contact_addresses(&guid).map_err(|e| e.to_string())+}++/// Change a card's addresses: set a part, set a label, add one or take one out — any number+/// at once, in order. `base` is the list the form opened (the stored list when absent); the+/// edits are laid over Apple's addresses as they stand at the moment of writing, so a part+/// changed on another device stays. Shown here at once; on a refusal Apple's card is read+/// back, so what is on screen is never something Apple does not have. Answers the list.+#[tauri::command]+pub async fn contact_address_edit(+ guid: String,+ base: Option<Vec<PostalAddress>>,+ edits: Vec<AddressEdit>,+ auth: State<'_, crate::Auth>,+ data: State<'_, Data>,+) -> UiResult<Vec<PostalAddress>> {+ let _one = crate::CONTACTS_PASS.lock().await;+ let (http, root, params) = crate::contacts_context(&auth).await?;+ let base = match base {+ Some(base) => base,+ None => {+ let library = data.0.lock().await;+ library+ .contact_addresses(&guid)+ .map_err(|e| e.to_string())?+ }+ };+ // Checked, and shown, before anything is sent.+ let (after, _) = address::apply_edits(&base, &edits).map_err(|e| e.to_string())?;+ {+ let mut library = data.0.lock().await;+ library+ .set_contact_addresses(&guid, &after)+ .map_err(|e| e.to_string())?;+ }+ match address::edit(&http, &root, params.clone(), &guid, &base, &edits).await {+ Ok(written) => {+ crate::settle(crate::resync_contacts(&http, &root, params, &data).await)?;+ Ok(written)+ }+ Err(e) => {+ // Put back what Apple has.+ let _ = crate::resync_contacts(&http, &root, params, &data).await;+ Err(e.to_string())+ }+ }+}diff --git a/src-tauri/src/intake.rs b/src-tauri/src/intake.rsnew file mode 100644index 0000000..006a4b9--- /dev/null+++ b/src-tauri/src/intake.rs@@ -0,0 +1,1258 @@+//! What comes into Pomander from outside its own windows: a calendar or contact file opened+//! with it (`.ics`, `.vcf`) and the quick-capture launcher actions (`pomander --new reminder`).+//!+//! A file is read here, on this computer, and nothing is sent anywhere until the person says+//! so in the import sheet: what it holds is shown first — the events with their days and+//! repeats, the people with their numbers — and what cannot be brought in is said, with why.+//! Confirmed, the sheet writes through the same commands the apps' own forms use+//! (`event_save`, `contacts_import`), so an imported event is made exactly as one typed in.+//!+//! A quick capture is a small window of its own with one field: a reminder into the list last+//! added to, or a note into Notes, written with `reminder_create` / `note_create` and gone.++use serde::Serialize;+use std::path::Path;+use std::sync::Mutex as StdMutex;+use tauri::{AppHandle, Emitter, Manager, WebviewUrl, WebviewWindowBuilder};++use jiff::civil::{Date, DateTime, Weekday};+use jiff::tz::TimeZone;+use jiff::{Span, Timestamp};+use quince_icloud::calendar::EventRepeat;++/// Told to a window when something has arrived for it: it asks `intake_pending` for it.+const ARRIVED: &str = "quince://intake";+/// Told to the quick-capture window when it is asked for again, perhaps for the other kind.+const CAPTURE: &str = "quince://capture";+/// The quick-capture window's label.+const CAPTURE_WINDOW: &str = "capture";+/// Larger than any calendar or address book a person would open by hand; a file past it is+/// refused rather than read into memory.+const MOST_BYTES: u64 = 16 * 1024 * 1024;++/// What arrived, waiting for the window it is for (by label) to collect it. A window that is+/// still loading collects it once drawn; one already open is told.+static PENDING: StdMutex<Vec<(String, Arrival)>> = StdMutex::new(Vec::new());++/// One opened file, read and ready to be shown.+#[derive(Debug, Clone, Serialize)]+#[serde(+ tag = "kind",+ rename_all = "camelCase",+ rename_all_fields = "camelCase"+)]+pub enum Arrival {+ /// A calendar file: the events that can be added, and those that cannot.+ Events {+ file: String,+ events: Vec<ImportEvent>,+ refused: Vec<Refused>,+ },+ /// A contacts file: the people in it. Added by `contacts_import` from `path`.+ Contacts {+ file: String,+ path: String,+ contacts: Vec<ImportContact>,+ },+ /// A file that could not be read at all.+ Unreadable { file: String, reason: String },+}++/// An event as `event_save` takes it, less the calendar the person picks.+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]+#[serde(rename_all = "camelCase")]+pub struct ImportEvent {+ pub title: String,+ pub location: Option<String>,+ pub starts_at: i64,+ pub ends_at: i64,+ pub all_day: bool,+ pub timezone: Option<String>,+ pub notes: Option<String>,+ pub url: Option<String>,+ /// Minutes before the start, `0` at the time; `None` when the file sets none.+ pub alerts: Option<Vec<i64>>,+ pub repeat: Option<EventRepeat>,+ /// Already in a calendar here: the same title at the same time. Left out of the import.+ pub duplicate: bool,+}++/// Something in a file that cannot be brought in, and why, in plain words.+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]+#[serde(rename_all = "camelCase")]+pub struct Refused {+ pub title: String,+ pub reason: String,+}++/// A person in a contacts file, for the preview.+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]+#[serde(rename_all = "camelCase")]+pub struct ImportContact {+ pub name: String,+ /// A phone number or address to tell people of the same name apart.+ pub detail: Option<String>,+ /// Already in Contacts; `contacts_import` leaves them out.+ pub known: bool,+}++/// Act on a command line — this launch's, or one forwarded by a second launch: a quick+/// capture, or files to import. Whether it asked for either; if not, the caller opens what+/// it would have opened anyway.+pub fn arrived(app: &AppHandle, args: &[String], cwd: &Path) -> bool {+ if let Some(kind) = crate::apps::new_asked(args) {+ capture(app, kind);+ return true;+ }+ let files = crate::apps::files_asked(args, cwd);+ if files.is_empty() {+ return false;+ }+ for path in files {+ let app = app.clone();+ tauri::async_runtime::spawn(async move {+ let (window_key, arrival) = read(&app, &path).await;+ let label = format!("app-{window_key}");+ if let Ok(mut pending) = PENDING.lock() {+ pending.push((label.clone(), arrival));+ }+ // Its app's window: made (it collects the file once drawn) or brought forward+ // and told.+ crate::apps::open(&app, window_key);+ app.emit_to(label.as_str(), ARRIVED, ()).ok();+ });+ }+ true+}++/// Read one file, and which app's window shows it.+async fn read(app: &AppHandle, path: &Path) -> (&'static str, Arrival) {+ let file = path.file_name().map_or_else(+ || path.display().to_string(),+ |n| n.to_string_lossy().into_owned(),+ );+ let lower = file.to_ascii_lowercase();+ let contacts_file = lower.ends_with(".vcf") || lower.ends_with(".vcard");+ let key = if contacts_file {+ "contacts"+ } else {+ "calendar"+ };+ let text = match load(path) {+ Ok(text) => text,+ Err(reason) => return (key, Arrival::Unreadable { file, reason }),+ };+ let data = app.state::<crate::Data>();+ if contacts_file {+ let book = data.0.lock().await.contacts(None).unwrap_or_default();+ let contacts = preview_contacts(&text, &book);+ if contacts.is_empty() {+ let reason = "There are no contacts in this file.".to_string();+ return (key, Arrival::Unreadable { file, reason });+ }+ let path = path.display().to_string();+ return (+ key,+ Arrival::Contacts {+ file,+ path,+ contacts,+ },+ );+ }+ let zone = TimeZone::system();+ let (mut events, refused) = match parse_calendar(&text, &zone) {+ Ok(read) => read,+ Err(reason) => return (key, Arrival::Unreadable { file, reason }),+ };+ {+ let library = data.0.lock().await;+ for event in &mut events {+ event.duplicate = library+ .events_starting_between(event.starts_at, event.starts_at + 1)+ .unwrap_or_default()+ .iter()+ .filter_map(|(guid, _)| library.event(guid).ok().flatten())+ .any(|e| e.title.trim().eq_ignore_ascii_case(event.title.trim()));+ }+ }+ (+ key,+ Arrival::Events {+ file,+ events,+ refused,+ },+ )+}++fn load(path: &Path) -> Result<String, String> {+ let size = std::fs::metadata(path)+ .map_err(|_| "The file couldn’t be found, or can’t be read.".to_string())?+ .len();+ if size > MOST_BYTES {+ return Err("The file is too large to be a calendar or contacts file.".into());+ }+ let bytes = std::fs::read(path).map_err(|_| "The file couldn’t be read.".to_string())?;+ Ok(String::from_utf8_lossy(&bytes).into_owned())+}++/// Open the quick-capture window for `kind` ("reminder" or "note"), or bring it back.+pub fn capture(app: &AppHandle, kind: &'static str) {+ if let Some(w) = app.get_webview_window(CAPTURE_WINDOW) {+ app.emit_to(CAPTURE_WINDOW, CAPTURE, kind).ok();+ w.unminimize().ok();+ w.show().ok();+ w.set_focus().ok();+ return;+ }+ let made = WebviewWindowBuilder::new(+ app,+ CAPTURE_WINDOW,+ WebviewUrl::App(format!("index.html?capture={kind}").into()),+ )+ .title(if kind == "note" {+ "New Note"+ } else {+ "New Reminder"+ })+ .inner_size(460.0, 132.0)+ // A fixed size: a tiling compositor (Hyprland, sway) floats a window that cannot be+ // resized, as it floats a dialog, rather than tiling one field across half the screen.+ .resizable(false)+ .maximizable(false)+ .minimizable(false)+ .center()+ .always_on_top(true)+ .skip_taskbar(true)+ .decorations(false)+ // Shown by window_ready, once drawn: never a blank frame.+ .visible(false)+ .build();+ match made {+ Ok(window) => {+ // Shown anyway if the page never says it is drawn.+ tauri::async_runtime::spawn(async move {+ tokio::time::sleep(std::time::Duration::from_secs(3)).await;+ if !window.is_visible().unwrap_or(true) {+ window.show().ok();+ window.set_focus().ok();+ }+ });+ }+ Err(e) => quiet!("the quick capture window could not be made: {e}"),+ }+}++/// What has arrived for the window asking, taken from the queue.+#[tauri::command]+pub fn intake_pending(window: tauri::WebviewWindow) -> Vec<Arrival> {+ let Ok(mut pending) = PENDING.lock() else {+ return Vec::new();+ };+ let label = window.label().to_string();+ let (mine, rest): (Vec<_>, Vec<_>) = pending.drain(..).partition(|(l, _)| *l == label);+ *pending = rest;+ mine.into_iter().map(|(_, a)| a).collect()+}++/// The quick-capture window, done with: closed.+#[tauri::command]+pub fn intake_capture_close(app: AppHandle) {+ if let Some(w) = app.get_webview_window(CAPTURE_WINDOW) {+ w.close().ok();+ }+}++/// From the quick-capture window when Pomander is not signed in: the main window, where the+/// sign-in is.+#[tauri::command]+pub fn intake_open_main(app: AppHandle) {+ crate::show_window(&app);+}++// ── vCard ───────────────────────────────────────────────────────────────────────────────────++/// The people in a vCard file, named as Contacts would name them.+pub fn preview_contacts(text: &str, book: &[quince_core::contacts::Contact]) -> Vec<ImportContact> {+ quince_icloud::contacts::split_vcards(text)+ .iter()+ .map(|card| {+ let mut full = None;+ let mut structured = None;+ let mut org = None;+ let mut email = None;+ let mut phone = None;+ for line in unfold(card) {+ let Some(p) = property(&line) else { continue };+ // `item1.EMAIL` — Apple's grouping prefix — is still an email.+ let name = p.name.rsplit('.').next().unwrap_or("").to_string();+ let value = if p+ .param("ENCODING")+ .is_some_and(|e| e.eq_ignore_ascii_case("QUOTED-PRINTABLE"))+ {+ quoted_printable(&p.value)+ } else {+ p.value.clone()+ };+ match name.as_str() {+ "FN" => full = Some(unescape(&value)),+ "N" => {+ let parts: Vec<String> = split_unescaped(&value, ';')+ .into_iter()+ .map(|s| unescape(&s))+ .collect();+ let given = parts.get(1).map_or("", String::as_str);+ let family = parts.first().map_or("", String::as_str);+ structured = Some(format!("{given} {family}").trim().to_string());+ }+ "ORG" => {+ org = split_unescaped(&value, ';').first().map(|s| unescape(s));+ }+ "EMAIL" if email.is_none() => email = Some(unescape(&value)),+ "TEL" if phone.is_none() => phone = Some(unescape(&value)),+ _ => {}+ }+ }+ let name = [full, structured, org]+ .into_iter()+ .flatten()+ .map(|s| s.trim().to_string())+ .find(|s| !s.is_empty())+ .unwrap_or_else(|| "No Name".into());+ ImportContact {+ name,+ detail: phone.or(email).filter(|s| !s.trim().is_empty()),+ known: quince_icloud::contacts::already_in(card, book),+ }+ })+ .collect()+}++fn quoted_printable(s: &str) -> String {+ let bytes = s.as_bytes();+ let mut out = Vec::with_capacity(bytes.len());+ let mut i = 0;+ while i < bytes.len() {+ if bytes[i] == b'=' && i + 2 < bytes.len() && s.is_char_boundary(i + 3) {+ if let Ok(b) = u8::from_str_radix(&s[i + 1..i + 3], 16) {+ out.push(b);+ i += 3;+ continue;+ }+ }+ out.push(bytes[i]);+ i += 1;+ }+ String::from_utf8_lossy(&out).into_owned()+}++// ── iCalendar ───────────────────────────────────────────────────────────────────────────────++/// One content line: `NAME;PARAM=VALUE:value`.+#[derive(Debug, Clone)]+struct Property {+ name: String,+ params: Vec<(String, String)>,+ value: String,+}++impl Property {+ fn param(&self, name: &str) -> Option<&str> {+ self.params+ .iter()+ .find(|(k, _)| k.eq_ignore_ascii_case(name))+ .map(|(_, v)| v.as_str())+ }+}++/// Lines with their folds undone: a line that starts with a space or tab continues the one+/// before it (RFC 5545 §3.1).+fn unfold(text: &str) -> Vec<String> {+ let mut out: Vec<String> = Vec::new();+ for raw in text.split('\n') {+ let line = raw.strip_suffix('\r').unwrap_or(raw);+ if let Some(rest) = line.strip_prefix([' ', '\t']) {+ if let Some(last) = out.last_mut() {+ last.push_str(rest);+ continue;+ }+ }+ // vCard 2.1's quoted-printable soft line break: `=` at the end joins the next line.+ if let Some(last) = out.last_mut() {+ if last.ends_with('=') && last.to_ascii_uppercase().contains("QUOTED-PRINTABLE") {+ last.pop();+ last.push_str(line);+ continue;+ }+ }+ if !line.is_empty() {+ out.push(line.to_string());+ }+ }+ out+}++fn property(line: &str) -> Option<Property> {+ // The name and parameters end at the first colon outside quotes.+ let mut quoted = false;+ let mut split = None;+ for (i, c) in line.char_indices() {+ match c {+ '"' => quoted = !quoted,+ ':' if !quoted => {+ split = Some(i);+ break;+ }+ _ => {}+ }+ }+ let split = split?;+ let (head, value) = (&line[..split], &line[split + 1..]);+ let mut parts = split_quoted(head, ';').into_iter();+ let name = parts.next()?.trim().to_ascii_uppercase();+ if name.is_empty() {+ return None;+ }+ let params = parts+ .filter_map(|p| {+ let (k, v) = p.split_once('=')?;+ Some((+ k.trim().to_ascii_uppercase(),+ v.trim().trim_matches('"').to_string(),+ ))+ })+ .collect();+ Some(Property {+ name,+ params,+ value: value.to_string(),+ })+}++fn split_quoted(s: &str, on: char) -> Vec<String> {+ let mut out = vec![String::new()];+ let mut quoted = false;+ for c in s.chars() {+ if c == '"' {+ quoted = !quoted;+ }+ if c == on && !quoted {+ out.push(String::new());+ } else if let Some(last) = out.last_mut() {+ last.push(c);+ }+ }+ out+}++/// Split on `on`, but not on an escaped one (`\;`).+fn split_unescaped(s: &str, on: char) -> Vec<String> {+ let mut out = vec![String::new()];+ let mut escaped = false;+ for c in s.chars() {+ if escaped {+ if let Some(last) = out.last_mut() {+ last.push('\\');+ last.push(c);+ }+ escaped = false;+ } else if c == '\\' {+ escaped = true;+ } else if c == on {+ out.push(String::new());+ } else if let Some(last) = out.last_mut() {+ last.push(c);+ }+ }+ out+}++/// TEXT values with their escapes undone: `\n`, `\,`, `\;`, `\\`.+fn unescape(s: &str) -> String {+ let mut out = String::with_capacity(s.len());+ let mut chars = s.chars();+ while let Some(c) = chars.next() {+ if c != '\\' {+ out.push(c);+ continue;+ }+ match chars.next() {+ Some('n' | 'N') => out.push('\n'),+ Some(other) => out.push(other),+ None => out.push('\\'),+ }+ }+ out+}++/// A component's own properties, and the components inside it (an event's alarms).+#[derive(Debug, Default)]+struct Component {+ name: String,+ props: Vec<Property>,+ children: Vec<Component>,+}++impl Component {+ fn get(&self, name: &str) -> Option<&Property> {+ self.props.iter().find(|p| p.name == name)+ }+ fn all(&self, name: &str) -> impl Iterator<Item = &Property> {+ let name = name.to_string();+ self.props.iter().filter(move |p| p.name == name)+ }+ fn text(&self, name: &str) -> Option<String> {+ self.get(name)+ .map(|p| unescape(&p.value).trim().to_string())+ .filter(|s| !s.is_empty())+ }+}++/// The components of a file, nested as written.+fn components(text: &str) -> Vec<Component> {+ let mut stack: Vec<Component> = Vec::new();+ let mut top = Vec::new();+ for line in unfold(text) {+ let Some(p) = property(&line) else { continue };+ match p.name.as_str() {+ "BEGIN" => stack.push(Component {+ name: p.value.trim().to_ascii_uppercase(),+ ..Default::default()+ }),+ "END" => {+ let Some(done) = stack.pop() else { continue };+ match stack.last_mut() {+ Some(parent) => parent.children.push(done),+ None => top.push(done),+ }+ }+ _ => {+ if let Some(current) = stack.last_mut() {+ current.props.push(p);+ }+ }+ }+ }+ // A file cut short: what was open still counts.+ while let Some(done) = stack.pop() {+ match stack.last_mut() {+ Some(parent) => parent.children.push(done),+ None => top.push(done),+ }+ }+ top+}++/// A date or time as a file writes it.+#[derive(Debug, Clone)]+enum When {+ /// `VALUE=DATE`: a day, not an instant.+ Day(Date),+ /// No zone: the same clock time wherever it is read — this computer's.+ Floating(DateTime),+ /// `…Z`.+ Utc(Timestamp),+ /// `TZID=…`: a clock time in that zone, and the zone's own name.+ Zoned(DateTime, TimeZone, String),+}++impl When {+ fn instant(&self, here: &TimeZone) -> Option<Timestamp> {+ Some(match self {+ When::Day(d) => d.to_zoned(here.clone()).ok()?.timestamp(),+ When::Floating(dt) => dt.to_zoned(here.clone()).ok()?.timestamp(),+ When::Utc(ts) => *ts,+ When::Zoned(dt, tz, _) => dt.to_zoned(tz.clone()).ok()?.timestamp(),+ })+ }+ /// The civil time in the zone the event's own clock runs on.+ fn civil(&self, here: &TimeZone) -> DateTime {+ match self {+ When::Day(d) => d.to_datetime(jiff::civil::Time::midnight()),+ When::Floating(dt) | When::Zoned(dt, _, _) => *dt,+ When::Utc(ts) => ts.to_zoned(here.clone()).datetime(),+ }+ }+}++fn parse_date(s: &str) -> Option<Date> {+ let s = s.trim();+ if s.len() != 8 || !s.bytes().all(|b| b.is_ascii_digit()) {+ return None;+ }+ Date::new(+ s[0..4].parse().ok()?,+ s[4..6].parse().ok()?,+ s[6..8].parse().ok()?,+ )+ .ok()+}++fn parse_datetime(s: &str) -> Option<(DateTime, bool)> {+ let s = s.trim();+ let (s, utc) = match s.strip_suffix(['Z', 'z']) {+ Some(rest) => (rest, true),+ None => (s, false),+ };+ let (d, t) = s.split_once(['T', 't'])?;+ let date = parse_date(d)?;+ if t.len() < 4 || !t.bytes().all(|b| b.is_ascii_digit()) {+ return None;+ }+ let hour: i8 = t[0..2].parse().ok()?;+ let minute: i8 = t[2..4].parse().ok()?;+ // A leap second is read as the second before it.+ let second: i8 = t.get(4..6).map_or(Some(0), |x| x.parse().ok())?.min(59);+ let time = jiff::civil::Time::new(hour, minute, second, 0).ok()?;+ Some((date.to_datetime(time), utc))+}++/// A `TZID` this computer knows: an IANA name as it stands; one carried inside a longer id+/// (`/mozilla.org/20050126_1/Europe/Berlin`); or one of the Windows names Outlook writes.+fn zone_named(tzid: &str) -> Option<(TimeZone, String)> {+ let tzid = tzid.trim().trim_matches('"').trim_start_matches('/');+ let found = |name: &str| {+ TimeZone::get(name)+ .ok()+ .map(|tz| (tz.clone(), tz.iana_name().unwrap_or(name).to_string()))+ };+ if let Some(z) = found(tzid) {+ return Some(z);+ }+ let segments: Vec<&str> = tzid.split('/').collect();+ for start in 1..segments.len() {+ if let Some(z) = found(&segments[start..].join("/")) {+ return Some(z);+ }+ }+ WINDOWS_ZONES+ .iter()+ .find(|(w, _)| w.eq_ignore_ascii_case(tzid))+ .and_then(|(_, iana)| found(iana))+}++/// Windows' zone names, as Outlook and Exchange write them in a `TZID`, and the IANA zone+/// each is (CLDR's windowsZones, the territory "001" row).+const WINDOWS_ZONES: &[(&str, &str)] = &[+ ("UTC", "UTC"),+ ("GMT Standard Time", "Europe/London"),+ ("Greenwich Standard Time", "Atlantic/Reykjavik"),+ ("W. Europe Standard Time", "Europe/Berlin"),+ ("Romance Standard Time", "Europe/Paris"),+ ("Central Europe Standard Time", "Europe/Budapest"),+ ("Central European Standard Time", "Europe/Warsaw"),+ ("E. Europe Standard Time", "Europe/Chisinau"),+ ("FLE Standard Time", "Europe/Kiev"),+ ("GTB Standard Time", "Europe/Bucharest"),+ ("Russian Standard Time", "Europe/Moscow"),+ ("Turkey Standard Time", "Europe/Istanbul"),+ ("Israel Standard Time", "Asia/Jerusalem"),+ ("South Africa Standard Time", "Africa/Johannesburg"),+ ("Egypt Standard Time", "Africa/Cairo"),+ ("Arabian Standard Time", "Asia/Dubai"),+ ("Arab Standard Time", "Asia/Riyadh"),+ ("Pakistan Standard Time", "Asia/Karachi"),+ ("India Standard Time", "Asia/Kolkata"),+ ("Sri Lanka Standard Time", "Asia/Colombo"),+ ("Nepal Standard Time", "Asia/Kathmandu"),+ ("Bangladesh Standard Time", "Asia/Dhaka"),+ ("SE Asia Standard Time", "Asia/Bangkok"),+ ("Singapore Standard Time", "Asia/Singapore"),+ ("China Standard Time", "Asia/Shanghai"),+ ("Taipei Standard Time", "Asia/Taipei"),+ ("Tokyo Standard Time", "Asia/Tokyo"),+ ("Korea Standard Time", "Asia/Seoul"),+ ("AUS Eastern Standard Time", "Australia/Sydney"),+ ("E. Australia Standard Time", "Australia/Brisbane"),+ ("W. Australia Standard Time", "Australia/Perth"),+ ("New Zealand Standard Time", "Pacific/Auckland"),+ ("Hawaiian Standard Time", "Pacific/Honolulu"),+ ("Alaskan Standard Time", "America/Anchorage"),+ ("Pacific Standard Time", "America/Los_Angeles"),+ ("Mountain Standard Time", "America/Denver"),+ ("US Mountain Standard Time", "America/Phoenix"),+ ("Central Standard Time", "America/Chicago"),+ ("Eastern Standard Time", "America/New_York"),+ ("Atlantic Standard Time", "America/Halifax"),+ ("Newfoundland Standard Time", "America/St_Johns"),+ ("E. South America Standard Time", "America/Sao_Paulo"),+ ("Argentina Standard Time", "America/Buenos_Aires"),+ ("Mexico Standard Time", "America/Mexico_City"),+ ("Central Standard Time (Mexico)", "America/Mexico_City"),+];++fn when(p: &Property) -> Result<When, String> {+ let date_only = p+ .param("VALUE")+ .is_some_and(|v| v.eq_ignore_ascii_case("DATE"))+ || (p.value.trim().len() == 8 && !p.value.contains('T'));+ if date_only {+ return parse_date(&p.value)+ .map(When::Day)+ .ok_or_else(|| "Its date can’t be read.".to_string());+ }+ let (dt, utc) =+ parse_datetime(&p.value).ok_or_else(|| "Its date can’t be read.".to_string())?;+ if utc {+ return dt+ .to_zoned(TimeZone::UTC)+ .map(|z| When::Utc(z.timestamp()))+ .map_err(|_| "Its date can’t be read.".to_string());+ }+ match p.param("TZID") {+ None => Ok(When::Floating(dt)),+ Some(tzid) => match zone_named(tzid) {+ Some((tz, name)) => Ok(When::Zoned(dt, tz, name)),+ None => Err(format!(+ "It uses a time zone this computer doesn’t know ({tzid})."+ )),+ },+ }+}++/// An iCalendar duration in seconds: `PT1H30M`, `-P1D`, `P2W`.+fn duration(s: &str) -> Option<i64> {+ let s = s.trim();+ let (sign, s) = match s.as_bytes().first()? {+ b'-' => (-1, &s[1..]),+ b'+' => (1, &s[1..]),+ _ => (1, s),+ };+ let s = s.strip_prefix(['P', 'p'])?;+ let mut total = 0i64;+ let mut number = String::new();+ let mut in_time = false;+ let mut any = false;+ for c in s.chars() {+ match c.to_ascii_uppercase() {+ '0'..='9' => number.push(c),+ 'T' => in_time = true,+ unit => {+ let n: i64 = number.parse().ok()?;+ number.clear();+ any = true;+ total += n * match (unit, in_time) {+ ('W', _) => 7 * 86_400,+ ('D', _) => 86_400,+ ('H', true) => 3_600,+ ('M', true) => 60,+ ('S', true) => 1,+ _ => return None,+ };+ }+ }+ }+ (any && number.is_empty()).then_some(sign * total)+}++/// A calendar file read into the events it holds, and what of it cannot be brought in. An+/// error when it is not a calendar file at all.+pub fn parse_calendar(+ text: &str,+ here: &TimeZone,+) -> Result<(Vec<ImportEvent>, Vec<Refused>), String> {+ let top = components(text);+ let Some(calendar) = top.iter().find(|c| c.name == "VCALENDAR") else {+ return Err("This isn’t a calendar file.".into());+ };+ let cancelled_file = calendar+ .get("METHOD")+ .is_some_and(|m| m.value.trim().eq_ignore_ascii_case("CANCEL"));+ let here_name = here.iana_name().map(ToString::to_string);+ let mut events = Vec::new();+ let mut refused = Vec::new();+ for c in &calendar.children {+ let title = c.text("SUMMARY");+ let shown = || title.clone().unwrap_or_else(|| "Untitled".into());+ match c.name.as_str() {+ "VEVENT" => {}+ "VTODO" => {+ refused.push(Refused {+ title: shown(),+ reason: "It’s a to-do, not an event. Pomander imports events.".into(),+ });+ continue;+ }+ "VJOURNAL" => {+ refused.push(Refused {+ title: shown(),+ reason: "It’s a journal entry, not an event.".into(),+ });+ continue;+ }+ _ => continue,+ }+ if cancelled_file {+ refused.push(Refused {+ title: shown(),+ reason: "The file cancels this event rather than adding it.".into(),+ });+ continue;+ }+ match event_of(c, here, here_name.as_deref()) {+ Ok(event) => events.push(event),+ Err(reason) => refused.push(Refused {+ title: shown(),+ reason,+ }),+ }+ }+ Ok((events, refused))+}++fn event_of(+ c: &Component,+ here: &TimeZone,+ here_name: Option<&str>,+) -> Result<ImportEvent, String> {+ if c.get("STATUS")+ .is_some_and(|s| s.value.trim().eq_ignore_ascii_case("CANCELLED"))+ {+ return Err("It was cancelled.".into());+ }+ if c.get("RECURRENCE-ID").is_some() {+ return Err(+ "It’s a change to one day of a repeating event, which can’t be imported on its own."+ .into(),+ );+ }+ let start = when(c.get("DTSTART").ok_or("It has no start date.")?)?;+ let all_day = matches!(start, When::Day(_));+ let starts_at = start.instant(here).ok_or("Its date can’t be read.")?;++ let ends_at = if all_day {+ let When::Day(first) = start else {+ unreachable!()+ };+ let last = match (c.get("DTEND"), c.get("DURATION")) {+ (Some(end), _) => match when(end)? {+ When::Day(d) => d,+ other => other.civil(here).date(),+ },+ (None, Some(d)) => {+ let secs = duration(&d.value).ok_or("Its length can’t be read.")?;+ first+ .checked_add(Span::new().days(secs.div_euclid(86_400)))+ .map_err(|_| "Its length can’t be read.")?+ }+ (None, None) => first,+ };+ // DTEND is the day after the last (exclusive); a one-day event may leave it out, or+ // give the same day.+ let last = if last <= first {+ first.tomorrow().map_err(|_| "Its date can’t be read.")?+ } else {+ last+ };+ When::Day(last)+ .instant(here)+ .ok_or("Its date can’t be read.")?+ } else {+ match (c.get("DTEND"), c.get("DURATION")) {+ (Some(end), _) => when(end)?.instant(here).ok_or("Its end can’t be read.")?,+ (None, Some(d)) => {+ let secs = duration(&d.value).ok_or("Its length can’t be read.")?;+ starts_at+ .checked_add(Span::new().seconds(secs))+ .map_err(|_| "Its length can’t be read.")?+ }+ (None, None) => starts_at,+ }+ };+ if ends_at < starts_at {+ return Err("It ends before it starts.".into());+ }++ let repeat = repeat_of(c, &start, here)?;+ let alerts = alerts_of(c, starts_at);+ let timezone = match &start {+ When::Zoned(_, _, name) => Some(name.clone()),+ _ => here_name.map(ToString::to_string),+ };+ Ok(ImportEvent {+ title: c.text("SUMMARY").unwrap_or_else(|| "New Event".into()),+ location: c.text("LOCATION"),+ starts_at: starts_at.as_second(),+ ends_at: ends_at.as_second(),+ all_day,+ timezone,+ notes: c.text("DESCRIPTION"),+ url: c+ .get("URL")+ .map(|p| p.value.trim().to_string())+ .filter(|s| !s.is_empty()),+ alerts,+ repeat,+ duplicate: false,+ })+}++const WEEKDAYS: [(&str, Weekday); 7] = [+ ("MO", Weekday::Monday),+ ("TU", Weekday::Tuesday),+ ("WE", Weekday::Wednesday),+ ("TH", Weekday::Thursday),+ ("FR", Weekday::Friday),+ ("SA", Weekday::Saturday),+ ("SU", Weekday::Sunday),+];++/// How an event repeats, as Apple's repeat holds it — every N days, weeks, months or years,+/// for a number of times or for ever. A rule saying more than that (several weekdays, the+/// second Tuesday, skipped dates) is refused rather than brought in as something else.+fn repeat_of(c: &Component, start: &When, here: &TimeZone) -> Result<Option<EventRepeat>, String> {+ let rules: Vec<&Property> = c.all("RRULE").collect();+ if c.get("RDATE").is_some() || rules.len() > 1 {+ return Err("It repeats on extra dates, which Pomander can’t set up.".into());+ }+ let Some(rule) = rules.first() else {+ return Ok(None);+ };+ if c.get("EXDATE").is_some() {+ return Err("Its repeat skips some dates, which Pomander can’t set up.".into());+ }+ let mut freq = None;+ let mut interval = 1i64;+ let mut count = None;+ let mut until = None;+ let first = start.civil(here);+ for part in rule.value.trim().split(';').filter(|p| !p.is_empty()) {+ let (key, value) = part.split_once('=').ok_or("Its repeat can’t be read.")?;+ let value = value.trim();+ match key.trim().to_ascii_uppercase().as_str() {+ "FREQ" => {+ freq = Some(match value.to_ascii_uppercase().as_str() {+ "DAILY" => "daily",+ "WEEKLY" => "weekly",+ "MONTHLY" => "monthly",+ "YEARLY" => "yearly",+ "HOURLY" | "MINUTELY" | "SECONDLY" => {+ return Err(+ "It repeats more than once a day, which Pomander can’t set up.".into(),+ )+ }+ _ => return Err("Its repeat can’t be read.".into()),+ });+ }+ "INTERVAL" => {+ interval = value+ .parse::<i64>()+ .ok()+ .filter(|n| *n >= 1)+ .ok_or("Its repeat can’t be read.")?;+ }+ "COUNT" => {+ count = Some(+ value+ .parse::<i64>()+ .ok()+ .filter(|n| *n >= 1)+ .ok_or("Its repeat can’t be read.")?,+ );+ }+ "UNTIL" => until = Some(value.to_string()),+ "WKST" => {}+ // Saying again what the start already says — weekly on the start's own weekday,+ // monthly on its own day — is the same repeat.+ "BYDAY" => {+ let same = WEEKDAYS+ .iter()+ .find(|(code, _)| code.eq_ignore_ascii_case(value))+ .is_some_and(|(_, day)| *day == first.weekday());+ if !same {+ return Err(if value.contains(',') {+ "It repeats on several days of the week, which Pomander can’t set up yet."+ .into()+ } else if value+ .chars()+ .next()+ .is_some_and(|c| c.is_ascii_digit() || c == '-' || c == '+')+ {+ "It repeats on a weekday of the month (like the second Tuesday), which Pomander can’t set up yet.".into()+ } else {+ "It repeats on a different weekday than it starts on, which Pomander can’t set up.".into()+ });+ }+ }+ "BYMONTHDAY" => {+ if value.parse::<i8>().ok() != Some(first.day()) {+ return Err("It repeats on other days of the month than it starts on, which Pomander can’t set up yet.".into());+ }+ }+ "BYMONTH" => {+ if value.parse::<i8>().ok() != Some(first.month()) {+ return Err("It repeats in other months than it starts in, which Pomander can’t set up yet.".into());+ }+ }+ _ => return Err("It repeats in a way Pomander can’t set up yet.".into()),+ }+ }+ let freq = freq.ok_or("Its repeat can’t be read.")?;+ if count.is_some() && until.is_some() {+ return Err("Its repeat can’t be read.".into());+ }+ if let Some(until) = until {+ // Apple's repeat ends after a number of times: the times there are up to the date.+ let last = until_civil(&until, start, here).ok_or("Its repeat can’t be read.")?;+ let times = occurrences_until(first, freq, interval, last);+ if times <= 1 {+ return Ok(None);+ }+ count = Some(times);+ }+ Ok(Some(EventRepeat {+ freq: freq.to_string(),+ interval,+ count,+ }))+}++/// The repeat's end, as a clock time on the event's own clock.+fn until_civil(until: &str, start: &When, here: &TimeZone) -> Option<DateTime> {+ if let Some(day) = parse_date(until) {+ // A day: every time on it counts.+ return Some(day.to_datetime(jiff::civil::Time::constant(23, 59, 59, 0)));+ }+ let (dt, utc) = parse_datetime(until)?;+ if !utc {+ return Some(dt);+ }+ let instant = dt.to_zoned(TimeZone::UTC).ok()?.timestamp();+ let zone = match start {+ When::Zoned(_, tz, _) => tz.clone(),+ _ => here.clone(),+ };+ Some(instant.to_zoned(zone).datetime())+}++/// How many times a repeat starting at `first` falls on or before `last`. A month without+/// the start's day (the 31st) is skipped, as RFC 5545 has it.+fn occurrences_until(first: DateTime, freq: &str, interval: i64, last: DateTime) -> i64 {+ let mut times = 0;+ for k in 0..10_000i64 {+ let step = k * interval;+ let span = match freq {+ "daily" => Span::new().days(step),+ "weekly" => Span::new().weeks(step),+ "monthly" => Span::new().months(step),+ _ => Span::new().years(step),+ };+ let Ok(next) = first.checked_add(span) else {+ break;+ };+ if next > last {+ break;+ }+ if next.day() == first.day() {+ times += 1;+ }+ }+ times+}++/// The event's alerts: minutes before its start, from each `VALARM` that rings at or before+/// it. One timed from the end, or after the start, is not something Apple's alerts hold.+fn alerts_of(c: &Component, starts_at: Timestamp) -> Option<Vec<i64>> {+ let mut minutes: Vec<i64> = c+ .children+ .iter()+ .filter(|a| a.name == "VALARM")+ .filter_map(|a| {+ let trigger = a.get("TRIGGER")?;+ if trigger+ .param("RELATED")+ .is_some_and(|r| r.eq_ignore_ascii_case("END"))+ {+ return None;+ }+ let before = if trigger+ .param("VALUE")+ .is_some_and(|v| v.eq_ignore_ascii_case("DATE-TIME"))+ {+ let (dt, _) = parse_datetime(&trigger.value)?;+ let at = dt.to_zoned(TimeZone::UTC).ok()?.timestamp();+ starts_at.as_second() - at.as_second()+ } else {+ -duration(&trigger.value)?+ };+ (before >= 0).then_some(before / 60)+ })+ .collect();+ minutes.sort_unstable();+ minutes.dedup();+ (!minutes.is_empty()).then_some(minutes)+}++#[cfg(test)]+mod tests {+ use super::*;++ const DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/intake");++ fn sample(name: &str) -> String {+ std::fs::read_to_string(format!("{DIR}/{name}")).expect("sample file")+ }++ fn kolkata() -> TimeZone {+ TimeZone::get("Asia/Kolkata").expect("zone")+ }++ fn at(s: &str) -> i64 {+ s.parse::<Timestamp>().expect("timestamp").as_second()+ }++ #[test]+ fn a_meeting_invite_is_read_in_its_own_zone_with_its_alert() {+ let (events, refused) = parse_calendar(&sample("invite.ics"), &kolkata()).unwrap();+ assert!(refused.is_empty(), "{refused:?}");+ assert_eq!(events.len(), 1);+ let e = &events[0];+ assert_eq!(e.title, "Design review, round 2");+ assert_eq!(e.location.as_deref(), Some("Studio; Room 4"));+ assert_eq!(+ e.notes.as_deref(),+ Some("Bring the prototypes.\nAnd the notes.")+ );+ // 10:00 in Berlin in November is 09:00 UTC.+ assert_eq!(e.starts_at, at("2026-11-05T09:00:00Z"));+ assert_eq!(e.ends_at, at("2026-11-05T10:30:00Z"));+ assert!(!e.all_day);+ assert_eq!(e.timezone.as_deref(), Some("Europe/Berlin"));+ assert_eq!(e.alerts, Some(vec![15]));+ assert_eq!(e.repeat, None);+ }++ #[test]+ fn several_events_with_all_day_repeats_and_refusals() {+ let (events, refused) = parse_calendar(&sample("family.ics"), &kolkata()).unwrap();+ let titles: Vec<&str> = events.iter().map(|e| e.title.as_str()).collect();+ assert_eq!(+ titles,+ [+ "Holiday in Goa",+ "Gym",+ "Rent",+ "Team sync",+ "Floating lunch"+ ]+ );++ // All day, three days: the 24th to the 26th, ends on the 27th's midnight, here.+ let goa = &events[0];+ assert!(goa.all_day);+ assert_eq!(goa.starts_at, at("2026-12-23T18:30:00Z"));+ assert_eq!(goa.ends_at, at("2026-12-26T18:30:00Z"));+ assert_eq!(goa.timezone.as_deref(), Some("Asia/Kolkata"));++ // Weekly on the start's own weekday, ten times: passed through.+ assert_eq!(+ events[1].repeat,+ Some(EventRepeat {+ freq: "weekly".into(),+ interval: 1,+ count: Some(10)+ })+ );+ // Monthly until a date: counted — 1 Jan to 1 Jun is six times.+ assert_eq!(+ events[2].repeat,+ Some(EventRepeat {+ freq: "monthly".into(),+ interval: 1,+ count: Some(6)+ })+ );+ assert!(events[2].all_day);+ // Every other day, for ever, in UTC: the instant kept, written on this computer's clock.+ assert_eq!(+ events[3].repeat,+ Some(EventRepeat {+ freq: "daily".into(),+ interval: 2,+ count: None+ })+ );+ assert_eq!(events[3].starts_at, at("2026-11-02T04:30:00Z"));+ assert_eq!(events[3].timezone.as_deref(), Some("Asia/Kolkata"));+ // No zone at all: 13:00 on this computer's clock; no end, so a duration.+ assert_eq!(events[4].starts_at, at("2026-11-03T07:30:00Z"));+ assert_eq!(events[4].ends_at, at("2026-11-03T08:15:00Z"));++ let reasons: Vec<(&str, &str)> = refused+ .iter()+ .map(|r| (r.title.as_str(), r.reason.as_str()))+ .collect();+ assert_eq!(reasons.len(), 6, "{reasons:?}");+ assert!(reasons[0].0 == "Classes" && reasons[0].1.contains("several days of the week"));+ assert!(reasons[1].0 == "Book club" && reasons[1].1.contains("weekday of the month"));+ assert!(reasons[2].0 == "Standup" && reasons[2].1.contains("skips some dates"));+ assert!(reasons[3].0 == "Standup" && reasons[3].1.contains("one day of a repeating"));+ assert!(reasons[4].0 == "Cancelled thing" && reasons[4].1.contains("cancelled"));+ assert!(reasons[5].0 == "Buy milk" && reasons[5].1.contains("to-do"));+ }++ #[test]+ fn outlook_zone_names_and_unknown_zones() {+ let (events, refused) = parse_calendar(&sample("outlook.ics"), &kolkata()).unwrap();+ assert_eq!(events.len(), 2);+ // 09:00 Eastern in July is 13:00 UTC.+ assert_eq!(events[0].starts_at, at("2026-07-14T13:00:00Z"));+ assert_eq!(events[0].timezone.as_deref(), Some("America/New_York"));+ // A zone carried inside a longer id.+ assert_eq!(events[1].timezone.as_deref(), Some("Europe/Berlin"));+ assert_eq!(events[1].alerts, Some(vec![0, 1440]));+ assert_eq!(refused.len(), 1);+ assert!(refused[0].reason.contains("Mars/Olympus_Mons"));+ }++ #[test]+ fn not_a_calendar_and_a_cancellation() {+ assert!(parse_calendar("hello", &kolkata()).is_err());+ let cancel = "BEGIN:VCALENDAR\r\nMETHOD:CANCEL\r\nBEGIN:VEVENT\r\nSUMMARY:Off\r\nDTSTART:20261101T100000Z\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";+ let (events, refused) = parse_calendar(cancel, &kolkata()).unwrap();+ assert!(events.is_empty());+ assert!(refused[0].reason.contains("cancels"));+ }++ #[test]+ fn durations_and_escapes() {+ assert_eq!(duration("PT1H30M"), Some(5400));+ assert_eq!(duration("-PT15M"), Some(-900));+ assert_eq!(duration("P1W"), Some(604_800));+ assert_eq!(duration("P1DT2H"), Some(93_600));+ assert_eq!(duration("PT"), None);+ assert_eq!(duration("1H"), None);+ assert_eq!(unescape(r"a\, b\; c\\d\ne"), "a, b; c\\d\ne");+ }++ #[test]+ fn contacts_are_named_and_known_ones_marked() {+ let book: Vec<quince_core::contacts::Contact> =+ serde_json::from_value(serde_json::json!([{+ "guid": "c1", "firstName": "Zoya", "lastName": "Ahuja", "company": null,+ "isCompany": false, "birthday": null, "notes": null, "etag": null,+ "methods": [{ "kind": "phone", "label": null, "value": "+91 90000 00001" }]+ }]))+ .unwrap();+ let people = preview_contacts(&sample("people.vcf"), &book);+ let names: Vec<&str> = people.iter().map(|p| p.name.as_str()).collect();+ assert_eq!(+ names,+ [+ "Zoya Ahuja",+ "Ravi Kumar",+ "Northfield University",+ "José Núñez"+ ]+ );+ assert!(people[0].known);+ assert!(!people[1].known);+ assert_eq!(people[1].detail.as_deref(), Some("+91 98765 43210"));+ assert_eq!(+ people[2].detail.as_deref(),+ Some("[email protected]")+ );+ assert!(preview_contacts("nothing here", &book).is_empty());+ }+}diff --git a/src-tauri/src/login.rs b/src-tauri/src/login.rsindex 7022d37..fba0fa5 100644--- a/src-tauri/src/login.rs+++ b/src-tauri/src/login.rs@@ -55,10 +55,10 @@ pub struct LoginItem {#[cfg(not(windows))]fn entry(app: &AppHandle) -> Option<PathBuf> {use tauri::Manager;- app.path()- .config_dir()- .ok()- .map(|c| c.join("autostart").join("dev.quince.client.desktop"))+ app.path().config_dir().ok().map(|c| {+ c.join("autostart")+ .join(format!("{}.desktop", app.config().identifier))+ })}/// The command that starts this Quince hidden: the AppImage itself when run from one (its@@ -76,13 +76,17 @@ fn command() -> String {}/// A program path as the Desktop Entry spec wants it in Exec: in double quotes, with `"`,-/// `` ` ``, `$` and `\` escaped.+/// `` ` ``, `$` and `\` escaped, and `%` doubled — alone it starts a field code (`%f`, `%u`),+/// which the launcher would replace with something else.fn quoted(path: &str) -> String {let mut out = String::from("\"");for c in path.chars() {if matches!(c, '"' | '`' | '$' | '\\') {out.push('\\');}+ if c == '%' {+ out.push('%');+ }out.push(c);}out.push('"');@@ -90,9 +94,9 @@ fn quoted(path: &str) -> String {}#[cfg(not(windows))]-fn desktop_file(command: &str) -> String {+fn desktop_file(command: &str, icon: &str) -> String {format!(- "[Desktop Entry]\nType=Application\nName=Pomander\nComment=Keeps iCloud in sync in the background\nExec={command}\nIcon=dev.quince.client\nTerminal=false\nNoDisplay=true\nX-GNOME-Autostart-enabled=true\n"+ "[Desktop Entry]\nType=Application\nName=Pomander\nComment=Keeps iCloud in sync in the background\nExec={command}\nIcon={icon}\nTerminal=false\nNoDisplay=true\nX-GNOME-Autostart-enabled=true\n",)}@@ -212,7 +216,8 @@ pub async fn login_item_set(on: bool, app: AppHandle) -> Result<LoginItem, Strinif let Some(dir) = path.parent() {std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;}- std::fs::write(&path, desktop_file(&command())).map_err(|e| e.to_string())?;+ std::fs::write(&path, desktop_file(&command(), &app.config().identifier))+ .map_err(|e| e.to_string())?;} else if path.exists() {std::fs::remove_file(&path).map_err(|e| e.to_string())?;}@@ -224,6 +229,7 @@ mod tests {use super::*;/// The Exec line survives any path: spaces quoted, the spec's special characters escaped.+ #[cfg(not(windows))]#[test]fn the_exec_line_is_quoted_as_the_spec_says() {assert_eq!(@@ -231,7 +237,8 @@ mod tests {"\"/opt/Quince App/quince\"");assert_eq!(quoted("/a/$HOME\"x`\\"), "\"/a/\\$HOME\\\"x\\`\\\\\"");- let file = desktop_file("\"/usr/bin/quince-app\" --background");+ assert_eq!(quoted("/opt/100%u/q"), "\"/opt/100%%u/q\"");+ let file = desktop_file("\"/usr/bin/quince-app\" --background", "org.example.App");assert!(file.contains("Exec=\"/usr/bin/quince-app\" --background\n"));assert!(file.starts_with("[Desktop Entry]\nType=Application\n"));}diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rsindex 809d3cf..d7e3ce0 100644--- a/src-tauri/src/main.rs+++ b/src-tauri/src/main.rs@@ -14,10 +14,14 @@ macro_rules! quiet {mod alerts;mod apps;+mod contacts_cmds;mod cpu;+mod intake;mod login;+mod migrate;mod mount;mod mount_photos;+mod notes_cmds;mod outbox;mod photos;#[cfg(target_os = "linux")]@@ -31,6 +35,8 @@ mod poster {}mod push;mod refresh;+mod reminders_cmds;+mod settings;mod video;use quince_auth::{Client, SignInOutcome, TwoFactorOptions};@@ -139,15 +145,21 @@ async fn refresh_reminders(.sync_token("reminders").map_err(|e| e.to_string())?};+ let asked_for = asked_as(¶ms);let fetched = quince_icloud::reminders::fetch_cloudkit(http, root, params, since.as_deref()).await.map_err(|e| e.to_string())?;{let mut library = data.0.lock().await;- quince_icloud::reminders::apply_cloudkit(&mut library, fetched)+ owned_by(&library, asked_for.as_deref())?;+ // Changes still on their way to Apple stay as made here — stored with the pass, as one.+ library+ .atomically(|library| {+ quince_icloud::reminders::apply_cloudkit(library, fetched)?;+ outbox::replay_reminders(library)?;+ Ok::<_, quince_icloud::Error>(())+ }).map_err(|e| e.to_string())?;- // Changes still on their way to Apple stay as made here.- outbox::replay_reminders(&mut library).map_err(|e| e.to_string())?;}alerts::changed();Ok(())@@ -175,12 +187,19 @@ async fn refresh_notes(.await.sync_token("notes").map_err(|e| e.to_string())?;+ let asked_for = asked_as(¶ms);let fetched = quince_icloud::notes::fetch_cloudkit(http, root, params, since.as_deref()).await.map_err(|e| e.to_string())?;let mut library = data.0.lock().await;- quince_icloud::notes::apply_cloudkit(&mut library, fetched)- .map(|_| ())+ owned_by(&library, asked_for.as_deref())?;+ // Edits still on their way to Apple stay as typed here — stored with the pass, as one.+ library+ .atomically(|library| {+ quince_icloud::notes::apply_cloudkit(library, fetched)?;+ outbox::replay(library, outbox::NOTES)?;+ Ok::<_, quince_icloud::Error>(())+ }).map_err(|e| e.to_string())}@@ -211,15 +230,10 @@ fn note_part(path: &str) -> Option<(String, quince_icloud::note_media::Part)> {(!id.is_empty()).then(|| (id.to_string(), part))}-/// A note attachment's picture, from disk when it has been fetched before, from Apple when-/// not — kept, so a note opens on its pictures at once the next time.-async fn note_media_cached(- app: &tauri::AppHandle,- id: &str,- part: quince_icloud::note_media::Part,-) -> Result<Vec<u8>, String> {- let safe: String = id- .chars()+/// A note attachment's id as part of a file name in `note-media`: letters, digits and dashes,+/// so an id from a request is never a path.+fn media_file_id(id: &str) -> String {+ id.chars().map(|c| {if c.is_ascii_alphanumeric() || c == '-' {c@@ -227,7 +241,17 @@ async fn note_media_cached('_'}})- .collect();+ .collect()+}++/// A note attachment's picture, from disk when it has been fetched before, from Apple when+/// not — kept, so a note opens on its pictures at once the next time.+async fn note_media_cached(+ app: &tauri::AppHandle,+ id: &str,+ part: quince_icloud::note_media::Part,+) -> Result<Vec<u8>, String> {+ let safe = media_file_id(id);let name = match part {quince_icloud::note_media::Part::Preview => "preview",quince_icloud::note_media::Part::File => "file",@@ -275,16 +299,7 @@ async fn note_media_shown(if !drawing && !quince_media::is_heif(&bytes) {return Ok(bytes);}- let safe: String = id- .chars()- .map(|c| {- if c.is_ascii_alphanumeric() || c == '-' {- c- } else {- '_'- }- })- .collect();+ let safe = media_file_id(id);let name = match (drawing, dark) {(true, true) => format!("{safe}-ink-dark.png"),(true, false) => format!("{safe}-ink.png"),@@ -310,6 +325,24 @@ async fn note_media_shown(Ok(jpeg)}+/// Show a file the app saved in its folder, in the file manager, chosen: a "Saved to+/// Downloads" toast's Show in Folder. Only a file in Downloads — what the app itself saves+/// there — never any other path the page might name.+#[tauri::command]+async fn download_reveal(path: String, app: tauri::AppHandle) -> UiResult<()> {+ use tauri_plugin_opener::OpenerExt;+ let downloads = app.path().download_dir().map_err(|e| e.to_string())?;+ let downloads = std::fs::canonicalize(&downloads).map_err(|e| e.to_string())?;+ let file =+ std::fs::canonicalize(&path).map_err(|_| "That file isn’t there any more.".to_string())?;+ if !file.starts_with(&downloads) {+ return Err("Only a file in Downloads can be shown.".into());+ }+ app.opener()+ .reveal_item_in_dir(&file)+ .map_err(|e| e.to_string())+}+/// A plain report of how this install is doing, for a bug report: versions, the system, and/// each service's last sync and last error — never a name, an address, or anything from a/// note, card or file. Written to Downloads for the person to read and send themselves;@@ -424,28 +457,197 @@ async fn note_attachment_open(.await.map_err(|e| e.to_string())?;let bytes = note_media_cached(&app, &id, quince_icloud::note_media::Part::File).await?;- let name = info- .filename- .filter(|n| !n.contains('/') && !n.starts_with('.'))- .unwrap_or_else(|| format!("Attachment {}", &id[..id.len().min(8)]));- let dir = state_dir(&app).join("note-files").join(- id.chars()- .filter(char::is_ascii_alphanumeric)- .collect::<String>(),- );+ let folder: String = id.chars().filter(char::is_ascii_alphanumeric).collect();+ if folder.is_empty() {+ return Err("That attachment is not one Pomander knows.".into());+ }+ // The name is whoever shared the note's to choose: made a plain file name here, never a+ // path, and never one that pretends to be something else.+ let name = attachment_name(info.filename.as_deref(), &folder);+ let dir = state_dir(&app).join("note-files").join(&folder);tokio::fs::create_dir_all(&dir).await.map_err(|e| e.to_string())?;- let path = dir.join(name);+ let path = dir.join(&name);tokio::fs::write(&path, &bytes).await.map_err(|e| e.to_string())?;+ // Readable by this user alone, and never runnable, whatever was there before.+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ tokio::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600))+ .await+ .map_err(|e| e.to_string())?;+ }use tauri_plugin_opener::OpenerExt;+ // A program, a script or a launcher is shown in its folder, not opened: opening it would+ // run it, and a shared note can carry one from anyone.+ if runs_code(&name, &bytes) {+ return app+ .opener()+ .reveal_item_in_dir(&path)+ .map_err(|e| e.to_string());+ }app.opener().open_path(path.to_string_lossy(), None::<&str>).map_err(|e| e.to_string())}+/// A note attachment's file name as it is saved: Apple's name for it with anything that could+/// make it a path (`/`, `\\`, `:`, `..`), hide it (a leading dot), or show it as something it+/// is not (direction marks that turn `exe.pdf` around) taken out; a name Windows keeps for a+/// device made harmless. Nothing left, and it is named after the attachment.+pub(crate) fn attachment_name(given: Option<&str>, id: &str) -> String {+ let cleaned: String = given+ .unwrap_or_default()+ .chars()+ .filter(|c| {+ !c.is_control()+ && !matches!(+ c,+ '/' | '\\'+ | ':'+ | '*'+ | '?'+ | '"'+ | '<'+ | '>'+ | '|'+ | '\u{200E}'+ | '\u{200F}'+ | '\u{202A}'..='\u{202E}'+ | '\u{2066}'..='\u{2069}'+ | '\u{FEFF}'+ )+ })+ .collect();+ let trimmed = cleaned+ .trim_start_matches(['.', ' '])+ .trim_end_matches(['.', ' ']);+ // Long enough for any real name, short enough for every file system.+ let mut name: String = trimmed.chars().take(120).collect();+ let stem = name+ .split('.')+ .next()+ .unwrap_or_default()+ .to_ascii_uppercase();+ let device = matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL")+ || (stem.len() == 4+ && (stem.starts_with("COM") || stem.starts_with("LPT"))+ && stem.as_bytes()[3].is_ascii_digit());+ if device {+ name.insert(0, '_');+ }+ if name.is_empty() {+ name = format!("Attachment {}", id.chars().take(8).collect::<String>());+ }+ name+}++/// Whether opening this file would run it rather than show it: a program, a script, a+/// launcher or an installer, by its name or by what its first bytes say it is.+pub(crate) fn runs_code(name: &str, bytes: &[u8]) -> bool {+ const RUN: &[&str] = &[+ // Linux+ "desktop",+ "kdelnk",+ "sh",+ "bash",+ "zsh",+ "csh",+ "ksh",+ "fish",+ "run",+ "bin",+ "out",+ "elf",+ "so",+ "appimage",+ "flatpak",+ "flatpakref",+ "flatpakrepo",+ "snap",+ "deb",+ "rpm",+ "pkg",+ "py",+ "pyw",+ "pyc",+ "pl",+ "rb",+ "php",+ "lua",+ "tcl",+ "jar",+ "jnlp",+ "class",+ // Windows+ "exe",+ "com",+ "scr",+ "pif",+ "msi",+ "msix",+ "msp",+ "msc",+ "appx",+ "bat",+ "cmd",+ "ps1",+ "psm1",+ "psd1",+ "vbs",+ "vbe",+ "js",+ "jse",+ "wsf",+ "wsh",+ "ws",+ "hta",+ "cpl",+ "inf",+ "reg",+ "lnk",+ "url",+ "scf",+ "chm",+ "application",+ "appref-ms",+ "gadget",+ "library-ms",+ "settingcontent-ms",+ "dll",+ "sys",+ "iso",+ "img",+ "vhd",+ "vhdx",+ // macOS+ "app",+ "command",+ "tool",+ "workflow",+ "scpt",+ "terminal",+ "webloc",+ "inetloc",+ "dmg",+ "mpkg",+ ];+ let ext = name+ .rsplit_once('.')+ .map(|(_, e)| e.to_ascii_lowercase())+ .unwrap_or_default();+ RUN.contains(&ext.as_str())+ || bytes.starts_with(b"#!")+ || bytes.starts_with(b"\x7fELF")+ || bytes.starts_with(b"MZ")+ || bytes.starts_with(b"[Desktop Entry]")+ || bytes.starts_with(&[0xCF, 0xFA, 0xED, 0xFE])+ || bytes.starts_with(&[0xCA, 0xFE, 0xBA, 0xBE])+}+/// The contact a `quince://` request asks for the photo of.////// WebKitGTK reads `quince://photo/<id>` with "photo" as the host, while Tauri's own helper@@ -511,6 +713,9 @@ async fn auth_status(auth: State<'_, Auth>) -> UiResult<Status> {/// Try the stored session. `false` just means a sign-in is needed — not an error.#[tauri::command]async fn auth_resume(app: tauri::AppHandle, auth: State<'_, Auth>) -> UiResult<&'static str> {+ if LIVE.load(Ordering::SeqCst) {+ return Ok("library");+ }let outcome = {let mut client = auth.client.lock().await;let outcome = resume_session(&mut client).await?;@@ -554,6 +759,8 @@ async fn folders_up(app: &tauri::AppHandle) {/// Emitted when a lapsed session signed itself back in only as far as Apple's code.const NEEDS_CODE: &str = "quince://needs-code";+/// A session Apple will take back only with the password.+const NEEDS_SIGNIN: &str = "quince://needs-signin";/// Make sure the session is alive before a refresh uses it, signing back in if it lapsed.///@@ -561,12 +768,34 @@ const NEEDS_CODE: &str = "quince://needs-code";/// refresh failing quietly from then on. Checked here, a lapse is mended before it is felt;/// one that needs a code brings the code screen up instead.async fn keep_signed_in(app: &tauri::AppHandle, client: &Arc<Mutex<Client>>) {+ // Said once per lapse, not on every pass after it.+ static TOLD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);let mut guard = client.lock().await;if guard.session().webservices.is_none() {return;}- if matches!(guard.heartbeat().await, Ok(false)) && guard.awaiting_code() {- app.emit(NEEDS_CODE, ()).ok();+ match guard.heartbeat().await {+ Ok(false) if guard.awaiting_code() => {+ LIVE.store(false, Ordering::SeqCst);+ app.emit(NEEDS_CODE, ()).ok();+ }+ // Apple will not take the session back without the password: every sync would fail+ // quietly from here on. The window says so where it is open, and the desktop once,+ // for someone with only the tray running.+ Ok(false) => {+ LIVE.store(false, Ordering::SeqCst);+ app.emit(NEEDS_SIGNIN, ()).ok();+ if !TOLD.swap(true, std::sync::atomic::Ordering::Relaxed) {+ alerts::tell(+ app,+ "Sign in to keep iCloud up to date",+ "Apple signed Pomander out. Your copy on this computer is still here.",+ );+ }+ }+ Ok(true) => TOLD.store(false, std::sync::atomic::Ordering::Relaxed),+ // Not reaching Apple says nothing about the session.+ Err(_) => {}}}@@ -724,6 +953,50 @@ async fn account_now(auth: &Auth) -> Option<String> {.map(account_tag)}+/// The account a request's parameters ask as (its `dsid`), as the library names accounts.+fn asked_as(params: &[(String, String)]) -> Option<String> {+ params+ .iter()+ .find(|(k, _)| k == "dsid")+ .map(|(_, dsid)| account_tag(dsid))+}++/// Whether what was read with one account's session may be stored in this library: never in a+/// library another account owns. A pass after a write read with the session the write was+/// sent with; another Apple ID signing in meanwhile swapped the library under it, and that+/// pass stored the first account's notes, reminders and sync position in the second's.+fn owned_by(library: &quince_core::Library, asked_for: Option<&str>) -> Result<(), String> {+ let owner = library.state(ACCOUNT_KEY).ok().flatten();+ match (owner.as_deref(), asked_for) {+ (Some(owner), Some(asked)) if owner != asked => Err(+ "Signed in to another account while this was on its way, so nothing was stored.".into(),+ ),+ _ => Ok(()),+ }+}++#[cfg(test)]+mod account_write_tests {+ use super::*;++ #[test]+ fn what_one_account_read_is_never_stored_in_anothers_library() {+ let mut lib = Library::in_memory().unwrap();+ let params = |dsid: &str| vec![("dsid".to_string(), dsid.to_string())];+ lib.set_state(ACCOUNT_KEY, &account_tag("111")).unwrap();+ let a = asked_as(¶ms("111"));+ let b = asked_as(¶ms("222"));+ assert!(owned_by(&lib, a.as_deref()).is_ok());+ assert!(+ owned_by(&lib, b.as_deref()).is_err(),+ "the other account's read is refused"+ );+ // A library from before accounts were told apart, and a request with no account, pass.+ assert!(owned_by(&Library::in_memory().unwrap(), b.as_deref()).is_ok());+ assert!(owned_by(&lib, None).is_ok());+ }+}+/// Whether the library still belongs to `account`, taken when a command began: a result that/// came back after a sign-out, or another account's sign-in, is never stored over its data.fn still_owned(library: &quince_core::Library, account: Option<&str>) -> Result<(), String> {@@ -742,9 +1015,15 @@ async fn signed_in(app: &tauri::AppHandle, client: &mut Client) -> Result<(), Stlet _ = client.sign_out();return Err(e);}+ LIVE.store(true, Ordering::SeqCst);Ok(())}+/// This process holds a signed-in session, its library claimed: a window opened now (an app's+/// own, from the tray or its launcher) is told so at once. Asking Apple again first, behind the+/// sign-in lock a running sync may hold, kept every app window waiting about five seconds.+static LIVE: AtomicBool = AtomicBool::new(false);+#[tauri::command]async fn auth_sign_in(apple_id: String,@@ -884,6 +1163,9 @@ async fn account_unsent(app: tauri::AppHandle, data: State<'_, Data>) -> UiResulasync fn auth_sign_out(keep: bool, app: tauri::AppHandle, auth: State<'_, Auth>) -> UiResult<()> {// The folders go with the session they were served by — before the auth lock is taken,// since what they are still answering may be waiting on it.+ LIVE.store(false, Ordering::SeqCst);+ // A notes password typed this session goes with the session.+ notes_cmds::forget_passwords();tauri::async_runtime::spawn_blocking(mount::release).await.map_err(|e| e.to_string())?;@@ -1193,7 +1475,7 @@ async fn event_save(notes: draft.notes.filter(|s| !s.trim().is_empty()),// Apple rejects a write whose etag is not the version it holds, which is what stops// this from landing on top of a change made on a phone.- etag: existing.and_then(|e| e.etag),+ etag: existing.as_ref().and_then(|e| e.etag.clone()),};let ctag = quince_icloud::sync::calendar_ctag(&*data.0.lock().await, &event.calendar_guid);@@ -1205,10 +1487,10 @@ async fn event_save(}None => None,};- let kept = quince_icloud::sync::save_event_with_alerts(+ let first = quince_icloud::sync::save_event_with_alerts(&http,&root,- params,+ params.clone(),ctag.as_deref(),&event,draft.alerts.as_deref(),@@ -1217,7 +1499,57 @@ async fn event_save(from.as_ref().map(|(old, tag)| (old.as_str(), tag.as_deref())),)- .await+ .await;+ // Refused because the event changed on another device since it was read: as Calendar+ // settles it, Apple's copy is read again and this edit laid over it — their changes to+ // other fields kept, this edit's own fields this edit's — and saved once more against+ // Apple's newest version. One of a repeating series is not merged: which days a change+ // there reaches is Apple's to settle, so it is refused as before.+ let kept = match (first, existing.as_ref()) {+ (Err(quince_icloud::Error::Conflict), Some(base))+ if !quince_icloud::calendar::is_occurrence(&guid) =>+ {+ let client = quince_icloud::calendar::CalendarClient::new(&http, &root, params.clone());+ // Gone from where it was: deleted (or moved away) elsewhere. Never written back.+ let Some(theirs) = client+ .current_event(base)+ .await+ .map_err(|e| e.to_string())?+ else {+ return Err("This event was deleted on another device, so it wasn’t saved.".into());+ };+ let merged = quince_icloud::calendar::merge_edit(base, &event, &theirs);+ // Where it is at Apple now, and where it is going, with each calendar's tag read+ // afresh: the refusal may have been for the calendar's tag as much as the event's.+ let fresh_tag = |guid: String| {+ let client = &client;+ async move { client.current_ctag(&guid).await.ok().flatten() }+ };+ let ctag = fresh_tag(merged.calendar_guid.clone()).await;+ let from = if theirs.calendar_guid != merged.calendar_guid {+ Some((+ theirs.calendar_guid.clone(),+ fresh_tag(theirs.calendar_guid.clone()).await,+ ))+ } else {+ None+ };+ quince_icloud::sync::save_event_with_alerts(+ &http,+ &root,+ params,+ ctag.as_deref(),+ &merged,+ draft.alerts.as_deref(),+ draft.repeat_changed.then_some(draft.repeat.as_ref()),+ draft.scope,+ from.as_ref()+ .map(|(old, tag)| (old.as_str(), tag.as_deref())),+ )+ .await+ }+ (result, _) => result,+ }.map_err(|e| e.to_string())?;let mut library = data.0.lock().await;still_owned(&library, account.as_deref())?;@@ -1563,6 +1895,85 @@ async fn reminder_set_done(set_done(&auth, &data, &guid, &list_guid, done).await}+/// What the window is told when a reminder it acted on is not in the library at all: deleted+/// on another device and synced away, or still a stand-in for one being added. Not a sentence+/// for a person — the window answers it by quietly reading the list again (RemindersView).+pub const REMINDER_GONE: &str = "reminder-gone";++/// The stored reminder a write is made against, found by its id alone.+///+/// The window also sends the list it saw the reminder in, and that used to be required to+/// match. It goes stale without anything being wrong: moved to another list on the phone and+/// synced in, or moved here with a tick queued behind the move, the reminder was still there+/// and still the one meant — and the write was refused with a red "no longer in the local+/// library" over a list that plainly showed it. A record id belongs to one reminder whatever+/// list holds it, and the write goes to the list the record is in now.+fn reminder_to_write(+ library: &Library,+ guid: &str,+) -> Result<quince_core::reminders::Reminder, String> {+ library+ .reminder(guid)+ .map_err(|e| e.to_string())?+ .ok_or_else(|| REMINDER_GONE.to_string())+}++#[cfg(test)]+mod reminder_write_tests {+ use super::*;+ use quince_core::reminders::{Reminder, ReminderList};++ fn library() -> Library {+ let mut lib = Library::in_memory().unwrap();+ let list = |g: &str| ReminderList {+ guid: g.into(),+ title: g.into(),+ enabled: true,+ ..Default::default()+ };+ lib.put_reminder_lists(&[list("A"), list("B")]).unwrap();+ lib.put_reminders(&[Reminder {+ guid: "r".into(),+ list_guid: "A".into(),+ title: "r".into(),+ ..Default::default()+ }])+ .unwrap();+ lib+ }++ #[test]+ fn a_reminder_is_found_by_its_id_whatever_list_holds_it() {+ let mut lib = library();+ assert_eq!(reminder_to_write(&lib, "r").unwrap().list_guid, "A");+ // Moved on the phone and synced in while the window still showed it under A.+ lib.put_reminders(&[Reminder {+ guid: "r".into(),+ list_guid: "B".into(),+ title: "r".into(),+ ..Default::default()+ }])+ .unwrap();+ let found = reminder_to_write(&lib, "r").unwrap();+ assert_eq!(+ found.list_guid, "B",+ "the write goes where the record is now"+ );+ }++ #[test]+ fn one_truly_gone_is_reported_for_a_quiet_reread_not_as_a_sentence() {+ let mut lib = library();+ lib.forget_reminders(&["r".into()], &[]).unwrap();+ assert_eq!(reminder_to_write(&lib, "r").unwrap_err(), REMINDER_GONE);+ // A stand-in for a reminder still being added is not in the library either.+ assert_eq!(+ reminder_to_write(&lib, "pending:1").unwrap_err(),+ REMINDER_GONE+ );+ }+}+/// Tick a reminder off or put it back — from the window, or from an alert's button.////// In the library at once and queued for Apple (see outbox.rs): the window never waits on the@@ -1572,16 +1983,13 @@ async fn set_done(auth: &State<'_, Auth>,data: &State<'_, Data>,guid: &str,- list_guid: &str,+ // Where the caller saw it; the record says where it is now (reminder_to_write).+ _list_guid: &str,done: bool,) -> UiResult<()> {let reminder = {let library = data.0.lock().await;- library- .reminder(guid)- .map_err(|e| e.to_string())?- .filter(|r| r.list_guid == list_guid)- .ok_or("That reminder is no longer in the local library.")?+ reminder_to_write(&library, guid)?};if !(done && reminder.repeats()) {let now = jiff::Timestamp::now().as_second();@@ -1606,7 +2014,8 @@ async fn set_done(.await.map_err(|e| e.to_string())?;- refresh_reminders(&http, &root, params, data, false).await+ // Made at Apple: a refresh failing now is not the tick failing (see `settle`).+ settle(refresh_reminders(&http, &root, params, data, false).await)}/// Set or clear how often a reminder comes back.@@ -1616,7 +2025,8 @@ async fn set_done(#[tauri::command]async fn reminder_set_repeat(guid: String,- list_guid: String,+ // The list the window saw it in: a hint that can be stale, never checked (reminder_to_write).+ #[allow(unused_variables)] list_guid: String,repeat: Option<quince_icloud::reminders::Repeat>,auth: State<'_, Auth>,data: State<'_, Data>,@@ -1625,11 +2035,7 @@ async fn reminder_set_repeat(let reminder = {let library = data.0.lock().await;- library- .reminder(&guid)- .map_err(|e| e.to_string())?- .filter(|r| r.list_guid == list_guid)- .ok_or("That reminder is no longer in the local library.")?+ reminder_to_write(&library, &guid)?};quince_icloud::reminders::set_recurrence_cloudkit(@@ -1671,160 +2077,77 @@ async fn reminder_create(due_at: Option<i64>,all_day: Option<bool>,flagged: Option<bool>,- auth: State<'_, Auth>,data: State<'_, Data>,-) -> UiResult<()> {- let (http, root, params) = cloudkit_context(&auth).await?;- let guid =- quince_icloud::reminders::create_cloudkit(&http, &root, params.clone(), &list_guid, &title)- .await- .map_err(|e| e.to_string())?;- if due_at.is_some() || flagged.is_some() {- let made = quince_core::reminders::Reminder {- guid,- list_guid: list_guid.clone(),- title: title.clone(),- ..Default::default()- };- let edit = quince_icloud::reminders::ReminderEdit {- due_at: due_at.map(Some),- all_day,- flagged,- ..Default::default()- };- // The reminder exists at Apple now, whatever happens next: a failure here must not- // read as "nothing was made", or the title put back and entered again made a second.- if let Err(e) =- quince_icloud::reminders::edit_cloudkit(&http, &root, params.clone(), &made, &edit)- .await- {- quiet!("a new reminder's date or flag was not set: {e}");- }+) -> UiResult<String> {+ // Said now, not when the queue reaches Apple: nothing to send would be refused there.+ if title.trim().is_empty() {+ return Err("A reminder needs a title.".into());}-- refresh_reminders(&http, &root, params, &data, false).await+ if list_guid.trim().is_empty() {+ return Err("A reminder has to go in a list, and this account has none yet.".into());+ }+ // In the library at once under a name chosen here, and queued for Apple (outbox.rs): made+ // offline, it is there now and reaches Apple when Apple can be reached — made once.+ let guid = {+ let mut library = data.0.lock().await;+ outbox::record_reminder_create(+ &mut library,+ &outbox::Create {+ list_guid,+ title,+ due_at,+ all_day,+ flagged,+ },+ )+ .map_err(|e| e.to_string())?+ };+ outbox::kick();+ alerts::changed();+ Ok(guid)}#[tauri::command]async fn reminder_delete(guid: String,- list_guid: String,- auth: State<'_, Auth>,+ // The list the window saw it in: a hint that can be stale, never checked (reminder_to_write).+ #[allow(unused_variables)] list_guid: String,data: State<'_, Data>,) -> UiResult<()> {- let (http, root, params) = cloudkit_context(&auth).await?;-- let reminder = {- let library = data.0.lock().await;- library- .reminder(&guid)- .map_err(|e| e.to_string())?- .filter(|r| r.list_guid == list_guid)- .ok_or("That reminder is no longer in the local library.")?- };-- // Its subtasks go with it, as on the phone: left behind they came back at the top level- // here and stayed in iCloud.- let children = data.0.lock().await.subtasks_of(&guid).unwrap_or_default();- quince_icloud::reminders::delete_cloudkit(&http, &root, params.clone(), &reminder)- .await- .map_err(|e| e.to_string())?;- for child in &children {- if let Err(e) =- quince_icloud::reminders::delete_cloudkit(&http, &root, params.clone(), child).await- {- quiet!("a subtask did not go with its reminder: {e}");- }+ // Gone from the library at once, its subtasks with it, as on the phone; queued for Apple.+ {+ let mut library = data.0.lock().await;+ let reminder = reminder_to_write(&library, &guid)?;+ outbox::record_reminder_delete(&mut library, &reminder).map_err(|e| e.to_string())?;}-- refresh_reminders(&http, &root, params, &data, false).await+ outbox::kick();+ alerts::changed();+ Ok(())}/// Apply an edit — title, notes, due date, flag, completion — in one write.#[tauri::command]async fn reminder_edit(guid: String,- list_guid: String,+ // The list the window saw it in: a hint that can be stale, never checked (reminder_to_write).+ #[allow(unused_variables)] list_guid: String,edit: quince_icloud::reminders::ReminderEdit,- auth: State<'_, Auth>,data: State<'_, Data>,) -> UiResult<()> {- let (http, root, params) = cloudkit_context(&auth).await?;-- let reminder = {- let library = data.0.lock().await;- library- .reminder(&guid)- .map_err(|e| e.to_string())?- .filter(|r| r.list_guid == list_guid)- .ok_or("That reminder is no longer in the local library.")?- };-- quince_icloud::reminders::edit_cloudkit(&http, &root, params.clone(), &reminder, &edit)- .await- .map_err(|e| e.to_string())?;-- // Moved to another list, a reminder takes its subtasks with it, as on the phone: left- // behind, they sat in the old list nested under a parent that was no longer in it.- if let Some(to) = edit.list_guid.as_deref().filter(|to| *to != list_guid) {- let children: Vec<quince_core::reminders::Reminder> = {- let library = data.0.lock().await;- library.subtasks_of(&guid).unwrap_or_default()- };- let follow = quince_icloud::reminders::ReminderEdit {- list_guid: Some(to.to_string()),- ..Default::default()- };- for child in &children {- if let Err(e) = quince_icloud::reminders::edit_cloudkit(- &http,- &root,- params.clone(),- child,- &follow,- )- .await- {- quiet!("a subtask did not follow its reminder: {e}");- }- }+ if edit.title.as_deref().is_some_and(|t| t.trim().is_empty()) {+ return Err("A reminder needs a title.".into());}-- // A due date on its own notifies nobody. Every reminder on a real account that has a- // time carries an Alarm pointing at an AlarmTrigger, and one written here used to have- // the date and no alarm — so a phone showed the right time and then said nothing when it- // came. The alert is part of setting a date, not a separate thing to remember.- //- // The edit is already on Apple by now. If the alert fails, the library is still re-read- // before saying so: returning early left the old date on screen though Apple had the new- // one, and the next edit was made against a reminder that was not there any more.- // An all-day reminder rings no alarm, as on the phone.- // Made all-day, a reminder keeps no timed alarm: the old one kept ringing at the time it- // used to have.- let alarm_change = if edit.all_day == Some(true) {- Some(None)- } else {- edit.due_at- };- let alarm = match alarm_change {- Some(due) => {- let zone = jiff::tz::TimeZone::system();- quince_icloud::reminders::set_alarm_cloudkit(- &http,- &root,- params.clone(),- &guid,- due,- zone.iana_name().unwrap_or("UTC"),- )- .await- .map_err(|e| format!("The date was saved, but its alert was not: {e}"))- }- None => Ok(()),- };-- refresh_reminders(&http, &root, params, &data, false).await?;- alarm+ // In the library at once and queued for Apple (outbox.rs). Sent, it is one write of the+ // fields changed, its subtasks follow a move, and a date carries its alert, as on the+ // phone — whenever Apple can be reached.+ {+ let mut library = data.0.lock().await;+ let reminder = reminder_to_write(&library, &guid)?;+ outbox::record_reminder_edit(&mut library, &reminder, &edit).map_err(|e| e.to_string())?;+ }+ outbox::kick();+ alerts::changed();+ Ok(())}/// One of Apple's smart lists. `until` is the end of today in the viewer's own timezone,@@ -2183,10 +2506,8 @@ async fn note_save(// The formatting the editor began from, over `base`: a line not restyled since keeps// what Apple holds now, so a tick made on the phone is not undone.base_runs: Option<Vec<quince_icloud::ckdocument::Run>>,- auth: State<'_, Auth>,data: State<'_, Data>,) -> UiResult<String> {- let (http, root, params) = cloudkit_context(&auth).await?;let note = note_by_guid(&data, &guid).await?;if !note.editable {return Err(@@ -2194,50 +2515,16 @@ async fn note_save(.into(),);}- let saved = quince_icloud::notes::edit_rich_cloudkit_from(- &http,- &root,- params.clone(),- ¬e,- base.as_deref(),- &body,- runs.as_deref(),- base_runs.as_deref(),- )- .await- .map_err(|e| e.to_string())?;- // Apple has it; a refresh failing now must not read as the save failing.- if let Err(e) = resync_notes(&http, &root, params, &data).await {- quiet!("notes refresh after a save: {e}");- }-- // Apple accepted the body, but its change feed does not always carry our own write back- // on the very next pass. Without this the editor re-reads the old text a moment after- // saving, which reads as the edit having been lost. Only the text is set: the note's- // formatting and the rest come from Apple's own copy.- let (title, snippet) = quince_icloud::notes::title_and_snippet(&saved);- let mut library = data.0.lock().await;- library- .set_note_text(- &guid,- &saved,- &title,- Some(snippet.as_str()).filter(|s| !s.is_empty()),- )- .map_err(|e| e.to_string())?;- if let Some(runs) = runs {- let laid = if saved == body {- runs- } else {- quince_icloud::ckdocument::carry_runs(&body, &runs, &saved)- };- if let Ok(json) = serde_json::to_string(&laid) {- library- .set_note_runs(&guid, &json)- .map_err(|e| e.to_string())?;- }+ // Kept in the library first — durable, and what every read shows — then sent behind+ // (outbox.rs), merged with whatever Apple holds by then against the text it was typed+ // over. Offline, it waits there, across a restart, until Apple can be reached.+ {+ let mut library = data.0.lock().await;+ outbox::record_note_save(&mut library, &guid, &body, base, runs, base_runs)+ .map_err(|e| e.to_string())?;}- Ok(saved)+ outbox::kick();+ Ok(body)}/// Write a new note and return the record name Apple gave it.@@ -2466,12 +2753,18 @@ async fn resync_contacts(params: Vec<(String, String)>,data: &State<'_, Data>,) -> Result<(), String> {+ let asked_for = asked_as(¶ms);let people = quince_icloud::contacts::fetch(http, root, params).await.map_err(|e| e.to_string())?;let mut library = data.0.lock().await;- quince_icloud::contacts::apply(&mut library, people)- .map(|_| ())+ owned_by(&library, asked_for.as_deref())?;+ library+ .atomically(|library| {+ quince_icloud::contacts::apply(library, people)?;+ outbox::replay(library, outbox::CONTACTS)?;+ Ok::<_, quince_icloud::Error>(())+ }).map_err(|e| e.to_string())}@@ -2589,38 +2882,19 @@ async fn contact_save(contact: Contact,// The card as the form opened it: only what differs from it is written.base: Option<Contact>,- auth: State<'_, Auth>,data: State<'_, Data>,) -> UiResult<String> {- let _one = CONTACTS_PASS.lock().await;- let (http, root, params) = contacts_context(&auth).await?;- let (_, tokens) = quince_icloud::contacts::fetch_with_tokens(&http, &root, params.clone())- .await- .map_err(|e| e.to_string())?;-- let guid = if contact.guid.is_empty() {- quince_icloud::contacts::create(&http, &root, params.clone(), &tokens, &contact)- .await- .map_err(|e| e.to_string())?- } else {- let card = quince_icloud::contacts::card(&http, &root, params.clone(), &contact.guid)- .await- .map_err(|e| e.to_string())?;- quince_icloud::contacts::update_from(- &http,- &root,- params.clone(),- &tokens,- &contact,- card.as_ref(),- base.as_ref(),- )- .await- .map_err(|e| e.to_string())?;- contact.guid.clone()+ if contact.guid.is_empty() && quince_icloud::contacts::blank_card(&contact) {+ return Err("Add a name, a phone number or an email address first.".into());+ }+ // In the library at once — a new card under the id it will have at Apple — and queued+ // (outbox.rs). Sent, an edit starts from Apple's own card, so everything this app does not+ // model — a photo, related names, social profiles — is written back untouched.+ let guid = {+ let mut library = data.0.lock().await;+ outbox::record_contact_save(&mut library, &contact, base).map_err(|e| e.to_string())?};-- settle(resync_contacts(&http, &root, params, &data).await)?;+ outbox::kick();Ok(guid)}@@ -2866,10 +3140,12 @@ async fn resync_drive_folder(folder_id: &str,) -> Result<(), String> {let _one = DRIVE_PASS.lock().await;+ let asked_for = asked_as(¶ms);let items = quince_icloud::drive::fetch_folder(http, root, params, folder_id).await.map_err(|e| e.to_string())?;let mut library = data.0.lock().await;+ owned_by(&library, asked_for.as_deref())?;quince_icloud::drive::store_folder(&mut library, folder_id, &items).map(|_| ()).map_err(|e| e.to_string())@@ -3751,6 +4027,30 @@ async fn sync_all(Ok(result)}+/// Refresh only the services named — one app's "update now" — and report on those.+///+/// The event carries the whole library's freshness, not this partial report: every open+/// screen and the account's status read the event as the complete picture, and a report of+/// one service would have made the others look never synced.+#[tauri::command]+async fn sync_some(+ app: tauri::AppHandle,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+ services: Vec<String>,+) -> UiResult<refresh::Refresh> {+ let client = Arc::clone(&auth.client);+ keep_signed_in(&app, &client).await;+ let names: Vec<&str> = services.iter().map(String::as_str).collect();+ let result = refresh::some(&client, &data.0, &names).await;+ alerts::changed();+ if names.contains(&"contacts") {+ warm_contact_photos(app.clone());+ }+ app.emit(SYNCED, refresh::status(&data.0).await).ok();+ Ok(result)+}+/// What the library already knows about its own freshness, with nothing fetched.#[tauri::command]async fn sync_status(data: State<'_, Data>) -> UiResult<refresh::Refresh> {@@ -4105,32 +4405,49 @@ fn show_window(app: &tauri::AppHandle) {/// closed, and can be opened again or quit from there.fn build_tray(app: &tauri::App) -> tauri::Result<()> {use tauri::menu::PredefinedMenuItem;- use tauri::menu::{Menu, MenuItem};+ use tauri::menu::{Menu, MenuItem, Submenu};use tauri::tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent};+ // Five lines, as a menu-bar extra keeps it: the window, the apps folded under one, the two+ // quick notes a person reaches for, and Quit. Syncing needs no button (it runs by itself)+ // and Settings lives in the window; a longer menu was a list nobody could scan.let open = MenuItem::with_id(app, "open", "Open Pomander", true, None::<&str>)?;- // Each app on its own, as its launcher entry opens it.let each: Vec<MenuItem<tauri::Wry>> = apps::APPS.iter().map(|(key, name)| MenuItem::with_id(app, format!("app:{key}"), *name, true, None::<&str>)).collect::<tauri::Result<_>>()?;+ let each_ref: Vec<&dyn tauri::menu::IsMenuItem<tauri::Wry>> = each+ .iter()+ .map(|i| i as &dyn tauri::menu::IsMenuItem<tauri::Wry>)+ .collect();+ let apps_menu = Submenu::with_items(app, "Open App", true, &each_ref)?;+ let new_reminder = MenuItem::with_id(app, "new:reminder", "New Reminder", true, None::<&str>)?;+ let new_note = MenuItem::with_id(app, "new:note", "New Note", true, None::<&str>)?;let line = PredefinedMenuItem::separator(app)?;let line2 = PredefinedMenuItem::separator(app)?;let quit = MenuItem::with_id(app, "quit", "Quit Pomander", true, None::<&str>)?;- let mut items: Vec<&dyn tauri::menu::IsMenuItem<tauri::Wry>> = vec![&open, &line];- items.extend(- each.iter()- .map(|i| i as &dyn tauri::menu::IsMenuItem<tauri::Wry>),- );- items.push(&line2);- items.push(&quit);- let menu = Menu::with_items(app, &items)?;+ let menu = Menu::with_items(+ app,+ &[+ &open,+ &apps_menu,+ &line,+ &new_reminder,+ &new_note,+ &line2,+ &quit,+ ],+ )?;let mut tray = TrayIconBuilder::with_id("quince").tooltip("Pomander").menu(&menu)- .show_menu_on_left_click(false)+ // A click opens the window, as a tray icon does on Windows (and in most Linux panels);+ // the menu is the right click's. A Mac menu-bar extra opens its menu on any click.+ .show_menu_on_left_click(cfg!(target_os = "macos")).on_menu_event(|app, event| match event.id.as_ref() {"open" => show_window(app),"quit" => shutdown(app, 0),+ "new:reminder" => intake::capture(app, "reminder"),+ "new:note" => intake::capture(app, "note"),other => {if let Some(key) = other.strip_prefix("app:") {apps::open(app, key);@@ -4144,11 +4461,21 @@ fn build_tray(app: &tauri::App) -> tauri::Result<()> {..} = event{- show_window(tray.app_handle());+ if !cfg!(target_os = "macos") {+ show_window(tray.app_handle());+ }}});- if let Some(icon) = app.default_window_icon() {- tray = tray.icon(icon.clone());+ // The icon drawn for small sizes, not the window's: on Windows that is the .ico's first+ // entry, 256px, which the tray shrank to 16px into a blur. The 32px one halves cleanly at+ // 100% scaling and is shown as drawn at 200%.+ match tauri::image::Image::from_bytes(include_bytes!("../icons/32x32.png")) {+ Ok(icon) => tray = tray.icon(icon),+ Err(_) => {+ if let Some(icon) = app.default_window_icon() {+ tray = tray.icon(icon.clone());+ }+ }}tray.build(app)?;Ok(())@@ -4158,10 +4485,25 @@ fn main() {login::note_launch();steady_drawing();smooth_video();+ // After the two above (they set the environment, which only a single thread may) and+ // before anything opens the library, the webview its storage, or the window-state plugin+ // its file: the folders moved from the old identifier, or — if they could not be — this+ // launch run under the old one, from them as they are (migrate.rs).+ let mut context = tauri::generate_context!();+ let current = context.config().identifier.clone();+ let identifier = migrate::at_launch(¤t);+ if identifier != current {+ context.config_mut().identifier = identifier;+ }tauri::Builder::default()// One Quince at a time: opening it again brings back the one already running, which// may be sitting in the tray with its window closed.- .plugin(tauri_plugin_single_instance::init(|app, args, _cwd| {+ .plugin(tauri_plugin_single_instance::init(|app, args, cwd| {+ // A file opened with Pomander, or a quick capture (`--new reminder`): handled+ // here, in the one already running.+ if intake::arrived(app, &args, std::path::Path::new(&cwd)) {+ return;+ }// `--app notes` from a launcher entry: that app's window, in this same process.match apps::asked(&args) {Some(key) => apps::open(app, key),@@ -4185,11 +4527,16 @@ fn main() {.plugin(tauri::plugin::Builder::<tauri::Wry, ()>::new("links").on_navigation(|webview, url| {+ // The app's own page only: Windows serves it as tauri.localhost. Any other+ // address on this computer (a server some other program runs on localhost)+ // is somewhere else, opened outside; only a development build, whose page+ // comes from the dev server, counts localhost as its own.let inside =matches!(url.scheme(), "tauri" | "quince" | "about" | "data" | "blob")- || url- .host_str()- .is_some_and(|h| h == "tauri.localhost" || h == "localhost");+ || url.host_str().is_some_and(|h| {+ h == "tauri.localhost"+ || (cfg!(debug_assertions) && h == "localhost")+ });if !inside {use tauri_plugin_opener::OpenerExt;if let Err(e) = webview@@ -4208,12 +4555,21 @@ fn main() {// in the tray. Where no tray could be made there is nowhere to come back from, so// there closing quits as it always did..on_window_event(|window, event| {- // An app's own window closes for good, giving its memory back; the whole-library- // window is put away, as the engine keeps running behind the tray.+ // The whole-library window is put away, as the engine keeps running behind the+ // tray. An app's own window is put away too, so opening it again is instant rather+ // than a new web view built from nothing — and given back for good once it has+ // gone unused for a while, so six put-away windows do not sit on memory.if let tauri::WindowEvent::CloseRequested { api, .. } = event {- if window.label() == "main" && window.app_handle().tray_by_id("quince").is_some() {+ if window.app_handle().tray_by_id("quince").is_none() {+ return;+ }+ if window.label() == "main" {+ api.prevent_close();+ window.hide().ok();+ } else if window.label().starts_with("app-") {api.prevent_close();window.hide().ok();+ apps::put_away(window);}}})@@ -4331,7 +4687,6 @@ fn main() {}).setup(|app| {video::serve(app.handle().clone());- outbox::start(app.handle().clone());let dir = state_dir(app.handle());keep_private(&dir);let client = Arc::new(Mutex::new(Client::new(&dir)?));@@ -4344,6 +4699,10 @@ fn main() {let mut library = Library::open(&dir)?;adopt_writer(&mut library);app.manage(Data(Mutex::new(library)));+ // The sender of edits made offline, started once what it sends with — the session+ // and the library — is in place: started first, its opening pass found neither and+ // its task died, and nothing waiting was sent all session.+ outbox::start(app.handle().clone());// A photo cache past what this computer can spare now — the disk filled since —// is brought back under its budget first thing.let trim = app.handle().clone();@@ -4395,6 +4754,15 @@ fn main() {spawn_heartbeat(Arc::clone(&client));push::spawn(app.handle().clone(), Arc::clone(&client));spawn_auto_sync(app.handle().clone(), client);+ // Each service's part of a pass, told to the open screens as it is stored.+ let landing = app.handle().clone();+ refresh::on_landed(move |_| {+ let app = landing.clone();+ tauri::async_runtime::spawn(async move {+ let status = refresh::status(&app.state::<Data>().0).await;+ app.emit(SYNCED, status).ok();+ });+ });alerts::spawn(app.handle().clone());alerts::spawn_events(app.handle().clone());// A tiling compositor places, sizes and closes windows itself; a title bar with@@ -4409,7 +4777,11 @@ fn main() {quiet!("no tray on this desktop, so closing the window quits: {e}");}let launched: Vec<String> = std::env::args().collect();- if let Some(key) = apps::asked(&launched) {+ let here = std::env::current_dir().unwrap_or_default();+ // Started to open a file, or for a quick capture: that window is what shows.+ if intake::arrived(app.handle(), &launched, &here) {+ LAUNCHED_AS_APP.store(true, Ordering::SeqCst);+ } else if let Some(key) = apps::asked(&launched) {LAUNCHED_AS_APP.store(true, Ordering::SeqCst);apps::open(app.handle(), key);}@@ -4419,6 +4791,9 @@ fn main() {Ok(())}).invoke_handler(tauri::generate_handler![+ outbox::outbox_status,+ outbox::outbox_resend,+ outbox::outbox_discard,auth_status,auth_resume,auth_sign_in,@@ -4431,7 +4806,13 @@ fn main() {account_unsent,search_everything,apps::app_open,+ intake::intake_pending,+ intake::intake_capture_close,+ intake::intake_open_main,login::login_item_status,+ settings::local_storage,+ settings::local_storage_clear,+ settings::alerts_shown,mount::drive_kept,mount::drive_keep,login::login_item_set,@@ -4440,6 +4821,7 @@ fn main() {settings_get,settings_set,sync_all,+ sync_some,sync_status,calendar_sync,calendar_events,@@ -4519,6 +4901,7 @@ fn main() {note_attachment_info,note_attachment_open,diagnostics_save,+ download_reveal,note_paragraph,note_save,note_create,@@ -4537,6 +4920,24 @@ fn main() {contact_set_me,contact_list_write,contact_delete,+ contacts_cmds::contact_addresses,+ contacts_cmds::contact_address_edit,+ notes_cmds::note_unlock,+ notes_cmds::note_lock_hint,+ notes_cmds::note_lock_forget,+ notes_cmds::note_attach_file,+ reminders_cmds::reminder_detail,+ reminders_cmds::reminder_tags,+ reminders_cmds::reminders_tagged,+ reminders_cmds::reminder_smart_lists,+ reminders_cmds::reminders_in_smart_list,+ reminders_cmds::reminder_tag_add,+ reminders_cmds::reminder_tag_remove,+ reminders_cmds::reminder_url_set,+ reminders_cmds::reminder_early_alert_set,+ reminders_cmds::reminder_section_create,+ reminders_cmds::reminder_section_rename,+ reminders_cmds::reminder_section_move,drive_sync_folder,drive_children,drive_download,@@ -4558,7 +4959,7 @@ fn main() {reminder_set_done,reminder_set_repeat,])- .build(tauri::generate_context!())+ .build(context).expect("Pomander failed to start").run(|_app, event| {// The iCloud Drive folder goes with the app: left mounted, it would answer@@ -4572,6 +4973,72 @@ fn main() {#[cfg(test)]mod tests {+ /// A shared note's attachment is saved under a plain name in its own folder, whatever its+ /// sender called it, and a program in one is shown in its folder, never run.+ #[test]+ fn a_note_attachment_cannot_escape_or_run() {+ use super::{attachment_name, runs_code};+ for (given, want) in [+ (Some("Report.pdf"), "Report.pdf"),+ (Some("../../.bashrc"), "bashrc"),+ (Some("..\\..\\x.txt"), "x.txt"),+ (Some("C:evil.txt"), "Cevil.txt"),+ (Some(".hidden"), "hidden"),+ (Some("invoice\u{202E}fdp.exe"), "invoicefdp.exe"),+ (Some("a\nb\0c.pdf"), "abc.pdf"),+ (Some("CON.txt"), "_CON.txt"),+ (Some("com1"), "_com1"),+ (Some("trailing. . "), "trailing"),+ (Some("/"), "Attachment ABC"),+ (Some(".."), "Attachment ABC"),+ (None, "Attachment ABC"),+ ] {+ let name = attachment_name(given, "ABC");+ assert_eq!(name, want, "{given:?}");+ let dir = std::path::Path::new("/data/note-files/ABC");+ assert_eq!(dir.join(&name).parent(), Some(dir), "{given:?}");+ }+ assert!(attachment_name(Some(&"x".repeat(1000)), "A").len() <= 120);+ for runs in [+ "evil.desktop",+ "x.SH",+ "setup.exe",+ "a.pdf.jar",+ "Run.AppImage",+ "s.lnk",+ ] {+ assert!(runs_code(runs, b"%PDF-"), "{runs}");+ }+ assert!(runs_code("notes.txt", b"#!/bin/sh\nrm -rf ~"));+ assert!(runs_code("photo.jpg", b"\x7fELF\x02\x01"));+ assert!(runs_code("Attachment 1", b"[Desktop Entry]\nExec=sh"));+ assert!(!runs_code("Report.pdf", b"%PDF-1.7"));+ assert!(!runs_code("IMG_0001.HEIC", b"\0\0\0\x18ftypheic"));+ }++ /// No `quince://` request reaches a file outside the folders its kind is kept in.+ #[test]+ fn the_scheme_reads_nothing_outside_its_folders() {+ for path in [+ "/pic/..%2F..%2Fcookies.json/original",+ "/pic/../original",+ "/pic/a%2Fb/original",+ "/pic//original",+ "/pic/%2e%2e/fit512",+ ] {+ assert_eq!(super::photos::requested(path), None, "{path}");+ assert_eq!(super::photos::requested_fit(path), None, "{path}");+ }+ assert_eq!(super::photos::requested_upload("/up/..%2Fx"), None);+ let dir = std::path::Path::new("/data");+ let guid = super::photo_guid(Some("photo"), "/..%2F..%2Fetc%2Fpasswd").unwrap();+ let at = super::photo_path(dir, &guid, "../../sig/..");+ assert_eq!(at.parent(), Some(dir.join("faces").as_path()));+ let (id, _) = super::note_part("/note/..%2F..%2Fcookies.json/file").unwrap();+ let safe = super::media_file_id(&id);+ assert_eq!(safe, "______cookies_json");+ }+/// Two Apple IDs on one computer: each one's library and caches set aside whole while the/// other is signed in, and back exactly as they were — never mixed, never deleted — with/// this computer's settings staying put through both switches.diff --git a/src-tauri/src/migrate.rs b/src-tauri/src/migrate.rsnew file mode 100644index 0000000..60c3b9c--- /dev/null+++ b/src-tauri/src/migrate.rs@@ -0,0 +1,1335 @@+//! The move from identifiers the app had before (`PREVIOUS`) to the one it has now+//! (tauri.conf.json's `identifier`), once, at launch, before anything opens the library.+//!+//! The identifier names every folder the app keeps: the library and everything beside it+//! (`~/.local/share/<id>`, `%APPDATA%\<id>`), WebKitGTK's storage inside it (localStorage, its+//! caches), the window-state file (`~/.config/<id>`), the cache folder, and on Windows+//! WebView2's (`%LOCALAPPDATA%\<id>\EBWebView`). Changed without a move, an existing install+//! would open on an empty library, its unsent Drive files and signed-in session left behind.+//! The keyring entries move on their own, on first read (quince-auth `read_moving`).+//!+//! Crash safety. Each folder moves with one `rename` where it can: atomic, so a crash leaves it+//! either all old or all new. Where it cannot (another filesystem), it is copied into a staging+//! folder beside the new one, compared byte for byte, recorded as complete in a journal, and+//! only then put in place and the old one deleted. A journal left by a crash says which side+//! is whole: `copying` — the old one, and the staging copy is thrown away and redone; `copied` —+//! the copy, and the move is finished. Nothing is ever half in both places and read as whole.+//!+//! Never empty. If the move fails, this launch runs under the old identifier, from the old+//! folders as they were, and the next launch tries again. Both folders present (a build with+//! the new identifier ran before this one): a new folder with no library in it is set aside —+//! renamed, never deleted — and the old one moved in; if both hold a library, the larger one+//! is kept in place and the other set aside beside it.++use std::fs;+use std::io;+use std::path::{Path, PathBuf};++/// Identifiers this app was published under before, newest first (kept in quince-auth, which+/// moves the keyring entries by the same list). The current one is tauri.conf.json's.+pub use quince_auth::session::PREVIOUS_IDENTIFIERS as PREVIOUS;++/// One move: the folders of an identifier the app had (`old`) to the one it has (`new`).+#[derive(Clone, Copy, Debug)]+pub struct Ids<'a> {+ pub old: &'a str,+ pub new: &'a str,+}++/// Left in a folder that came from an earlier identifier (`.migrated-from-<old>`): it says the+/// folder is the established one, so an old build run later (which makes a fresh old folder)+/// is not mistaken for it.+const MARKER_PREFIX: &str = ".migrated-from-";++impl Ids<'_> {+ fn marker(&self) -> String {+ format!("{MARKER_PREFIX}{}", self.old)+ }+ /// Beside the folders, while a move is under way: the lock, and the phase of a copy.+ fn journal(&self) -> String {+ format!(".{}.migration", self.new)+ }+ /// Beside the folders, while a copy is under way.+ fn staging(&self) -> String {+ format!(".{}.partial", self.new)+ }+}++/// The folders the identifiers live in.+pub struct Roots {+ /// Where the library is: the move that decides which identifier this launch runs as.+ pub primary: PathBuf,+ /// The others (config, cache; Windows' local folder). They follow, and a failure there+ /// is logged and tried again next launch — nothing in them is the person's data.+ pub secondary: Vec<PathBuf>,+ /// The XDG autostart folder, for the Open at Login entry.+ pub autostart: Option<PathBuf>,+}++impl Roots {+ /// The folders Tauri's path resolver uses (the `dirs` crate's), from the environment, as+ /// it reads them: before the app exists there is no resolver to ask.+ pub fn system() -> Option<Self> {+ #[cfg(windows)]+ {+ let roaming = std::env::var_os("APPDATA").map(PathBuf::from)?;+ let local = std::env::var_os("LOCALAPPDATA").map(PathBuf::from);+ Some(Self {+ primary: roaming,+ secondary: local.into_iter().collect(),+ autostart: None,+ })+ }+ #[cfg(target_os = "macos")]+ {+ let home = std::env::var_os("HOME").map(PathBuf::from)?;+ Some(Self {+ primary: home.join("Library/Application Support"),+ secondary: vec![home.join("Library/Caches")],+ autostart: None,+ })+ }+ #[cfg(not(any(windows, target_os = "macos")))]+ {+ let home = std::env::var_os("HOME").map(PathBuf::from)?;+ // Only an absolute XDG path counts, as the spec (and `dirs`) say.+ let xdg = |var: &str, fallback: &str| {+ std::env::var_os(var)+ .map(PathBuf::from)+ .filter(|p| p.is_absolute())+ .unwrap_or_else(|| home.join(fallback))+ };+ let config = xdg("XDG_CONFIG_HOME", ".config");+ Some(Self {+ primary: xdg("XDG_DATA_HOME", ".local/share"),+ secondary: vec![config.clone(), xdg("XDG_CACHE_HOME", ".cache")],+ autostart: Some(config.join("autostart")),+ })+ }+ }+}++/// How the launch goes on.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Outcome {+ /// Nothing under either identifier: a first run.+ Fresh,+ /// Moved now (or a move left half-done by a crash finished now).+ Moved,+ /// Already under the new identifier.+ Current,+ /// The move failed: this launch runs from the old folders, and the next one tries again.+ Fallback,+}++impl Outcome {+ /// The identifier this launch runs as.+ pub fn identifier(self, ids: Ids<'_>) -> &str {+ match self {+ Outcome::Fallback => ids.old,+ _ => ids.new,+ }+ }+}++/// A point in a move where a crash can land. Tests stop there; production never does.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Step {+ Marked,+ SetAside,+ Renamed,+ Copying,+ CopiedOne,+ Verified,+ InPlace,+ Removing,+}++/// How a move is made. `Mover::default()` in production.+pub struct Mover<'a> {+ /// Copy even where a rename would do: what a move across filesystems takes.+ pub across: bool,+ /// Called at each `Step`; an error there stops the move as a crash would.+ pub checkpoint: &'a dyn Fn(Step) -> io::Result<()>,+}++impl Default for Mover<'_> {+ fn default() -> Self {+ Mover {+ across: false,+ checkpoint: &|_| Ok(()),+ }+ }+}++/// At launch, before Tauri starts: hand off to an instance already running under the current+/// identifier or an earlier one, else move what earlier identifiers left, and answer the+/// identifier to run as — `current` (tauri.conf.json's), or an earlier one whose folders could+/// not be moved this time.+pub fn at_launch(current: &str) -> String {+ // One running under the current identifier: the single-instance plugin hands off to it.+ // Nothing is moved under a running app.+ if instance::running(current) {+ return current.to_string();+ }+ // One running under an earlier one (the build before this one, still open after an+ // update, or this build after a failed move): it has the library open, so nothing moves+ // under it. It is shown, as the single-instance plugin would show it, and this launch ends.+ for old in PREVIOUS {+ if instance::running(old) {+ instance::hand_off(old);+ std::process::exit(0);+ }+ }+ let Some(roots) = Roots::system() else {+ return current.to_string();+ };+ for old in PREVIOUS.iter().filter(|old| **old != current) {+ let ids = Ids { old, new: current };+ let outcome = run(&roots, ids, &Mover::default());+ quiet!("quince: identifier: {old} -> {current}: {outcome:?}");+ if outcome == Outcome::Fallback {+ return outcome.identifier(ids).to_string();+ }+ }+ current.to_string()+}++/// Everything that moves, in order: the library's folder before the other folders, since it+/// decides which identifier this launch runs as; the others only once it has moved.+pub fn run(roots: &Roots, ids: Ids<'_>, mover: &Mover) -> Outcome {+ // The login entry first, whatever happens to the folders: it starts the app, under any+ // identifier, and Settings looks for it under the new name.+ if let Some(dir) = &roots.autostart {+ if let Err(e) = autostart(dir, ids) {+ quiet!("quince: identifier: the login entry did not move ({e})");+ }+ }+ let outcome = match primary(&roots.primary, ids, mover) {+ Ok(outcome) => outcome,+ Err(e) => {+ quiet!("quince: identifier: the library did not move ({e})");+ return if old_is_whole(&roots.primary, ids) {+ distrust_copy(&roots.primary, ids);+ Outcome::Fallback+ } else {+ Outcome::Current+ };+ }+ };+ for parent in roots.secondary.iter().filter(|p| **p != roots.primary) {+ if let Err(e) = secondary(parent, ids, mover) {+ quiet!("quince: identifier: a folder did not move ({e}); trying again next launch");+ }+ }+ outcome+}++/// Whether, after a failed move, the old folder is still the whole library: it is there, and+/// no completed copy has replaced it (a `copied` journal with the new folder in place means+/// the old one may be part-deleted — the new one is the library then).+fn old_is_whole(parent: &Path, ids: Ids<'_>) -> bool {+ let copied = fs::read_to_string(parent.join(ids.journal())).is_ok_and(|j| j.trim() == COPIED);+ present(&parent.join(ids.old)) && !(copied && present(&parent.join(ids.new)))+}++/// About to run from the old folder: any copy of it made so far is stale the moment this launch+/// changes something there, so it is no longer complete — the next launch copies again rather+/// than finishing with it.+fn distrust_copy(parent: &Path, ids: Ids<'_>) {+ let journal = parent.join(ids.journal());+ if present(&journal) {+ let _ = fs::write(&journal, COPYING);+ }+ let _ = fs::remove_dir_all(parent.join(ids.staging()));+}++/// The library's folder.+fn primary(parent: &Path, ids: Ids<'_>, mover: &Mover) -> io::Result<Outcome> {+ let old = parent.join(ids.old);+ let new = parent.join(ids.new);+ let journal_path = parent.join(ids.journal());+ // The everyday case after the move, and a first run: two lookups and nothing written.+ if !present(&old) && !present(&journal_path) {+ return Ok(if present(&new) {+ Outcome::Current+ } else {+ Outcome::Fresh+ });+ }+ let mut journal = Journal::open(&journal_path)?;+ let outcome = primary_locked(parent, ids, &mut journal, mover)?;+ journal.finish()?;+ Ok(outcome)+}++fn primary_locked(+ parent: &Path,+ ids: Ids<'_>,+ journal: &mut Journal,+ mover: &Mover,+) -> io::Result<Outcome> {+ let (old, new) = (&parent.join(ids.old), &parent.join(ids.new));+ if resume(parent, ids, journal, mover)? {+ return Ok(Outcome::Moved);+ }+ if !present(old) {+ return Ok(if present(new) {+ Outcome::Current+ } else {+ Outcome::Fresh+ });+ }+ if present(new) {+ if holds_marker(new) {+ // Moved before; an old build has run since and made a fresh old folder. Not this+ // app's library: left exactly as it is.+ quiet!(+ "quince: identifier: {} left by an older build, not moved",+ ids.old+ );+ return Ok(Outcome::Current);+ }+ if holds_library(new) && weight(new) > weight(old) {+ // The new folder is the established library: the old one is set aside beside it.+ set_aside(old)?;+ write_marker(new, ids)?;+ return Ok(Outcome::Current);+ }+ // A stub (no library), or the smaller library: set aside, never written over.+ set_aside(new)?;+ (mover.checkpoint)(Step::SetAside)?;+ }+ move_dir(parent, ids, journal, mover, true)?;+ Ok(Outcome::Moved)+}++/// Any other folder: config, cache, Windows' local one.+fn secondary(parent: &Path, ids: Ids<'_>, mover: &Mover) -> io::Result<()> {+ let old = parent.join(ids.old);+ let new = parent.join(ids.new);+ let journal_path = parent.join(ids.journal());+ if !present(&old) && !present(&journal_path) {+ return Ok(());+ }+ let mut journal = Journal::open(&journal_path)?;+ if !resume(parent, ids, &mut journal, mover)? && present(&old) {+ if present(&new) {+ merge(&old, &new)?;+ } else {+ move_dir(parent, ids, &mut journal, mover, false)?;+ }+ }+ journal.finish()+}++/// A move a crash interrupted: finished if its copy was complete (`true`), its staging copy+/// thrown away if not, so it starts again from the old folder.+fn resume(parent: &Path, ids: Ids<'_>, journal: &mut Journal, mover: &Mover) -> io::Result<bool> {+ if journal.phase()? == COPIED {+ finish_copy(parent, ids, mover)?;+ return Ok(true);+ }+ let staging = parent.join(ids.staging());+ if present(&staging) {+ fs::remove_dir_all(&staging)?;+ }+ Ok(false)+}++/// `old` to `new`: renamed, or copied where a rename cannot cross.+fn move_dir(+ parent: &Path,+ ids: Ids<'_>,+ journal: &mut Journal,+ mover: &Mover,+ mark: bool,+) -> io::Result<()> {+ let (old, new) = (&parent.join(ids.old), &parent.join(ids.new));+ if mark {+ // Inside the old folder before it moves, so it arrives with it, whichever way.+ write_marker(old, ids)?;+ (mover.checkpoint)(Step::Marked)?;+ }+ if !mover.across {+ match fs::rename(old, new) {+ Ok(()) => {+ sync_dir(parent);+ return (mover.checkpoint)(Step::Renamed);+ }+ Err(e) if crosses_devices(&e) => {}+ Err(e) => return Err(e),+ }+ }+ journal.set(COPYING)?;+ (mover.checkpoint)(Step::Copying)?;+ let staging = parent.join(ids.staging());+ copy_tree(old, &staging, mover)?;+ verify_tree(old, &staging)?;+ sync_dir(parent);+ // From here the copy is the whole library: a crash finishes the move, never redoes it.+ journal.set(COPIED)?;+ (mover.checkpoint)(Step::Verified)?;+ finish_copy(parent, ids, mover)+}++/// The verified copy put in place, then the old folder deleted.+fn finish_copy(parent: &Path, ids: Ids<'_>, mover: &Mover) -> io::Result<()> {+ let (old, new) = (&parent.join(ids.old), &parent.join(ids.new));+ let staging = parent.join(ids.staging());+ if present(&staging) {+ if present(new) {+ return Err(io::Error::new(+ io::ErrorKind::AlreadyExists,+ "the new folder appeared while the copy was in progress",+ ));+ }+ fs::rename(&staging, new)?;+ sync_dir(parent);+ }+ (mover.checkpoint)(Step::InPlace)?;+ if !present(old) {+ return Ok(());+ }+ for entry in fs::read_dir(old)? {+ let path = entry?.path();+ if fs::symlink_metadata(&path)?.is_dir() {+ fs::remove_dir_all(&path)?;+ } else {+ fs::remove_file(&path)?;+ }+ (mover.checkpoint)(Step::Removing)?;+ }+ // A mount point cannot be removed; emptied, it no longer holds anything to move.+ if let Err(e) = fs::remove_dir(old) {+ quiet!("quince: identifier: the emptied old folder stays ({e})");+ }+ Ok(())+}++/// Whatever `old` holds that `new` does not, moved in; what both hold, `new`'s kept. For the+/// folders that are not the library: a window's size, caches.+fn merge(old: &Path, new: &Path) -> io::Result<()> {+ for entry in fs::read_dir(old)? {+ let entry = entry?;+ let to = new.join(entry.file_name());+ if present(&to) {+ continue;+ }+ match fs::rename(entry.path(), &to) {+ Ok(()) => {}+ Err(e) if crosses_devices(&e) => {+ quiet!("quince: identifier: left in the old folder: {e}");+ }+ Err(e) => return Err(e),+ }+ }+ // Gone only once empty: anything left is left where it was.+ let _ = fs::remove_dir(old);+ Ok(())+}++/// Open at Login (`~/.config/autostart`): the entry under the new name, then the old removed.+fn autostart(dir: &Path, ids: Ids<'_>) -> io::Result<()> {+ let old = dir.join(format!("{}.desktop", ids.old));+ let new = dir.join(format!("{}.desktop", ids.new));+ if !present(&old) {+ return Ok(());+ }+ if !present(&new) {+ let text = fs::read_to_string(&old)?;+ let mut moved = String::with_capacity(text.len());+ for line in text.lines() {+ // The Exec line stays as the person's install wrote it (an AppImage's own path).+ if line.trim_end() == format!("Icon={}", ids.old) {+ moved.push_str(&format!("Icon={}", ids.new));+ } else {+ moved.push_str(line);+ }+ moved.push('\n');+ }+ let part = dir.join(format!(".{}.desktop.part", ids.new));+ write_synced(&part, moved.as_bytes())?;+ fs::rename(&part, &new)?;+ sync_dir(dir);+ }+ fs::remove_file(&old)+}++const COPYING: &str = "copying";+const COPIED: &str = "copied";++/// The journal beside the folders: held locked while a move runs (two launches at once —+/// login and a click — never move together), and saying how far a copy got.+struct Journal {+ file: fs::File,+ path: PathBuf,+}++impl Journal {+ fn open(path: &Path) -> io::Result<Self> {+ #[cfg(unix)]+ loop {+ use std::os::unix::fs::MetadataExt;+ use std::os::unix::io::AsRawFd;+ let file = fs::OpenOptions::new()+ .read(true)+ .write(true)+ .create(true)+ .truncate(false)+ .open(path)?;+ // SAFETY: flock on a descriptor this function owns.+ if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX) } != 0 {+ return Err(io::Error::last_os_error());+ }+ // The launch that held it may have finished and removed it while this one+ // waited: then this lock is on a file nobody else sees. Open it again.+ let held = file.metadata()?;+ match fs::metadata(path) {+ Ok(now) if now.ino() == held.ino() && now.dev() == held.dev() => {+ return Ok(Self {+ file,+ path: path.to_path_buf(),+ })+ }+ _ => continue,+ }+ }+ #[cfg(windows)]+ {+ use std::os::windows::fs::OpenOptionsExt;+ // Opened unshared: a second launch is refused until the first lets go.+ let mut tries = 0;+ loop {+ match fs::OpenOptions::new()+ .read(true)+ .write(true)+ .create(true)+ .truncate(false)+ .share_mode(0)+ .open(path)+ {+ Ok(file) => {+ return Ok(Self {+ file,+ path: path.to_path_buf(),+ })+ }+ // ERROR_SHARING_VIOLATION: the other launch has it.+ Err(e) if e.raw_os_error() == Some(32) && tries < 600 => {+ tries += 1;+ std::thread::sleep(std::time::Duration::from_millis(100));+ }+ Err(e) => return Err(e),+ }+ }+ }+ #[cfg(not(any(unix, windows)))]+ {+ let file = fs::OpenOptions::new()+ .read(true)+ .write(true)+ .create(true)+ .truncate(false)+ .open(path)?;+ Ok(Self {+ file,+ path: path.to_path_buf(),+ })+ }+ }++ fn phase(&mut self) -> io::Result<String> {+ use io::{Read, Seek};+ let mut text = String::new();+ self.file.seek(io::SeekFrom::Start(0))?;+ self.file.read_to_string(&mut text)?;+ Ok(text.trim().to_string())+ }++ fn set(&mut self, phase: &str) -> io::Result<()> {+ use io::{Seek, Write};+ self.file.set_len(0)?;+ self.file.seek(io::SeekFrom::Start(0))?;+ self.file.write_all(phase.as_bytes())?;+ self.file.sync_all()+ }++ /// The move done: the journal gone (on Windows, closed first — it is held unshared).+ fn finish(self) -> io::Result<()> {+ let Self { file, path } = self;+ #[cfg(windows)]+ drop(file);+ let removed = fs::remove_file(&path);+ #[cfg(not(windows))]+ drop(file);+ match removed {+ Err(e) if e.kind() != io::ErrorKind::NotFound => Err(e),+ _ => Ok(()),+ }+ }+}++/// There, as itself: a symlink counts even if what it points at is gone.+fn present(path: &Path) -> bool {+ fs::symlink_metadata(path).is_ok()+}++fn holds_library(dir: &Path) -> bool {+ present(&dir.join("library.db"))+}++/// How much library a folder holds: the database and what its WAL has not yet folded in.+fn weight(dir: &Path) -> u64 {+ ["library.db", "library.db-wal"]+ .iter()+ .filter_map(|f| fs::metadata(dir.join(f)).ok())+ .map(|m| m.len())+ .sum()+}++/// `dir` renamed beside itself (`<name>.set-aside-<time>`), or removed if it is empty.+fn set_aside(dir: &Path) -> io::Result<()> {+ if fs::remove_dir(dir).is_ok() {+ return Ok(());+ }+ let name = dir+ .file_name()+ .map(|n| n.to_string_lossy().into_owned())+ .unwrap_or_default();+ let secs = std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .map(|d| d.as_secs())+ .unwrap_or(0);+ let mut to = dir.with_file_name(format!("{name}.set-aside-{secs}"));+ let mut n = 1;+ while present(&to) {+ n += 1;+ to = dir.with_file_name(format!("{name}.set-aside-{secs}-{n}"));+ }+ quiet!(+ "quince: identifier: {} set aside as {}",+ dir.display(),+ to.display()+ );+ fs::rename(dir, &to)+}++fn write_marker(dir: &Path, ids: Ids<'_>) -> io::Result<()> {+ write_synced(+ &dir.join(ids.marker()),+ format!(+ "This folder was {}, moved when the app's identifier changed.\n",+ ids.old+ )+ .as_bytes(),+ )+}++/// Whether `dir` came from an earlier identifier, whichever.+fn holds_marker(dir: &Path) -> bool {+ fs::read_dir(dir).is_ok_and(|entries| {+ entries+ .flatten()+ .any(|e| e.file_name().to_string_lossy().starts_with(MARKER_PREFIX))+ })+}++fn write_synced(path: &Path, bytes: &[u8]) -> io::Result<()> {+ use io::Write;+ let mut f = fs::File::create(path)?;+ f.write_all(bytes)?;+ f.sync_all()+}++/// A rename's own entries on the disk, not only the files' bytes. Unix only: Windows has no+/// way to sync a folder and its renames are journaled by NTFS.+fn sync_dir(dir: &Path) {+ #[cfg(unix)]+ if let Ok(d) = fs::File::open(dir) {+ let _ = d.sync_all();+ }+ #[cfg(not(unix))]+ let _ = dir;+}++fn crosses_devices(e: &io::Error) -> bool {+ e.kind() == io::ErrorKind::CrossesDevices || (cfg!(unix) && e.raw_os_error() == Some(18))+}++/// `from` copied to `to` (which must not exist): files synced, folders with their+/// permissions, symlinks as symlinks.+fn copy_tree(from: &Path, to: &Path, mover: &Mover) -> io::Result<()> {+ fs::create_dir(to)?;+ fs::set_permissions(to, fs::metadata(from)?.permissions())?;+ for entry in fs::read_dir(from)? {+ let entry = entry?;+ let src = entry.path();+ let dst = to.join(entry.file_name());+ let kind = fs::symlink_metadata(&src)?.file_type();+ if kind.is_symlink() {+ copy_link(&src, &dst)?;+ } else if kind.is_dir() {+ copy_tree(&src, &dst, mover)?;+ } else {+ fs::copy(&src, &dst)?;+ fs::File::open(&dst)?.sync_all()?;+ (mover.checkpoint)(Step::CopiedOne)?;+ }+ }+ sync_dir(to);+ Ok(())+}++#[cfg(unix)]+fn copy_link(src: &Path, dst: &Path) -> io::Result<()> {+ std::os::unix::fs::symlink(fs::read_link(src)?, dst)+}++#[cfg(not(unix))]+fn copy_link(src: &Path, dst: &Path) -> io::Result<()> {+ // Windows: what the link points at, copied as itself.+ if fs::metadata(src)?.is_dir() {+ copy_tree(src, dst, &Mover::default())+ } else {+ fs::copy(src, dst).map(|_| ())+ }+}++/// `copy` holds exactly what `original` does: every entry, of the same kind, every file's+/// bytes the same.+fn verify_tree(original: &Path, copy: &Path) -> io::Result<()> {+ let differ = |what: &Path| {+ io::Error::new(+ io::ErrorKind::InvalidData,+ format!("the copy differs at {}", what.display()),+ )+ };+ let mut seen = 0usize;+ for entry in fs::read_dir(original)? {+ let entry = entry?;+ seen += 1;+ let a = entry.path();+ let b = copy.join(entry.file_name());+ let (ka, kb) = (+ fs::symlink_metadata(&a)?.file_type(),+ fs::symlink_metadata(&b)+ .map_err(|_| differ(&a))?+ .file_type(),+ );+ if ka.is_symlink() && cfg!(unix) {+ if !kb.is_symlink() || fs::read_link(&a)? != fs::read_link(&b)? {+ return Err(differ(&a));+ }+ } else if ka.is_dir() {+ if !fs::metadata(&b)?.is_dir() {+ return Err(differ(&a));+ }+ verify_tree(&a, &b)?;+ } else if !same_bytes(&a, &b)? {+ return Err(differ(&a));+ }+ }+ if fs::read_dir(copy)?.count() != seen {+ return Err(differ(copy));+ }+ Ok(())+}++fn same_bytes(a: &Path, b: &Path) -> io::Result<bool> {+ use io::Read;+ let (mut fa, mut fb) = (fs::File::open(a)?, fs::File::open(b)?);+ if fa.metadata()?.len() != fb.metadata()?.len() {+ return Ok(false);+ }+ let (mut ba, mut bb) = (vec![0u8; 1 << 16], vec![0u8; 1 << 16]);+ loop {+ let n = fa.read(&mut ba)?;+ if n == 0 {+ return Ok(true);+ }+ fb.read_exact(&mut bb[..n])?;+ if ba[..n] != bb[..n] {+ return Ok(false);+ }+ }+}++/// Whether a Pomander is running under an identifier, and handing a launch to it: the same+/// channel tauri-plugin-single-instance listens on, so the running one opens what was asked+/// for (`--app notes`, a file) exactly as it would for a launch under its own identifier.+mod instance {+ /// The session bus, with a limit on every call: a running app that never answers must not+ /// keep this launch waiting for ever.+ #[cfg(target_os = "linux")]+ fn bus() -> Option<zbus::blocking::Connection> {+ zbus::blocking::connection::Builder::session()+ .ok()?+ .method_timeout(std::time::Duration::from_secs(5))+ .build()+ .ok()+ }++ #[cfg(target_os = "linux")]+ pub fn running(id: &str) -> bool {+ let Some(bus) = bus() else {+ return false;+ };+ bus.call_method(+ Some("org.freedesktop.DBus"),+ "/org/freedesktop/DBus",+ Some("org.freedesktop.DBus"),+ "NameHasOwner",+ &(format!("{id}.SingleInstance"),),+ )+ .ok()+ .and_then(|reply| reply.body().deserialize::<bool>().ok())+ .unwrap_or(false)+ }++ #[cfg(target_os = "linux")]+ pub fn hand_off(id: &str) {+ let Some(bus) = bus() else {+ return;+ };+ let name = format!("{id}.SingleInstance");+ let path = format!("/{}", name.replace('.', "/").replace('-', "_"));+ let cwd = std::env::current_dir().unwrap_or_default();+ let _ = bus.call_method(+ Some(name.as_str()),+ path.as_str(),+ Some("org.SingleInstance.DBus"),+ "ExecuteCallback",+ &(+ std::env::args().collect::<Vec<String>>(),+ cwd.to_str().unwrap_or_default(),+ ),+ );+ }++ #[cfg(windows)]+ mod win {+ use std::ffi::c_void;++ #[repr(C)]+ pub struct CopyData {+ pub data: usize,+ pub len: u32,+ pub ptr: *const c_void,+ }++ #[link(name = "user32")]+ extern "system" {+ pub fn FindWindowW(class: *const u16, window: *const u16) -> *mut c_void;+ pub fn SendMessageW(hwnd: *mut c_void, msg: u32, wparam: usize, lparam: isize)+ -> isize;+ pub fn GetWindowThreadProcessId(hwnd: *mut c_void, pid: *mut u32) -> u32;+ pub fn AllowSetForegroundWindow(pid: u32) -> i32;+ }++ pub fn wide(s: &str) -> Vec<u16> {+ s.encode_utf16().chain(std::iter::once(0)).collect()+ }++ /// The plugin's hidden window for `id` (`<id>-sic` / `<id>-siw`).+ pub fn window(id: &str) -> *mut c_void {+ let class = wide(&format!("{id}-sic"));+ let name = wide(&format!("{id}-siw"));+ // SAFETY: two NUL-terminated UTF-16 strings that outlive the call.+ unsafe { FindWindowW(class.as_ptr(), name.as_ptr()) }+ }+ }++ #[cfg(windows)]+ pub fn running(id: &str) -> bool {+ !win::window(id).is_null()+ }++ #[cfg(windows)]+ pub fn hand_off(id: &str) {+ const WM_COPYDATA: u32 = 0x004A;+ /// tauri-plugin-single-instance's tag on the message.+ const SINGLE_INSTANCE_DATA: usize = 1542;+ let hwnd = win::window(id);+ if hwnd.is_null() {+ return;+ }+ let cwd = std::env::current_dir().unwrap_or_default();+ let args = std::env::args().collect::<Vec<String>>().join("|");+ let data = format!("{}|{args}\0", cwd.to_str().unwrap_or_default());+ let cds = win::CopyData {+ data: SINGLE_INSTANCE_DATA,+ len: u32::try_from(data.len()).unwrap_or(u32::MAX),+ ptr: data.as_ptr().cast(),+ };+ // SAFETY: a window handle just found; `cds` and `data` outlive the synchronous send.+ unsafe {+ let mut pid = 0;+ win::GetWindowThreadProcessId(hwnd, &mut pid);+ if pid != 0 {+ win::AllowSetForegroundWindow(pid);+ }+ win::SendMessageW(hwnd, WM_COPYDATA, 0, std::ptr::addr_of!(cds) as isize);+ }+ }++ #[cfg(not(any(target_os = "linux", windows)))]+ pub fn running(_id: &str) -> bool {+ false+ }++ #[cfg(not(any(target_os = "linux", windows)))]+ pub fn hand_off(_id: &str) {}+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::cell::Cell;++ /// Any two identifiers: nothing here depends on which.+ const OLD_ID: &str = "dev.quince.client";+ const NEW_ID: &str = "org.example.Renamed";+ const IDS: Ids<'static> = Ids {+ old: OLD_ID,+ new: NEW_ID,+ };++ /// A temporary home: the three XDG roots and an autostart folder, nothing of the real one.+ struct Home {+ _dir: tempfile::TempDir,+ roots: Roots,+ }++ fn home() -> Home {+ let dir = tempfile::tempdir().unwrap();+ let data = dir.path().join("share");+ let config = dir.path().join("config");+ let cache = dir.path().join("cache");+ for d in [&data, &config, &cache] {+ fs::create_dir_all(d).unwrap();+ }+ let roots = Roots {+ primary: data,+ secondary: vec![config.clone(), cache],+ autostart: Some(config.join("autostart")),+ };+ Home { _dir: dir, roots }+ }++ impl Home {+ fn old(&self) -> PathBuf {+ self.roots.primary.join(OLD_ID)+ }+ fn current(&self) -> PathBuf {+ self.roots.primary.join(NEW_ID)+ }+ fn config(&self, id: &str) -> PathBuf {+ self.roots.secondary[0].join(id)+ }+ }++ /// What an install holds: a library whose last changes are only in its WAL, a Drive file+ /// waiting to upload, cookies, the cooldown, a photo, note media, WebKit's localStorage,+ /// and the window's size in the config folder.+ fn install(h: &Home) {+ let old = h.old();+ {+ let mut library = quince_core::Library::open(&old).unwrap();+ library+ .set_state("remembered", "kept-through-the-move")+ .unwrap();+ // Ended as a crash ends it: no checkpoint, so the row lives in the WAL alone.+ std::mem::forget(library);+ }+ assert!(+ fs::metadata(old.join("library.db-wal")).unwrap().len() > 0,+ "the test needs the change to be in the WAL"+ );+ let writes = quince_vfs::writes::Writes::new(&old.join("drive-writes")).unwrap();+ let file = writes.staging(7, "report.pdf");+ fs::create_dir_all(file.parent().unwrap()).unwrap();+ fs::write(&file, b"%PDF unsent").unwrap();+ let pending = quince_vfs::writes::Pending {+ folder: "FOLDER".into(),+ name: "report.pdf".into(),+ replaces: None,+ open: 0,+ dirty: true,+ generation: 0,+ modified: std::time::SystemTime::now(),+ sender: false,+ quiet_since: None,+ sending: false,+ failure: None,+ };+ fs::write(+ old.join("drive-writes/pending.json"),+ serde_json::to_vec(&vec![(7u64, pending)]).unwrap(),+ )+ .unwrap();+ fs::write(old.join("cookies.json"), b"{\"cookies\":[]}").unwrap();+ fs::write(old.join("cooldown.json"), b"{\"consecutive_failures\":0}").unwrap();+ fs::create_dir_all(old.join("photos/full")).unwrap();+ fs::write(old.join("photos/full/a.heic"), vec![7u8; 200_000]).unwrap();+ fs::create_dir_all(old.join("note-media")).unwrap();+ fs::write(old.join("note-media/x.png"), b"png").unwrap();+ fs::create_dir_all(old.join("localstorage")).unwrap();+ fs::write(+ old.join("localstorage/tauri_localhost_0.localstorage"),+ b"screen=notes",+ )+ .unwrap();+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ fs::set_permissions(&old, fs::Permissions::from_mode(0o700)).unwrap();+ }+ fs::create_dir_all(h.config(OLD_ID)).unwrap();+ fs::write(+ h.config(OLD_ID).join(".window-state.json"),+ b"{\"main\":{}}",+ )+ .unwrap();+ }++ /// Everything `install` put there, read back through the app's own code from `dir`.+ fn assert_whole(dir: &Path) {+ let library = quince_core::Library::open(dir).unwrap();+ assert_eq!(+ library.state("remembered").unwrap().as_deref(),+ Some("kept-through-the-move"),+ "the WAL's change survived"+ );+ drop(library);+ let waiting = quince_vfs::writes::Writes::new(&dir.join("drive-writes"))+ .unwrap()+ .load();+ assert_eq!(waiting.len(), 1, "the unsent Drive file is still waiting");+ assert_eq!(waiting[0].1.name, "report.pdf");+ assert_eq!(+ fs::read(dir.join("drive-writes/7/report.pdf")).unwrap(),+ b"%PDF unsent"+ );+ assert_eq!(+ fs::read(dir.join("photos/full/a.heic")).unwrap(),+ vec![7u8; 200_000]+ );+ assert!(dir.join("cookies.json").exists() && dir.join("cooldown.json").exists());+ assert_eq!(fs::read(dir.join("note-media/x.png")).unwrap(), b"png");+ assert_eq!(+ fs::read(dir.join("localstorage/tauri_localhost_0.localstorage")).unwrap(),+ b"screen=notes"+ );+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ assert_eq!(+ fs::metadata(dir).unwrap().permissions().mode() & 0o777,+ 0o700+ );+ }+ }++ fn no_leftovers(h: &Home) {+ for parent in std::iter::once(&h.roots.primary).chain(&h.roots.secondary) {+ assert!(+ !parent.join(IDS.journal()).exists(),+ "journal left in {}",+ parent.display()+ );+ assert!(+ !parent.join(IDS.staging()).exists(),+ "staging left in {}",+ parent.display()+ );+ }+ }++ #[test]+ fn a_fresh_install_moves_nothing_and_writes_nothing() {+ let h = home();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Fresh);+ assert_eq!(fs::read_dir(&h.roots.primary).unwrap().count(), 0);+ assert_eq!(fs::read_dir(&h.roots.secondary[0]).unwrap().count(), 0);+ assert_eq!(Outcome::Fresh.identifier(IDS), NEW_ID);+ }++ #[test]+ fn an_install_moves_whole_with_its_wal_and_unsent_files() {+ let h = home();+ install(&h);+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ assert!(!h.old().exists());+ assert_whole(&h.current());+ assert!(h.current().join(IDS.marker()).exists());+ assert!(!h.config(OLD_ID).exists());+ assert!(h.config(NEW_ID).join(".window-state.json").exists());+ no_leftovers(&h);+ // And the next launch has nothing to do.+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Current);+ }++ #[test]+ fn across_filesystems_it_is_copied_verified_and_the_old_removed() {+ let h = home();+ install(&h);+ let across = Mover {+ across: true,+ ..Mover::default()+ };+ assert_eq!(run(&h.roots, IDS, &across), Outcome::Moved);+ assert!(!h.old().exists());+ assert_whole(&h.current());+ no_leftovers(&h);+ }++ /// A crash at every point of either kind of move: the launch it happens in runs from the+ /// old folder whole (or the new one, once the copy is complete) — never an empty or a half+ /// library — and the next launch finishes the move.+ #[test]+ fn a_move_interrupted_anywhere_is_resumed_without_loss() {+ let steps = [+ Step::Marked,+ Step::Renamed,+ Step::Copying,+ Step::CopiedOne,+ Step::Verified,+ Step::InPlace,+ Step::Removing,+ ];+ for across in [false, true] {+ for stop in steps {+ // The nth time a step is reached, for steps reached more than once.+ for nth in [1, 3] {+ let h = home();+ install(&h);+ let count = Cell::new(0);+ let crash = |s: Step| {+ if s == stop {+ count.set(count.get() + 1);+ if count.get() == nth {+ return Err(io::Error::other("crashed"));+ }+ }+ Ok(())+ };+ let mover = Mover {+ across,+ checkpoint: &crash,+ };+ let first = run(&h.roots, IDS, &mover);+ let label = format!("across={across} stop={stop:?} nth={nth}");+ match first {+ Outcome::Fallback => {+ assert_whole(&h.old());+ // This launch runs from the old folder and changes it: the next+ // move must carry that, never an earlier copy.+ fs::write(h.old().join("written-in-fallback"), b"1").unwrap();+ }+ Outcome::Moved | Outcome::Current => assert_whole(&h.current()),+ Outcome::Fresh => panic!("{label}: started empty"),+ }+ // The next launch, uninterrupted.+ let second = run(&h.roots, IDS, &Mover::default());+ assert_ne!(second, Outcome::Fallback, "{label}");+ assert_whole(&h.current());+ if first == Outcome::Fallback {+ assert!(+ h.current().join("written-in-fallback").exists(),+ "{label}: stale copy"+ );+ }+ assert!(!h.old().exists(), "{label}: old left behind");+ no_leftovers(&h);+ }+ }+ }+ }++ #[test]+ fn a_crash_while_copying_never_counts_the_partial_copy() {+ let h = home();+ install(&h);+ // As a crash leaves it: the journal saying the copy was under way, half a copy.+ fs::write(h.roots.primary.join(IDS.journal()), COPYING).unwrap();+ fs::create_dir_all(h.roots.primary.join(IDS.staging()).join("photos")).unwrap();+ fs::write(+ h.roots.primary.join(IDS.staging()).join("library.db"),+ b"half",+ )+ .unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ assert_whole(&h.current());+ no_leftovers(&h);+ }++ #[test]+ fn a_new_folder_that_is_only_a_stub_is_set_aside_not_kept() {+ let h = home();+ install(&h);+ // What a build with the new identifier leaves before it has synced anything.+ fs::create_dir_all(h.current().join("localstorage")).unwrap();+ fs::write(+ h.current()+ .join("localstorage/tauri_localhost_0.localstorage"),+ b"",+ )+ .unwrap();+ fs::write(h.current().join("cooldown.json"), b"{}").unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ assert_whole(&h.current());+ let aside: Vec<_> = fs::read_dir(&h.roots.primary)+ .unwrap()+ .filter_map(Result::ok)+ .map(|e| e.file_name().to_string_lossy().into_owned())+ .filter(|n| n.starts_with(&format!("{NEW_ID}.set-aside-")))+ .collect();+ assert_eq!(aside.len(), 1, "the stub kept, renamed, never deleted");+ }++ #[test]+ fn an_empty_new_folder_is_simply_replaced() {+ let h = home();+ install(&h);+ fs::create_dir_all(h.current()).unwrap();+ fs::create_dir_all(h.config(NEW_ID)).unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ assert_whole(&h.current());+ assert!(+ h.config(NEW_ID).join(".window-state.json").exists(),+ "merged in"+ );+ assert_eq!(fs::read_dir(&h.roots.primary).unwrap().count(), 1);+ }++ #[test]+ fn when_both_hold_a_library_the_larger_stays_and_the_other_is_set_aside() {+ let h = home();+ install(&h);+ // A smaller library under the new identifier: the old one wins.+ quince_core::Library::open(&h.current()).unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ assert_whole(&h.current());++ // The other way round: an old folder smaller than the established new one.+ let h = home();+ install(&h);+ fs::rename(h.old(), h.current()).unwrap();+ quince_core::Library::open(&h.old()).unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Current);+ assert_whole(&h.current());+ assert!(!h.old().exists(), "set aside, so it is not tried again");+ assert!(h.current().join(IDS.marker()).exists());+ }++ #[test]+ fn an_old_folder_made_by_an_older_build_after_the_move_is_left_alone() {+ let h = home();+ install(&h);+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ // The older build run again: a fresh library under the old identifier, bigger even.+ fs::create_dir_all(h.old()).unwrap();+ fs::write(h.old().join("library.db"), vec![0u8; 50_000_000 / 1000]).unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Current);+ assert_whole(&h.current());+ assert!(h.old().join("library.db").exists(), "not touched");+ }++ #[cfg(unix)]+ #[test]+ fn a_move_that_fails_runs_from_the_old_folder_and_tries_again() {+ use std::os::unix::fs::PermissionsExt;+ let h = home();+ install(&h);+ // The folder above refuses the rename (and the journal).+ fs::set_permissions(&h.roots.primary, fs::Permissions::from_mode(0o555)).unwrap();+ let first = run(&h.roots, IDS, &Mover::default());+ fs::set_permissions(&h.roots.primary, fs::Permissions::from_mode(0o755)).unwrap();+ if first == Outcome::Moved {+ // Running as root: permissions do not stop it. Nothing to show here.+ return;+ }+ assert_eq!(first, Outcome::Fallback);+ assert_eq!(first.identifier(IDS), OLD_ID);+ assert_whole(&h.old());+ assert!(!h.current().exists());+ assert!(+ h.config(OLD_ID).exists(),+ "nothing else moved without the library"+ );+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ assert_whole(&h.current());+ }++ #[test]+ fn the_other_folders_merge_keeping_the_new_ones_files() {+ let h = home();+ fs::create_dir_all(h.config(OLD_ID)).unwrap();+ fs::write(h.config(OLD_ID).join(".window-state.json"), b"old").unwrap();+ fs::write(h.config(OLD_ID).join("other"), b"o").unwrap();+ fs::create_dir_all(h.config(NEW_ID)).unwrap();+ fs::write(h.config(NEW_ID).join(".window-state.json"), b"new").unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Fresh);+ assert_eq!(+ fs::read(h.config(NEW_ID).join(".window-state.json")).unwrap(),+ b"new"+ );+ assert_eq!(fs::read(h.config(NEW_ID).join("other")).unwrap(), b"o");+ assert!(+ h.config(OLD_ID).join(".window-state.json").exists(),+ "left, not lost"+ );+ }++ #[test]+ fn the_login_entry_moves_to_the_new_name() {+ let h = home();+ let dir = h.roots.autostart.clone().unwrap();+ fs::create_dir_all(&dir).unwrap();+ let entry = "[Desktop Entry]\nType=Application\nName=Pomander\nExec=\"/opt/Pomander.AppImage\" --background\nIcon=dev.quince.client\nX-GNOME-Autostart-enabled=true\n";+ fs::write(dir.join(format!("{OLD_ID}.desktop")), entry).unwrap();+ run(&h.roots, IDS, &Mover::default());+ assert!(!dir.join(format!("{OLD_ID}.desktop")).exists());+ let moved = fs::read_to_string(dir.join(format!("{NEW_ID}.desktop"))).unwrap();+ assert!(moved.contains("Exec=\"/opt/Pomander.AppImage\" --background\n"));+ assert!(moved.contains(&format!("Icon={NEW_ID}\n")));+ assert_eq!(fs::read_dir(&dir).unwrap().count(), 1, "no part file left");+ }++ /// Renamed twice: the folders of the first identifier reach the third, through the second+ /// or straight there, and an empty identifier in between changes nothing.+ #[test]+ fn a_second_rename_carries_the_first_ones_folders() {+ let h = home();+ install(&h);+ let third = "org.example.Third";+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ let second = Ids {+ old: NEW_ID,+ new: third,+ };+ assert_eq!(run(&h.roots, second, &Mover::default()), Outcome::Moved);+ let first = Ids {+ old: OLD_ID,+ new: third,+ };+ assert_eq!(run(&h.roots, first, &Mover::default()), Outcome::Current);+ assert_whole(&h.roots.primary.join(third));+ assert_eq!(fs::read_dir(&h.roots.primary).unwrap().count(), 1);+ }++ #[test]+ fn a_symlinked_library_moves_as_the_link() {+ #[cfg(unix)]+ {+ let h = home();+ let elsewhere = tempfile::tempdir().unwrap();+ fs::write(elsewhere.path().join("library.db"), b"db").unwrap();+ std::os::unix::fs::symlink(elsewhere.path(), h.old()).unwrap();+ assert_eq!(run(&h.roots, IDS, &Mover::default()), Outcome::Moved);+ assert_eq!(fs::read_link(h.current()).unwrap(), elsewhere.path());+ assert_eq!(fs::read(h.current().join("library.db")).unwrap(), b"db");+ }+ }+}diff --git a/src-tauri/src/mount.rs b/src-tauri/src/mount.rsindex a6c812f..2c31f0d 100644--- a/src-tauri/src/mount.rs+++ b/src-tauri/src/mount.rs@@ -291,6 +291,10 @@ pub struct FolderStatus {pub problem: Option<String>,/// Files written into it and not yet at Apple (the Drive folder).pub waiting: Option<quince_vfs::writes::Waiting>,+ /// Whether this system can have the folder at all: Linux's FUSE only, until Windows has+ /// it through the Cloud Files API. Not offered where it cannot be, rather than offered and+ /// refused.+ pub available: bool,}#[cfg(target_os = "linux")]@@ -463,6 +467,7 @@ fn status(app: &AppHandle, which: Which, problem: Option<String>) -> FolderStatupath: at.to_string_lossy().into_owned(),problem,waiting,+ available: cfg!(target_os = "linux"),}}diff --git a/src-tauri/src/notes_cmds.rs b/src-tauri/src/notes_cmds.rsnew file mode 100644index 0000000..c58cd1d--- /dev/null+++ b/src-tauri/src/notes_cmds.rs@@ -0,0 +1,130 @@+//! Notes commands for locked notes and attachments.+//!+//! Locked notes open read-only: the password crosses from the window once, opens the note,+//! and is kept in this process's memory for the session only — never in the library, the+//! settings or the keyring — so the same note opens again without asking until the app quits,+//! the account signs out, or the window says to lock again ([`note_lock_forget`]). The opened+//! text is handed to the window and not stored either: a locked note's words never reach disk+//! here.++use crate::{Auth, Data, UiResult};+use quince_icloud::notes::attach::Attached;+use quince_icloud::notes::locked::Unlocked;+use std::collections::HashMap;+use std::sync::Mutex;+use tauri::State;++/// A password held in memory, wiped when let go of.+struct Secret(Vec<u8>);++impl Drop for Secret {+ fn drop(&mut self) {+ self.0.fill(0);+ }+}++/// The password that opened each locked note this session, by note.+static PASSWORDS: Mutex<Option<HashMap<String, Secret>>> = Mutex::new(None);++fn remembered(guid: &str) -> Option<String> {+ PASSWORDS+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .as_ref()?+ .get(guid)+ .and_then(|s| String::from_utf8(s.0.clone()).ok())+}++fn remember(guid: &str, password: &str) {+ PASSWORDS+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .get_or_insert_with(HashMap::new)+ .insert(guid.to_string(), Secret(password.as_bytes().to_vec()));+}++/// Every remembered password let go of: on sign-out, or when the window locks notes again.+pub fn forget_passwords() {+ *PASSWORDS+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner) = None;+}++/// Open a locked note: its text and formatting. With no password, the one that opened it+/// earlier this session is used; a wrong one is forgotten, never kept.+#[tauri::command]+pub async fn note_unlock(+ guid: String,+ password: Option<String>,+ auth: State<'_, Auth>,+) -> UiResult<Unlocked> {+ let password = password+ .filter(|p| !p.is_empty())+ .or_else(|| remembered(&guid))+ .ok_or("Enter this note’s password to open it.")?;+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ match quince_icloud::notes::locked::unlock_cloudkit(&http, &root, params, &guid, &password)+ .await+ {+ Ok(opened) => {+ remember(&guid, &password);+ Ok(opened)+ }+ Err(e) => {+ if let Some(map) = PASSWORDS+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .as_mut()+ {+ map.remove(&guid);+ }+ Err(e.to_string())+ }+ }+}++/// The hint left with a locked note's password, if any.+#[tauri::command]+pub async fn note_lock_hint(guid: String, auth: State<'_, Auth>) -> UiResult<Option<String>> {+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ quince_icloud::notes::locked::hint_cloudkit(&http, &root, params, &guid)+ .await+ .map_err(|e| e.to_string())+}++/// Lock every opened note again: the passwords this session held are wiped.+#[tauri::command]+pub fn note_lock_forget() {+ forget_passwords();+}++/// Add the file at `path` to a note at `at_offset` (UTF-16 units of `base`, the text the+/// editor shows, or of Apple's text when no base is given). Answers what was added, then+/// brings the library up to date.+#[tauri::command]+pub async fn note_attach_file(+ guid: String,+ path: String,+ at_offset: u64,+ base: Option<String>,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<Attached> {+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let attached = quince_icloud::notes::attach::attach_file_cloudkit(+ &http,+ &root,+ params.clone(),+ &guid,+ std::path::Path::new(&path),+ base.as_deref(),+ at_offset,+ )+ .await+ .map_err(|e| e.to_string())?;+ // Apple has it. A refresh failing now must not read as the attach failing.+ if let Err(e) = crate::resync_notes(&http, &root, params, &data).await {+ quiet!("notes refresh after an attachment: {e}");+ }+ Ok(attached)+}diff --git a/src-tauri/src/outbox.rs b/src-tauri/src/outbox.rsindex dd938c0..460b84b 100644--- a/src-tauri/src/outbox.rs+++ b/src-tauri/src/outbox.rs@@ -1,24 +1,37 @@-//! Changes go to Apple behind the window, never in front of it. A command changes the library-//! and queues the change (quince_core::outbox), then returns: every view shows it at once, as-//! a native app's own store would. This worker sends what is queued, in the order it was made,-//! one service at a time:+//! Changes go to Apple behind the window, never in front of it. A command records the change+//! (quince_core::outbox) and lays it over the library in one transaction, then returns: every+//! view shows it at once, as a native app's own store would, with or without a network. This+//! worker sends what is queued, in the order it was made, one service at a time://!//! - taken: off the queue; one sync pass afterwards brings Apple's own version of the record;//! - Apple can't be reached (offline, signed out, a server fault): kept, and tried again with a//! growing wait, so a change made offline lands when the connection comes back — even after//! a restart, since the queue is in the library;-//! - refused (changed elsewhere, gone, turned down): off the queue, Apple's version read back-//! over ours, and the window told why — `quince://outbox-refused`.+//! - refused for good (deleted elsewhere, edited in the same place, turned down): kept in the+//! library marked refused, with what was typed, for the person to send again or let go;+//! Apple's version read back over ours, and the window told why — `quince://outbox-refused`.+//!+//! Sent exactly once in effect: every change is safe to send twice. A reminder or card made+//! here carries a name chosen before it is queued, and a create finding that name at Apple+//! already does nothing; edits are merges against what Apple holds (a note's text against the+//! base it was typed over, a reminder's fields, a card's fields against the form's base), so+//! one that already landed lands again as no change.//!//! A sync pass that lands while changes wait would put Apple's older version over them, so-//! every pass lays the waiting changes over what it read (see `replay_reminders`).+//! every pass lays the waiting changes over what it read (see [`replay`]).use crate::{cloudkit_context, Auth, Data};+use quince_core::contacts::Contact;use quince_core::outbox::Pending;+use quince_core::reminders::Reminder;+use quince_core::Library;+use quince_icloud::ckdocument::Run;+use quince_icloud::reminders::ReminderEdit;use quince_icloud::Error;+use serde::{Deserialize, Serialize};use std::time::Duration;-use tauri::{AppHandle, Emitter, Manager};-use tokio::sync::Notify;+use tauri::{AppHandle, Emitter, Manager, State};+use tokio::sync::{Mutex, Notify};static WAKE: Notify = Notify::const_new();@@ -27,44 +40,523 @@ pub fn kick() {WAKE.notify_one();}+pub const REMINDERS: &str = "reminders";+pub const NOTES: &str = "notes";+pub const CONTACTS: &str = "contacts";+/// What a waiting change does to a reminder: ticked (`at` the moment) or not.-#[derive(serde::Serialize, serde::Deserialize)]+#[derive(Serialize, Deserialize)]pub struct Done {pub done: bool,pub at: i64,}-/// Runs for as long as the app does.+/// A reminder made here, under the name it was given here.+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct Create {+ pub list_guid: String,+ pub title: String,+ pub due_at: Option<i64>,+ pub all_day: Option<bool>,+ pub flagged: Option<bool>,+}++/// `Option<Option<T>>` kept whole through JSON: absent is "leave it", null is "clear it".+mod double {+ use serde::{Deserialize, Deserializer, Serialize, Serializer};+ #[allow(clippy::ref_option)]+ pub fn serialize<S: Serializer, T: Serialize>(+ v: &Option<Option<T>>,+ s: S,+ ) -> Result<S::Ok, S::Error> {+ match v {+ Some(inner) => inner.serialize(s),+ None => s.serialize_none(),+ }+ }+ pub fn deserialize<'de, D: Deserializer<'de>, T: Deserialize<'de>>(+ d: D,+ ) -> Result<Option<Option<T>>, D::Error> {+ Option::<T>::deserialize(d).map(Some)+ }+}++/// A reminder edit as queued: [`ReminderEdit`], with "clear" and "leave" kept apart, and the+/// list the reminder was in before any of it — what a move is made from.+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+pub struct Edit {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub title: Option<String>,+ #[serde(default, skip_serializing_if = "Option::is_none", with = "double")]+ pub notes: Option<Option<String>>,+ #[serde(default, skip_serializing_if = "Option::is_none", with = "double")]+ pub due_at: Option<Option<i64>>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub all_day: Option<bool>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub flagged: Option<bool>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub completed: Option<bool>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub priority: Option<i64>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub list_guid: Option<String>,+ #[serde(default, skip_serializing_if = "Option::is_none", with = "double")]+ pub parent_guid: Option<Option<String>>,+ pub from_list: String,+}++impl Edit {+ fn new(e: &ReminderEdit, from_list: &str) -> Self {+ Self {+ title: e.title.clone(),+ notes: e.notes.clone(),+ due_at: e.due_at,+ all_day: e.all_day,+ flagged: e.flagged,+ completed: e.completed,+ priority: e.priority,+ list_guid: e.list_guid.clone(),+ parent_guid: e.parent_guid.clone(),+ from_list: from_list.to_string(),+ }+ }++ /// A later edit laid over this one: what it says wins, what it leaves stays.+ fn then(mut self, later: Self) -> Self {+ macro_rules! over {+ ($($f:ident),*) => { $( if later.$f.is_some() { self.$f = later.$f; } )* };+ }+ over!(+ title,+ notes,+ due_at,+ all_day,+ flagged,+ completed,+ priority,+ list_guid,+ parent_guid+ );+ self+ }++ fn to_apple(&self) -> ReminderEdit {+ ReminderEdit {+ title: self.title.clone(),+ notes: self.notes.clone(),+ due_at: self.due_at,+ all_day: self.all_day,+ flagged: self.flagged,+ completed: self.completed,+ priority: self.priority,+ list_guid: self.list_guid.clone(),+ parent_guid: self.parent_guid.clone(),+ }+ }++ /// The edit, made to the stored reminder.+ fn lay_on(&self, r: &mut Reminder) {+ if let Some(t) = &self.title {+ r.title = t.trim().to_string();+ }+ if let Some(n) = &self.notes {+ r.notes.clone_from(n);+ }+ if let Some(due) = self.due_at {+ r.due_at = due;+ r.all_day = self.all_day.unwrap_or(false) && due.is_some();+ }+ if let Some(f) = self.flagged {+ r.flagged = f;+ }+ if let Some(c) = self.completed {+ r.completed_at = if c {+ r.completed_at.or(Some(jiff::Timestamp::now().as_second()))+ } else {+ None+ };+ }+ if let Some(p) = self.priority {+ r.priority = match p {+ 1..=3 => 1,+ 4..=6 => 5,+ 7..=9 => 9,+ _ => 0,+ };+ }+ if let Some(l) = &self.list_guid {+ r.list_guid.clone_from(l);+ }+ if let Some(p) = &self.parent_guid {+ r.parent_guid.clone_from(p);+ }+ }+}++/// A reminder deleted here, with the subtasks that go with it, as they were.+#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct Delete {+ pub reminder: Reminder,+ pub children: Vec<Reminder>,+}++/// A note's text saved here: what was typed, and what it was typed over.+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct NoteSave {+ pub body: String,+ pub base: Option<String>,+ pub runs: Option<Vec<Run>>,+ pub base_runs: Option<Vec<Run>>,+}++/// A card saved here: as the form left it, and as it opened (`None` for a new card).+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct ContactSave {+ pub contact: Contact,+ pub base: Option<Contact>,+ pub create: bool,+}++fn json<T: Serialize>(v: &T) -> quince_core::Result<String> {+ serde_json::to_string(v)+ .map_err(|e| quince_core::Error::Io(std::io::Error::other(e.to_string())))+}++/// The newest change waiting for `record` in `service`, if it is still the last word on that+/// record (nothing of another kind queued after it) and of `kind`.+fn last_word(+ library: &Library,+ service: &str,+ record: &str,+ kind: &str,+) -> quince_core::Result<Option<Pending>> {+ Ok(library+ .outbox_pending(service)?+ .into_iter()+ .rfind(|p| p.record == record)+ .filter(|p| p.kind == kind))+}++// --- Recording: the command's half. Each records the change and lays it over the library as+// one transaction, so a crash leaves both or neither.++/// A note's text, saved here. Several saves before one is sent become one, sent from the+/// text the first was typed over; one already on its way is followed by the next, typed over+/// what it sends.+pub fn record_note_save(+ library: &mut Library,+ guid: &str,+ body: &str,+ base: Option<String>,+ runs: Option<Vec<Run>>,+ base_runs: Option<Vec<Run>>,+) -> quince_core::Result<()> {+ library.atomically(|l| {+ let stored = l.note_body(guid)?;+ let waiting: Option<(Pending, NoteSave)> = l+ .outbox_waiting(NOTES, guid, "save")?+ .into_iter()+ .next_back()+ .and_then(|p| serde_json::from_str(&p.payload).ok().map(|s| (p, s)));+ let save = |base, base_runs| NoteSave {+ body: body.to_string(),+ base,+ runs: runs.clone(),+ base_runs,+ };+ match waiting {+ Some((p, before)) if p.tries == 0 => {+ let merged = save(before.base, before.base_runs);+ if !l.outbox_amend(p.id, &json(&merged)?)? {+ l.outbox_append(NOTES, guid, "save", &json(&merged)?)?;+ }+ }+ Some((_, before)) => {+ l.outbox_append(+ NOTES,+ guid,+ "save",+ &json(&save(Some(before.body), before.runs))?,+ )?;+ }+ None => {+ // Nothing waiting: the library holds what Apple holds, the base when the+ // editor did not say.+ let base = base.or(stored);+ l.outbox_append(NOTES, guid, "save", &json(&save(base, base_runs))?)?;+ }+ }+ lay_note(l, guid, body, runs.as_deref())+ })+}++fn lay_note(+ l: &mut Library,+ guid: &str,+ body: &str,+ runs: Option<&[Run]>,+) -> quince_core::Result<()> {+ let (title, snippet) = quince_icloud::notes::title_and_snippet(body);+ l.set_note_text(+ guid,+ body,+ &title,+ Some(snippet.as_str()).filter(|s| !s.is_empty()),+ )?;+ if let Some(runs) = runs {+ l.set_note_runs(guid, &json(&runs)?)?;+ }+ Ok(())+}++/// A reminder made here: named now, shown now, sent behind.+pub fn record_reminder_create(+ library: &mut Library,+ create: &Create,+) -> quince_core::Result<String> {+ let guid = quince_icloud::reminders::new_reminder_name();+ library.atomically(|l| {+ l.outbox_append(REMINDERS, &guid, "create", &json(create)?)?;+ lay_create(l, &guid, create)?;+ Ok(guid.clone())+ })+}++fn lay_create(l: &mut Library, guid: &str, c: &Create) -> quince_core::Result<()> {+ if l.reminder(guid)?.is_some() {+ return Ok(());+ }+ // A list deleted since has nowhere to show it.+ if !l.reminder_lists()?.iter().any(|x| x.guid == c.list_guid) {+ return Ok(());+ }+ l.put_reminder_local(&Reminder {+ guid: guid.to_string(),+ list_guid: c.list_guid.clone(),+ title: c.title.trim().to_string(),+ due_at: c.due_at,+ all_day: c.all_day.unwrap_or(false) && c.due_at.is_some(),+ flagged: c.flagged.unwrap_or(false),+ ..Default::default()+ })+}++/// An edit to a reminder. Edits not yet sent and still the last word on it are one edit.+pub fn record_reminder_edit(+ library: &mut Library,+ reminder: &Reminder,+ edit: &ReminderEdit,+) -> quince_core::Result<()> {+ library.atomically(|l| {+ let fresh = Edit::new(edit, &reminder.list_guid);+ let waiting = last_word(l, REMINDERS, &reminder.guid, "edit")?+ .filter(|p| p.tries == 0)+ .and_then(|p| {+ serde_json::from_str::<Edit>(&p.payload)+ .ok()+ .map(|e| (p, e))+ });+ let amended = match waiting {+ Some((p, before)) => l.outbox_amend(p.id, &json(&before.then(fresh.clone()))?)?,+ None => false,+ };+ if !amended {+ l.outbox_append(REMINDERS, &reminder.guid, "edit", &json(&fresh)?)?;+ }+ lay_edit(l, &reminder.guid, &fresh)+ })+}++fn lay_edit(l: &mut Library, guid: &str, e: &Edit) -> quince_core::Result<()> {+ let Some(mut r) = l.reminder(guid)? else {+ return Ok(());+ };+ e.lay_on(&mut r);+ l.put_reminder_local(&r)?;+ // Moved, its subtasks go with it, as on the phone.+ if let Some(to) = &e.list_guid {+ for mut child in l.subtasks_of(guid)? {+ child.list_guid.clone_from(to);+ l.put_reminder_local(&child)?;+ }+ }+ Ok(())+}++/// A reminder deleted here, with its subtasks.+pub fn record_reminder_delete(+ library: &mut Library,+ reminder: &Reminder,+) -> quince_core::Result<()> {+ library.atomically(|l| {+ let children = l.subtasks_of(&reminder.guid)?;+ let delete = Delete {+ reminder: reminder.clone(),+ children,+ };+ l.outbox_append(REMINDERS, &reminder.guid, "delete", &json(&delete)?)?;+ lay_delete(l, &delete)+ })+}++fn lay_delete(l: &mut Library, d: &Delete) -> quince_core::Result<()> {+ let mut gone: Vec<String> = d.children.iter().map(|c| c.guid.clone()).collect();+ gone.push(d.reminder.guid.clone());+ l.forget_reminders(&gone, &[])+}++/// A card saved here — made (no id yet: one is given now) or edited. Answers its id.+pub fn record_contact_save(+ library: &mut Library,+ contact: &Contact,+ base: Option<Contact>,+) -> quince_core::Result<String> {+ let create = contact.guid.is_empty();+ let mut contact = contact.clone();+ if create {+ contact.guid = quince_icloud::contacts::new_contact_id();+ contact.etag = None;+ }+ let guid = contact.guid.clone();+ library.atomically(|l| {+ let waiting = last_word(l, CONTACTS, &guid, "save")?.and_then(|p| {+ serde_json::from_str::<ContactSave>(&p.payload)+ .ok()+ .map(|s| (p, s))+ });+ match waiting {+ Some((p, before)) if p.tries == 0 => {+ // One save, from the card as the form first opened it (or still a create).+ let save = ContactSave {+ contact: contact.clone(),+ base: before.base,+ create: before.create,+ };+ if !l.outbox_amend(p.id, &json(&save)?)? {+ l.outbox_append(CONTACTS, &guid, "save", &json(&save)?)?;+ }+ }+ Some((_, before)) => {+ // Behind one that may have landed: an edit of the card that one sends.+ let save = ContactSave {+ contact: contact.clone(),+ base: Some(before.contact),+ create: false,+ };+ l.outbox_append(CONTACTS, &guid, "save", &json(&save)?)?;+ }+ None => {+ let save = ContactSave {+ contact: contact.clone(),+ base: if create { None } else { base.clone() },+ create,+ };+ l.outbox_append(CONTACTS, &guid, "save", &json(&save)?)?;+ }+ }+ l.put_contact(&contact)?;+ Ok(guid.clone())+ })+}++/// Lay one waiting change over the library.+fn lay(l: &mut Library, p: &Pending) -> quince_core::Result<()> {+ match (p.service.as_str(), p.kind.as_str()) {+ (REMINDERS, "done") => {+ if let Ok(d) = serde_json::from_str::<Done>(&p.payload) {+ l.set_reminder_completed(&p.record, d.done.then_some(d.at))?;+ }+ }+ (REMINDERS, "create") => {+ if let Ok(c) = serde_json::from_str::<Create>(&p.payload) {+ lay_create(l, &p.record, &c)?;+ }+ }+ (REMINDERS, "edit") => {+ if let Ok(e) = serde_json::from_str::<Edit>(&p.payload) {+ lay_edit(l, &p.record, &e)?;+ }+ }+ (REMINDERS, "delete") => {+ if let Ok(d) = serde_json::from_str::<Delete>(&p.payload) {+ lay_delete(l, &d)?;+ }+ }+ (NOTES, "save") => {+ if let Ok(s) = serde_json::from_str::<NoteSave>(&p.payload) {+ if l.note(&p.record)?.is_some() {+ lay_note(l, &p.record, &s.body, s.runs.as_deref())?;+ }+ }+ }+ (CONTACTS, "save") => {+ if let Ok(s) = serde_json::from_str::<ContactSave>(&p.payload) {+ l.put_contact(&s.contact)?;+ }+ }+ _ => {}+ }+ Ok(())+}++/// Lay every change still waiting for `service` over what a sync pass just stored, in the+/// order they were made.+pub fn replay(library: &mut Library, service: &str) -> quince_core::Result<()> {+ for p in library.outbox_pending(service)? {+ lay(library, &p)?;+ }+ Ok(())+}++/// The reminder changes still waiting, laid over what a pass stored.+pub fn replay_reminders(library: &mut Library) -> quince_core::Result<()> {+ replay(library, REMINDERS)+}++// --- Sending: the worker's half.++/// Runs for as long as the app does. Starts by sending whatever an earlier run left.pub fn start(app: AppHandle) {tauri::async_runtime::spawn(async move {- let mut wait = Duration::from_secs(30);+ let mut wait = Duration::ZERO;loop {tokio::select! {() = WAKE.notified() => {}() = tokio::time::sleep(wait) => {}}- wait = match drain_reminders(&app).await {- Outcome::Clear => Duration::from_secs(30),+ let _ = app.emit(CHANGED, ());+ let outcomes = [+ drain_reminders(&app).await,+ drain_notes(&app).await,+ drain_contacts(&app).await,+ ];+ let _ = app.emit(CHANGED, ());+ wait = if outcomes.iter().any(|o| matches!(o, Outcome::Later)) {// Apple out of reach: wait longer each time, up to two minutes.- Outcome::Later => {- (wait * 2).clamp(Duration::from_secs(4), Duration::from_secs(120))- }+ (wait * 2).clamp(Duration::from_secs(4), Duration::from_secs(120))+ } else {+ Duration::from_secs(30)};}});}+/// Told to the window whenever what waits may have changed.+pub const CHANGED: &str = "quince://outbox-changed";+enum Outcome {Clear,Later,}-/// Whether Apple could not be reached (keep it) rather than said no (drop it).-/// How many times an answer this app does not understand is retried before the change is-/// given up and said to be refused — a fault that will never clear held every change queued-/// after it forever, each shown as made.+/// How many times an answer this app does not understand (or a conflict a merge did not+/// settle) is retried before the change is held as refused — a fault that will never clear+/// held every change queued after it forever, each shown as made.const PROTOCOL_TRIES: i64 = 5;+/// Whether Apple could not be reached (keep it) rather than said no (hold it as refused).+/// `tries` counts this one.fn transient(e: &Error, tries: i64) -> bool {match e {Error::Network(_)@@ -73,84 +565,18 @@ fn transient(e: &Error, tries: i64) -> bool {| Error::Busy| Error::Io(_)| Error::Storage(_) => true,- Error::Protocol(_) => tries < PROTOCOL_TRIES,+ Error::Protocol(_) | Error::Conflict => tries < PROTOCOL_TRIES,_ => false,}}#[derive(Clone, serde::Serialize)]-struct Refused {+struct RefusedEvent {service: &'static str,record: String,message: String,}-async fn drain_reminders(app: &AppHandle) -> Outcome {- let auth = app.state::<Auth>();- let data = app.state::<Data>();- let session = if crate::same_account(app).await {- cloudkit_context(&auth).await- } else {- Err(String::new())- };- let Ok((http, root, params)) = session else {- // Not signed in, or the session is being renewed: nothing can go yet.- return if data- .0- .lock()- .await- .outbox_pending("reminders")- .map(|p| p.is_empty())- .unwrap_or(true)- {- Outcome::Clear- } else {- Outcome::Later- };- };- let report = drain(&data.0, &crate::REMINDERS_PASS, |reminder, d| {- let (http, root, params) = (http.clone(), root.clone(), params.clone());- async move {- // A change made on another device after this one was queued wins; the pass after- // sending reads Apple's version back.- if quince_icloud::reminders::tick_overtaken(- &http,- &root,- params.clone(),- &reminder,- d.done,- d.at,- )- .await?- {- return Ok(());- }- quince_icloud::reminders::set_completed_cloudkit(- &http, &root, params, &reminder, d.done,- )- .await- }- })- .await;- for (record, message) in &report.refused {- let _ = app.emit(- "quince://outbox-refused",- Refused {- service: "reminders",- record: record.clone(),- message: message.clone(),- },- );- }- // Apple's own version of what was sent — its new change tags, and the truth over anything- // it refused.- if report.sent || !report.refused.is_empty() {- let _ = crate::refresh_reminders(&http, &root, params, &data, false).await;- let _ = app.emit("quince://reminders-synced", ());- }- report.outcome-}-/// What one pass over the queue came to.struct Report {outcome: Outcome,@@ -159,15 +585,11 @@ struct Report {refused: Vec<(String, String)>,}-/// Send what is waiting for Reminders, oldest first, with `send`. Stops at the first change+/// Send what is waiting for `service`, oldest first, with `send`. Stops at the first change/// Apple can't be reached for, leaving it and everything after it queued, in order.-async fn drain<F, Fut>(- library: &tokio::sync::Mutex<quince_core::Library>,- pass: &tokio::sync::Mutex<()>,- send: F,-) -> Report+async fn drain<F, Fut>(library: &Mutex<Library>, service: &str, pass: &Mutex<()>, send: F) -> Reportwhere- F: Fn(quince_core::reminders::Reminder, Done) -> Fut,+ F: Fn(Pending) -> Fut,Fut: std::future::Future<Output = Result<(), Error>>,{let mut report = Report {@@ -176,101 +598,547 @@ whererefused: Vec::new(),};loop {- let next: Option<Pending> = match library.lock().await.outbox_pending("reminders") {- Ok(p) => p.into_iter().next(),- Err(_) => {- report.outcome = Outcome::Later;- return report;- }- };- let Some(p) = next else { break };// No sync pass between sending and taking it off the queue: one fetched just before// the write and stored just after would put the old state back with nothing waiting// to lay over it.let _pass = pass.lock().await;- let reminder = {- let lib = library.lock().await;- lib.reminder(&p.record).ok().flatten()- };- let Some(reminder) = reminder else {- // Gone from the library (deleted here or elsewhere): nothing left to send.- let _ = library.lock().await.outbox_done(p.id);- continue;- };- let result = match (p.kind.as_str(), serde_json::from_str::<Done>(&p.payload)) {- ("done", Ok(d)) => send(reminder, d).await,- ("done", Err(e)) => Err(Error::Refused(format!(- "A queued change could not be read: {e}"- ))),- (other, _) => Err(Error::Refused(format!(- "Pomander does not know how to send “{other}”."- ))),+ let next = library.lock().await.outbox_take(service);+ let p = match next {+ Ok(Some(p)) => p,+ Ok(None) => break,+ Err(_) => {+ report.outcome = Outcome::Later;+ return report;+ }};- match result {+ let (id, tries, record) = (p.id, p.tries, p.record.clone());+ match send(p).await {Ok(()) => {- let _ = library.lock().await.outbox_done(p.id);+ let _ = library.lock().await.outbox_done(id);report.sent = true;}- Err(e) if transient(&e, p.tries) => {- let _ = library.lock().await.outbox_retry(p.id, &e.to_string());+ Err(e) if transient(&e, tries) => {+ let _ = library.lock().await.outbox_retry(id, &e.to_string());report.outcome = Outcome::Later;return report;}Err(e) => {- let _ = library.lock().await.outbox_done(p.id);- report.refused.push((p.record.clone(), e.to_string()));+ let _ = library.lock().await.outbox_refuse(id, &e.to_string());+ report.refused.push((record, e.to_string()));}}}report}-/// Lay the reminder changes still waiting over what a sync pass just stored.-pub fn replay_reminders(library: &mut quince_core::Library) -> quince_core::Result<()> {- for p in library.outbox_pending("reminders")? {- if p.kind == "done" {- if let Ok(d) = serde_json::from_str::<Done>(&p.payload) {- library.set_reminder_completed(&p.record, d.done.then_some(d.at))?;+fn unreadable(e: &serde_json::Error) -> Error {+ Error::Refused(format!("A queued change could not be read: {e}"))+}++fn tell_refused(app: &AppHandle, service: &'static str, report: &Report) {+ for (record, message) in &report.refused {+ let _ = app.emit(+ "quince://outbox-refused",+ RefusedEvent {+ service,+ record: record.clone(),+ message: message.clone(),+ },+ );+ }+}++/// Whether anything waits for `service` — the answer when Apple can't be asked yet.+async fn waiting(data: &Data, service: &str) -> Outcome {+ if data+ .0+ .lock()+ .await+ .outbox_pending(service)+ .map(|p| p.is_empty())+ .unwrap_or(true)+ {+ Outcome::Clear+ } else {+ Outcome::Later+ }+}++async fn drain_reminders(app: &AppHandle) -> Outcome {+ let auth = app.state::<Auth>();+ let data = app.state::<Data>();+ if waiting(&data, REMINDERS).await.is_clear() {+ return Outcome::Clear;+ }+ let session = if crate::same_account(app).await {+ cloudkit_context(&auth).await+ } else {+ Err(String::new())+ };+ let Ok((http, root, params)) = session else {+ // Not signed in, or the session is being renewed: nothing can go yet.+ return Outcome::Later;+ };+ let report = drain(&data.0, REMINDERS, &crate::REMINDERS_PASS, |p| {+ send_reminder(&data.0, &http, &root, params.clone(), p)+ })+ .await;+ tell_refused(app, REMINDERS, &report);+ // Apple's own version of what was sent — its new change tags, and the truth over anything+ // it refused.+ if report.sent || !report.refused.is_empty() {+ let _ = crate::refresh_reminders(&http, &root, params, &data, false).await;+ crate::alerts::changed();+ let _ = app.emit("quince://reminders-synced", ());+ }+ report.outcome+}++impl Outcome {+ fn is_clear(&self) -> bool {+ matches!(self, Outcome::Clear)+ }+}++async fn send_reminder(+ library: &Mutex<Library>,+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ p: Pending,+) -> Result<(), Error> {+ use quince_icloud::reminders as r;+ let stored = library.lock().await.reminder(&p.record)?;+ match p.kind.as_str() {+ "done" => {+ let d: Done = serde_json::from_str(&p.payload).map_err(|e| unreadable(&e))?;+ // Gone from the library (deleted here or elsewhere): nothing left to tick.+ let Some(reminder) = stored else {+ return Ok(());+ };+ // A change made on another device after this one was queued wins; the pass after+ // sending reads Apple's version back.+ if r::tick_overtaken(http, root, params.clone(), &reminder, d.done, d.at).await? {+ return Ok(());+ }+ r::set_completed_cloudkit(http, root, params, &reminder, d.done).await+ }+ "create" => {+ let c: Create = serde_json::from_str(&p.payload).map_err(|e| unreadable(&e))?;+ r::create_cloudkit_named(+ http,+ root,+ params.clone(),+ &p.record,+ &c.list_guid,+ &c.title,+ )+ .await?;+ if c.due_at.is_some() || c.flagged.is_some() {+ let made = Reminder {+ guid: p.record.clone(),+ list_guid: c.list_guid.clone(),+ title: c.title.clone(),+ ..Default::default()+ };+ let edit = ReminderEdit {+ due_at: c.due_at.map(Some),+ all_day: c.all_day,+ flagged: c.flagged,+ ..Default::default()+ };+ // The reminder exists at Apple now: its date or flag failing is noted, never+ // a reason to make it again.+ if let Err(e) = r::edit_cloudkit(http, root, params, &made, &edit).await {+ quiet!("a new reminder's date or flag was not set: {e}");+ }+ }+ Ok(())+ }+ "edit" => {+ let e: Edit = serde_json::from_str(&p.payload).map_err(|e| unreadable(&e))?;+ let Some(mut reminder) = stored else {+ return Err(Error::Refused(+ "This reminder was deleted on another device, so the change wasn’t saved."+ .into(),+ ));+ };+ // Sent as a move from where it was before any of this edit.+ reminder.list_guid.clone_from(&e.from_list);+ let edit = e.to_apple();+ r::edit_cloudkit(http, root, params.clone(), &reminder, &edit).await?;+ if let Some(to) = e.list_guid.as_deref().filter(|to| *to != e.from_list) {+ let children = library.lock().await.subtasks_of(&p.record)?;+ let follow = ReminderEdit {+ list_guid: Some(to.to_string()),+ ..Default::default()+ };+ for mut child in children {+ child.list_guid.clone_from(&e.from_list);+ if let Err(e) =+ r::edit_cloudkit(http, root, params.clone(), &child, &follow).await+ {+ quiet!("a subtask did not follow its reminder: {e}");+ }+ }+ }+ // A date carries its alert, as on the phone; made all-day, it rings none.+ let alarm_change = if e.all_day == Some(true) {+ Some(None)+ } else {+ e.due_at+ };+ if let Some(due) = alarm_change {+ let zone = jiff::tz::TimeZone::system();+ r::set_alarm_cloudkit(+ http,+ root,+ params,+ &p.record,+ due,+ zone.iana_name().unwrap_or("UTC"),+ )+ .await?;+ }+ Ok(())+ }+ "delete" => {+ let d: Delete = serde_json::from_str(&p.payload).map_err(|e| unreadable(&e))?;+ match r::delete_cloudkit(http, root, params.clone(), &d.reminder).await {+ Ok(()) | Err(Error::NotFound) => {}+ Err(e) => return Err(e),+ }+ for child in &d.children {+ if let Err(e) = r::delete_cloudkit(http, root, params.clone(), child).await {+ quiet!("a subtask did not go with its reminder: {e}");+ }}+ Ok(())+ }+ other => Err(Error::Refused(format!(+ "Pomander does not know how to send “{other}”."+ ))),+ }+}++async fn drain_notes(app: &AppHandle) -> Outcome {+ let auth = app.state::<Auth>();+ let data = app.state::<Data>();+ if waiting(&data, NOTES).await.is_clear() {+ return Outcome::Clear;+ }+ let session = if crate::same_account(app).await {+ cloudkit_context(&auth).await+ } else {+ Err(String::new())+ };+ let Ok((http, root, params)) = session else {+ return Outcome::Later;+ };+ let report = drain(&data.0, NOTES, &crate::NOTES_PASS, |p| {+ send_note(&data.0, &http, &root, params.clone(), p)+ })+ .await;+ tell_refused(app, NOTES, &report);+ if report.sent || !report.refused.is_empty() {+ let _ = crate::refresh_notes(&http, &root, params, &data).await;+ }+ report.outcome+}++async fn send_note(+ library: &Mutex<Library>,+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ p: Pending,+) -> Result<(), Error> {+ let s: NoteSave = serde_json::from_str(&p.payload).map_err(|e| unreadable(&e))?;+ let Some(note) = library.lock().await.note(&p.record)? else {+ return Err(Error::Refused(+ "This note was deleted on another device, so the edit wasn’t saved.".into(),+ ));+ };+ let saved = quince_icloud::notes::edit_rich_cloudkit_from(+ http,+ root,+ params,+ ¬e,+ s.base.as_deref(),+ &s.body,+ s.runs.as_deref(),+ s.base_runs.as_deref(),+ )+ .await?;+ // Apple's change feed does not always carry our own write back on the very next pass:+ // what Apple now holds — ours, or ours with another device's edit merged in — is what the+ // note says, unless more typing waits to go after it.+ let mut l = library.lock().await;+ let more = l+ .outbox_waiting(NOTES, &p.record, "save")?+ .iter()+ .any(|w| w.id != p.id);+ if !more {+ let runs = s.runs.as_ref().map(|runs| {+ if saved == s.body {+ runs.clone()+ } else {+ quince_icloud::ckdocument::carry_runs(&s.body, runs, &saved)+ }+ });+ lay_note(&mut l, &p.record, &saved, runs.as_deref())?;+ }+ Ok(())+}++async fn drain_contacts(app: &AppHandle) -> Outcome {+ let auth = app.state::<Auth>();+ let data = app.state::<Data>();+ if waiting(&data, CONTACTS).await.is_clear() {+ return Outcome::Clear;+ }+ let session = if crate::same_account(app).await {+ crate::contacts_context(&auth).await+ } else {+ Err(String::new())+ };+ let Ok((http, root, params)) = session else {+ return Outcome::Later;+ };+ let report = drain(&data.0, CONTACTS, &crate::CONTACTS_PASS, |p| {+ send_contact(&http, &root, params.clone(), p)+ })+ .await;+ tell_refused(app, CONTACTS, &report);+ if report.sent || !report.refused.is_empty() {+ let _one = crate::CONTACTS_PASS.lock().await;+ let _ = crate::resync_contacts(&http, &root, params, &data).await;+ }+ report.outcome+}++async fn send_contact(+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ p: Pending,+) -> Result<(), Error> {+ use quince_icloud::contacts as c;+ let s: ContactSave = serde_json::from_str(&p.payload).map_err(|e| unreadable(&e))?;+ let (_, tokens) = c::fetch_with_tokens(http, root, params.clone()).await?;+ if s.create {+ return c::create_named(http, root, params, &tokens, &p.record, &s.contact).await;+ }+ let card = c::card(http, root, params.clone(), &p.record).await?;+ c::update_from(+ http,+ root,+ params,+ &tokens,+ &s.contact,+ card.as_ref(),+ s.base.as_ref(),+ )+ .await+}++// --- What the window asks.++/// A change waiting to go.+#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+pub struct WaitingView {+ service: String,+ record: String,+ kind: String,+}++/// A change Apple turned down, with what it held, for the person to keep.+#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+pub struct RefusedView {+ id: i64,+ service: String,+ record: String,+ kind: String,+ reason: String,+ made_at: i64,+ /// What was typed, in words: the note's text, the reminder's title, the person's name.+ content: String,+}++#[derive(Serialize)]+pub struct Status {+ waiting: Vec<WaitingView>,+ refused: Vec<RefusedView>,+}++/// The words a refused change held.+fn content_of(p: &Pending) -> String {+ let v: serde_json::Value = serde_json::from_str(&p.payload).unwrap_or_default();+ let s = |ptr: &str| v.pointer(ptr).and_then(|x| x.as_str()).map(str::to_string);+ match (p.service.as_str(), p.kind.as_str()) {+ (NOTES, _) => s("/body"),+ (REMINDERS, "create") => s("/title"),+ (REMINDERS, "edit") => s("/title").or_else(|| s("/notes")),+ (REMINDERS, "delete") => s("/reminder/title"),+ (CONTACTS, _) => {+ let name: Vec<String> = [+ "/contact/firstName",+ "/contact/lastName",+ "/contact/company",+ ]+ .iter()+ .filter_map(|ptr| s(ptr))+ .filter(|x| !x.trim().is_empty())+ .collect();+ Some(name.join(" "))}+ _ => None,+ }+ .unwrap_or_default()+}++pub fn status(library: &Library) -> quince_core::Result<Status> {+ Ok(Status {+ waiting: library+ .outbox_all_pending()?+ .into_iter()+ .map(|p| WaitingView {+ service: p.service,+ record: p.record,+ kind: p.kind,+ })+ .collect(),+ refused: library+ .outbox_refused()?+ .into_iter()+ .map(|r| RefusedView {+ id: r.change.id,+ content: content_of(&r.change),+ service: r.change.service,+ record: r.change.record,+ kind: r.change.kind,+ reason: r.reason,+ made_at: r.made_at,+ })+ .collect(),+ })+}++/// What waits for Apple and what Apple turned down.+#[tauri::command]+pub async fn outbox_status(data: State<'_, Data>) -> Result<Status, String> {+ status(&*data.0.lock().await).map_err(|e| e.to_string())+}++/// A refused change, sent again. It is laid over the library again as it goes.+#[tauri::command]+pub async fn outbox_resend(id: i64, app: AppHandle, data: State<'_, Data>) -> Result<(), String> {+ {+ let mut l = data.0.lock().await;+ l.atomically(|l| {+ if l.outbox_resend(id)? {+ if let Some(service) = l+ .outbox_all_pending()?+ .into_iter()+ .next_back()+ .map(|p| p.service)+ {+ replay(l, &service)?;+ }+ }+ Ok::<_, quince_core::Error>(())+ })+ .map_err(|e| e.to_string())?;}+ let _ = app.emit(CHANGED, ());+ kick();+ Ok(())+}++/// A refused change let go of: Apple's version stands.+#[tauri::command]+pub async fn outbox_discard(id: i64, app: AppHandle, data: State<'_, Data>) -> Result<(), String> {+ data.0+ .lock()+ .await+ .outbox_discard(id)+ .map_err(|e| e.to_string())?;+ let _ = app.emit(CHANGED, ());Ok(())}#[cfg(test)]mod tests {use super::*;- use quince_core::reminders::{Reminder, ReminderList};+ use quince_core::reminders::ReminderList;use std::sync::{Arc, Mutex as StdMutex};- fn library() -> tokio::sync::Mutex<quince_core::Library> {- let mut lib = quince_core::Library::in_memory().unwrap();- let list: ReminderList = serde_json::from_value(serde_json::json!({- "guid": "L", "title": "Today", "colour": null, "ctag": null, "sortOrder": 0, "enabled": true- }))- .unwrap();- lib.put_reminder_lists(&[list]).unwrap();- let r = |g: &str| -> Reminder {- serde_json::from_value(serde_json::json!({- "guid": g, "listGuid": "L", "title": g, "notes": null, "dueAt": null,- "completedAt": null, "priority": 0, "etag": "t"- }))- .unwrap()+ fn library() -> Library {+ let mut lib = Library::in_memory().unwrap();+ let list = |g: &str| ReminderList {+ guid: g.into(),+ title: g.into(),+ enabled: true,+ ..Default::default()+ };+ lib.put_reminder_lists(&[list("L"), list("M")]).unwrap();+ let r = |g: &str| Reminder {+ guid: g.into(),+ list_guid: "L".into(),+ title: g.into(),+ etag: Some("t".into()),+ ..Default::default()};lib.put_reminders(&[r("a"), r("b"), r("c")]).unwrap();- tokio::sync::Mutex::new(lib)+ lib}- fn queue(lib: &mut quince_core::Library, g: &str, done: bool) {+ fn queue(lib: &mut Library, g: &str, done: bool) {lib.set_reminder_completed(g, done.then_some(1)).unwrap();let payload = serde_json::to_string(&Done { done, at: 1 }).unwrap();- lib.outbox_push("reminders", g, "done", &payload).unwrap();+ lib.outbox_push(REMINDERS, g, "done", &payload).unwrap();+ }+ fn note(lib: &mut Library, guid: &str, body: &str) {+ lib.put_notes(&[quince_core::notes::Note {+ guid: guid.into(),+ folder_guid: None,+ title: body.into(),+ snippet: None,+ body: Some(body.into()),+ locked: false,+ pinned: false,+ created_at: None,+ modified_at: None,+ editable: true,+ etag: None,+ runs: None,+ }])+ .unwrap();+ }+ fn person(guid: &str, first: &str) -> Contact {+ Contact {+ guid: guid.into(),+ first_name: Some(first.into()),+ middle_name: None,+ last_name: None,+ company: None,+ is_company: false,+ birthday: None,+ notes: None,+ photo_url: None,+ photo_signature: None,+ photo_crop: None,+ etag: None,+ methods: vec![],+ }}#[test]- fn sends_in_order_keeps_what_cannot_reach_apple_and_reports_refusals() {+ fn sends_in_order_keeps_what_cannot_reach_apple_and_holds_refusals() {tauri::async_runtime::block_on(async {- let lib = library();- let pass = tokio::sync::Mutex::new(());+ let lib = Mutex::new(library());+ let pass = Mutex::new(());{let mut l = lib.lock().await;queue(&mut l, "a", true);@@ -280,11 +1148,10 @@ mod tests {// Apple turns "b" down; everything goes through in the order it was made.let seen = Arc::new(StdMutex::new(Vec::new()));let s2 = seen.clone();- let report = drain(&lib, &pass, move |r, d| {- s2.lock().unwrap().push((r.guid.clone(), d.done));- let g = r.guid;+ let report = drain(&lib, REMINDERS, &pass, move |p| {+ s2.lock().unwrap().push(p.record.clone());async move {- if g == "b" {+ if p.record == "b" {Err(Error::Refused("changed on another device".into()))} else {Ok(())@@ -292,11 +1159,8 @@ mod tests {}}).await;- assert_eq!(- *seen.lock().unwrap(),- vec![("a".into(), true), ("b".into(), true), ("c".into(), true)]- );- assert!(report.sent && matches!(report.outcome, Outcome::Clear));+ assert_eq!(*seen.lock().unwrap(), vec!["a", "b", "c"]);+ assert!(report.sent && report.outcome.is_clear());assert_eq!(report.refused,vec![("b".to_string(), "changed on another device".to_string())]@@ -304,9 +1168,13 @@ mod tests {assert!(lib.lock().await- .outbox_pending("reminders")+ .outbox_pending(REMINDERS).unwrap().is_empty());+ // Refused is kept, never dropped.+ let refused = lib.lock().await.outbox_refused().unwrap();+ assert_eq!(refused.len(), 1);+ assert_eq!(refused[0].change.record, "b");// Offline: the first stays, with all after it, in order, for next time.{@@ -314,12 +1182,12 @@ mod tests {queue(&mut l, "a", false);queue(&mut l, "c", false);}- let report = drain(&lib, &pass, |_r, _d| async {+ let report = drain(&lib, REMINDERS, &pass, |_p| async {Err(Error::Protocol("CloudKit refused the change (503)".into()))}).await;- assert!(matches!(report.outcome, Outcome::Later) && !report.sent);- let left = lib.lock().await.outbox_pending("reminders").unwrap();+ assert!(!report.outcome.is_clear() && !report.sent);+ let left = lib.lock().await.outbox_pending(REMINDERS).unwrap();assert_eq!(left.iter().map(|p| p.record.as_str()).collect::<Vec<_>>(),vec!["a", "c"]@@ -331,22 +1199,306 @@ mod tests {let mut l = lib.lock().await;l.set_reminder_completed("a", Some(5)).unwrap();replay_reminders(&mut l).unwrap();- let rs = l.reminders_in("L", true).unwrap();- assert_eq!(- rs.iter().find(|r| r.guid == "a").unwrap().completed_at,- None- );+ assert_eq!(l.reminder("a").unwrap().unwrap().completed_at, None);}// Back online: both go.- let report = drain(&lib, &pass, |_r, _d| async { Ok(()) }).await;- assert!(report.sent && matches!(report.outcome, Outcome::Clear));+ let report = drain(&lib, REMINDERS, &pass, |_p| async { Ok(()) }).await;+ assert!(report.sent && report.outcome.is_clear());assert!(lib.lock().await- .outbox_pending("reminders")+ .outbox_pending(REMINDERS).unwrap().is_empty());});}++ /// Offline, a reminder is made, edited twice and another deleted: each shows at once, a+ /// pass reading Apple's older state is laid over with them all, and they go in the order+ /// they were made, the two edits as one.+ #[test]+ fn reminder_changes_show_at_once_survive_a_pass_and_go_in_order() {+ let mut lib = library();+ let made = record_reminder_create(+ &mut lib,+ &Create {+ list_guid: "L".into(),+ title: " Buy milk ".into(),+ due_at: Some(100),+ all_day: Some(true),+ flagged: None,+ },+ )+ .unwrap();+ assert!(made.starts_with("Reminder/"), "named here, before Apple");+ let shown = lib.reminder(&made).unwrap().unwrap();+ assert_eq!(+ (shown.title.as_str(), shown.due_at, shown.all_day),+ ("Buy milk", Some(100), true)+ );++ let a = lib.reminder("a").unwrap().unwrap();+ record_reminder_edit(+ &mut lib,+ &a,+ &ReminderEdit {+ title: Some("A renamed".into()),+ ..Default::default()+ },+ )+ .unwrap();+ let a = lib.reminder("a").unwrap().unwrap();+ record_reminder_edit(+ &mut lib,+ &a,+ &ReminderEdit {+ notes: Some(None),+ list_guid: Some("M".into()),+ ..Default::default()+ },+ )+ .unwrap();+ let b = lib.reminder("b").unwrap().unwrap();+ record_reminder_delete(&mut lib, &b).unwrap();++ let a = lib.reminder("a").unwrap().unwrap();+ assert_eq!((a.title.as_str(), a.list_guid.as_str()), ("A renamed", "M"));+ assert!(lib.reminder("b").unwrap().is_none(), "deleted at once");+ assert!(a.etag.is_some(), "Apple's tag kept for the write");++ let p = lib.outbox_pending(REMINDERS).unwrap();+ assert_eq!(+ p.iter()+ .map(|x| (x.record.as_str(), x.kind.as_str()))+ .collect::<Vec<_>>(),+ vec![(made.as_str(), "create"), ("a", "edit"), ("b", "delete")]+ );+ let edit: Edit = serde_json::from_str(&p[1].payload).unwrap();+ assert_eq!(edit.title.as_deref(), Some("A renamed"));+ assert_eq!(edit.notes, Some(None), "clear kept apart from leave");+ assert_eq!(edit.from_list, "L", "moved from where it first was");++ // A full pass reads Apple's state from before any of it.+ lib.retain_reminders(&["a".into(), "b".into(), "c".into()])+ .unwrap();+ lib.put_reminders(&[+ Reminder {+ guid: "a".into(),+ list_guid: "L".into(),+ title: "a".into(),+ etag: Some("t2".into()),+ ..Default::default()+ },+ Reminder {+ guid: "b".into(),+ list_guid: "L".into(),+ title: "b".into(),+ ..Default::default()+ },+ ])+ .unwrap();+ replay_reminders(&mut lib).unwrap();+ assert!(lib.reminder(&made).unwrap().is_some());+ let a = lib.reminder("a").unwrap().unwrap();+ assert_eq!(+ (a.title.as_str(), a.list_guid.as_str(), a.etag.as_deref()),+ ("A renamed", "M", Some("t2"))+ );+ assert!(lib.reminder("b").unwrap().is_none());+ }++ /// An edit already taken to be sent is followed, never rewritten.+ #[test]+ fn an_edit_on_its_way_is_followed_not_rewritten() {+ let mut lib = library();+ let a = lib.reminder("a").unwrap().unwrap();+ let edit = |t: &str| ReminderEdit {+ title: Some(t.into()),+ ..Default::default()+ };+ record_reminder_edit(&mut lib, &a, &edit("one")).unwrap();+ lib.outbox_take(REMINDERS).unwrap();+ record_reminder_edit(&mut lib, &a, &edit("two")).unwrap();+ let p = lib.outbox_pending(REMINDERS).unwrap();+ assert_eq!(p.len(), 2);+ assert_eq!(+ serde_json::from_str::<Edit>(&p[0].payload)+ .unwrap()+ .title+ .as_deref(),+ Some("one")+ );+ assert_eq!(+ serde_json::from_str::<Edit>(&p[1].payload)+ .unwrap()+ .title+ .as_deref(),+ Some("two")+ );+ }++ /// Note saves: shown at once; several unsent are one, from the first base; one on its way+ /// is followed by the next typed over what it sends; a pass is laid over.+ #[test]+ fn note_saves_keep_their_base_and_survive_a_pass() {+ let mut lib = Library::in_memory().unwrap();+ note(&mut lib, "N", "Apple's text");+ record_note_save(&mut lib, "N", "Apple's text, mine", None, None, None).unwrap();+ record_note_save(+ &mut lib,+ "N",+ "Apple's text, mine more",+ Some("ignored".into()),+ None,+ None,+ )+ .unwrap();+ assert_eq!(+ lib.note_body("N").unwrap().as_deref(),+ Some("Apple's text, mine more")+ );+ let p = lib.outbox_pending(NOTES).unwrap();+ assert_eq!(p.len(), 1, "one save");+ let s: NoteSave = serde_json::from_str(&p[0].payload).unwrap();+ assert_eq!(+ s.base.as_deref(),+ Some("Apple's text"),+ "from what was typed over first"+ );++ lib.outbox_take(NOTES).unwrap();+ record_note_save(+ &mut lib,+ "N",+ "Apple's text, mine more and more",+ None,+ None,+ None,+ )+ .unwrap();+ let p = lib.outbox_pending(NOTES).unwrap();+ let s: NoteSave = serde_json::from_str(&p[1].payload).unwrap();+ assert_eq!(s.base.as_deref(), Some("Apple's text, mine more"));++ // A pass brings Apple's older text: the waiting typing is laid back over it.+ note(&mut lib, "N", "Apple's text");+ replay(&mut lib, NOTES).unwrap();+ assert_eq!(+ lib.note_body("N").unwrap().as_deref(),+ Some("Apple's text, mine more and more")+ );+ }++ /// Contacts: a new card gets its id here, shows at once, and edits before it is sent stay+ /// one create; a pass that does not have it yet keeps it.+ #[test]+ fn a_new_card_shows_at_once_and_stays_one_create() {+ let mut lib = Library::in_memory().unwrap();+ lib.put_contacts(&[person("X", "Old")]).unwrap();+ let guid = record_contact_save(&mut lib, &person("", "Asha"), None).unwrap();+ assert!(!guid.is_empty());+ record_contact_save(+ &mut lib,+ &person(&guid, "Asha Rao"),+ Some(person(&guid, "Asha")),+ )+ .unwrap();+ let p = lib.outbox_pending(CONTACTS).unwrap();+ assert_eq!(p.len(), 1);+ let s: ContactSave = serde_json::from_str(&p[0].payload).unwrap();+ assert!(s.create && s.base.is_none());+ assert_eq!(s.contact.first_name.as_deref(), Some("Asha Rao"));++ // An edit to an existing card keeps the form's base.+ record_contact_save(&mut lib, &person("X", "New"), Some(person("X", "Old"))).unwrap();+ // A pass that read the book before either.+ lib.put_contacts(&[person("X", "Old")]).unwrap();+ replay(&mut lib, CONTACTS).unwrap();+ let names: Vec<(String, Option<String>)> = lib+ .contacts(None)+ .unwrap()+ .into_iter()+ .map(|c| (c.guid, c.first_name))+ .collect();+ assert!(names.contains(&(guid.clone(), Some("Asha Rao".into()))));+ assert!(names.contains(&("X".into(), Some("New".into()))));+ }++ /// Sent twice — the app died after Apple took it, before the queue heard — a change does+ /// what it did once: the create finds its own name and makes nothing more.+ #[test]+ fn a_create_replayed_after_a_crash_is_made_once() {+ tauri::async_runtime::block_on(async {+ let dir = tempfile::tempdir().unwrap();+ let made = {+ let mut l = Library::open(dir.path()).unwrap();+ l.put_reminder_lists(&[ReminderList {+ guid: "L".into(),+ title: "L".into(),+ enabled: true,+ ..Default::default()+ }])+ .unwrap();+ let made = record_reminder_create(+ &mut l,+ &Create {+ list_guid: "L".into(),+ title: "Once".into(),+ due_at: None,+ all_day: None,+ flagged: None,+ },+ )+ .unwrap();+ // Taken and sent; the process dies before it is marked done.+ l.outbox_take(REMINDERS).unwrap();+ made+ };+ let lib = Mutex::new(Library::open(dir.path()).unwrap());+ let pass = Mutex::new(());+ // Apple, as a set of names: a create of a name it holds makes nothing.+ let apple = Arc::new(StdMutex::new(std::collections::HashSet::from([+ made.clone()+ ])));+ let creates = Arc::new(StdMutex::new(0));+ let (a2, c2) = (apple.clone(), creates.clone());+ let report = drain(&lib, REMINDERS, &pass, move |p| {+ let (apple, creates) = (a2.clone(), c2.clone());+ async move {+ if apple.lock().unwrap().insert(p.record.clone()) {+ *creates.lock().unwrap() += 1;+ }+ Ok(())+ }+ })+ .await;+ assert!(report.sent);+ assert_eq!(+ *creates.lock().unwrap(),+ 0,+ "already at Apple: not made again"+ );+ assert_eq!(apple.lock().unwrap().len(), 1);+ assert!(lib+ .lock()+ .await+ .outbox_pending(REMINDERS)+ .unwrap()+ .is_empty());+ });+ }++ #[test]+ fn an_edit_round_trips_clear_and_leave() {+ let e = Edit {+ notes: Some(None),+ due_at: Some(Some(5)),+ parent_guid: None,+ from_list: "L".into(),+ ..Default::default()+ };+ let back: Edit = serde_json::from_str(&serde_json::to_string(&e).unwrap()).unwrap();+ assert_eq!(back, e);+ }}diff --git a/src-tauri/src/photos.rs b/src-tauri/src/photos.rsindex ddf2135..a23299a 100644--- a/src-tauri/src/photos.rs+++ b/src-tauri/src/photos.rs@@ -512,28 +512,52 @@ pub fn keep_ahead(app: AppHandle) {let library = data.0.lock().await;library.photos(View::Library).unwrap_or_default()};- // Videos whose black poster was kept before posters were remade: remade now, once.- for p in newest- .iter()- .filter(|p| p.kind == quince_core::photos::Kind::Video)- {- if cache_path(&app, &p.id, Size::Thumb).exists() {- crate::cpu::ahead(repair_poster(&app, &p.id)).await;+ // Videos whose black poster was kept before posters were remade: remade now, once —+ // once per video for the life of the process. Every pass decoded every video's poster+ // again to ask (1.7 ms each, measured), and a pass follows each read of the library.+ static LOOKED: Mutex<Option<std::collections::HashSet<String>>> = Mutex::new(None);+ let unlooked: Vec<String> = {+ let looked = LOOKED+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ newest+ .iter()+ .filter(|p| p.kind == quince_core::photos::Kind::Video)+ .filter(|p| looked.as_ref().is_none_or(|l| !l.contains(&p.id)))+ .map(|p| p.id.clone())+ .collect()+ };+ for id in unlooked {+ // Looked at only once its poster is here to look at.+ if cache_path(&app, &id, Size::Thumb).exists() {+ crate::cpu::ahead(repair_poster(&app, &id)).await;+ LOOKED+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .get_or_insert_with(Default::default)+ .insert(id);}}- let wanted: Vec<(String, Size)> = newest- .into_iter()- .take(600)- .map(|p| {- let size = if p.kind == quince_core::photos::Kind::Video {- Size::Original- } else {- Size::Full- };- (p.id, size)- })- .filter(|(id, size)| !cache_path(&app, id, *size).exists())- .collect();+ // What is on disk already, asked of the disk off the runtime's workers: a stat each, and+ // on Windows a stat is slow enough to count.+ let ask = app.clone();+ let wanted: Vec<(String, Size)> = tauri::async_runtime::spawn_blocking(move || {+ newest+ .into_iter()+ .take(600)+ .map(|p| {+ let size = if p.kind == quince_core::photos::Kind::Video {+ Size::Original+ } else {+ Size::Full+ };+ (p.id, size)+ })+ .filter(|(id, size)| !cache_path(&ask, id, *size).exists())+ .collect()+ })+ .await+ .unwrap_or_default();// At most 3 GB a pass, and never past the cache's budget: a computer short of space// keeps fewer ahead, not a full disk.let room = {@@ -643,19 +667,24 @@ pub fn prepare(app: AppHandle) {library.photos(View::Library).unwrap_or_default()};let fit_dir = crate::state_dir(&app).join("photos").join("fit");- let wanted: Vec<(String, u32)> = photos- .iter()- .filter(|p| p.kind != quince_core::photos::Kind::Video)- .map(|p| (p.id.clone(), steps_of(p, shown).0))- .chain(- photos- .iter()- .filter(|p| p.kind != quince_core::photos::Kind::Video)- .take(600)- .map(|p| (p.id.clone(), steps_of(p, shown).1)),- )- .filter(|(id, step)| !fit_dir.join(step.to_string()).join(id).exists())- .collect();+ // A stat per picture, off the runtime's workers (see keep_ahead).+ let wanted: Vec<(String, u32)> = tauri::async_runtime::spawn_blocking(move || {+ photos+ .iter()+ .filter(|p| p.kind != quince_core::photos::Kind::Video)+ .map(|p| (p.id.clone(), steps_of(p, shown).0))+ .chain(+ photos+ .iter()+ .filter(|p| p.kind != quince_core::photos::Kind::Video)+ .take(600)+ .map(|p| (p.id.clone(), steps_of(p, shown).1)),+ )+ .filter(|(id, step)| !fit_dir.join(step.to_string()).join(id).exists())+ .collect()+ })+ .await+ .unwrap_or_default();futures_util::stream::iter(wanted).for_each_concurrent(4, |(id, step)| {let app = app.clone();@@ -1631,15 +1660,17 @@ pub async fn photo_play(id: String, app: AppHandle, data: State<'_, Data>) -> UiSize::Video};let source = cached(&app, &id, size).await?;- let name = photo- .filename- .filter(|n| !n.contains('/') && !n.starts_with('.'))- .unwrap_or_else(|| format!("{id}.mp4"));+ // Cleaned as a note attachment's name is: a shared album's item is named by whoever+ // shared it, and a name is no place for a path, a hidden file or a reversed extension.+ let name = match photo.filename.as_deref() {+ Some(given) => crate::attachment_name(Some(given), &id),+ None => format!("{id}.mp4"),+ };let dir = crate::state_dir(&app).join("photos").join("open").join(&id);tokio::fs::create_dir_all(&dir).await.map_err(|e| e.to_string())?;- let path = dir.join(name);+ let path = dir.join(&name);// Under its own name for the player, linked to the cached file rather than copied.if tokio::fs::metadata(&path).await.is_err()&& tokio::fs::hard_link(&source, &path).await.is_err()@@ -1649,6 +1680,24 @@ pub async fn photo_play(id: String, app: AppHandle, data: State<'_, Data>) -> Ui.map_err(|e| e.to_string())?;}use tauri_plugin_opener::OpenerExt;+ // A video plays in a player; anything that would run instead (a program dressed as a+ // film) is shown in its folder, never started.+ let head = {+ use tokio::io::AsyncReadExt;+ let mut head = vec![0u8; 512];+ let n = match tokio::fs::File::open(&path).await {+ Ok(mut f) => f.read(&mut head).await.unwrap_or(0),+ Err(_) => 0,+ };+ head.truncate(n);+ head+ };+ if crate::runs_code(&name, &head) {+ return app+ .opener()+ .reveal_item_in_dir(&path)+ .map_err(|e| e.to_string());+ }app.opener().open_path(path.to_string_lossy(), None::<&str>).map_err(|e| format!("No app on this computer opens that video: {e}"))diff --git a/src-tauri/src/push.rs b/src-tauri/src/push.rsindex c4d1815..e799864 100644--- a/src-tauri/src/push.rs+++ b/src-tauri/src/push.rs@@ -59,10 +59,7 @@ async fn watch_contacts(let mut tokens: Option<quince_icloud::contacts::Tokens> = None;let mut backoff = Duration::from_secs(5);loop {- let visible = app- .get_webview_window("main")- .and_then(|w| w.is_visible().ok())- .unwrap_or(false);+ let visible = shown(&app);tokio::time::sleep(if visible { LOOK } else { LOOK_HIDDEN }).await;let session = {let guard = client.lock().await;@@ -105,6 +102,13 @@ async fn watch_contacts(}}+/// Whether the window is in front of anyone: shown and not minimized. A minimized window is+/// still "visible" to Windows (and to Tauri there), and was asked at the open window's pace.+fn shown(app: &tauri::AppHandle) -> bool {+ app.get_webview_window("main")+ .is_some_and(|w| w.is_visible().unwrap_or(false) && !w.is_minimized().unwrap_or(false))+}+/// How often Calendar and Contacts are asked whether anything changed: often while the window is open,/// rarely from the tray, where only an alert depends on it.const LOOK: Duration = Duration::from_secs(4);@@ -128,10 +132,7 @@ async fn watch_calendar(let mut seeded = false;let mut backoff = Duration::from_secs(5);loop {- let visible = app- .get_webview_window("main")- .and_then(|w| w.is_visible().ok())- .unwrap_or(false);+ let visible = shown(&app);tokio::time::sleep(if visible { LOOK } else { LOOK_HIDDEN }).await;let session = {let guard = client.lock().await;diff --git a/src-tauri/src/refresh.rs b/src-tauri/src/refresh.rsindex b73b168..748ebfc 100644--- a/src-tauri/src/refresh.rs+++ b/src-tauri/src/refresh.rs@@ -123,6 +123,21 @@ async fn context(client: &Arc<Mutex<Client>>) -> Context {}}+/// Told each time one service's part of a pass has been stored, before the rest are done.+static LANDED: std::sync::OnceLock<Box<dyn Fn(&'static str) + Send + Sync>> =+ std::sync::OnceLock::new();++/// What to do when a service lands: set once, by the app, to tell the open screens.+pub fn on_landed(f: impl Fn(&'static str) + Send + Sync + 'static) {+ let _ = LANDED.set(Box::new(f));+}++fn landed(service: &'static str) {+ if let Some(f) = LANDED.get() {+ f(service);+ }+}+/// Refresh every service the account has, and report on each.////// Never returns an error: a refresh that partly failed is a normal outcome with a partial@@ -143,10 +158,16 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&stlet ctx = context(client).await;let (from, to, zone) = default_window();- let mut reports = Vec::with_capacity(COVERED.len());+ // The services fetched side by side, not one after another: each has its own pass lock,+ // and waiting on Photos' whole library before Reminders was asked anything left every+ // screen empty through a first sync. Each one says it has landed as it does, so its+ // screen fills then rather than when the slowest is done.- if wanted("calendar") {- reports.push(match ctx.calendar.as_deref() {+ let calendar = async {+ if !wanted("calendar") {+ return None;+ }+ let report = match ctx.calendar.as_deref() {None => unavailable("calendar", "Calendar"),Some(root) => {// Fetch and store as one, never across a save: see `CALENDAR_PASS`.@@ -179,11 +200,16 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&st).await}- });- }+ };+ landed(report.service);+ Some(report)+ };- if wanted("reminders") {- reports.push(match ctx.cloudkit.as_deref() {+ let reminders = async {+ if !wanted("reminders") {+ return None;+ }+ let report = match ctx.cloudkit.as_deref() {None => unavailable("reminders", "Reminders"),Some(root) => {let _one = crate::REMINDERS_PASS.lock().await;@@ -221,11 +247,16 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&st).await}- });- }+ };+ landed(report.service);+ Some(report)+ };- if wanted("notes") {- reports.push(match ctx.cloudkit.as_deref() {+ let notes = async {+ if !wanted("notes") {+ return None;+ }+ let report = match ctx.cloudkit.as_deref() {None => unavailable("notes", "Notes"),Some(root) => {// One notes pass at a time, from reading the position through storing what came@@ -248,6 +279,8 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&stfetched,move |library, f| {let (folders, notes, _) = quince_icloud::notes::apply_cloudkit(library, f)?;+ // Edits still on their way to Apple stay as typed here.+ crate::outbox::replay(library, crate::outbox::NOTES)?;if full {library.mark_full_sync("notes")?;}@@ -260,11 +293,16 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&st).await}- });- }+ };+ landed(report.service);+ Some(report)+ };- if wanted("contacts") {- reports.push(match ctx.contacts.as_deref() {+ let contacts = async {+ if !wanted("contacts") {+ return None;+ }+ let report = match ctx.contacts.as_deref() {None => unavailable("contacts", "Contacts"),Some(root) => {// Fetch and store as one, never across a save: see `CONTACTS_PASS`. The book@@ -299,6 +337,8 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&stusize::try_from(n).unwrap_or(0)}};+ // Cards saved here and still on their way to Apple stay as saved.+ crate::outbox::replay(library, crate::outbox::CONTACTS)?;if full {library.mark_full_sync("contacts")?;}@@ -307,14 +347,19 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&st).await}- });- }+ };+ landed(report.service);+ Some(report)+ };// Drive is read a folder at a time as it is opened; the pass keeps its top level current,// so what changed there on another device is here before anyone looks, and its freshness// is stated with the rest. Fetched and stored as one — see `DRIVE_PASS`.- if wanted("drive") {- reports.push(match ctx.drive.as_deref() {+ let drive = async {+ if !wanted("drive") {+ return None;+ }+ let report = match ctx.drive.as_deref() {None => unavailable("drive", "iCloud Drive"),Some(root) => {let _one = crate::DRIVE_PASS.lock().await;@@ -342,13 +387,18 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&st).await}- });- }+ };+ landed(report.service);+ Some(report)+ };// Photos: the whole library through the change feed once, then only what changed — under// half a second when nothing did. Fetched and stored as one: see `PHOTOS_PASS`.- if wanted("photos") {- reports.push(match ctx.cloudkit.as_deref() {+ let photos = async {+ if !wanted("photos") {+ return None;+ }+ let report = match ctx.cloudkit.as_deref() {None => unavailable("photos", "Photos"),Some(root) => {let _one = crate::PHOTOS_PASS.lock().await;@@ -375,14 +425,36 @@ async fn run(client: &Arc<Mutex<Client>>, data: &Mutex<Library>, services: &[&stlibrary.mark_full_sync(quince_icloud::photos::SERVICE)?;}crate::photos::remember(links);- let n = library.photos(quince_core::photos::View::Library)?.len();+ // Counted, not read: every row of the library loaded to say how many+ // there were held the library's lock through each pass.+ let n = library+ .photo_counts()?+ .into_iter()+ .find(|(v, _)| *v == quince_core::photos::View::Library)+ .map_or(0, |(_, n)| usize::try_from(n).unwrap_or(0));Ok(format!("{n} photo{}", plural(n)))},).await}- });+ };+ landed(report.service);+ Some(report)+ };++ let (calendar, reminders, notes, contacts, drive, photos) =+ tokio::join!(calendar, reminders, notes, contacts, drive, photos);+ // Apple answered: whatever waits to be sent goes now, not on the outbox's own timer.+ if [&reminders, ¬es, &contacts]+ .iter()+ .any(|r| r.as_ref().is_some_and(|r| r.outcome == Outcome::Ok))+ {+ crate::outbox::kick();}+ let reports: Vec<ServiceReport> = [calendar, reminders, notes, contacts, drive, photos]+ .into_iter()+ .flatten()+ .collect();let available: Vec<&str> = reports.iter()@@ -493,7 +565,20 @@ wherelast_synced_at: None,};}- let result = fetched.and_then(|value| apply(&mut library, value));+ // SQLite is synchronous: a full pass's apply (a whole photo library, every reminder and its+ // alarms) is CPU and disk work that would otherwise sit on one of the runtime's few+ // workers, stalling every task queued behind it there — the pictures the window is asking+ // for among them. Run in place, its worker hands those tasks on first.+ let started = std::time::Instant::now();+ // And as one change: the records, the changes still waiting laid over them and the new+ // position land together, or — failing, or the app dying part way — none of them do.+ let result = tokio::task::block_in_place(|| {+ fetched.and_then(|value| library.atomically(|library| apply(library, value)))+ });+ let took = started.elapsed();+ if took > std::time::Duration::from_millis(50) {+ quiet!("{service}: stored in {} ms", took.as_millis());+ }match result {Ok(detail) => ServiceReport {service,diff --git a/src-tauri/src/reminders_cmds.rs b/src-tauri/src/reminders_cmds.rsnew file mode 100644index 0000000..3aa7944--- /dev/null+++ b/src-tauri/src/reminders_cmds.rs@@ -0,0 +1,201 @@+//! Reminders commands for what sits beside a reminder: tags, its link, an early alert, custom+//! smart lists, and sections. Reads come from the library; writes go to Apple (each refused+//! there while `REMINDER_DETAIL_WRITES` is off) and the library is read again after.++use crate::{Auth, Data, UiResult};+use quince_core::reminders::{+ Reminder, ReminderDetail, ReminderSection, ReminderSmartList, SmartListContents, TagCount,+};+use quince_icloud::reminders::details;+use tauri::State;++fn now() -> i64 {+ std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .map_or(0, |d| i64::try_from(d.as_secs()).unwrap_or(i64::MAX))+}++/// One reminder's tags, link and early alerts.+#[tauri::command]+pub async fn reminder_detail(guid: String, data: State<'_, Data>) -> UiResult<ReminderDetail> {+ let library = data.0.lock().await;+ library.reminder_detail(&guid).map_err(|e| e.to_string())+}++/// Every tag on the account, with how many reminders still to do carry each.+#[tauri::command]+pub async fn reminder_tags(data: State<'_, Data>) -> UiResult<Vec<TagCount>> {+ let library = data.0.lock().await;+ library.reminder_tags().map_err(|e| e.to_string())+}++/// Reminders still to do carrying a tag.+#[tauri::command]+pub async fn reminders_tagged(name: String, data: State<'_, Data>) -> UiResult<Vec<Reminder>> {+ let library = data.0.lock().await;+ library.reminders_tagged(&name).map_err(|e| e.to_string())+}++/// The account's smart lists, built-in and custom.+#[tauri::command]+pub async fn reminder_smart_lists(data: State<'_, Data>) -> UiResult<Vec<ReminderSmartList>> {+ let library = data.0.lock().await;+ library.reminder_smart_lists().map_err(|e| e.to_string())+}++/// What a custom smart list holds now, and any part of its filter not understood.+#[tauri::command]+pub async fn reminders_in_smart_list(+ guid: String,+ data: State<'_, Data>,+) -> UiResult<SmartListContents> {+ let library = data.0.lock().await;+ library+ .reminders_in_smart_list(&guid, now())+ .map_err(|e| e.to_string())+}++/// A write's result, with the library read again either way: on success it brings Apple's+/// copy, on a refusal it puts back whatever was shown ahead of Apple.+async fn finish<T>(+ result: Result<T, quince_icloud::Error>,+ http: &reqwest::Client,+ root: &str,+ params: Vec<(String, String)>,+ data: &State<'_, Data>,+) -> UiResult<T> {+ let refreshed = crate::resync_reminders(http, root, params, data).await;+ let value = result.map_err(|e| e.to_string())?;+ crate::settle(refreshed)?;+ Ok(value)+}++/// Tag a reminder.+#[tauri::command]+pub async fn reminder_tag_add(+ guid: String,+ name: String,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<()> {+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let made = details::add_tag_cloudkit(&http, &root, params.clone(), &guid, &name).await;+ finish(made.map(|_| ()), &http, &root, params, &data).await+}++/// Take a tag off a reminder.+#[tauri::command]+pub async fn reminder_tag_remove(+ guid: String,+ name: String,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<()> {+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let done = details::remove_tag_cloudkit(&http, &root, params.clone(), &guid, &name).await;+ finish(done, &http, &root, params, &data).await+}++/// Set a reminder's link, or clear it with `null`.+#[tauri::command]+pub async fn reminder_url_set(+ guid: String,+ url: Option<String>,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<()> {+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let url = url.filter(|u| !u.trim().is_empty());+ let done = details::set_url_cloudkit(&http, &root, params.clone(), &guid, url.as_deref()).await;+ finish(done, &http, &root, params, &data).await+}++/// Remind early: `count` units before it is due (unit 0 minutes, 1 hours, 2 days, 3 weeks,+/// 4 months), or `null` to clear.+#[tauri::command]+pub async fn reminder_early_alert_set(+ guid: String,+ count: Option<i64>,+ unit: Option<i64>,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<()> {+ let account = {+ let library = data.0.lock().await;+ library.early_alert_account().map_err(|e| e.to_string())?+ };+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let alert = count.map(|c| (c, unit.unwrap_or(0)));+ let done = details::set_early_alert_cloudkit(+ &http,+ &root,+ params.clone(),+ &guid,+ alert,+ account.as_deref(),+ )+ .await;+ finish(done, &http, &root, params, &data).await+}++/// Make a section in a list. Answers it, already stored.+#[tauri::command]+pub async fn reminder_section_create(+ list_guid: String,+ title: String,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<ReminderSection> {+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let made =+ details::create_section_cloudkit(&http, &root, params.clone(), &list_guid, &title).await;+ if let Ok(section) = &made {+ let mut library = data.0.lock().await;+ library+ .put_reminder_section_local(section)+ .map_err(|e| e.to_string())?;+ }+ finish(made, &http, &root, params, &data).await+}++/// Rename a section.+#[tauri::command]+pub async fn reminder_section_rename(+ guid: String,+ title: String,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<()> {+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let done = details::rename_section_cloudkit(&http, &root, params.clone(), &guid, &title).await;+ finish(done, &http, &root, params, &data).await+}++/// Move a reminder into a section of its list, or out of every one with `null`. Shown here+/// at once; a refusal puts it back as Apple has it.+#[tauri::command]+pub async fn reminder_section_move(+ list_guid: String,+ guid: String,+ section: Option<String>,+ auth: State<'_, Auth>,+ data: State<'_, Data>,+) -> UiResult<()> {+ {+ let mut library = data.0.lock().await;+ library+ .set_reminder_section(&guid, section.as_deref())+ .map_err(|e| e.to_string())?;+ }+ let (http, root, params) = crate::cloudkit_context(&auth).await?;+ let done = details::move_to_section_cloudkit(+ &http,+ &root,+ params.clone(),+ &list_guid,+ &guid,+ section.as_deref(),+ )+ .await;+ finish(done, &http, &root, params, &data).await+}diff --git a/src-tauri/src/settings.rs b/src-tauri/src/settings.rsnew file mode 100644index 0000000..b87e694--- /dev/null+++ b/src-tauri/src/settings.rs@@ -0,0 +1,314 @@+//! What Settings reads of this computer: how much room the local copy takes, the pictures+//! that can be let go of because Apple still has them, and whether this desktop shows alerts.+//!+//! Sizes are the disk the files really take — the Drive folder's cache is sparse, and a video+//! opened in another app is a hard link to its cached file — so the figure is what clearing+//! would give back, not what the files claim to be.++use std::collections::HashSet;+use std::path::{Path, PathBuf};++/// The local copy, by what it holds, in bytes on disk.+#[derive(Debug, Default, Clone, PartialEq, Eq, serde::Serialize)]+#[serde(rename_all = "camelCase")]+pub struct LocalStorage {+ /// Every record: calendars, reminders, notes' text, contacts, the Drive and Photos lists.+ pub library: u64,+ /// Photos' pictures and videos, and photos waiting to go up from the Photos folder.+ pub photos: u64,+ /// Notes' pictures and attachments.+ pub notes: u64,+ /// The Drive folder's downloads and what waits to go up from it, and file thumbnails.+ pub drive: u64,+ /// Everything else here: the window's own cache, other accounts set aside.+ pub other: u64,+ pub total: u64,+ /// What "Clear Cached Pictures" would give back.+ pub clearable: u64,+}++/// What belongs to each part, by name in the data folder.+const LIBRARY: [&str; 3] = ["library.db", "library.db-wal", "library.db-shm"];+const PHOTOS: [&str; 3] = ["photos", "photos-folder-cache", "photos-folder-writes"];+const NOTES: [&str; 2] = ["note-media", "note-files"];+const DRIVE: [&str; 3] = ["drive-cache", "drive-writes", "thumbnails"];++/// Pictures Apple still has, made or fetched for showing: let go of, each comes back when it+/// is next wanted. Photos' grid thumbnails are not among them (the grid is drawn from them),+/// nor is the Drive folder's cache (it holds what was chosen to Keep on This Computer), nor+/// anything waiting to be sent.+const CLEARABLE: [&str; 3] = ["photos", "note-media", "note-files"];+/// Drive's file thumbnails: wholly a cache.+const CLEARABLE_WHOLE: [&str; 1] = ["thumbnails"];++/// A file's identity, so one held under two names (a hard link) is counted once.+type Seen = HashSet<(u64, u64)>;++/// The room a file takes on disk, or nothing when it was counted already under another name.+fn on_disk(meta: &std::fs::Metadata, seen: &mut Seen) -> u64 {+ #[cfg(unix)]+ {+ use std::os::unix::fs::MetadataExt;+ if meta.nlink() > 1 && !seen.insert((meta.dev(), meta.ino())) {+ return 0;+ }+ meta.blocks().saturating_mul(512)+ }+ #[cfg(not(unix))]+ {+ let _ = seen;+ meta.len()+ }+}++/// Everything under `path` (never following a link out of it), in bytes on disk.+fn size_of(path: &Path, seen: &mut Seen) -> u64 {+ let Ok(meta) = std::fs::symlink_metadata(path) else {+ return 0;+ };+ if !meta.is_dir() {+ return if meta.is_file() {+ on_disk(&meta, seen)+ } else {+ 0+ };+ }+ std::fs::read_dir(path)+ .into_iter()+ .flatten()+ .flatten()+ .map(|e| size_of(&e.path(), seen))+ .sum()+}++/// Every file under `path`, a download still being written (`.part`) left out.+fn files_under(path: &Path, out: &mut Vec<PathBuf>) {+ let Ok(meta) = std::fs::symlink_metadata(path) else {+ return;+ };+ if meta.is_file() {+ if path.extension().is_none_or(|e| e != "part") {+ out.push(path.to_path_buf());+ }+ return;+ }+ if meta.is_dir() {+ for e in std::fs::read_dir(path).into_iter().flatten().flatten() {+ files_under(&e.path(), out);+ }+ }+}++/// The files "Clear Cached Pictures" removes, under the data folder `dir`.+fn clearable_files(dir: &Path) -> Vec<PathBuf> {+ let mut out = Vec::new();+ for name in CLEARABLE {+ let Ok(entries) = std::fs::read_dir(dir.join(name)) else {+ continue;+ };+ for e in entries.flatten() {+ // Photos keeps its pictures a folder per size; the grid's thumbnails stay.+ let photos_thumbs = name == "photos" && e.file_name() == "thumb";+ // A file loose at the head of photos/ is none of Photos' sizes: not known, so kept.+ let loose = name == "photos" && e.path().is_file();+ if !photos_thumbs && !loose {+ files_under(&e.path(), &mut out);+ }+ }+ }+ for name in CLEARABLE_WHOLE {+ files_under(&dir.join(name), &mut out);+ }+ out+}++/// How the data folder `dir` is used.+pub fn measure(dir: &Path) -> LocalStorage {+ let mut seen = Seen::new();+ let mut part =+ |names: &[&str]| -> u64 { names.iter().map(|n| size_of(&dir.join(n), &mut seen)).sum() };+ let library = part(&LIBRARY);+ let photos = part(&PHOTOS);+ let notes = part(&NOTES);+ let drive = part(&DRIVE);+ let named: Vec<&str> = [&LIBRARY[..], &PHOTOS, &NOTES, &DRIVE].concat();+ let rest: Vec<String> = std::fs::read_dir(dir)+ .into_iter()+ .flatten()+ .flatten()+ .map(|e| e.file_name().to_string_lossy().into_owned())+ .filter(|n| !named.contains(&n.as_str()))+ .collect();+ let other = rest.iter().map(|n| size_of(&dir.join(n), &mut seen)).sum();+ let mut seen = Seen::new();+ let clearable = clearable_files(dir)+ .iter()+ .filter_map(|p| std::fs::symlink_metadata(p).ok())+ .map(|m| on_disk(&m, &mut seen))+ .sum();+ LocalStorage {+ library,+ photos,+ notes,+ drive,+ other,+ total: library + photos + notes + drive + other,+ clearable,+ }+}++/// Remove the cached pictures under `dir`, answering how the folder is used after. Files only:+/// the folders stay, so a picture being saved this moment never finds its folder gone.+pub fn clear(dir: &Path) -> LocalStorage {+ for f in clearable_files(dir) {+ let _ = std::fs::remove_file(f);+ }+ measure(dir)+}++/// How much room the local copy takes on this computer. Walked off the main thread.+#[tauri::command]+pub async fn local_storage(app: tauri::AppHandle) -> Result<LocalStorage, String> {+ let dir = crate::state_dir(&app);+ tauri::async_runtime::spawn_blocking(move || measure(&dir))+ .await+ .map_err(|e| e.to_string())+}++/// Let go of the pictures Apple still has (see `CLEARABLE`); answers how the copy is used now.+#[tauri::command]+pub async fn local_storage_clear(app: tauri::AppHandle) -> Result<LocalStorage, String> {+ let dir = crate::state_dir(&app);+ tauri::async_runtime::spawn_blocking(move || clear(&dir))+ .await+ .map_err(|e| e.to_string())+}++/// Whether this desktop shows alerts: on Linux an alert is shown by a notification service,+/// and a desktop without one (a bare window manager) drops every alert silently. The question+/// is the one an alert asks first — the same D-Bus service, started on demand as an alert would+/// start it. `None` where the system always shows them, or the answer did not come in time.+#[tauri::command]+pub async fn alerts_shown() -> Option<bool> {+ #[cfg(all(unix, not(target_os = "macos")))]+ {+ let ask =+ tauri::async_runtime::spawn_blocking(|| notify_rust::get_server_information().is_ok());+ tokio::time::timeout(std::time::Duration::from_secs(4), ask)+ .await+ .ok()+ .and_then(Result::ok)+ }+ #[cfg(not(all(unix, not(target_os = "macos"))))]+ None+}++#[cfg(test)]+mod tests {+ use super::*;++ fn put(dir: &Path, rel: &str, bytes: usize) {+ let p = dir.join(rel);+ std::fs::create_dir_all(p.parent().unwrap()).unwrap();+ std::fs::write(p, vec![7u8; bytes]).unwrap();+ }++ /// A data folder as the app leaves it: the library, every cache, things waiting to go up.+ fn folder() -> tempfile::TempDir {+ let t = tempfile::tempdir().unwrap();+ let d = t.path();+ put(d, "library.db", 40_000);+ put(d, "library.db-wal", 8_000);+ put(d, "photos/thumb/A", 10_000);+ put(d, "photos/medium/A", 50_000);+ put(d, "photos/original/V", 200_000);+ put(d, "photos/fit/512/A", 20_000);+ put(d, "photos/full/B.part", 30_000);+ put(d, "photos/LOOSE", 5_000);+ put(d, "photos-folder-writes/outgoing/h/IMG.HEIC", 60_000);+ put(d, "note-media/n1-preview", 12_000);+ put(d, "note-files/n1/Scan.pdf", 12_000);+ put(d, "drive-cache/FILE__x", 16_000);+ put(d, "drive-cache/.kept.json", 100);+ put(d, "drive-writes/journal", 4_000);+ put(d, "thumbnails/F-1", 3_000);+ put(d, "WebKitCache/blob", 9_000);+ put(d, "accounts/abc/library.db", 9_000);+ t+ }++ #[test]+ fn the_parts_add_up_to_the_whole() {+ let t = folder();+ let s = measure(t.path());+ assert!(s.library >= 48_000 && s.photos >= 375_000 && s.notes >= 24_000);+ assert!(s.drive >= 23_000 && s.other >= 18_000);+ assert_eq!(s.total, s.library + s.photos + s.notes + s.drive + s.other);+ assert!(s.clearable > 0 && s.clearable < s.total);+ }++ #[test]+ fn clearing_keeps_the_library_thumbnails_and_what_waits_to_go_up() {+ let t = folder();+ let d = t.path();+ let before = measure(d);+ let after = clear(d);+ for kept in [+ "library.db",+ "library.db-wal",+ "photos/thumb/A",+ "photos/full/B.part",+ "photos/LOOSE",+ "photos-folder-writes/outgoing/h/IMG.HEIC",+ "drive-cache/FILE__x",+ "drive-cache/.kept.json",+ "drive-writes/journal",+ "WebKitCache/blob",+ "accounts/abc/library.db",+ ] {+ assert!(d.join(kept).exists(), "{kept} was kept");+ }+ for gone in [+ "photos/medium/A",+ "photos/original/V",+ "photos/fit/512/A",+ "note-media/n1-preview",+ "note-files/n1/Scan.pdf",+ "thumbnails/F-1",+ ] {+ assert!(!d.join(gone).exists(), "{gone} was cleared");+ }+ // The folders stay, for a picture being saved this moment.+ assert!(d.join("photos/medium").is_dir() && d.join("note-media").is_dir());+ assert_eq!(after.clearable, 0);+ assert_eq!(before.total - after.total, before.clearable);+ assert_eq!(after.library, before.library);+ }++ #[cfg(unix)]+ #[test]+ fn a_file_under_two_names_is_counted_once() {+ let t = folder();+ let d = t.path();+ std::fs::create_dir_all(d.join("photos/open/V")).unwrap();+ let before = measure(d);+ std::fs::hard_link(+ d.join("photos/original/V"),+ d.join("photos/open/V/Clip.mov"),+ )+ .unwrap();+ let linked = measure(d);+ assert_eq!(linked.total, before.total);+ assert_eq!(linked.clearable, before.clearable);+ clear(d);+ assert!(!d.join("photos/open/V/Clip.mov").exists());+ }++ #[test]+ fn an_empty_or_missing_folder_is_nothing() {+ let t = tempfile::tempdir().unwrap();+ assert_eq!(measure(t.path()), LocalStorage::default());+ assert_eq!(measure(&t.path().join("none")), LocalStorage::default());+ assert_eq!(clear(&t.path().join("none")), LocalStorage::default());+ }+}diff --git a/src-tauri/src/video.rs b/src-tauri/src/video.rsindex 587e8e2..411f703 100644--- a/src-tauri/src/video.rs+++ b/src-tauri/src/video.rs@@ -3,6 +3,13 @@//! a page of ours may not load `file://`. So the disk cache's videos are served over HTTP on//! the loopback interface: a port of the system's choosing, a fresh secret in every path, only//! cached videos by asset id, in the ranges the player asks for, streamed from disk.+//!+//! Only the window can read it. The port is open to every program and every user on this+//! computer, and to any web page a browser here shows, so a request is answered only when it+//! carries the secret (122 random bits, made at each start and given to the window alone), is+//! addressed to `127.0.0.1:<port>` by name (a page that rebinds its own name to this computer+//! still says its own name), and comes from no web page (no `Origin` but the app's). No CORS+//! header is ever sent, so a page that guessed everything still could not read the answer.use crate::photos::{self, Film, Size};use std::sync::OnceLock;@@ -45,10 +52,26 @@ whereF: Fn(String, Size) -> Fut + Clone + Send + Sync + 'static,Fut: std::future::Future<Output = Result<Film, String>> + Send,{- while let Ok((stream, _)) = listener.accept().await {- let (find, secret) = (find.clone(), secret.clone());+ let Ok(addr) = listener.local_addr() else {+ return;+ };+ let host = format!("127.0.0.1:{}", addr.port());+ while let Ok((stream, peer)) = listener.accept().await {+ // Bound to loopback, so nothing else can connect; checked all the same.+ if !peer.ip().is_loopback() {+ continue;+ }+ let (find, secret, host) = (find.clone(), secret.clone(), host.clone());tauri::async_runtime::spawn(async move {- let _ = answer(find, &secret, stream).await;+ let _ = answer(+ find,+ &Gate {+ secret: &secret,+ host: &host,+ },+ stream,+ )+ .await;});}}@@ -62,8 +85,33 @@ struct Asked {head: bool,}+/// What a request must show to be answered: the secret in its path, and this server's own+/// address as its `Host`.+struct Gate<'a> {+ secret: &'a str,+ host: &'a str,+}++/// The same bytes, compared in a time that does not tell how many matched.+fn same(a: &[u8], b: &[u8]) -> bool {+ a.len() == b.len() && a.iter().zip(b).fold(0u8, |d, (x, y)| d | (x ^ y)) == 0+}++/// Every value a header is given, in order: a request that names two hosts is refused, not+/// read one way here and another elsewhere.+fn headers<'a>(lines: &'a [String], name: &str) -> Vec<&'a str> {+ lines+ .iter()+ .skip(1)+ .filter_map(|l| {+ let (k, v) = l.split_once(':')?;+ k.trim().eq_ignore_ascii_case(name).then_some(v.trim())+ })+ .collect()+}+/// The request line and headers, read up to the blank line; anything not ours is `None`.-fn parse(secret: &str, lines: &[String]) -> Option<Asked> {+fn parse(gate: &Gate<'_>, lines: &[String]) -> Option<Asked> {let mut first = lines.first()?.split_whitespace();let method = first.next()?;let head = match method {@@ -72,17 +120,29 @@ fn parse(secret: &str, lines: &[String]) -> Option<Asked> {_ => return None,};let path = first.next()?.split('?').next()?;- let rest = path.strip_prefix('/')?.strip_prefix(secret)?;+ // Addressed to this server by its own address: a web page whose name was rebound to this+ // computer (DNS rebinding) still sends its own name.+ match headers(lines, "host").as_slice() {+ [host] if same(host.as_bytes(), gate.host.as_bytes()) => {}+ _ => return None,+ }+ // Asked by the window's player, never by a web page: one sends an `Origin` of its own.+ if headers(lines, "origin")+ .iter()+ .any(|o| !matches!(*o, "tauri://localhost" | "http://tauri.localhost"))+ {+ return None;+ }+ let rest = path.strip_prefix('/')?;+ let (key, rest) = rest.split_at_checked(gate.secret.len())?;+ if !same(key.as_bytes(), gate.secret.as_bytes()) {+ return None;+ }let (id, size) = photos::requested(&format!("pic{rest}"))?;if !matches!(size, Size::Original | Size::Video) {return None;}- let range = lines.iter().skip(1).find_map(|l| {- let (k, v) = l.split_once(':')?;- k.trim()- .eq_ignore_ascii_case("range")- .then(|| v.trim().to_string())- });+ let range = headers(lines, "range").first().map(|v| (*v).to_string());Some(Asked {id,size,@@ -91,7 +151,7 @@ fn parse(secret: &str, lines: &[String]) -> Option<Asked> {})}-async fn answer<F, Fut>(find: F, secret: &str, stream: TcpStream) -> std::io::Result<()>+async fn answer<F, Fut>(find: F, gate: &Gate<'_>, stream: TcpStream) -> std::io::Result<()>whereF: Fn(String, Size) -> Fut,Fut: std::future::Future<Output = Result<Film, String>>,@@ -112,7 +172,7 @@ wherelines.push(line);}let mut stream = reader.into_inner();- let Some(asked) = parse(secret, &lines) else {+ let Some(asked) = parse(gate, &lines) else {return status(&mut stream, "404 Not Found", "").await;};let Ok(film) = find(asked.id.clone(), asked.size).await else {@@ -228,7 +288,14 @@ mod tests {use super::*;/// One raw request to the server, and its whole answer: head and body.+ /// Sent as the window's player sends it, addressed to the server by its own address — unless+ /// the request names a host of its own.async fn get(port: u16, request: &str) -> (String, Vec<u8>) {+ let request = if request.to_ascii_lowercase().contains("\r\nhost:") {+ request.to_string()+ } else {+ request.replacen("\r\n", &format!("\r\nHost: 127.0.0.1:{port}\r\n"), 1)+ };let mut s = TcpStream::connect(("127.0.0.1", port)).await.unwrap();s.write_all(request.as_bytes()).await.unwrap();let mut all = Vec::new();@@ -262,7 +329,7 @@ mod tests {}}));- let (head, body) = get(port, "GET /k3y/v1/original HTTP/1.1\r\nHost: x\r\n\r\n").await;+ let (head, body) = get(port, "GET /k3y/v1/original HTTP/1.1\r\n\r\n").await;assert!(head.starts_with("HTTP/1.1 200 OK"), "{head}");assert!(head.contains("Accept-Ranges: bytes") && head.contains("Content-Type: video/mp4")@@ -308,6 +375,31 @@ mod tests {assert!(head.starts_with("HTTP/1.1 404"), "{head}");let (head, _) = get(port, "GET /k3y/v2/original HTTP/1.1\r\n\r\n").await;assert!(head.starts_with("HTTP/1.1 404"), "{head}");+ // The secret alone is not enough: a page whose name was rebound to this computer,+ // a request with no host, a web page's own request — none is read.+ for refused in [+ "GET /k3y/v1/original HTTP/1.1\r\nHost: evil.example:80\r\n\r\n".to_string(),+ format!("GET /k3y/v1/original HTTP/1.1\r\nHost: localhost:{port}\r\n\r\n"),+ format!(+ "GET /k3y/v1/original HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\n\+ Host: evil.example\r\n\r\n"+ ),+ "GET /k3y/v1/original HTTP/1.0\r\nHost:\r\n\r\n".to_string(),+ "GET /k3y/v1/original HTTP/1.1\r\nOrigin: https://evil.example\r\n\r\n".to_string(),+ ] {+ let (head, body) = get(port, &refused).await;+ assert!(head.starts_with("HTTP/1.1 404"), "{refused}: {head}");+ assert!(+ body.is_empty() && !head.contains("Access-Control"),+ "{head}"+ );+ }+ let (head, _) = get(+ port,+ "GET /k3y/v1/original HTTP/1.1\r\nOrigin: tauri://localhost\r\n\r\n",+ )+ .await;+ assert!(head.starts_with("HTTP/1.1 200"), "{head}");std::fs::remove_dir_all(&dir).ok();});}@@ -393,16 +485,22 @@ mod tests {);}- fn lines(s: &[&str]) -> Vec<String> {- s.iter().map(|l| l.to_string()).collect()+ /// A request to a server whose secret is `s3cret`, addressed to it as the player does.+ fn ask(s: &[&str]) -> Option<Asked> {+ let mut l: Vec<String> = s.iter().map(|l| l.to_string()).collect();+ l.insert(1, "Host: 127.0.0.1:9".into());+ parse(+ &Gate {+ secret: "s3cret",+ host: "127.0.0.1:9",+ },+ &l,+ )}#[test]fn only_our_secret_and_only_videos() {- let ok = parse(- "s3cret",- &lines(&["GET /s3cret/abc-1/original HTTP/1.1", "Range: bytes=0-"]),- );+ let ok = ask(&["GET /s3cret/abc-1/original HTTP/1.1", "Range: bytes=0-"]);assert_eq!(ok,Some(Asked {@@ -412,35 +510,14 @@ mod tests {head: false}));- let live = parse("s3cret", &lines(&["HEAD /s3cret/abc/video HTTP/1.1"])).unwrap();+ let live = ask(&["HEAD /s3cret/abc/video HTTP/1.1"]).unwrap();assert!(live.head && live.size == Size::Video && live.range.is_none());// Someone else's guess, a picture, a path out of the cache, another method.- assert_eq!(- parse("s3cret", &lines(&["GET /wrong/abc/original HTTP/1.1"])),- None- );- assert_eq!(- parse("s3cret", &lines(&["GET /s3cret/abc/full HTTP/1.1"])),- None- );- assert_eq!(- parse("s3cret", &lines(&["GET /s3cret/../x/original HTTP/1.1"])),- None- );- assert_eq!(- parse(- "s3cret",- &lines(&["GET /s3cret/a%2F..%2Fb/original HTTP/1.1"])- ),- None- );- assert_eq!(- parse("s3cret", &lines(&["POST /s3cret/abc/original HTTP/1.1"])),- None- );- assert_eq!(- parse("s3cret", &lines(&["GET /s3cretabc/original HTTP/1.1"])),- None- );+ assert_eq!(ask(&["GET /wrong/abc/original HTTP/1.1"]), None);+ assert_eq!(ask(&["GET /s3cret/abc/full HTTP/1.1"]), None);+ assert_eq!(ask(&["GET /s3cret/../x/original HTTP/1.1"]), None);+ assert_eq!(ask(&["GET /s3cret/a%2F..%2Fb/original HTTP/1.1"]), None);+ assert_eq!(ask(&["POST /s3cret/abc/original HTTP/1.1"]), None);+ assert_eq!(ask(&["GET /s3cretabc/original HTTP/1.1"]), None);}}diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.jsonindex 882f8e5..e9b61d8 100644--- a/src-tauri/tauri.conf.json+++ b/src-tauri/tauri.conf.json@@ -2,7 +2,7 @@"$schema": "https://schema.tauri.app/config/2","productName": "Pomander","version": "0.1.0",- "identifier": "dev.quince.client",+ "identifier": "io.github.yashwanthkamireddi.Pomander","build": {"frontendDist": "../dist","beforeBuildCommand": "npm run build"@@ -38,6 +38,22 @@"icons/icon.png"],"category": "Productivity",+ "fileAssociations": [+ {+ "ext": ["ics", "ical", "icalendar"],+ "name": "iCalendar",+ "description": "Calendar events",+ "mimeType": "text/calendar",+ "role": "Viewer"+ },+ {+ "ext": ["vcf", "vcard"],+ "name": "vCard",+ "description": "Contact card",+ "mimeType": "text/vcard",+ "role": "Viewer"+ }+ ],"shortDescription": "Your iCloud, on this computer","longDescription": "Pomander keeps your iCloud notes, reminders, calendar, contacts, Drive and photos on your own computer, so they open instantly and work offline. An independent project, not affiliated with or endorsed by Apple Inc. iCloud is a trademark of Apple Inc.","licenseFile": "../LICENSE",@@ -59,15 +75,15 @@"libsecret-1-0","libheif1"],- "desktopTemplate": "../packaging/dev.quince.client.desktop.in",+ "desktopTemplate": "../packaging/io.github.yashwanthkamireddi.Pomander.desktop.in","files": {- "/usr/share/metainfo/dev.quince.client.metainfo.xml": "../packaging/dev.quince.client.metainfo.xml",- "/usr/share/applications/dev.quince.client.Notes.desktop": "../packaging/apps/dev.quince.client.Notes.desktop",- "/usr/share/applications/dev.quince.client.Reminders.desktop": "../packaging/apps/dev.quince.client.Reminders.desktop",- "/usr/share/applications/dev.quince.client.Calendar.desktop": "../packaging/apps/dev.quince.client.Calendar.desktop",- "/usr/share/applications/dev.quince.client.Contacts.desktop": "../packaging/apps/dev.quince.client.Contacts.desktop",- "/usr/share/applications/dev.quince.client.Drive.desktop": "../packaging/apps/dev.quince.client.Drive.desktop",- "/usr/share/applications/dev.quince.client.Photos.desktop": "../packaging/apps/dev.quince.client.Photos.desktop"+ "/usr/share/metainfo/io.github.yashwanthkamireddi.Pomander.metainfo.xml": "../packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xml",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Notes.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Notes.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Reminders.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Reminders.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Calendar.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Calendar.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Contacts.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Contacts.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Drive.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Drive.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Photos.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Photos.desktop"}},"rpm": {@@ -75,15 +91,15 @@"libsecret","libheif"],- "desktopTemplate": "../packaging/dev.quince.client.desktop.in",+ "desktopTemplate": "../packaging/io.github.yashwanthkamireddi.Pomander.desktop.in","files": {- "/usr/share/metainfo/dev.quince.client.metainfo.xml": "../packaging/dev.quince.client.metainfo.xml",- "/usr/share/applications/dev.quince.client.Notes.desktop": "../packaging/apps/dev.quince.client.Notes.desktop",- "/usr/share/applications/dev.quince.client.Reminders.desktop": "../packaging/apps/dev.quince.client.Reminders.desktop",- "/usr/share/applications/dev.quince.client.Calendar.desktop": "../packaging/apps/dev.quince.client.Calendar.desktop",- "/usr/share/applications/dev.quince.client.Contacts.desktop": "../packaging/apps/dev.quince.client.Contacts.desktop",- "/usr/share/applications/dev.quince.client.Drive.desktop": "../packaging/apps/dev.quince.client.Drive.desktop",- "/usr/share/applications/dev.quince.client.Photos.desktop": "../packaging/apps/dev.quince.client.Photos.desktop"+ "/usr/share/metainfo/io.github.yashwanthkamireddi.Pomander.metainfo.xml": "../packaging/io.github.yashwanthkamireddi.Pomander.metainfo.xml",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Notes.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Notes.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Reminders.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Reminders.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Calendar.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Calendar.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Contacts.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Contacts.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Drive.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Drive.desktop",+ "/usr/share/applications/io.github.yashwanthkamireddi.Pomander.Photos.desktop": "../packaging/apps/io.github.yashwanthkamireddi.Pomander.Photos.desktop"}},"appimage": {diff --git a/src-tauri/tests/intake/family.ics b/src-tauri/tests/intake/family.icsnew file mode 100644index 0000000..dc304d0--- /dev/null+++ b/src-tauri/tests/intake/family.ics@@ -0,0 +1,74 @@+BEGIN:VCALENDAR+VERSION:2.0+PRODID:-//Example//Family//EN+BEGIN:VEVENT+UID:goa+DTSTART;VALUE=DATE:20261224+DTEND;VALUE=DATE:20261227+SUMMARY:Holiday in Goa+END:VEVENT+BEGIN:VEVENT+UID:gym+DTSTART;TZID=Asia/Kolkata:20261102T070000+DTEND;TZID=Asia/Kolkata:20261102T080000+RRULE:FREQ=WEEKLY;BYDAY=MO;COUNT=10;WKST=MO+SUMMARY:Gym+END:VEVENT+BEGIN:VEVENT+UID:rent+DTSTART;VALUE=DATE:20270101+RRULE:FREQ=MONTHLY;UNTIL=20270601+SUMMARY:Rent+END:VEVENT+BEGIN:VEVENT+UID:sync+DTSTART:20261102T043000Z+DTEND:20261102T050000Z+RRULE:FREQ=DAILY;INTERVAL=2+SUMMARY:Team sync+END:VEVENT+BEGIN:VEVENT+UID:lunch+DTSTART:20261103T130000+DURATION:PT45M+SUMMARY:Floating lunch+END:VEVENT+BEGIN:VEVENT+UID:classes+DTSTART;TZID=Asia/Kolkata:20261102T090000+DTEND;TZID=Asia/Kolkata:20261102T100000+RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR+SUMMARY:Classes+END:VEVENT+BEGIN:VEVENT+UID:book+DTSTART;TZID=Asia/Kolkata:20261110T190000+RRULE:FREQ=MONTHLY;BYDAY=2TU+SUMMARY:Book club+END:VEVENT+BEGIN:VEVENT+UID:standup+DTSTART;TZID=Asia/Kolkata:20261102T093000+DTEND;TZID=Asia/Kolkata:20261102T094500+RRULE:FREQ=DAILY+EXDATE;TZID=Asia/Kolkata:20261104T093000+SUMMARY:Standup+END:VEVENT+BEGIN:VEVENT+UID:standup+RECURRENCE-ID;TZID=Asia/Kolkata:20261105T093000+DTSTART;TZID=Asia/Kolkata:20261105T100000+DTEND;TZID=Asia/Kolkata:20261105T101500+SUMMARY:Standup+END:VEVENT+BEGIN:VEVENT+UID:gone+DTSTART:20261106T100000Z+STATUS:CANCELLED+SUMMARY:Cancelled thing+END:VEVENT+BEGIN:VTODO+UID:milk+SUMMARY:Buy milk+END:VTODO+END:VCALENDARdiff --git a/src-tauri/tests/intake/invite.ics b/src-tauri/tests/intake/invite.icsnew file mode 100644index 0000000..406f4ff--- /dev/null+++ b/src-tauri/tests/intake/invite.ics@@ -0,0 +1,30 @@+BEGIN:VCALENDAR+VERSION:2.0+PRODID:-//Example Corp//Mail//EN+METHOD:REQUEST+BEGIN:VTIMEZONE+TZID:Europe/Berlin+BEGIN:STANDARD+DTSTART:19701025T030000+TZOFFSETFROM:+0200+TZOFFSETTO:+0100+END:STANDARD+END:VTIMEZONE+BEGIN:VEVENT+UID:[email protected]+DTSTAMP:20261020T120000Z+DTSTART;TZID=Europe/Berlin:20261105T100000+DTEND;TZID=Europe/Berlin:20261105T113000+SUMMARY:Design review\, round 2+LOCATION:Studio\; Room 4+DESCRIPTION:Bring the prototypes.\nAnd the+ notes.+ORGANIZER;CN="Asha Rao":mailto:[email protected]+ATTENDEE;CN=Ravi;RSVP=TRUE:mailto:[email protected]+BEGIN:VALARM+ACTION:DISPLAY+TRIGGER:-PT15M+DESCRIPTION:Reminder+END:VALARM+END:VEVENT+END:VCALENDARdiff --git a/src-tauri/tests/intake/outlook.ics b/src-tauri/tests/intake/outlook.icsnew file mode 100644index 0000000..a66f5f9--- /dev/null+++ b/src-tauri/tests/intake/outlook.ics@@ -0,0 +1,33 @@+BEGIN:VCALENDAR+PRODID:-//Microsoft Corporation//Outlook 16.0 MIMEDIR//EN+VERSION:2.0+BEGIN:VTIMEZONE+TZID:Eastern Standard Time+END:VTIMEZONE+BEGIN:VEVENT+DTSTART;TZID="Eastern Standard Time":20260714T090000+DTEND;TZID="Eastern Standard Time":20260714T100000+SUMMARY:Quarterly planning+END:VEVENT+BEGIN:VEVENT+DTSTART;TZID=/mozilla.org/20050126_1/Europe/Berlin:20260801T180000+DTEND;TZID=/mozilla.org/20050126_1/Europe/Berlin:20260801T200000+SUMMARY:Concert+BEGIN:VALARM+TRIGGER;VALUE=DATE-TIME:20260731T160000Z+ACTION:DISPLAY+END:VALARM+BEGIN:VALARM+TRIGGER;RELATED=START:PT0S+ACTION:DISPLAY+END:VALARM+BEGIN:VALARM+TRIGGER;RELATED=END:-PT5M+ACTION:DISPLAY+END:VALARM+END:VEVENT+BEGIN:VEVENT+DTSTART;TZID=Mars/Olympus_Mons:20260901T080000+SUMMARY:Launch+END:VEVENT+END:VCALENDARdiff --git a/src-tauri/tests/intake/people.vcf b/src-tauri/tests/intake/people.vcfnew file mode 100644index 0000000..9654752--- /dev/null+++ b/src-tauri/tests/intake/people.vcf@@ -0,0 +1,22 @@+BEGIN:VCARD+VERSION:3.0+N:Ahuja;Zoya;;;+FN:Zoya Ahuja+TEL;TYPE=CELL:+91 90000 00001+END:VCARD+BEGIN:VCARD+VERSION:3.0+N:Kumar;Ravi;;;+item1.TEL;type=pref:+91 98765 43210+EMAIL;TYPE=HOME:[email protected]+END:VCARD+BEGIN:VCARD+VERSION:3.0+N:;;;;+ORG:Northfield University;Admissions+EMAIL;TYPE=WORK:[email protected]+END:VCARD+BEGIN:VCARD+VERSION:2.1+N;CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:N=C3=BA=C3=B1ez;Jos=C3=A9;;;+END:VCARD