Genarrative/src/services/assetReadUrlService.test.ts

import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';

import {
  clearStoredAccessToken,
  getStoredAccessToken,
  setStoredAccessToken,
} from './apiClient';
import {
  clearSignedAssetReadUrlCache,
  getSignedAssetReadUrl,
  readAssetBytes,
  resolveAssetReadUrl,
} from './assetReadUrlService';

function createLocalStorageMock() {
  const store = new Map<string, string>();

  return {
    getItem(key: string) {
      return store.has(key) ? store.get(key)! : null;
    },
    setItem(key: string, value: string) {
      store.set(key, String(value));
    },
    removeItem(key: string) {
      store.delete(key);
    },
    clear() {
      store.clear();
    },
  };
}

describe('assetReadUrlService', () => {
  beforeEach(() => {
    const sessionStorage = createLocalStorageMock();
    vi.stubGlobal('window', {
      localStorage: createLocalStorageMock(),
      sessionStorage,
      dispatchEvent: vi.fn(),
    });
    vi.stubGlobal('sessionStorage', sessionStorage);
    clearSignedAssetReadUrlCache();
    clearStoredAccessToken({ emit: false });
    setStoredAccessToken('test-access-token', { emit: false });
    vi.restoreAllMocks();
  });

  afterEach(() => {
    clearStoredAccessToken({ emit: false });
    vi.useRealTimers();
  });

  test('resolveAssetReadUrl returns passthrough for absolute url', async () => {
    await expect(resolveAssetReadUrl('https://example.com/demo.png')).resolves.toBe(
      'https://example.com/demo.png',
    );
  });

  test('resolveAssetReadUrl returns passthrough for data url', async () => {
    await expect(resolveAssetReadUrl('data:image/png;base64,abc')).resolves.toBe(
      'data:image/png;base64,abc',
    );
  });

  test('resolveAssetReadUrl exchanges legacy generated path for signed url', async () => {
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: true,
          data: {
            read: {
              objectKey: 'generated-characters/hero/visual/asset-01/master.png',
              signedUrl: 'https://signed.example.com/master.png',
              expiresAt: '2099-01-01T00:10:00Z',
            },
          },
          error: null,
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 200,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    await expect(
      resolveAssetReadUrl('/generated-characters/hero/visual/asset-01/master.png'),
    ).resolves.toBe('https://signed.example.com/master.png');

    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      '/api/assets/read-url?',
    );
  });

  test('resolveAssetReadUrl normalizes generated object key without leading slash', async () => {
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: true,
          data: {
            read: {
              objectKey:
                'generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
              signedUrl: 'https://signed.example.com/puzzle.png',
              expiresAt: '2099-01-01T00:10:00Z',
            },
          },
          error: null,
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 200,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    await expect(
      resolveAssetReadUrl(
        'generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
      ),
    ).resolves.toBe('https://signed.example.com/puzzle.png');

    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      'legacyPublicPath=%2Fgenerated-puzzle-assets%2Fpuzzle-session-1%2Fcandidate-1%2Fasset-1%2Fimage.png',
    );
  });

  test('resolveAssetReadUrl exchanges generated Aliyun OSS url for signed url', async () => {
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: true,
          data: {
            read: {
              objectKey:
                'generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
              signedUrl: 'https://signed.example.com/puzzle.png',
              expiresAt: '2099-01-01T00:10:00Z',
            },
          },
          error: null,
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 200,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    await expect(
      resolveAssetReadUrl(
        'https://genarrative-release.oss-cn-beijing.aliyuncs.com/generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
      ),
    ).resolves.toBe('https://signed.example.com/puzzle.png');

    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      'legacyPublicPath=%2Fgenerated-puzzle-assets%2Fpuzzle-session-1%2Fcandidate-1%2Fasset-1%2Fimage.png',
    );
  });

  test('resolveAssetReadUrl does not append cache busting query to OSS signed url', async () => {
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: true,
          data: {
            read: {
              objectKey:
                'generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
              signedUrl:
                'https://bucket.oss-cn-beijing.aliyuncs.com/generated-puzzle-assets/puzzle.png?x-oss-signature=abc&x-oss-expires=600',
              expiresAt: '2099-01-01T00:10:00Z',
            },
          },
          error: null,
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 200,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    await expect(
      resolveAssetReadUrl(
        '/generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
        { refreshKey: 'latest-result' },
      ),
    ).resolves.toBe(
      'https://bucket.oss-cn-beijing.aliyuncs.com/generated-puzzle-assets/puzzle.png?x-oss-signature=abc&x-oss-expires=600',
    );
  });

  test('resolveAssetReadUrl reuses signed url for the same refreshKey version', async () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date('2099-01-01T00:00:00Z'));
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: true,
          data: {
            read: {
              objectKey:
                'generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
              signedUrl: 'https://signed.example.com/puzzle.png?x-oss-signature=stable',
              expiresAt: '2099-01-01T00:10:00Z',
            },
          },
          error: null,
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 200,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    const source =
      '/generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png';
    const first = await resolveAssetReadUrl(source, {
      refreshKey: 'asset-version-1',
    });
    const second = await resolveAssetReadUrl(source, {
      refreshKey: 'asset-version-1',
    });

    expect(first).toBe(second);
    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
  });

  test('getSignedAssetReadUrl reuses cached signed url before expiry', async () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date('2099-01-01T00:00:00Z'));

    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: true,
          data: {
            read: {
              objectKey: 'generated-custom-world-scenes/profile-1/landmark-1/scene.png',
              signedUrl: 'https://signed.example.com/scene.png',
              expiresAt: '2099-01-01T00:10:00Z',
            },
          },
          error: null,
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 200,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    const first = await getSignedAssetReadUrl({
      legacyPublicPath: '/generated-custom-world-scenes/profile-1/landmark-1/scene.png',
    });
    const second = await getSignedAssetReadUrl({
      legacyPublicPath: '/generated-custom-world-scenes/profile-1/landmark-1/scene.png',
    });

    expect(first).toBe('https://signed.example.com/scene.png');
    expect(second).toBe(first);
    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
  });

  test('getSignedAssetReadUrl reuses session cached signed url after module reload', async () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date('2099-01-01T00:00:00Z'));

    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: true,
          data: {
            read: {
              objectKey:
                'generated-character-drafts/editor/specs/spec-image.png',
              signedUrl: 'https://signed.example.com/spec-image.png',
              expiresAt: '2099-01-01T00:10:00Z',
            },
          },
          error: null,
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 200,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    const request = {
      objectKey: 'generated-character-drafts/editor/specs/spec-image.png',
    };
    const first = await getSignedAssetReadUrl(request);
    vi.resetModules();
    const { getSignedAssetReadUrl: getSignedAssetReadUrlAfterReload } =
      await import('./assetReadUrlService');
    const second = await getSignedAssetReadUrlAfterReload(request);

    expect(first).toBe('https://signed.example.com/spec-image.png');
    expect(second).toBe(first);
    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
  });

  test('getSignedAssetReadUrl throttles distinct signed url bursts', async () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date('2099-01-01T00:00:00Z'));

    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(
      async (input) => {
        const url = new URL(
          String(input),
          globalThis.location?.origin ?? 'https://www.genarrative.world',
        );
        const objectKey = url.searchParams.get('objectKey') ?? 'missing.png';
        return new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey,
                signedUrl: `https://signed.example.com/${encodeURIComponent(objectKey)}`,
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        );
      },
    );

    const requests = Array.from({ length: 28 }, (_, index) =>
      getSignedAssetReadUrl({
        objectKey: `generated-character-drafts/editor/ui-design-assets/result/asset-${String(index + 1).padStart(3, '0')}.png`,
      }),
    );

    await vi.advanceTimersByTimeAsync(0);
    expect(fetchSpy).toHaveBeenCalledTimes(24);

    await vi.advanceTimersByTimeAsync(16);
    expect(fetchSpy).toHaveBeenCalledTimes(25);

    await vi.advanceTimersByTimeAsync(48);
    expect(fetchSpy).toHaveBeenCalledTimes(28);
    await expect(Promise.all(requests)).resolves.toHaveLength(28);
  });

  test('getSignedAssetReadUrl caches not-found failures for the same legacy path', async () => {
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: false,
          data: null,
          error: {
            code: 'NOT_FOUND',
            message: '对象不存在',
          },
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 404,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    await expect(
      getSignedAssetReadUrl({
        legacyPublicPath: '/generated-characters/hero/missing/master.png',
      }),
    ).rejects.toThrow();
    await expect(
      getSignedAssetReadUrl({
        legacyPublicPath: '/generated-characters/hero/missing/master.png',
      }),
    ).rejects.toThrow('资源不存在或暂时不可读取');

    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
  });

  test('getSignedAssetReadUrl 401 不会清空全局登录态', async () => {
    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
      new Response(
        JSON.stringify({
          ok: false,
          data: null,
          error: {
            code: 'UNAUTHORIZED',
            message: '登录状态已失效',
          },
          meta: {
            apiVersion: '2026-06-16',
            routeVersion: '2026-06-16',
            latencyMs: 1,
            timestamp: '2099-01-01T00:00:00Z',
          },
        }),
        {
          status: 401,
          headers: {
            'Content-Type': 'application/json',
          },
        },
      ),
    );

    await expect(
      getSignedAssetReadUrl({
        legacyPublicPath:
          '/generated-puzzle-assets/puzzle-session-1/candidate-1/asset-1/image.png',
      }),
    ).rejects.toThrow('登录状态已失效');

    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
    expect(getStoredAccessToken()).toBe('test-access-token');
    expect(window.dispatchEvent).not.toHaveBeenCalled();
  });

  test('readAssetBytes reads generated resources through signed OSS url first', async () => {
    vi.spyOn(globalThis, 'fetch')
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey:
                  'generated-match3d-assets/session/profile/items/match3d-item-1-item/image.png',
                signedUrl: 'https://signed.example.com/match3d-item.png',
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        ),
      )
      .mockResolvedValueOnce(
        new Response(new Uint8Array([104, 101, 108, 108, 111]), {
          status: 200,
          headers: {
            'Content-Type': 'image/png',
          },
        }),
      );

    const response = await readAssetBytes(
      '/generated-match3d-assets/session/profile/items/match3d-item-1-item/image.png',
      { expireSeconds: 300 },
    );
    const bytes = new Uint8Array(await response.arrayBuffer());

    expect(Array.from(bytes)).toEqual([104, 101, 108, 108, 111]);
    expect(response.headers.get('content-type')).toBe('image/png');
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      '/api/assets/read-url?',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      'legacyPublicPath=%2Fgenerated-match3d-assets%2Fsession%2Fprofile%2Fitems%2Fmatch3d-item-1-item%2Fimage.png',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[1]?.[0])).toBe(
      'https://signed.example.com/match3d-item.png',
    );
  });

  test('readAssetBytes reads object-key resources through signed OSS url first', async () => {
    vi.spyOn(globalThis, 'fetch')
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey: 'generated-editor-images/project/image.png',
                signedUrl: 'https://signed.example.com/editor-image.png',
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        ),
      )
      .mockResolvedValueOnce(
        new Response(new Uint8Array([1, 2, 3]), {
          status: 200,
          headers: {
            'Content-Type': 'image/png',
          },
        }),
      );

    const response = await readAssetBytes('/generated-editor-images/image.png', {
      objectKey: 'generated-editor-images/project/image.png',
      expireSeconds: 300,
    });
    const bytes = new Uint8Array(await response.arrayBuffer());

    expect(Array.from(bytes)).toEqual([1, 2, 3]);
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      '/api/assets/read-url?',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      'objectKey=generated-editor-images%2Fproject%2Fimage.png',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).not.toContain(
      'legacyPublicPath=',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[1]?.[0])).toBe(
      'https://signed.example.com/editor-image.png',
    );
  });

  test('readAssetBytes normalizes full OSS generated urls through signed read url', async () => {
    vi.spyOn(globalThis, 'fetch')
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey:
                  'generated-puzzle-assets/session/profile/covers/main.png',
                signedUrl: 'https://signed.example.com/main.png',
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        ),
      )
      .mockResolvedValueOnce(
        new Response(new Uint8Array([1, 2, 3]), {
          status: 200,
          headers: {
            'Content-Type': 'image/png',
          },
        }),
      );

    const response = await readAssetBytes(
      'https://genarrative.oss-cn-shanghai.aliyuncs.com/generated-puzzle-assets/session/profile/covers/main.png?x-oss-signature=abc',
      { expireSeconds: 300 },
    );

    expect(response.headers.get('content-type')).toBe('image/png');
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      '/api/assets/read-url?',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      'legacyPublicPath=%2Fgenerated-puzzle-assets%2Fsession%2Fprofile%2Fcovers%2Fmain.png',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[1]?.[0])).toBe(
      'https://signed.example.com/main.png',
    );
  });

  test('readAssetBytes falls back to same-origin bytes endpoint when OSS read fails', async () => {
    vi.spyOn(globalThis, 'fetch')
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey: 'generated-editor-images/project/image.png',
                signedUrl: 'https://signed.example.com/editor-image.png',
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        ),
      )
      .mockResolvedValueOnce(new Response('', { status: 403 }))
      .mockResolvedValueOnce(
        new Response(new Uint8Array([9, 8, 7]), {
          status: 200,
          headers: {
            'Content-Type': 'image/png',
          },
        }),
      );

    const response = await readAssetBytes('/generated-editor-images/image.png', {
      objectKey: 'generated-editor-images/project/image.png',
      expireSeconds: 300,
    });
    const bytes = new Uint8Array(await response.arrayBuffer());

    expect(Array.from(bytes)).toEqual([9, 8, 7]);
    expect(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[0])).toContain(
      '/api/assets/read-url?',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[1]?.[0])).toBe(
      'https://signed.example.com/editor-image.png',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[2]?.[0])).toContain(
      '/api/assets/read-bytes?',
    );
  });

  test('readAssetBytes falls back when a successful OSS response body fails to read', async () => {
    const signedResponseBlob = vi
      .fn()
      .mockRejectedValue(new TypeError('Failed to fetch'));
    const signedResponse = {
      ok: true,
      status: 206,
      statusText: 'Partial Content',
      headers: new Headers({
        'Content-Range': 'bytes 0-2/3',
        'Content-Type': 'image/png',
      }),
      blob: signedResponseBlob,
    } as unknown as Response;

    vi.spyOn(globalThis, 'fetch')
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey: 'generated-editor-images/project/image.png',
                signedUrl: 'https://signed.example.com/editor-image.png',
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        ),
      )
      .mockResolvedValueOnce(signedResponse)
      .mockResolvedValueOnce(
        new Response(new Uint8Array([9, 8, 7]), {
          status: 200,
          headers: {
            'Content-Type': 'image/png',
          },
        }),
      );

    const response = await readAssetBytes(
      '/generated-editor-images/image.png',
      {
        objectKey: 'generated-editor-images/project/image.png',
        expireSeconds: 300,
      },
    );
    const bytes = new Uint8Array(await response.arrayBuffer());

    expect(signedResponseBlob).toHaveBeenCalledTimes(1);
    expect(Array.from(bytes)).toEqual([9, 8, 7]);
    expect(String(vi.mocked(globalThis.fetch).mock.calls[1]?.[0])).toBe(
      'https://signed.example.com/editor-image.png',
    );
    expect(String(vi.mocked(globalThis.fetch).mock.calls[2]?.[0])).toContain(
      '/api/assets/read-bytes?',
    );
  });

  test('readAssetBytes rejects a partial 206 fragment and uses the full-byte fallback', async () => {
    const signedResponseBlob = vi.fn();
    const signedResponse = {
      ok: true,
      status: 206,
      statusText: 'Partial Content',
      headers: new Headers({
        'Content-Range': 'bytes 0-1/3',
        'Content-Type': 'image/png',
      }),
      blob: signedResponseBlob,
    } as unknown as Response;

    vi.spyOn(globalThis, 'fetch')
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey: 'generated-editor-images/project/image.png',
                signedUrl: 'https://signed.example.com/editor-image.png',
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        ),
      )
      .mockResolvedValueOnce(signedResponse)
      .mockResolvedValueOnce(
        new Response(new Uint8Array([9, 8, 7]), {
          status: 200,
          headers: {
            'Content-Type': 'image/png',
          },
        }),
      );

    const response = await readAssetBytes(
      '/generated-editor-images/image.png',
      {
        objectKey: 'generated-editor-images/project/image.png',
        expireSeconds: 300,
      },
    );
    const bytes = new Uint8Array(await response.arrayBuffer());

    expect(signedResponseBlob).not.toHaveBeenCalled();
    expect(Array.from(bytes)).toEqual([9, 8, 7]);
    expect(String(vi.mocked(globalThis.fetch).mock.calls[2]?.[0])).toContain(
      '/api/assets/read-bytes?',
    );
  });

  test('readAssetBytes preserves aborts during OSS body reads without fallback', async () => {
    const abortController = new AbortController();
    const signedResponseBlob = vi.fn().mockImplementation(async () => {
      abortController.abort();
      throw new DOMException('The operation was aborted.', 'AbortError');
    });
    const signedResponse = {
      ok: true,
      status: 200,
      statusText: 'OK',
      headers: new Headers({
        'Content-Type': 'image/png',
      }),
      blob: signedResponseBlob,
    } as unknown as Response;

    vi.spyOn(globalThis, 'fetch')
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({
            ok: true,
            data: {
              read: {
                objectKey: 'generated-editor-images/project/image.png',
                signedUrl: 'https://signed.example.com/editor-image.png',
                expiresAt: '2099-01-01T00:10:00Z',
              },
            },
            error: null,
            meta: {
              apiVersion: '2026-06-16',
              routeVersion: '2026-06-16',
              latencyMs: 1,
              timestamp: '2099-01-01T00:00:00Z',
            },
          }),
          {
            status: 200,
            headers: {
              'Content-Type': 'application/json',
            },
          },
        ),
      )
      .mockResolvedValueOnce(signedResponse);

    await expect(
      readAssetBytes('/generated-editor-images/image.png', {
        objectKey: 'generated-editor-images/project/image.png',
        expireSeconds: 300,
        signal: abortController.signal,
      }),
    ).rejects.toMatchObject({ name: 'AbortError' });

    expect(signedResponseBlob).toHaveBeenCalledTimes(1);
    expect(vi.mocked(globalThis.fetch)).toHaveBeenCalledTimes(2);
  });
});