@telecrypt-io/storage 0.2.2 → 0.2.4

package/README.md

@@ -8,14 +8,14 @@ Files are encrypted on the client before upload. The server stores only opaque c
 never holds the decryption keys. Shared folders let multiple people add and read files, and a
 Recovery Key restores your files on a new device — even if you lose the original.
 
-**Status:** library source only. `@telecrypt-io/storage@0.2.2` is the current public release,
-published from this repository's protected `v0.2.2` tag with NPM Trusted Publishing/OIDC
+**Status:** library source only. `@telecrypt-io/storage@0.2.4` is the current public release,
+published from this repository's protected `v0.2.4` tag with NPM Trusted Publishing/OIDC
 provenance. The older `0.1.3` release is the immutable legacy combined library-and-CLI package.
 
 ## Install
 
 ```bash
-npm install @telecrypt-io/storage@0.2.2
+npm install @telecrypt-io/storage@0.2.4
 ```
 
 This gives you the `TeleCryptIOStorage` library and its browser-safe `core` API.

package/dist/core/operations.js

@@ -1,5 +1,47 @@
 import { CliError } from "./errors.js";
 import { waitForCondition } from "./poll.js";
+/**
+ * Production Synapse enforces the built-in rc_messages budget (per-account
+ * burst 10, refill 1/5s) on every room/state mutation the tree operations
+ * issue. A delete/decline sequence (kick members + leave + forget) can
+ * exceed the burst within seconds, so each operation retries on 429 with the
+ * server-advised backoff. Mirrors the harness library suite's
+ * `withRateLimitRetry`; must not mask non-rate-limit failures.
+ */
+const RATE_LIMIT_RETRIES = 6;
+function isRateLimited(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (!("isRateLimitError" in error))
+        return false;
+    const isRateLimitError = error.isRateLimitError;
+    return typeof isRateLimitError === "function" && isRateLimitError.call(error) === true;
+}
+async function withRateLimitRetry(label, operation) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (!isRateLimited(error) || attempt >= RATE_LIMIT_RETRIES)
+                throw error;
+            // The server's retry_after_ms only covers one token; tree operations
+            // need several (kick + leave + forget). Wait at least 15s so the
+            // burst refills.
+            let retryAfter = 15_000;
+            if (error instanceof Error && "getRetryAfterMs" in error) {
+                const getRetryAfterMs = error.getRetryAfterMs;
+                if (typeof getRetryAfterMs === "function") {
+                    const advised = getRetryAfterMs.call(error);
+                    if (typeof advised === "number" && Number.isFinite(advised) && advised > 0) {
+                        retryAfter = Math.max(retryAfter, advised);
+                    }
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, retryAfter));
+        }
+    }
+}
 /**
  * Resolves a folder by ID, polling briefly: a room this same account just
  * created (or was just invited to, by another process/session) can be
@@ -100,8 +142,17 @@ export async function listPendingInvites(storage) {
 }
 /** Decline a folder invite (same as leaving before join). */
 export async function declineInvite(storage, folderId) {
+    const client = storage.getClient();
     try {
-        await storage.getClient().leave(folderId);
+        await withRateLimitRetry("declineInvite", async () => {
+            await client.leave(folderId);
+            // The server only allows forgetting a room once this account's
+            // membership is `leave`; forgetting removes the room from the local
+            // store immediately, so a declined invite stops showing up in
+            // listFolders/listPendingInvites without waiting for the leave event
+            // to round-trip through the background sync loop.
+            await client.forget(folderId);
+        });
     }
     catch (err) {
         throw new CliError(`decline failed: ${err.message}`);
@@ -167,7 +218,22 @@ export async function renameFolder(storage, folderId, name) {
 }
 export async function deleteFolder(storage, folderId) {
     const tree = await resolveTree(storage, folderId);
-    await tree.delete();
+    // `tree.delete()` kicks members and leaves this room AND every
+    // subdirectory room, but never forgets any of them, so they all linger in
+    // the local store and listFolders keeps returning the deleted folder until
+    // the leave events round-trip through the background sync loop (30-60s
+    // under full-suite load). Forgetting removes each room from the local
+    // store immediately; the server only accepts a forget once membership is
+    // `leave`, which `tree.delete()` has just completed for the whole tree.
+    const subdirectoryIds = tree.getDirectories().map((d) => d.id);
+    const client = storage.getClient();
+    await withRateLimitRetry("deleteFolder", async () => {
+        await tree.delete();
+        await client.forget(folderId);
+        for (const subId of subdirectoryIds) {
+            await client.forget(subId);
+        }
+    });
     return { id: folderId, deleted: true };
 }
 export async function renameFile(storage, folderId, fileId, name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telecrypt-io/storage",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "license": "BUSL-1.1",
   "type": "module",
   "main": "dist/index.js",