@telecrypt-io/storage 0.6.1 → 0.7.1

package/dist/core/operations.js

@@ -17,7 +17,7 @@ import { Method } from "matrix-js-sdk/lib/http-api/method.js";
 import { FileTooLargeError, MutationPartialError, MutationOutcomeUnknownError, NonEmptyTreeError, RoomCreationAmbiguousError, RoomCleanupIncompleteError, StorageError, } from "./errors.js";
 import { ConditionTimeoutError, waitForCondition } from "./poll.js";
 import { validateName } from "./validation.js";
-import { getDeletedTreeIds, isFileDeleted, isTreeDeleted, markFileDeleted, markTreeDeleted, } from "../deletion-markers.js";
+import { isFileDeleted, isTreeDeleted, markFileDeleted, markTreeDeleted, } from "../deletion-markers.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
@@ -100,9 +100,7 @@ function isRateLimited(error) {
 function requiresMutationReconciliation(error) {
     return (error instanceof MutationOutcomeUnknownError ||
         error instanceof RoomCreationAmbiguousError ||
-        error instanceof RoomCleanupIncompleteError ||
-        (error instanceof Error &&
-            error.cleanupIncomplete === true));
+        error instanceof RoomCleanupIncompleteError);
 }
 async function withRateLimitRetry(operation, signal) {
     for (;;) {
@@ -175,13 +173,9 @@ async function resolveTree(storage, treeId, signal) {
     }
 }
 function isMarkedTreeDeleted(storage, treeId) {
-    if (typeof storage.getClient !== "function")
-        return false;
     return isTreeDeleted(storage.getClient(), treeId);
 }
 function isMarkedFileDeleted(storage, treeId, fileId) {
-    if (typeof storage.getClient !== "function")
-        return false;
     return isFileDeleted(storage.getClient(), treeId, fileId);
 }
 /** As `resolveTree`, but for a specific file within an already-resolved
@@ -210,9 +204,7 @@ async function resolveFile(storage, tree, fileId, signal) {
  * room. This also prevents a folder/vault delete from silently deleting a
  * nested shared tree.
  */
-function assertTreeEmptyForDeletion(storage, tree, spaces) {
-    if (spaces.length !== 1)
-        throw new NonEmptyTreeError(tree.id);
+function assertTreeEmptyForDeletion(storage, tree) {
     let files;
     try {
         files = tree.listFiles().filter((file) => !isMarkedFileDeleted(storage, tree.id, file.id));
@@ -222,40 +214,74 @@ function assertTreeEmptyForDeletion(storage, tree, spaces) {
     }
     if (files.length > 0)
         throw new NonEmptyTreeError(tree.id);
+    const childEvents = readRelationEvents(storage.getClient(), tree.id, EventType.SpaceChild);
+    if (childEvents === null)
+        throw new StorageError("could not enumerate storage folders safely");
+    for (const event of childEvents) {
+        if (!isActiveRelationEvent(event))
+            continue;
+        const childId = relationStateKey(event);
+        if (!childId)
+            throw new StorageError("could not enumerate storage folders safely");
+        if (!isTreeDeleted(storage.getClient(), childId))
+            throw new NonEmptyTreeError(tree.id);
+    }
 }
 async function refreshDeletionRooms(storage, rootId, signal) {
     const client = storage.getClient();
-    const http = client.http;
-    // A real MatrixClient always exposes its authenticated HTTP transport. A
-    // client without one cannot prove that its local relation graph is current.
-    if (typeof http?.authedRequest !== "function") {
-        throw new StorageError("delete graph refresh is unavailable");
-    }
     await storage.refreshRoomState(rootId, { signal });
     if (signal?.aborted)
         throw new StorageError("operation cancelled");
-    // The refreshed root owns its parent relation. Verify its one supported
-    // external parent directly; unrelated local rooms are outside this deletion.
     const parentEvents = readRelationEvents(client, rootId, EventType.SpaceParent);
     if (parentEvents === null)
-        throw new StorageError("delete graph is unsafe");
+        throw new StorageError("could not enumerate storage parent safely");
     const parentIds = new Set();
     for (const event of parentEvents) {
         if (!isActiveRelationEvent(event))
             continue;
         const parentId = relationStateKey(event);
         if (!parentId)
-            throw new StorageError("delete graph is unsafe");
+            throw new StorageError("could not enumerate storage parent safely");
         if (parentId !== rootId)
             parentIds.add(parentId);
     }
     if (parentIds.size > 1)
-        throw new StorageError("delete graph is unsafe");
-    const parentId = parentIds.values().next().value;
-    if (parentId)
-        await storage.refreshRoomState(parentId, { signal });
+        throw new StorageError("storage room has multiple parents");
+    const parents = [...parentIds];
+    if (parents[0]) {
+        await storage.refreshRoomState(parents[0], { signal });
+        const childEvents = readRelationEvents(client, parents[0], EventType.SpaceChild, rootId);
+        if (childEvents === null ||
+            !childEvents.some((event) => isActiveRelationEvent(event) && relationStateKey(event, rootId) === rootId)) {
+            throw new StorageError("storage parent relation is inconsistent");
+        }
+    }
     if (signal?.aborted)
         throw new StorageError("operation cancelled");
+    return parents;
+}
+function snapshotTreeSpaces(root) {
+    const spaces = [];
+    const seen = new Set();
+    const pending = [root];
+    while (pending.length > 0) {
+        const tree = pending.pop();
+        if (!tree || seen.has(tree.id))
+            continue;
+        seen.add(tree.id);
+        spaces.push(tree);
+        let children;
+        try {
+            children = tree.getDirectories();
+        }
+        catch (error) {
+            if (error instanceof StorageError)
+                throw error;
+            throw new StorageError("could not enumerate storage folders", { cause: error });
+        }
+        pending.push(...children);
+    }
+    return spaces;
 }
 async function refreshTreeSpaces(storage, spaces, signal) {
     for (const space of spaces) {
@@ -286,126 +312,24 @@ function isActiveRelationEvent(event) {
 function activeTreeDirectories(client, tree) {
     const childEvents = readRelationEvents(client, tree.id, EventType.SpaceChild);
     if (childEvents === null)
-        throw new StorageError("delete graph is unsafe");
+        throw new StorageError("storage folder state is unavailable");
     const activeChildIds = new Set();
     for (const event of childEvents) {
         if (!isActiveRelationEvent(event))
             continue;
         const childId = relationStateKey(event);
         if (!childId)
-            throw new StorageError("delete graph is unsafe");
+            throw new StorageError("storage folder state is inconsistent");
         activeChildIds.add(childId);
     }
     const knownChildren = new Map(tree.getDirectories().map((child) => [child.id, child]));
     return [...activeChildIds].map((childId) => {
         const child = knownChildren.get(childId);
         if (!child)
-            throw new StorageError("delete graph is unsafe");
+            throw new StorageError("storage folder state is inconsistent");
         return child;
     });
 }
-function snapshotTreeSpaces(root, activeRelationClient) {
-    const spaces = [];
-    const seen = new Set();
-    const pending = [root];
-    while (pending.length > 0) {
-        const tree = pending.pop();
-        if (!tree)
-            continue;
-        if (seen.has(tree.id))
-            continue;
-        seen.add(tree.id);
-        spaces.push(tree);
-        let children;
-        try {
-            children = activeRelationClient
-                ? activeTreeDirectories(activeRelationClient, tree)
-                : tree.getDirectories();
-        }
-        catch (error) {
-            if (error instanceof StorageError)
-                throw error;
-            throw new StorageError("could not enumerate storage space descendants safely", { cause: error });
-        }
-        for (const child of children)
-            pending.push(child);
-    }
-    return spaces;
-}
-/**
- * Deletion is intentionally narrower than MSC3089TreeSpace.delete(): a local
- * child graph is not proof that the rooms are exclusively owned by this tree.
- * Validate every observed edge in both directions and reject any parent or
- * child edge outside the exact deletion set before the first mutation.
- */
-function validateDeletionGraph(client, root, ids, deletedRooms) {
-    const edges = new Set();
-    const externalParents = [];
-    const addEdge = (parentId, childId) => {
-        if (deletedRooms.has(childId))
-            return;
-        if (!ids.has(childId))
-            throw new StorageError("delete graph is unsafe");
-        edges.add(`${parentId}\u0000${childId}`);
-    };
-    for (const id of ids) {
-        const tree = client.unstableGetFileTreeSpace(id);
-        if (!tree)
-            throw new StorageError("delete graph is unsafe");
-        const directories = activeTreeDirectories(client, tree);
-        for (const child of directories)
-            addEdge(id, child.id);
-        const childEvents = readRelationEvents(client, id, EventType.SpaceChild);
-        if (childEvents === null)
-            throw new StorageError("delete graph is unsafe");
-        for (const event of childEvents) {
-            if (!isActiveRelationEvent(event))
-                continue;
-            const childId = relationStateKey(event);
-            if (!childId)
-                throw new StorageError("delete graph is unsafe");
-            addEdge(id, childId);
-        }
-    }
-    for (const edge of edges) {
-        const separator = edge.indexOf("\u0000");
-        const parentId = edge.slice(0, separator);
-        const childId = edge.slice(separator + 1);
-        const childLink = readRelationEvents(client, parentId, EventType.SpaceChild, childId);
-        const parentLink = readRelationEvents(client, childId, EventType.SpaceParent, parentId);
-        if (!childLink?.some((event) => isActiveRelationEvent(event) && relationStateKey(event, childId) === childId) ||
-            !parentLink?.some((event) => isActiveRelationEvent(event) && relationStateKey(event, parentId) === parentId)) {
-            throw new StorageError("delete graph is unsafe");
-        }
-    }
-    for (const id of ids) {
-        const parentEvents = readRelationEvents(client, id, EventType.SpaceParent);
-        if (parentEvents === null)
-            throw new StorageError("delete graph is unsafe");
-        for (const event of parentEvents) {
-            if (!isActiveRelationEvent(event))
-                continue;
-            const parentId = relationStateKey(event);
-            if (!parentId)
-                throw new StorageError("delete graph is unsafe");
-            if (!ids.has(parentId)) {
-                if (id !== root.id || externalParents.includes(parentId)) {
-                    throw new StorageError("delete graph is unsafe");
-                }
-                const childLink = readRelationEvents(client, parentId, EventType.SpaceChild, id);
-                if (!childLink?.some((candidate) => isActiveRelationEvent(candidate) && relationStateKey(candidate, id) === id)) {
-                    throw new StorageError("delete graph is unsafe");
-                }
-                externalParents.push(parentId);
-            }
-        }
-    }
-    if (!ids.has(root.id))
-        throw new StorageError("delete graph is unsafe");
-    if (externalParents.length > 1)
-        throw new StorageError("delete graph is unsafe");
-    return { externalParents };
-}
 async function unlinkExternalParents(storage, rootId, externalParents, signal) {
     const client = storage.getClient();
     let mutationAttempted = false;
@@ -417,10 +341,10 @@ async function unlinkExternalParents(storage, rootId, externalParents, signal) {
             // is not used here because it can be delayed or rejected independently of
             // the relation update.
             mutationAttempted = true;
-            await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.sendStateEvent(parentId, EventType.SpaceChild, {}, rootId), signal), signal);
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => client.sendStateEvent(parentId, EventType.SpaceChild, {}, rootId), signal), signal);
             if (signal?.aborted)
                 throw new StorageError("operation cancelled");
-            await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.sendStateEvent(rootId, EventType.SpaceParent, {}, parentId), signal), signal);
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => client.sendStateEvent(rootId, EventType.SpaceParent, {}, parentId), signal), signal);
             await storage.refreshRoomState(parentId, { signal });
             await storage.refreshRoomState(rootId, { signal });
             const childLink = readRelationEvents(client, parentId, EventType.SpaceChild, rootId);
@@ -461,8 +385,8 @@ async function relinkExternalParents(storage, rootId, externalParents, signal) {
     for (const parentId of externalParents) {
         if (signal?.aborted)
             throw new StorageError("operation cancelled");
-        await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.sendStateEvent(parentId, EventType.SpaceChild, { via: [via] }, rootId), signal), signal);
-        await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.sendStateEvent(rootId, EventType.SpaceParent, { via: [via] }, parentId), signal), signal);
+        await withRateLimitRetry(() => withMatrixMutationAbort(() => client.sendStateEvent(parentId, EventType.SpaceChild, { via: [via] }, rootId), signal), signal);
+        await withRateLimitRetry(() => withMatrixMutationAbort(() => client.sendStateEvent(rootId, EventType.SpaceParent, { via: [via] }, parentId), signal), signal);
         await storage.refreshRoomState(parentId, { signal });
         await storage.refreshRoomState(rootId, { signal });
         const childLink = readRelationEvents(client, parentId, EventType.SpaceChild, rootId);
@@ -487,10 +411,10 @@ async function deleteRoomDeterministically(storage, roomId, signal) {
         const client = storage.getClient();
         const tree = storage.getTree(roomId);
         if (!tree)
-            throw new StorageError("delete graph is unsafe");
+            throw new StorageError("storage room is unavailable for deletion");
         const self = client.getUserId();
         if (!self)
-            throw new StorageError("delete graph is unsafe");
+            throw new StorageError("Matrix user identity is unavailable");
         const members = await storage.listMembers(tree, { signal });
         if (members.some((member) => member.userId !== self && member.role === "owner" &&
             (member.membership === "join" || member.membership === "invite" || member.membership === "knock"))) {
@@ -503,7 +427,7 @@ async function deleteRoomDeterministically(storage, roomId, signal) {
                 continue;
             }
             try {
-                await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.kick(roomId, member.userId, "Room deleted"), signal), signal);
+                await withRateLimitRetry(() => withMatrixMutationAbort(() => client.kick(roomId, member.userId, "Room deleted"), signal), signal);
                 markRoomMutationComplete();
             }
             catch (error) {
@@ -523,7 +447,7 @@ async function deleteRoomDeterministically(storage, roomId, signal) {
         const ownMembership = await storage.getRoomMembership(roomId, undefined, { signal });
         if (ownMembership === "join" || ownMembership === "invite" || ownMembership === "knock") {
             try {
-                await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.leave(roomId), signal), signal);
+                await withRateLimitRetry(() => withMatrixMutationAbort(() => client.leave(roomId), signal), signal);
                 markRoomMutationComplete();
             }
             catch (error) {
@@ -532,7 +456,7 @@ async function deleteRoomDeterministically(storage, roomId, signal) {
             }
         }
         try {
-            await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.forget(roomId), signal), signal);
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => client.forget(roomId), signal), signal);
             markRoomMutationComplete();
         }
         catch (error) {
@@ -632,7 +556,7 @@ export async function joinVault(storage, vaultId, options) {
         if (membership === "join")
             return { vaultId, joined: true };
         try {
-            await withRateLimitRetry(() => withMatrixMutationAbort(storage.getClient(), () => storage.getClient().joinRoom(vaultId), signal), signal);
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => storage.getClient().joinRoom(vaultId), signal), signal);
         }
         catch (err) {
             if (err instanceof MutationOutcomeUnknownError)
@@ -765,7 +689,7 @@ export async function declineInvite(storage, vaultId, options) {
                 return { vaultId, declined: false };
             }
             try {
-                await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.leave(vaultId), signal), signal);
+                await withRateLimitRetry(() => withMatrixMutationAbort(() => client.leave(vaultId), signal), signal);
             }
             catch (error) {
                 let suppress = isGoneError(error);
@@ -777,7 +701,7 @@ export async function declineInvite(storage, vaultId, options) {
                     throw error;
             }
             try {
-                await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.forget(vaultId), signal), signal);
+                await withRateLimitRetry(() => withMatrixMutationAbort(() => client.forget(vaultId), signal), signal);
             }
             catch (error) {
                 let suppress = isGoneError(error);
@@ -815,7 +739,6 @@ export async function shareVault(storage, vaultId, userId, role, options) {
         ensureOperationActive(operation.signal);
         const tree = await resolveTree(storage, vaultId, operation.signal);
         const pending = withTreeMutation(storage.getClient(), async () => {
-            const client = storage.getClient();
             try {
                 ensureOperationActive(operation.signal);
                 await storage.refreshRoomState(tree.id, { signal: operation.signal });
@@ -839,7 +762,7 @@ export async function shareVault(storage, vaultId, userId, role, options) {
                     if (isActiveMembership(currentMembership ?? ""))
                         continue;
                     try {
-                        await withRateLimitRetry(() => withMatrixMutationAbort(client, () => space.invite(userId), operation.signal), operation.signal);
+                        await withRateLimitRetry(() => withMatrixMutationAbort(() => space.invite(userId), operation.signal), operation.signal);
                         completedRoomIds.add(space.id);
                     }
                     catch (error) {
@@ -863,7 +786,7 @@ export async function shareVault(storage, vaultId, userId, role, options) {
                     if (members.some((member) => member.userId === userId && member.role === "owner")) {
                         throw new StorageError("share will not demote an existing owner");
                     }
-                    await withRateLimitRetry(() => withMatrixMutationAbort(client, () => space.setPermissions(userId, role), operation.signal), operation.signal);
+                    await withRateLimitRetry(() => withMatrixMutationAbort(() => space.setPermissions(userId, role), operation.signal), operation.signal);
                     completedRoomIds.add(space.id);
                 }
             }
@@ -925,7 +848,7 @@ export async function unshareVault(storage, vaultId, userId, options) {
                     if (!isRevocableMembership(membership))
                         continue;
                     try {
-                        await withRateLimitRetry(() => withMatrixMutationAbort(storage.getClient(), () => storage.getClient().kick(space.id, userId, "unshared"), operation.signal), operation.signal);
+                        await withRateLimitRetry(() => withMatrixMutationAbort(() => storage.getClient().kick(space.id, userId, "unshared"), operation.signal), operation.signal);
                         completedRoomIds.add(space.id);
                     }
                     catch (error) {
@@ -1031,8 +954,7 @@ async function renameTree(storage, treeId, name, options) {
     return withOperationDeadline(options, async (signal) => {
         const tree = await resolveTree(storage, treeId, signal);
         try {
-            const client = typeof storage.getClient === "function" ? storage.getClient() : undefined;
-            await withRateLimitRetry(() => client ? withMatrixMutationAbort(client, () => tree.setName(name), signal) : tree.setName(name), signal);
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => tree.setName(name), signal), signal);
             await waitForCondition(async () => {
                 ensureOperationActive(signal);
                 const current = storage.getTree(treeId);
@@ -1070,38 +992,20 @@ async function deleteTree(storage, treeId, options) {
             if (isTreeDeleted(client, treeId))
                 return { id: treeId, deleted: true };
             const tree = await resolveTree(storage, treeId, operation.signal);
-            // Read reconciliation state after this operation reaches the single
-            // client queue; a preceding delete may have populated the set while we
-            // were waiting for its turn.
-            const removedRooms = getDeletedTreeIds(client);
-            let graph;
+            let externalParents;
             try {
-                // Re-read the candidate graph and any external parents it identifies
-                // before taking the immutable graph snapshot. Unrelated rooms are not
-                // part of this operation and must not block deletion merely because
-                // their membership is not joined.
-                await refreshDeletionRooms(storage, tree.id, operation.signal);
-                const spaces = snapshotTreeSpaces(tree, client);
-                const activeSpaces = spaces.filter((space) => !removedRooms.has(space.id));
-                const ids = new Set(activeSpaces.map((space) => space.id));
-                if (!ids.has(tree.id)) {
-                    if (removedRooms.has(tree.id)) {
-                        return { id: treeId, deleted: true };
-                    }
-                    throw new StorageError("delete graph is unsafe");
-                }
-                assertTreeEmptyForDeletion(storage, tree, activeSpaces);
-                graph = validateDeletionGraph(client, tree, ids, removedRooms);
+                // Deletion owns one room. Refresh its current state and its one
+                // supported parent before checking files/folders or changing links.
+                externalParents = await refreshDeletionRooms(storage, tree.id, operation.signal);
+                assertTreeEmptyForDeletion(storage, tree);
             }
             catch (error) {
                 if (error instanceof StorageError)
                     throw error;
                 throw new StorageError("delete failed", { cause: error });
             }
-            // Keep external parent links intact until the room deletion succeeds.
-            // Unlinking first would silently detach a live vault on failure.
             try {
-                await unlinkExternalParents(storage, tree.id, graph.externalParents, operation.signal);
+                await unlinkExternalParents(storage, tree.id, externalParents, operation.signal);
             }
             catch (error) {
                 if (error instanceof StorageError)
@@ -1112,11 +1016,8 @@ async function deleteTree(storage, treeId, options) {
                 await deleteRoomDeterministically(storage, tree.id, operation.signal);
             }
             catch (error) {
-                // The root is still live when its relation is removed. If deletion then
-                // fails, restore both sides before reporting failure; otherwise a live
-                // vault would be silently detached from its external parent.
                 try {
-                    await relinkExternalParents(storage, tree.id, graph.externalParents, new AbortController().signal);
+                    await relinkExternalParents(storage, tree.id, externalParents, new AbortController().signal);
                 }
                 catch (cleanupError) {
                     throw new StorageError("delete cleanup is incomplete", {
@@ -1149,8 +1050,7 @@ export async function renameFile(storage, treeId, fileId, name, options) {
         const tree = await resolveTree(storage, treeId, signal);
         const branch = await resolveFile(storage, tree, fileId, signal);
         try {
-            const client = typeof storage.getClient === "function" ? storage.getClient() : undefined;
-            await withRateLimitRetry(() => client ? withMatrixMutationAbort(client, () => branch.setName(name), signal) : branch.setName(name), signal);
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => branch.setName(name), signal), signal);
             // `setName` resolves when the homeserver accepts the state event, but a
             // fresh CLI/UI process can still read the previous local room state for a
             // short time. Do not report success until this client has observed the new
@@ -1181,7 +1081,7 @@ async function deleteFileMedia(storage, mediaIds, signal) {
     const client = storage.getClient();
     const http = requireFileDeletionTransport(client);
     try {
-        await withRateLimitRetry(() => withMatrixMutationAbort(client, () => http.authedRequest(Method.Post, "/io.telecrypt.storage/delete_media", undefined, { media_ids: [...mediaIds] }, { prefix: ClientPrefix.Unstable, rawResponseBody: true, abortSignal: signal }), signal, "delete file media"), signal);
+        await withRateLimitRetry(() => withMatrixMutationAbort(() => http.authedRequest(Method.Post, "/io.telecrypt.storage/delete_media", undefined, { media_ids: [...mediaIds] }, { prefix: ClientPrefix.Unstable, rawResponseBody: true, abortSignal: signal }), signal, "delete file media"), signal);
     }
     catch (error) {
         if (error instanceof MutationOutcomeUnknownError)
@@ -1209,11 +1109,9 @@ export async function deleteFile(storage, treeId, fileId, options) {
         await deleteFileMedia(storage, [mediaId], signal);
         const completedIds = [];
         try {
-            const client = typeof storage.getClient === "function" ? storage.getClient() : undefined;
-            if (!client)
-                throw new StorageError("Matrix client unavailable");
-            await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.sendStateEvent(tree.id, UNSTABLE_MSC3089_BRANCH.name, {}, branch.id), signal, "delete file state"), signal);
-            await withRateLimitRetry(() => withMatrixMutationAbort(client, () => client.redactEvent(tree.id, branch.id), signal, "delete file event"), signal);
+            const client = storage.getClient();
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => client.sendStateEvent(tree.id, UNSTABLE_MSC3089_BRANCH.name, {}, branch.id), signal, "delete file state"), signal);
+            await withRateLimitRetry(() => withMatrixMutationAbort(() => client.redactEvent(tree.id, branch.id), signal, "delete file event"), signal);
             completedIds.push(branch.id);
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telecrypt-io/storage",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "license": "BUSL-1.1",
   "type": "module",
   "packageManager": "npm@11.19.0",
@@ -25,12 +25,10 @@
     "node": "24.20.0"
   },
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "scripts": {
     "build": "tsc",
-    "typecheck:tests": "tsc -p tsconfig.test.json",
     "lint": "eslint src test --ext .ts",
     "test": "vitest run",
     "test:unit": "vitest run --config vitest.unit.config.ts",