@protontech/drive-sdk 0.15.1 → 0.15.2

package/src/internal/errors.ts

@@ -72,7 +72,7 @@ export function isNetworkError(error: unknown): boolean {
     if (!(error instanceof Error)) {
         return false;
     }
-    return (
+    if (
         error.name === 'OfflineError' ||
         error.name === 'NetworkError' ||
         error.message?.toLowerCase() === 'network error' ||
@@ -80,5 +80,44 @@ export function isNetworkError(error: unknown): boolean {
             ['Failed to fetch', 'NetworkError when attempting to fetch resource', 'Load failed'].includes(
                 error.message,
             ))
+    ) {
+        return true;
+    }
+    if (errorMessageIndicatesTransientTransportFailure(error.message) || errorHasTransientTransportCode(error)) {
+        return true;
+    }
+    if (error.cause instanceof Error) {
+        return (
+            errorMessageIndicatesTransientTransportFailure(error.cause.message) ||
+            errorHasTransientTransportCode(error.cause)
+        );
+    }
+    return false;
+}
+
+function errorMessageIndicatesTransientTransportFailure(message: string | undefined): boolean {
+    if (!message) {
+        return false;
+    }
+    const lower = message.toLowerCase();
+    return (
+        // Remote end closed TLS/TCP without a complete response.
+        lower.includes('socket connection was closed unexpectedly') ||
+        // Remote end sent RST or closed the write side mid-request.
+        lower.includes('other side closed') ||
+        // Remote end closed the socket abruptly.
+        lower.includes('socket hang up')
+    );
+}
+
+function errorHasTransientTransportCode(error: Error): boolean {
+    const code = (error as NodeJS.ErrnoException).code;
+    return (
+        // TCP RST or equivalent: common under flaky networks or after server restart.
+        code === 'ECONNRESET' ||
+        // Writing to a socket whose other end is gone (often grouped with reset/hang-up).
+        code === 'EPIPE' ||
+        // Socket-level failure after connect (e.g. unexpected close on the wire).
+        code === 'UND_ERR_SOCKET'
     );
 }

package/src/internal/events/apiService.ts

@@ -4,7 +4,7 @@ import { DriveEvent, DriveEventsListWithStatus, DriveEventType, NodeEvent, NodeE
 
 type GetCoreLatestEventResponse =
     corePaths['/core/{_version}/events/latest']['get']['responses']['200']['content']['application/json'];
-type GetCoreEventResponse =
+export type CoreApiEvent =
     corePaths['/core/{_version}/events/{id}']['get']['responses']['200']['content']['application/json'];
 
 type GetVolumeLatestEventResponse =
@@ -40,28 +40,33 @@ export class EventsAPIService {
 
     async getCoreEvents(eventId: string): Promise<DriveEventsListWithStatus> {
         // TODO: Switch to v6 endpoint?
-        const result = await this.apiService.get<GetCoreEventResponse>(`core/v5/events/${eventId}`);
+        const result = await this.apiService.get<CoreApiEvent>(`core/v5/events/${eventId}`);
+        const driveEvents = EventsAPIService.getDriveEventsFromCoreEvent(result);
         // in core/v5/events, refresh is always all apps, value 255
         const refresh = result.Refresh > 0;
-        const events: DriveEvent[] =
-            refresh || result.DriveShareRefresh?.Action === 2
-                ? [
-                      {
-                          type: DriveEventType.SharedWithMeUpdated,
-                          eventId: result.EventID,
-                          treeEventScopeId: 'core',
-                      },
-                  ]
-                : [];
-
         return {
             latestEventId: result.EventID,
             more: result.More === 1,
             refresh,
-            events,
+            events: driveEvents,
         };
     }
 
+    static getDriveEventsFromCoreEvent(result: CoreApiEvent): DriveEvent[] {
+        // in core/v5/events, refresh is always all apps, value 255
+        const refresh = result.Refresh > 0;
+        if (refresh || result.DriveShareRefresh?.Action === 2) {
+            return [
+                {
+                    type: DriveEventType.SharedWithMeUpdated,
+                    eventId: result.EventID,
+                    treeEventScopeId: 'core',
+                },
+            ];
+        }
+        return [];
+    }
+
     async getVolumeLatestEventId(volumeId: string): Promise<string> {
         const result = await this.apiService.get<GetVolumeLatestEventResponse>(
             `drive/volumes/${volumeId}/events/latest`,
@@ -81,9 +86,7 @@ export class EventsAPIService {
                 const type = VOLUME_EVENT_TYPE_MAP[event.EventType];
                 const uids = {
                     nodeUid: makeNodeUid(volumeId, event.Link.LinkID),
-                    parentNodeUid: event.Link.ParentLinkID
-                        ? makeNodeUid(volumeId, event.Link.ParentLinkID)
-                        : undefined,
+                    parentNodeUid: event.Link.ParentLinkID ? makeNodeUid(volumeId, event.Link.ParentLinkID) : undefined,
                 };
                 return {
                     type,

package/src/internal/events/index.test.ts

@@ -0,0 +1,67 @@
+import { getMockTelemetry } from '../../tests/telemetry';
+import { DriveAPIService } from '../apiService';
+import { CoreApiEvent } from './apiService';
+import { DriveEventsService } from './index';
+import { DriveEventType, DriveListener } from './interface';
+
+describe('DriveEventsService', () => {
+    describe('processCoreEvent', () => {
+        function createService(cacheEventListeners: DriveListener[] = []) {
+            const telemetry = getMockTelemetry();
+            const apiService = {} as unknown as DriveAPIService;
+            const sharesService = { isOwnVolume: jest.fn() };
+            return new DriveEventsService(telemetry, apiService, sharesService, cacheEventListeners);
+        }
+
+        it('returns no drive events and does not notify listeners when the raw event is not a refresh', async () => {
+            const listener: jest.MockedFunction<DriveListener> = jest.fn().mockResolvedValue(undefined);
+            const service = createService([listener]);
+            const raw = {
+                EventID: 'event-no-refresh',
+                Refresh: 0,
+            } as CoreApiEvent;
+
+            const result = await service.processCoreEvent(raw);
+
+            expect(result).toEqual([]);
+            expect(listener).not.toHaveBeenCalled();
+        });
+
+        it('returns SharedWithMeUpdated when Refresh is non-zero', async () => {
+            const service = createService();
+            const raw = {
+                EventID: 'event-refresh',
+                Refresh: 255,
+            } as CoreApiEvent;
+
+            const result = await service.processCoreEvent(raw);
+
+            expect(result).toEqual([
+                {
+                    type: DriveEventType.SharedWithMeUpdated,
+                    eventId: 'event-refresh',
+                    treeEventScopeId: 'core',
+                },
+            ]);
+        });
+
+        it('returns SharedWithMeUpdated when DriveShareRefresh.Action is 2', async () => {
+            const service = createService();
+            const raw = {
+                EventID: 'event-share-refresh',
+                Refresh: 0,
+                DriveShareRefresh: { Action: 2 },
+            } as CoreApiEvent;
+
+            const result = await service.processCoreEvent(raw);
+
+            expect(result).toEqual([
+                {
+                    type: DriveEventType.SharedWithMeUpdated,
+                    eventId: 'event-share-refresh',
+                    treeEventScopeId: 'core',
+                },
+            ]);
+        });
+    });
+});

package/src/internal/events/index.ts

@@ -1,11 +1,12 @@
 import { Logger, ProtonDriveTelemetry } from '../../interface';
 import { DriveAPIService } from '../apiService';
-import { EventsAPIService } from './apiService';
+import { CoreApiEvent, EventsAPIService } from './apiService';
 import { CoreEventManager } from './coreEventManager';
 import { EventManager } from './eventManager';
 import { DriveEvent, DriveListener, EventSubscription, LatestEventIdProvider, SharesService } from './interface';
 import { VolumeEventManager } from './volumeEventManager';
 
+export type { CoreApiEvent } from './apiService';
 export type { DriveEvent, DriveListener, EventSubscription } from './interface';
 export { DriveEventType } from './interface';
 
@@ -37,7 +38,9 @@ export class DriveEventsService {
         this.volumeEventManagers = {};
     }
 
-    // FIXME: Allow to pass own core events manager from the public interface.
+    /**
+     * @deprecated Use `processCoreEvent` instead.
+     */
     async subscribeToCoreEvents(callback: DriveListener): Promise<EventSubscription> {
         let manager = this.coreEventManager;
         const started = !!manager;
@@ -72,6 +75,21 @@ export class DriveEventsService {
         return eventManager;
     }
 
+    /**
+     * Process a raw core API event fetched by the caller's own event loop.
+     * The SDK derives drive-relevant events from it, updates internal caches,
+     * and notifies all listeners registered via `subscribeToPushedCoreEvents`.
+     */
+    async processCoreEvent(rawEvent: CoreApiEvent): Promise<DriveEvent[]> {
+        const driveEvents = EventsAPIService.getDriveEventsFromCoreEvent(rawEvent);
+        for (const event of driveEvents) {
+            for (const listener of this.cacheEventListeners) {
+                await listener(event);
+            }
+        }
+        return driveEvents;
+    }
+
     /**
      * Subscribe to drive events. The treeEventScopeId can be obtained from a node.
      */

package/src/internal/nodes/cryptoService.ts

@@ -73,6 +73,8 @@ type NodesCryptoReporterNode = {
 export class NodesCryptoService {
     private logger: Logger;
 
+    protected allowContentKeyPacketFallbackVerification = true;
+
     constructor(
         telemetry: ProtonDriveTelemetry,
         protected driveCrypto: DriveCrypto,
@@ -541,6 +543,10 @@ export class NodesCryptoService {
             return result;
         }
 
+        if (!this.allowContentKeyPacketFallbackVerification) {
+            return result;
+        }
+
         const { volumeId: ownVolumeId } = await this.sharesService.getRootIDs();
         const { volumeId: nodesVolumeId } = splitNodeUid(node.uid);
 

package/src/internal/nodes/nodesRevisions.ts

@@ -14,7 +14,7 @@ export class NodesRevisons {
         private logger: Logger,
         private apiService: NodeAPIServiceBase,
         private cryptoService: NodesCryptoService,
-        private nodesAccess: Pick<NodesAccess, 'getNodeKeys'>,
+        private nodesAccess: Pick<NodesAccess, 'getNodeKeys' | 'notifyNodeChanged'>,
     ) {
         this.logger = logger;
         this.apiService = apiService;
@@ -67,6 +67,10 @@ export class NodesRevisons {
 
     async restoreRevision(nodeRevisionUid: string): Promise<void> {
         await this.apiService.restoreRevision(nodeRevisionUid);
+
+        // Restoring a revision creates a new active revision.
+        const nodeUid = makeNodeUidFromRevisionUid(nodeRevisionUid);
+        await this.nodesAccess.notifyNodeChanged(nodeUid);
     }
 
     async deleteRevision(nodeRevisionUid: string): Promise<void> {

package/src/internal/photos/addToAlbum.test.ts

@@ -69,7 +69,7 @@ describe('AddToAlbumProcess', () => {
         // @ts-expect-error Mocking for testing purposes
         apiService = {
             addPhotosToAlbum: jest.fn(),
-            copyPhotoToAlbum: jest.fn(),
+            copyPhoto: jest.fn(),
         };
 
         // @ts-expect-error Mocking for testing purposes
@@ -154,7 +154,7 @@ describe('AddToAlbumProcess', () => {
         });
 
         let copyToAlbumReturnedMissing = false;
-        apiService.copyPhotoToAlbum.mockImplementation(async (albumUid, payload) => {
+        apiService.copyPhoto.mockImplementation(async (albumUid, payload) => {
             let error: Error | undefined;
             if (payload.nodeUid.includes('missingRelatedTwice')) {
                 error = new MissingRelatedPhotosError(['volume2~missingRelatedTwice1']);
@@ -322,7 +322,7 @@ describe('AddToAlbumProcess', () => {
             const photoUids = Array.from({ length: 25 }, (_, i) => `volume2~photo${i}`);
 
             let copyPhotoCallCount = 0;
-            apiService.copyPhotoToAlbum.mockImplementation(async (albumUid, payload) => {
+            apiService.copyPhoto.mockImplementation(async (albumUid, payload) => {
                 copyPhotoCallCount++;
 
                 // First few calls should happen before all 25 photos are prepared
@@ -351,8 +351,8 @@ describe('AddToAlbumProcess', () => {
                 uid: mainPhotoUid,
                 ok: true,
             }])
-            expect(apiService.copyPhotoToAlbum).toHaveBeenCalledTimes(1);
-            const params = apiService.copyPhotoToAlbum.mock.calls[0];
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(1);
+            const params = apiService.copyPhoto.mock.calls[0];
             expect(params[1].relatedPhotos?.length).toBe(15);
         });
 
@@ -366,7 +366,7 @@ describe('AddToAlbumProcess', () => {
                 ok: true,
             }]);
             expect(nodesService.iterateNodes).toHaveBeenCalledTimes(3); // main photo + related photo + missing related photo
-            expect(apiService.copyPhotoToAlbum).toHaveBeenCalledTimes(2); // two attempts
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(2); // two attempts
         });
 
         it('should return error if missing related photos error occurs twice', async () => {
@@ -380,7 +380,7 @@ describe('AddToAlbumProcess', () => {
                 error: new MissingRelatedPhotosError(['volume2~missingRelatedOnce1']),
             }]);
             expect(nodesService.iterateNodes).toHaveBeenCalledTimes(3); // main photo + related photo + missing related photo
-            expect(apiService.copyPhotoToAlbum).toHaveBeenCalledTimes(2); // two attempts
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(2); // two attempts
         });
 
         it('should return error when crypto service fails', async () => {
@@ -428,7 +428,7 @@ describe('AddToAlbumProcess', () => {
         it('should not notify for failed photo copies', async () => {
             const photoUid = 'volume2~photo1';
 
-            apiService.copyPhotoToAlbum.mockRejectedValue(new Error('API error'));
+            apiService.copyPhoto.mockRejectedValue(new Error('API error'));
 
             const results = await executeProcess([photoUid]);
 
@@ -467,9 +467,9 @@ describe('AddToAlbumProcess', () => {
             expect(nodesService.iterateNodes.mock.calls[1][0]).toMatchObject(differentVolumeUids);
             expect(apiService.addPhotosToAlbum).toHaveBeenCalledTimes(1);
             expect(apiService.addPhotosToAlbum.mock.calls[0][1].map(({ nodeUid }) => nodeUid)).toMatchObject(sameVolumeUids);
-            expect(apiService.copyPhotoToAlbum).toHaveBeenCalledTimes(2);
-            expect(apiService.copyPhotoToAlbum.mock.calls[0][1].nodeUid).toBe(differentVolumeUids[0]);
-            expect(apiService.copyPhotoToAlbum.mock.calls[1][1].nodeUid).toBe(differentVolumeUids[1]);
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(2);
+            expect(apiService.copyPhoto.mock.calls[0][1].nodeUid).toBe(differentVolumeUids[0]);
+            expect(apiService.copyPhoto.mock.calls[1][1].nodeUid).toBe(differentVolumeUids[1]);
         });
 
         it('should prepare payloads in parallel for both queues', async () => {
@@ -496,7 +496,7 @@ describe('AddToAlbumProcess', () => {
             expect(results[1].ok).toBe(true);
             expect(nodesService.iterateNodes).toHaveBeenCalledTimes(3 + 3); // main photo + related photo + missing related photo
             expect(apiService.addPhotosToAlbum).toHaveBeenCalledTimes(2); // two attempts
-            expect(apiService.copyPhotoToAlbum).toHaveBeenCalledTimes(2); // two attempts
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(2); // two attempts
         });
 
         it('should notify correctly for both volumes', async () => {

package/src/internal/photos/addToAlbum.ts

@@ -118,7 +118,7 @@ export class AddToAlbumProcess {
 
             for (const payload of payloads) {
                 try {
-                    const newPhotoNodeUid = await this.apiService.copyPhotoToAlbum(
+                    const newPhotoNodeUid = await this.apiService.copyPhoto(
                         this.albumNodeUid,
                         payload,
                         this.signal,

package/src/internal/photos/apiService.test.ts

@@ -147,7 +147,7 @@ describe('photosAPIService', () => {
         });
     });
 
-    describe('copyPhotoToAlbum', () => {
+    describe('copyPhoto', () => {
         const photoPayloads = [
             {
                 nodeUid: 'volumeId2~photoNodeId1',
@@ -181,7 +181,7 @@ describe('photosAPIService', () => {
                 LinkID: 'photoNodeId1',
             });
 
-            const result = await api.copyPhotoToAlbum(albumNodeUid, photoPayloads[0]);
+            const result = await api.copyPhoto(albumNodeUid, photoPayloads[0]);
 
             expect(result).toEqual('volumeId1~photoNodeId1');
             expect(apiMock.post).toHaveBeenCalledWith(
@@ -215,7 +215,7 @@ describe('photosAPIService', () => {
                 },
             ));
 
-            const promise = api.copyPhotoToAlbum(albumNodeUid, photoPayloads[0]);
+            const promise = api.copyPhoto(albumNodeUid, photoPayloads[0]);
 
             await expect(promise).rejects.toThrow(MissingRelatedPhotosError);
             try {
@@ -229,7 +229,7 @@ describe('photosAPIService', () => {
             const error = new APICodeError('Some error', 3000);
             apiMock.post = jest.fn().mockRejectedValue(error);
 
-            const promise = api.copyPhotoToAlbum(albumNodeUid, photoPayloads[0]);
+            const promise = api.copyPhoto(albumNodeUid, photoPayloads[0]);
 
             await expect(promise).rejects.toThrow(error);
         });

package/src/internal/photos/apiService.ts

@@ -358,7 +358,7 @@ export class PhotosAPIService {
     /**
      * Add photos from the same volume to an album.
      *
-     * To add photos from different volumes, use the {@link copyPhotoToAlbum} method.
+     * To add photos from different volumes, use the {@link copyPhoto} method.
      *
      * In the future, these two methods will be merged into a single one.
      */
@@ -432,26 +432,26 @@ export class PhotosAPIService {
     }
 
     /**
-     * Copy a photo to a shared album on a different volume.
+     * Copy a photo from a different volume to an album or to the user's own timeline root.
      *
      * To add photos from the same volume to an album, use the {@link addPhotosToAlbum} method.
      *
      * In the future, these two methods will be merged into a single one.
      */
-    async copyPhotoToAlbum(
-        albumNodeUid: string,
+    async copyPhoto(
+        targetNodeUid: string,
         payload: TransferEncryptedPhotoPayload,
         signal?: AbortSignal,
     ): Promise<string> {
         const { volumeId: sourceVolumeId, nodeId: sourceLinkId } = splitNodeUid(payload.nodeUid);
-        const { volumeId: targetVolumeId, nodeId: targetAlbumLinkId } = splitNodeUid(albumNodeUid);
+        const { volumeId: targetVolumeId, nodeId: targetNodeId } = splitNodeUid(targetNodeUid);
 
         try {
             const response = await this.apiService.post<PostCopyLinkRequest, PostCopyLinkResponse>(
                 `drive/volumes/${sourceVolumeId}/links/${sourceLinkId}/copy`,
                 {
                     TargetVolumeID: targetVolumeId,
-                    TargetParentLinkID: targetAlbumLinkId,
+                    TargetParentLinkID: targetNodeId,
                     Hash: payload.nameHash,
                     Name: payload.encryptedName,
                     NameSignatureEmail: payload.nameSignatureEmail,

package/src/internal/photos/photosManager.test.ts

@@ -58,7 +58,7 @@ async function collectSaveToTimelineResults(manager: PhotosManager, nodeUids: st
 describe('PhotosManager', () => {
     let logger: ReturnType<typeof getMockLogger>;
     let apiService: jest.Mocked<
-        Pick<PhotosAPIService, 'addPhotoTags' | 'removePhotoTags' | 'setPhotoFavorite' | 'transferPhotos'>
+        Pick<PhotosAPIService, 'addPhotoTags' | 'removePhotoTags' | 'setPhotoFavorite' | 'transferPhotos' | 'copyPhoto'>
     >;
     let cryptoService: jest.Mocked<Pick<AlbumsCryptoService, 'encryptPhotoForAlbum'>>;
     let nodesService: jest.Mocked<
@@ -70,6 +70,7 @@ describe('PhotosManager', () => {
             | 'iterateNodes'
             | 'getNodePrivateAndSessionKeys'
             | 'notifyNodeChanged'
+            | 'notifyChildCreated'
         >
     >;
     let manager: PhotosManager;
@@ -92,6 +93,7 @@ describe('PhotosManager', () => {
             removePhotoTags: jest.fn().mockResolvedValue(undefined),
             setPhotoFavorite: jest.fn().mockResolvedValue(undefined),
             transferPhotos: jest.fn().mockImplementation(async function* () {}),
+            copyPhoto: jest.fn().mockResolvedValue('volume1~newPhoto'),
         };
 
         cryptoService = {
@@ -122,6 +124,7 @@ describe('PhotosManager', () => {
                 passphraseSessionKey: 'passphraseSessionKey' as any,
             }),
             notifyNodeChanged: jest.fn().mockResolvedValue(undefined),
+            notifyChildCreated: jest.fn().mockResolvedValue(undefined),
         };
 
         manager = new PhotosManager(logger, apiService as any, cryptoService as any, nodesService as any);
@@ -304,5 +307,37 @@ describe('PhotosManager', () => {
             );
             expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
         });
+
+        it('copies cross-volume photo and notifies parent root folder', async () => {
+            apiService.copyPhoto.mockResolvedValue('volume1~newPhoto1');
+
+            const results = await collectSaveToTimelineResults(manager, ['volume2~photo1']);
+
+            expect(results).toEqual([{ uid: 'volume2~photo1', ok: true }]);
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(1);
+            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('volume1~root');
+            expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
+        });
+
+        it('re-queues cross-volume photo once on MissingRelatedPhotosError then succeeds', async () => {
+            const missingRelatedUid = 'volume2~related1';
+            let copyCall = 0;
+            apiService.copyPhoto.mockImplementation(async () => {
+                copyCall++;
+                if (copyCall === 1) {
+                    throw new MissingRelatedPhotosError([missingRelatedUid]);
+                }
+                return 'volume1~newPhoto1';
+            });
+
+            const results = await collectSaveToTimelineResults(manager, ['volume2~photo1']);
+
+            expect(results).toEqual([{ uid: 'volume2~photo1', ok: true }]);
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(2);
+            expect(logger.info).toHaveBeenCalledWith(
+                `Missing related photos for saving volume2~photo1, re-queuing: ${missingRelatedUid}`,
+            );
+            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('volume1~root');
+        });
     });
 });

package/src/internal/photos/photosManager.ts

@@ -3,12 +3,17 @@ import { c } from 'ttag';
 import { AbortError } from '../../errors';
 import { Logger, NodeResultWithError, PhotoTag } from '../../interface';
 import { batch } from '../batch';
+import { splitNodeUid } from '../uids';
 import { createBatches } from './addToAlbum';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { MissingRelatedPhotosError } from './errors';
 import { PhotosNodesAccess } from './nodes';
-import { PhotoAlreadyInTargetError, PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
+import {
+    PhotoAlreadyInTargetError,
+    PhotoTransferPayloadBuilder,
+    TransferEncryptedPhotoPayload,
+} from './photosTransferPayloadBuilder';
 
 /**
  * The number of photos that are loaded in parallel to prepare the payloads.
@@ -39,13 +44,14 @@ export class PhotosManager {
 
     async *saveToTimeline(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
         const rootNode = await this.nodesService.getVolumeRootFolder();
+        const { volumeId: userVolumeId } = splitNodeUid(rootNode.uid);
         const volumeRootKeys = await this.nodesService.getNodeKeys(rootNode.uid);
         const signingKeys = await this.nodesService.getNodeSigningKeys({ nodeUid: rootNode.uid });
 
-        const queue: {
-            photoNodeUid: string;
-            additionalRelatedPhotoNodeUids: string[];
-        }[] = nodeUids.map((nodeUid) => ({ photoNodeUid: nodeUid, additionalRelatedPhotoNodeUids: [] }));
+        const queue: { photoNodeUid: string; additionalRelatedPhotoNodeUids: string[] }[] = nodeUids.map((nodeUid) => ({
+            photoNodeUid: nodeUid,
+            additionalRelatedPhotoNodeUids: [],
+        }));
         const retriedPhotoUids = new Set<string>();
 
         while (queue.length > 0) {
@@ -62,7 +68,10 @@ export class PhotosManager {
                 yield { uid, ok: false, error };
             }
 
-            for (const batch of createBatches(payloads)) {
+            const sameVolumePayloads = payloads.filter((p) => splitNodeUid(p.nodeUid).volumeId === userVolumeId);
+            const crossVolumePayloads = payloads.filter((p) => splitNodeUid(p.nodeUid).volumeId !== userVolumeId);
+
+            for (const batch of createBatches(sameVolumePayloads)) {
                 for await (const result of this.apiService.transferPhotos(rootNode.uid, batch, signal)) {
                     if (
                         !result.ok &&
@@ -79,16 +88,48 @@ export class PhotosManager {
                         });
                         continue;
                     }
-
                     if (result.ok) {
                         await this.nodesService.notifyNodeChanged(result.uid);
                     }
                     yield result;
                 }
             }
+
+            // Cross-volume photos (e.g. from shared-with-me albums): copy into the user's own
+            // timeline root using the generic copy endpoint.
+            for (const payload of crossVolumePayloads) {
+                try {
+                    await this.copyPhoto(payload, signal);
+                    await this.nodesService.notifyChildCreated(rootNode.uid);
+                    yield { uid: payload.nodeUid, ok: true };
+                } catch (error) {
+                    if (error instanceof MissingRelatedPhotosError && !retriedPhotoUids.has(payload.nodeUid)) {
+                        retriedPhotoUids.add(payload.nodeUid);
+                        this.logger.info(
+                            `Missing related photos for saving ${payload.nodeUid}, re-queuing: ${error.missingNodeUids.join(', ')}`,
+                        );
+                        queue.push({
+                            photoNodeUid: payload.nodeUid,
+                            additionalRelatedPhotoNodeUids: error.missingNodeUids,
+                        });
+                        continue;
+                    }
+                    yield {
+                        uid: payload.nodeUid,
+                        ok: false,
+                        error:
+                            error instanceof Error ? error : new Error(c('Error').t`Unknown error`, { cause: error }),
+                    };
+                }
+            }
         }
     }
 
+    private async copyPhoto(payload: TransferEncryptedPhotoPayload, signal?: AbortSignal): Promise<string> {
+        const rootNode = await this.nodesService.getVolumeRootFolder();
+        return this.apiService.copyPhoto(rootNode.uid, payload, signal);
+    }
+
     async *updatePhotos(photos: UpdatePhotoSettings[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
         for await (const {
             photoSettings: { nodeUid, tagsToAdd, tagsToRemove },

package/src/internal/sharingPublic/nodes.ts

@@ -17,6 +17,9 @@ import { makeNodeUid, splitNodeUid } from '../uids';
 import { SharingPublicSharesManager } from './shares';
 
 export class SharingPublicNodesCryptoService extends NodesCryptoService {
+    // Do not allow fallback verification for public links, because it is not possible to load owners' address keys.
+    protected allowContentKeyPacketFallbackVerification = false;
+
     async generateDocument(
         parentKeys: { key: PrivateKey; hashKey: Uint8Array<ArrayBuffer> },
         signingKeys: NodeSigningKeys,