selfstore 1.8.35 → 1.8.36

package/README.md

@@ -66,13 +66,17 @@ in the environment where writing a real file is easiest. Hand the shell's own
 calls over once and it comes back, on a real path:
 
 ```ts
-import { readFile, writeFile, stat, exists } from '@tauri-apps/plugin-fs';
+import { readFile, writeFile, rename, stat, exists } from '@tauri-apps/plugin-fs';
 import { save, open } from '@tauri-apps/plugin-dialog';
 import { useDesktopFiles } from 'selfstore';
 
-useDesktopFiles({ readFile, writeFile, stat, exists, save, open });
+useDesktopFiles({ readFile, writeFile, rename, stat, exists, save, open });
 ```
 
+`rename` is what makes a save safe: the backup is written beside the previous
+one and moved over it, so a full disk or a crash mid-write leaves the last good
+copy whole. Without it the file is overwritten in place.
+
 That is the whole integration. `connectFile()`, `file: true` in the connect
 flow and the widgets all keep meaning what they meant; they just write a path.
 The path outlives the session, so the app reopens on its file with nothing

package/dist/advanced.d.ts

@@ -1,12 +1,12 @@
-import { B as BackupTarget } from './store-B4Zo0f6G.js';
-export { A as AuthExpiredError, f as BuiltinTargetKind, E as EncodeOptions, H as Header, K as KdfParams, L as LocalStore, g as LocalStoreOptions, e as LocalStoreState, M as MirrorState, h as Mode, i as PasswordCheck, b as PasswordPolicy, j as PasswordRequirement, P as PeerSource, k as PeerState, R as RESERVED_COLLECTION_PREFIX, l as RESERVED_STORE_MODES, m as RecipientStanza, n as ReplicaState, o as SelfstoreError, p as SelfstoreErrorCode, q as Severity, a as Snapshot, c as SnapshotFile, r as StatusAction, d as StatusDescriptor, s as StatusInput, t as StorageState, S as StoreError, u as StoreGroupConfig, v as SyncJournalEntry, w as SyncSource, T as TargetKind, x as checkPasswordPolicy, y as createLocalStore, z as deriveStatus, C as errorLabelKey, D as isAuthExpired, F as isReservedStoreMode, G as isSelfstoreError } from './store-B4Zo0f6G.js';
-import { K as KV } from './cache-C1edLncd.js';
-export { C as CachedFile, L as LocalCache, e as LockableCache, i as indexedDbCache, f as isLockableCache, m as memoryCache } from './cache-C1edLncd.js';
-export { G as GisDriveAuthOptions, a as GisTokenPersistence, d as datedName, e as exportSnapshot, g as gisDriveAuth, i as importSnapshot, b as inspect, c as isEncrypted, p as pickFromDisk, f as preloadGoogleIdentity, s as saveToDisk } from './local-Cr5cCaQ2.js';
-import { c as connect$2, f as fromSession$2, a as connect$3, b as fromSession$3, p as peer } from './s3-C2PrgMpD.js';
-export { S as S3Config, d as S3ConnectOptions, W as WebdavConfig, e as WebdavConnectOptions, g as WebdavPeerOptions } from './s3-C2PrgMpD.js';
-import { c as connect$1, f as fromSession$1, p as preview, b as adopt, d as findOrCreateOwnFile, l as listBackups, e as createBackup, g as deleteBackup, r as renameBackup, h as account, i as createCompanion, s as share, u as unshare, o as owner, j as secondary } from './drive-3K6pBAmG.js';
-export { k as DriveAccount, a as DriveAuth, m as DriveBackupInfo, D as DriveOptions } from './drive-3K6pBAmG.js';
+import { B as BackupTarget } from './store-bp1VRW7R.js';
+export { A as AuthExpiredError, f as BuiltinTargetKind, E as EncodeOptions, H as Header, K as KdfParams, L as LocalStore, g as LocalStoreOptions, e as LocalStoreState, M as MirrorState, h as Mode, i as PasswordCheck, b as PasswordPolicy, j as PasswordRequirement, P as PeerSource, k as PeerState, R as RESERVED_COLLECTION_PREFIX, l as RESERVED_STORE_MODES, m as RecipientStanza, n as ReplicaState, o as SelfstoreError, p as SelfstoreErrorCode, q as Severity, a as Snapshot, c as SnapshotFile, r as StatusAction, d as StatusDescriptor, s as StatusInput, t as StorageState, S as StoreError, u as StoreGroupConfig, v as SyncJournalEntry, w as SyncSource, T as TargetKind, x as checkPasswordPolicy, y as createLocalStore, z as deriveStatus, C as errorLabelKey, D as isAuthExpired, F as isReservedStoreMode, G as isSelfstoreError } from './store-bp1VRW7R.js';
+import { K as KV } from './cache-DBIn_Uo8.js';
+export { C as CachedFile, L as LocalCache, e as LockableCache, i as indexedDbCache, f as isLockableCache, m as memoryCache } from './cache-DBIn_Uo8.js';
+export { G as GisDriveAuthOptions, a as GisTokenPersistence, d as datedName, e as exportSnapshot, g as gisDriveAuth, i as importSnapshot, b as inspect, c as isEncrypted, p as pickFromDisk, f as preloadGoogleIdentity, s as saveToDisk } from './local-CpoBeJWk.js';
+import { c as connect$2, f as fromSession$2, a as connect$3, b as fromSession$3, p as peer } from './s3-kikEHI-g.js';
+export { S as S3Config, d as S3ConnectOptions, W as WebdavConfig, e as WebdavConnectOptions, g as WebdavPeerOptions } from './s3-kikEHI-g.js';
+import { c as connect$1, f as fromSession$1, p as preview, b as adopt, d as findOrCreateOwnFile, l as listBackups, e as createBackup, g as deleteBackup, r as renameBackup, h as account, i as createCompanion, s as share, u as unshare, o as owner, j as secondary } from './drive-BCRil91Q.js';
+export { k as DriveAccount, a as DriveAuth, m as DriveBackupInfo, D as DriveOptions } from './drive-BCRil91Q.js';
 import './sync.js';
 
 /**

package/dist/advanced.js

@@ -1,6 +1,6 @@
 import { peer, fromSession as fromSession$3, connect as connect$3 } from './chunk-GHSHIDF3.js';
 import { fromSession as fromSession$2, connect as connect$2 } from './chunk-IDW3WQKF.js';
-export { RESERVED_STORE_MODES, createLocalStore, deriveStatus, gisDriveAuth, indexedDbCache, isLockableCache, isReservedStoreMode, memoryCache, preloadGoogleIdentity } from './chunk-SHX36MIE.js';
+export { RESERVED_STORE_MODES, createLocalStore, deriveStatus, gisDriveAuth, indexedDbCache, isLockableCache, isReservedStoreMode, memoryCache, preloadGoogleIdentity } from './chunk-JE3BLKXO.js';
 import './chunk-3P2W3XQD.js';
 export { datedName, pickFromDisk, saveToDisk } from './chunk-XAONTUEC.js';
 import './chunk-FJGWTBAL.js';

package/dist/backups.d.ts

@@ -1,8 +1,8 @@
-import { B as BackupsHost } from './manager-Bl16FR-e.js';
-export { a as BackupFileInfo, b as BackupOwner, c as BackupRow, d as BackupsErrorCode, e as BackupsKeys, f as BackupsManager, g as BackupsNaming, h as BackupsSnapshot, K as KnownBackups, i as createBackupsManager } from './manager-Bl16FR-e.js';
+import { B as BackupsHost } from './manager-0puQEpZc.js';
+export { a as BackupFileInfo, b as BackupOwner, c as BackupRow, d as BackupsErrorCode, e as BackupsKeys, f as BackupsManager, g as BackupsNaming, h as BackupsSnapshot, K as KnownBackups, i as createBackupsManager } from './manager-0puQEpZc.js';
 import { DriveOptions } from './advanced.js';
-import './cache-C1edLncd.js';
-import './store-B4Zo0f6G.js';
+import './cache-DBIn_Uo8.js';
+import './store-bp1VRW7R.js';
 import './sync.js';
 import './machine-Dhbx3Eut.js';
 

package/dist/{cache-C1edLncd.d.ts → cache-DBIn_Uo8.d.ts}

@@ -81,6 +81,12 @@ interface KV {
 }
 interface LocalCache {
     readonly kv: KV;
+    /** A key/value space whose VALUES are sealed under the same key as the
+     *  payload (the device key, or the session secret of a locked cache): for
+     *  the bookkeeping that is itself a secret - a share key, a mailbox id, an
+     *  invitation capability. A locked cache rejects it with PASSWORD_REQUIRED
+     *  until unlock(). Optional: a cache with nothing at rest has no need of it. */
+    readonly sealedKv?: KV;
     /** Load the persisted collections + files, or null if nothing was ever saved. */
     load(): Promise<{
         collections: Record<string, unknown[]>;

package/dist/{chunk-SHX36MIE.js → chunk-JE3BLKXO.js}

@@ -562,6 +562,11 @@ function createLocalStore(opts) {
     }
     return now !== null && now === p.marker ? p.blob : null;
   }
+  async function readIncoming(t) {
+    const blob = await takeFreshPrefetch(t) ?? await t.load();
+    if (blob && blob.size > 0) await inspect(blob);
+    return blob;
+  }
   async function statRemote() {
     if (!durable?.stat) return null;
     try {
@@ -999,9 +1004,9 @@ function createLocalStore(opts) {
     return entry;
   }
   const pull = (source) => serialize(() => doPull(source));
-  async function loadFromRemote() {
+  async function loadFromRemote(incoming) {
     if (!durable) return;
-    const remote = await takeFreshPrefetch(durable) ?? await durable.load();
+    const remote = incoming === void 0 ? await takeFreshPrefetch(durable) ?? await durable.load() : incoming;
     if (remote) {
       const decoded = await importLocked(remote);
       if (decoded === "locked") return;
@@ -1305,8 +1310,9 @@ function createLocalStore(opts) {
             "attachTarget(): this identity is not a member of the manifest - the admin must add it first."
           );
         }
-        await becomePersistent();
         const strategy = attachOpts?.strategy ?? "merge";
+        const incoming = strategy === "replace-local" ? await readIncoming(target) : void 0;
+        await becomePersistent();
         if (strategy === "replace-local" && durable && !locked() && !needsAttention) {
           await flushBeforeLeaving();
         }
@@ -1340,7 +1346,7 @@ function createLocalStore(opts) {
         await kv.set(KEY.targetKind, target.kind);
         needsAttention = false;
         notify();
-        if (strategy === "replace-local") await loadFromRemote();
+        if (strategy === "replace-local") await loadFromRemote(incoming);
         else if (strategy === "replace-remote") await doSave();
         else await doPull("connect");
         notify();
@@ -1867,20 +1873,13 @@ function isLockableCache(cache) {
 }
 function memoryCache() {
   const kvMap = /* @__PURE__ */ new Map();
+  const sealedMap = /* @__PURE__ */ new Map();
   let collections;
   const files = /* @__PURE__ */ new Map();
   return {
-    kv: {
-      async get(key) {
-        return kvMap.get(key);
-      },
-      async set(key, value) {
-        kvMap.set(key, value);
-      },
-      async del(key) {
-        kvMap.delete(key);
-      }
-    },
+    kv: mapKv(kvMap),
+    // Nothing is at rest, so "sealed" is a separate space, not a cipher.
+    sealedKv: mapKv(sealedMap),
     async load() {
       if (collections === void 0) return null;
       return { collections: structuredClone(collections), files: [...files.values()] };
@@ -1894,14 +1893,29 @@ function memoryCache() {
     },
     async clear() {
       kvMap.clear();
+      sealedMap.clear();
       collections = void 0;
       files.clear();
     }
   };
 }
+function mapKv(map) {
+  return {
+    async get(key) {
+      return map.get(key);
+    },
+    async set(key, value) {
+      map.set(key, value);
+    },
+    async del(key) {
+      map.delete(key);
+    }
+  };
+}
 var COLLECTIONS_KEY = "__collections";
 var DEVICE_KEY = "__deviceKey";
 var CACHE_KDF = "__cacheKdf";
+var SEALED_PREFIX = "s:";
 async function sealFile(k, meta, bytes) {
   const sealedMeta = await seal(k, new TextEncoder().encode(JSON.stringify(meta)));
   return { meta: sealedMeta, ...await seal(k, bytes) };
@@ -1972,10 +1986,31 @@ function indexedDbCache(name, opts) {
       await (await db()).delete("kv", `m:${key2}`);
     }
   };
+  const sealedKv = {
+    async get(k) {
+      const raw = await (await db()).get("kv", `${SEALED_PREFIX}${k}`);
+      if (raw === void 0) return void 0;
+      if (!isEnvelope(raw)) {
+        throw new SelfstoreError(
+          "BAD_FORMAT",
+          "Unrecognized cache record (not a sealed envelope)."
+        );
+      }
+      return JSON.parse(new TextDecoder().decode(await unseal(await key(), raw)));
+    },
+    async set(k, value) {
+      const env = await seal(await key(), new TextEncoder().encode(JSON.stringify(value)));
+      await (await db()).put("kv", env, `${SEALED_PREFIX}${k}`);
+    },
+    async del(k) {
+      await (await db()).delete("kv", `${SEALED_PREFIX}${k}`);
+    }
+  };
   const written = /* @__PURE__ */ new Map();
   const changed = (f, have) => !have.has(f.id) || written.has(f.id) && written.get(f.id) !== f.blob;
   const base = {
     kv,
+    sealedKv,
     async load() {
       const d = await db();
       const rawCollections = await d.get("kv", COLLECTIONS_KEY);
@@ -2070,11 +2105,19 @@ function indexedDbCache(name, opts) {
         const meta = await openFileMeta(previous, v);
         files.push({ id: fileKey, rec: await sealFile(next, meta, await unseal(previous, v)) });
       }
+      const sealedRecords = [];
+      for (const kvKey of await d.getAllKeys("kv")) {
+        if (typeof kvKey !== "string" || !kvKey.startsWith(SEALED_PREFIX)) continue;
+        const v = await d.get("kv", kvKey);
+        if (!isEnvelope(v)) continue;
+        sealedRecords.push({ id: kvKey, rec: await seal(next, await unseal(previous, v)) });
+      }
       const tx = d.transaction(["kv", "files"], "readwrite");
       const store = tx.objectStore("kv");
       if (kdf) store.put(kdf, CACHE_KDF);
       else store.delete(CACHE_KDF);
       if (collections) store.put(collections, COLLECTIONS_KEY);
+      for (const { id, rec } of sealedRecords) store.put(rec, id);
       const fileStore = tx.objectStore("files");
       for (const { id, rec } of files) fileStore.put(rec, id);
       await tx.done;
@@ -2236,5 +2279,5 @@ function gisDriveAuth(opts) {
 }
 
 export { RESERVED_STORE_MODES, createLocalStore, deriveStatus, gisDriveAuth, indexedDbCache, isLockableCache, isReservedStoreMode, memoryCache, preloadGoogleIdentity };
-//# sourceMappingURL=chunk-SHX36MIE.js.map
-//# sourceMappingURL=chunk-SHX36MIE.js.map
+//# sourceMappingURL=chunk-JE3BLKXO.js.map
+//# sourceMappingURL=chunk-JE3BLKXO.js.map