nodejs-insta-private-api-mqt 1.3.83 → 1.3.84

package/dist-ts/dist/sendmedia/sendPhoto.js

@@ -0,0 +1,132 @@
+/**
+ * uploadPhoto.fixed.js
+ *
+ * Fixed and hardened version of uploadPhoto for nodejs-insta-private-api(-mqtt).
+ * - sends Buffer in `data` (axios uses `data`, not `body`)
+ * - sets axios-friendly headers (X-Entity-Type uses provided mimeType)
+ * - removes explicit Accept-Encoding header (axios handles it)
+ * - sets maxContentLength / maxBodyLength via Request httpClient (should be patched there too)
+ * - returns the rupload/uploadId (server-provided when available, otherwise local uploadId)
+ *
+ * Usage:
+ *   const uploadPhoto = require('./uploadPhoto.fixed');
+ *   const uploadId = await uploadPhoto(session, photoBuffer, { mimeType: 'image/jpeg' });
+ *
+ * Note: session.request.send(...) is expected to accept axios-like options.
+ */
+const { v4: uuidv4 } = require('uuid');
+function validateImageInput(photoBuffer, mimeType) {
+    if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
+        throw new Error('uploadPhoto: photoBuffer must be a non-empty Buffer.');
+    }
+    const allowed = ['image/jpeg', 'image/jpg', 'image/png'];
+    if (!allowed.includes(mimeType)) {
+        throw new Error(`uploadPhoto: mimeType must be one of ${allowed.join(', ')}.`);
+    }
+}
+function buildRuploadParams(uploadId, mimeType) {
+    const isJpeg = mimeType === 'image/jpeg' || mimeType === 'image/jpg';
+    const compression = isJpeg
+        ? { lib_name: 'moz', lib_version: '3.1.m', quality: '80' }
+        : { lib_name: 'png', lib_version: '1.0', quality: '100' };
+    // Match instagram-private-api shape; include is_sidecar for compatibility
+    return {
+        retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+        media_type: '1',
+        upload_id: uploadId.toString(),
+        xsharing_user_ids: JSON.stringify([]),
+        image_compression: JSON.stringify(compression),
+        is_sidecar: '0'
+    };
+}
+/**
+ * Upload a photo buffer to Instagram rupload endpoint.
+ *
+ * @param {Object} session - client/session object that exposes session.request.send(options)
+ * @param {Buffer} photoBuffer - binary buffer of the image
+ * @param {Object} options - { mimeType = 'image/jpeg', fileName?, signal? }
+ * @returns {Promise<string>} uploadId (server upload_id when available, otherwise local uploadId)
+ */
+async function uploadPhoto(session, photoBuffer, options = {}) {
+    const { mimeType = 'image/jpeg', fileName, signal } = options;
+    validateImageInput(photoBuffer, mimeType);
+    // local upload id similar to insta clients
+    const uploadId = Date.now().toString();
+    // create an entity name similar to instagram-private-api naming
+    const randomSuffix = Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000);
+    const name = `${uploadId}_0_${randomSuffix}`;
+    const contentLength = photoBuffer.byteLength;
+    const ruploadParams = buildRuploadParams(uploadId, mimeType);
+    const headers = {
+        'X_FB_PHOTO_WATERFALL_ID': uuidv4(),
+        'X-Entity-Type': mimeType, // use actual mimeType
+        'Offset': '0',
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X-Entity-Name': name,
+        'X-Entity-Length': String(contentLength),
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': String(contentLength),
+        // remove explicit Accept-Encoding to avoid conflicts; axios handles compression
+        // 'Accept-Encoding': 'gzip',
+    };
+    const url = `/rupload_igphoto/${name}`;
+    try {
+        // session.request.send is expected to forward options to axios (or similar)
+        // We MUST use `data` (not `body`) for axios-friendly request.
+        const response = await session.request.send({
+            url,
+            method: 'POST',
+            headers,
+            data: photoBuffer,
+            signal,
+            // ensure axios does not apply any transform that would corrupt binary
+            transformRequest: [(d) => d]
+        });
+        if (!response) {
+            throw new Error('uploadPhoto: Empty response from Instagram rupload endpoint.');
+        }
+        // The request wrapper in different forks may return { body, headers } OR axios response
+        // Normalize possible shapes:
+        let respBody = null;
+        if (response.body !== undefined) {
+            // wrapper returned { body, headers }
+            respBody = response.body;
+        }
+        else if (response.data !== undefined) {
+            respBody = response.data;
+        }
+        else {
+            respBody = response;
+        }
+        // If respBody is a string, try parse JSON
+        let parsed = null;
+        if (typeof respBody === 'string') {
+            try {
+                parsed = JSON.parse(respBody);
+            }
+            catch (e) {
+                parsed = null;
+            }
+        }
+        else if (typeof respBody === 'object') {
+            parsed = respBody;
+        }
+        // server might return upload_id inside parsed
+        const serverUploadId = parsed && (parsed.upload_id || parsed.uploadId || parsed.media && parsed.media.upload_id);
+        if (serverUploadId) {
+            return serverUploadId.toString();
+        }
+        // fallback: some endpoints respond with status only; return our local uploadId
+        return uploadId;
+    }
+    catch (err) {
+        // try to unwrap axios error message
+        let msg = '';
+        if (err && err.message)
+            msg = err.message;
+        else
+            msg = String(err);
+        throw new Error(`uploadPhoto: Upload failed — ${msg}`);
+    }
+}
+module.exports = uploadPhoto;

package/dist-ts/dist/sendmedia/sendRavenPhoto.js

@@ -0,0 +1,133 @@
+const { v4: uuidv4 } = require('uuid');
+const axios = require('axios');
+function buildRavenPhotoRuploadParams(uploadId) {
+    return {
+        retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+        media_type: '1',
+        upload_id: uploadId.toString(),
+        image_compression: JSON.stringify({ lib_name: 'moz', lib_version: '3.1.m', quality: '95' }),
+        xsharing_user_ids: JSON.stringify([]),
+        direct_v2: '1',
+        is_optimistic_upload: 'false',
+    };
+}
+async function sendRavenPhoto(session, photoBuffer, options = {}) {
+    var _a, _b, _c, _d;
+    const { threadId, viewMode = 'replayable', mimeType = 'image/jpeg', } = options;
+    if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
+        throw new Error('sendRavenPhoto: photoBuffer must be a non-empty Buffer.');
+    }
+    if (!threadId) {
+        throw new Error('sendRavenPhoto: threadId is required.');
+    }
+    const uploadId = Date.now().toString();
+    const randomSuffix = Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000);
+    const name = `${uploadId}_0_${randomSuffix}`;
+    const waterfallId = uuidv4();
+    const ruploadParams = buildRavenPhotoRuploadParams(uploadId);
+    const defaultHeaders = session.request.getDefaultHeaders();
+    const messengerUploadHeaders = {
+        ...defaultHeaders,
+        'X_FB_PHOTO_WATERFALL_ID': waterfallId,
+        'X-Entity-Type': mimeType,
+        'Offset': '0',
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X-Entity-Name': name,
+        'X-Entity-Length': String(photoBuffer.length),
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': String(photoBuffer.length),
+        'ephemeral_media_view_mode': viewMode === 'replayable' ? '1' : '0',
+        'ig_raven_metadata': '{}',
+        'image_type': 'FILE_ATTACHMENT',
+        'Host': 'rupload.facebook.com',
+    };
+    const uploadResp = await axios({
+        url: `https://rupload.facebook.com/messenger_image/${name}`,
+        method: 'POST',
+        headers: messengerUploadHeaders,
+        data: photoBuffer,
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+        transformRequest: [(d) => d],
+    });
+    const uploadParsed = uploadResp.data;
+    const serverUploadId = (uploadParsed.upload_id || uploadId).toString();
+    const attachmentFbid = uploadParsed.media_id
+        || (uploadParsed.media && uploadParsed.media.pk)
+        || (uploadParsed.media && uploadParsed.media.id)
+        || null;
+    const clientContext = BigInt(Math.floor(Math.random() * 2 ** 62)).toString();
+    const compositionId = uuidv4();
+    const cameraSessionId = uuidv4();
+    const now = Math.floor(Date.now() / 1000);
+    const form = {
+        allow_multi_configures: '1',
+        recipient_users: '[]',
+        view_mode: viewMode,
+        is_shh_mode: '0',
+        camera_entry_point: '3',
+        thread_ids: JSON.stringify([String(threadId)]),
+        reshare_mode: 'allow_reshare',
+        original_media_type: '1',
+        send_attribution: 'direct_thread_camera',
+        client_context: clientContext,
+        camera_session_id: cameraSessionId,
+        include_e2ee_mentioned_user_list: '1',
+        hide_from_profile_grid: 'false',
+        scene_capture_type: '',
+        timezone_offset: String(new Date().getTimezoneOffset() * -60),
+        client_shared_at: String(now),
+        configure_mode: '2',
+        source_type: '4',
+        camera_position: 'unknown',
+        _uid: String(session.state.cookieUserId || session.state.igUserId),
+        device_id: session.state.deviceId,
+        composition_id: compositionId,
+        mutation_token: clientContext,
+        _uuid: session.state.uuid,
+        creation_tool_info: '[]',
+        creation_surface: 'camera',
+        capture_type: 'normal',
+        audience: 'default',
+        upload_id: serverUploadId,
+        client_timestamp: String(now),
+        sampled: 'true',
+        media_transformation_info: JSON.stringify({
+            width: '720', height: '1280',
+            x_transform: '0', y_transform: '0',
+            zoom: '1.0', rotation: '0.0', background_coverage: '0.0',
+        }),
+        edits: JSON.stringify({ filter_type: 0, filter_strength: 0.5, crop_original_size: [720.0, 1280.0] }),
+        extra: JSON.stringify({ source_width: 720, source_height: 1280 }),
+        device: JSON.stringify({
+            manufacturer: ((_a = session.state.devicePayload) === null || _a === void 0 ? void 0 : _a.manufacturer) || 'samsung',
+            model: ((_b = session.state.devicePayload) === null || _b === void 0 ? void 0 : _b.model) || 'SM-S938B',
+            android_version: ((_c = session.state.devicePayload) === null || _c === void 0 ? void 0 : _c.android_version) || 35,
+            android_release: ((_d = session.state.devicePayload) === null || _d === void 0 ? void 0 : _d.android_release) || '15',
+        }),
+    };
+    if (attachmentFbid) {
+        form.attachment_fbid = String(attachmentFbid);
+    }
+    const signedForm = (session.request && typeof session.request.sign === 'function')
+        ? session.request.sign(form)
+        : form;
+    const broadcastResponse = await session.request.send({
+        url: '/api/v1/direct_v2/threads/broadcast/raven_attachment/',
+        method: 'POST',
+        form: signedForm,
+        qs: { use_unified_inbox: true },
+    });
+    const body = broadcastResponse && (broadcastResponse.body || broadcastResponse.data || broadcastResponse);
+    return typeof body === 'string' ? JSON.parse(body) : body;
+}
+async function sendRavenPhotoOnce(session, photoBuffer, options = {}) {
+    return sendRavenPhoto(session, photoBuffer, { ...options, viewMode: 'once' });
+}
+async function sendRavenPhotoReplayable(session, photoBuffer, options = {}) {
+    return sendRavenPhoto(session, photoBuffer, { ...options, viewMode: 'replayable' });
+}
+module.exports = sendRavenPhoto;
+module.exports.sendRavenPhoto = sendRavenPhoto;
+module.exports.sendRavenPhotoOnce = sendRavenPhotoOnce;
+module.exports.sendRavenPhotoReplayable = sendRavenPhotoReplayable;

package/dist-ts/dist/sendmedia/sendRavenVideo.js

@@ -0,0 +1,136 @@
+const { v4: uuidv4 } = require('uuid');
+const axios = require('axios');
+function buildRavenVideoRuploadParams(uploadId, options = {}) {
+    return {
+        retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+        media_type: '2',
+        upload_id: uploadId.toString(),
+        upload_media_duration_ms: String(Math.round((options.duration || 0) * 1000)),
+        upload_media_width: String(options.width || 720),
+        upload_media_height: String(options.height || 1280),
+        xsharing_user_ids: JSON.stringify([]),
+        direct_v2: '1',
+    };
+}
+async function sendRavenVideo(session, videoBuffer, options = {}) {
+    var _a, _b, _c, _d;
+    const { threadId, viewMode = 'replayable', duration = 0, width = 720, height = 1280, } = options;
+    if (!videoBuffer || !Buffer.isBuffer(videoBuffer) || videoBuffer.length === 0) {
+        throw new Error('sendRavenVideo: videoBuffer must be a non-empty Buffer.');
+    }
+    if (!threadId) {
+        throw new Error('sendRavenVideo: threadId is required.');
+    }
+    const uploadId = Date.now().toString();
+    const randomSuffix = Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000);
+    const name = `${uploadId}_0_${randomSuffix}`;
+    const waterfallId = uuidv4();
+    const ruploadParams = buildRavenVideoRuploadParams(uploadId, { duration, width, height });
+    const defaultHeaders = session.request.getDefaultHeaders();
+    const messengerUploadHeaders = {
+        ...defaultHeaders,
+        'X_FB_VIDEO_WATERFALL_ID': waterfallId,
+        'X-Entity-Type': 'video/mp4',
+        'Offset': '0',
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X-Entity-Name': name,
+        'X-Entity-Length': String(videoBuffer.length),
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': String(videoBuffer.length),
+        'ephemeral_media_view_mode': '1',
+        'ig_raven_metadata': '{}',
+        'video_type': 'FILE_ATTACHMENT',
+        'x-fb-congestion-signal': '1',
+        'Host': 'rupload.facebook.com',
+    };
+    const uploadResp = await axios({
+        url: `https://rupload.facebook.com/messenger_video/${name}`,
+        method: 'POST',
+        headers: messengerUploadHeaders,
+        data: videoBuffer,
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+        transformRequest: [(d) => d],
+    });
+    const uploadParsed = uploadResp.data;
+    const serverUploadId = (uploadParsed.upload_id || uploadId).toString();
+    const attachmentFbid = uploadParsed.media_id
+        || (uploadParsed.media && uploadParsed.media.pk)
+        || (uploadParsed.media && uploadParsed.media.id)
+        || null;
+    const clientContext = BigInt(Math.floor(Math.random() * 2 ** 62)).toString();
+    const compositionId = uuidv4();
+    const cameraSessionId = uuidv4();
+    const now = Math.floor(Date.now() / 1000);
+    const form = {
+        allow_multi_configures: '1',
+        recipient_users: '[]',
+        view_mode: viewMode,
+        is_shh_mode: '0',
+        camera_entry_point: '3',
+        thread_ids: JSON.stringify([String(threadId)]),
+        reshare_mode: 'allow_reshare',
+        original_media_type: '1',
+        send_attribution: 'direct_thread_camera',
+        client_context: clientContext,
+        camera_session_id: cameraSessionId,
+        include_e2ee_mentioned_user_list: '1',
+        hide_from_profile_grid: 'false',
+        scene_capture_type: '',
+        timezone_offset: String(new Date().getTimezoneOffset() * -60),
+        client_shared_at: String(now),
+        configure_mode: '2',
+        source_type: '4',
+        camera_position: 'unknown',
+        _uid: String(session.state.cookieUserId || session.state.igUserId),
+        device_id: session.state.deviceId,
+        composition_id: compositionId,
+        mutation_token: clientContext,
+        _uuid: session.state.uuid,
+        creation_tool_info: '[]',
+        creation_surface: 'camera',
+        capture_type: 'normal',
+        audience: 'default',
+        upload_id: serverUploadId,
+        client_timestamp: String(now),
+        sampled: 'true',
+        video_result: '',
+        media_type: '1',
+        media_transformation_info: JSON.stringify({
+            width: String(width), height: String(height),
+            x_transform: '0', y_transform: '0',
+            zoom: '1.0', rotation: '0.0', background_coverage: '0.0',
+        }),
+        extra: JSON.stringify({ source_width: width, source_height: height }),
+        device: JSON.stringify({
+            manufacturer: ((_a = session.state.devicePayload) === null || _a === void 0 ? void 0 : _a.manufacturer) || 'samsung',
+            model: ((_b = session.state.devicePayload) === null || _b === void 0 ? void 0 : _b.model) || 'SM-S938B',
+            android_version: ((_c = session.state.devicePayload) === null || _c === void 0 ? void 0 : _c.android_version) || 35,
+            android_release: ((_d = session.state.devicePayload) === null || _d === void 0 ? void 0 : _d.android_release) || '15',
+        }),
+    };
+    if (attachmentFbid) {
+        form.attachment_fbid = String(attachmentFbid);
+    }
+    const signedForm = (session.request && typeof session.request.sign === 'function')
+        ? session.request.sign(form)
+        : form;
+    const broadcastResponse = await session.request.send({
+        url: '/api/v1/direct_v2/threads/broadcast/raven_attachment/',
+        method: 'POST',
+        form: signedForm,
+        qs: { use_unified_inbox: true },
+    });
+    const body = broadcastResponse && (broadcastResponse.body || broadcastResponse.data || broadcastResponse);
+    return typeof body === 'string' ? JSON.parse(body) : body;
+}
+async function sendRavenVideoOnce(session, videoBuffer, options = {}) {
+    return sendRavenVideo(session, videoBuffer, { ...options, viewMode: 'once' });
+}
+async function sendRavenVideoReplayable(session, videoBuffer, options = {}) {
+    return sendRavenVideo(session, videoBuffer, { ...options, viewMode: 'replayable' });
+}
+module.exports = sendRavenVideo;
+module.exports.sendRavenVideo = sendRavenVideo;
+module.exports.sendRavenVideoOnce = sendRavenVideoOnce;
+module.exports.sendRavenVideoReplayable = sendRavenVideoReplayable;

package/dist-ts/dist/sendmedia/uploadPhoto.js

@@ -0,0 +1,89 @@
+/**
+ * uploadPhoto.js - FIXED version based on instagram-private-api
+ */
+const { v4: uuidv4 } = require('uuid');
+/**
+ * Validate buffer and mime type
+ */
+function validateImageInput(photoBuffer, mimeType) {
+    if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
+        throw new Error('uploadPhoto: photoBuffer must be a non-empty Buffer.');
+    }
+    const allowed = ['image/jpeg', 'image/jpg', 'image/png'];
+    if (!allowed.includes(mimeType)) {
+        throw new Error(`uploadPhoto: mimeType must be one of ${allowed.join(', ')}.`);
+    }
+}
+/**
+ * Build Instagram rupload params for photo - Matching instagram-private-api
+ */
+function buildRuploadParams(uploadId, mimeType) {
+    const isJpeg = mimeType === 'image/jpeg' || mimeType === 'image/jpg';
+    const compression = isJpeg
+        ? JSON.stringify({ lib_name: 'moz', lib_version: '3.1.m', quality: '80' })
+        : JSON.stringify({ lib_name: 'png', lib_version: '1.0', quality: '100' });
+    return {
+        retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+        media_type: '1', // String '1' per instagram-private-api
+        upload_id: uploadId.toString(),
+        xsharing_user_ids: JSON.stringify([]),
+        image_compression: compression,
+    };
+}
+/**
+ * Upload a photo to Instagram's rupload endpoint.
+ */
+async function uploadPhoto(session, photoBuffer, options = {}) {
+    const { mimeType = 'image/jpeg', fileName, signal, } = options;
+    validateImageInput(photoBuffer, mimeType);
+    const uploadId = Date.now().toString();
+    const name = `${uploadId}_0_${Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000)}`;
+    const contentLength = photoBuffer.byteLength;
+    const ruploadParams = buildRuploadParams(uploadId, mimeType);
+    // Headers expected by Instagram rupload (matched with instagram-private-api)
+    const headers = {
+        'X_FB_PHOTO_WATERFALL_ID': uuidv4(),
+        'X-Entity-Type': 'image/jpeg',
+        'Offset': '0',
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X-Entity-Name': name,
+        'X-Entity-Length': String(contentLength),
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': String(contentLength),
+        'Accept-Encoding': 'gzip',
+    };
+    // If it's png, maybe we should adjust X-Entity-Type? 
+    // instagram-private-api seems to hardcode 'image/jpeg' in the trace for 'photo' method.
+    // We'll stick to 'image/jpeg' for X-Entity-Type as per reference unless user provided PNG which might work anyway.
+    const url = `/rupload_igphoto/${name}`;
+    try {
+        const response = await session.request.send({
+            url,
+            method: 'POST',
+            headers,
+            body: photoBuffer,
+            signal,
+        });
+        if (!response) {
+            throw new Error('uploadPhoto: Empty response from Instagram rupload endpoint.');
+        }
+        // Try to get upload_id from response
+        let serverUploadId = null;
+        if (typeof response === 'object' && response.body) {
+            try {
+                const body = typeof response.body === 'string' ? JSON.parse(response.body) : response.body;
+                serverUploadId = body.upload_id;
+            }
+            catch (e) {
+                // ignore parse error
+            }
+        }
+        return serverUploadId || uploadId;
+    }
+    catch (err) {
+        // If error, try to extract message
+        const msg = err.message || err.toString();
+        throw new Error(`uploadPhoto: Upload failed — ${msg}`);
+    }
+}
+module.exports = uploadPhoto;

package/dist-ts/dist/sendmedia/uploadfFile.js

@@ -0,0 +1,108 @@
+/**
+ * uploadfFile.js - FIXED version based on instagram-private-api
+ */
+const { v4: uuidv4 } = require('uuid');
+const DEFAULT_CHUNK_SIZE = 512 * 1024; // 512KB
+/**
+ * Validate upload input
+ */
+function validateFileInput(fileBuffer, mimeType) {
+    if (!fileBuffer || !Buffer.isBuffer(fileBuffer) || fileBuffer.length === 0) {
+        throw new Error('uploadFile: fileBuffer must be a non-empty Buffer.');
+    }
+    if (typeof mimeType !== 'string' || mimeType.length === 0) {
+        throw new Error('uploadFile: mimeType must be a non-empty string.');
+    }
+}
+/**
+ * Build rupload params - Matching instagram-private-api
+ */
+function buildRuploadParams(uploadId, mimeType, opts) {
+    var _a, _b, _c;
+    const isVideo = mimeType.startsWith('video/');
+    const isAudio = mimeType.startsWith('audio/');
+    const params = {
+        retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+        media_type: isVideo ? '2' : '3', // 2 for video, 3 for audio/others?
+        upload_id: uploadId.toString(),
+        xsharing_user_ids: JSON.stringify([]),
+    };
+    if (isVideo) {
+        params.upload_media_duration_ms = ((_a = opts.duration) === null || _a === void 0 ? void 0 : _a.toString()) || '0';
+        params.upload_media_width = ((_b = opts.width) === null || _b === void 0 ? void 0 : _b.toString()) || '720';
+        params.upload_media_height = ((_c = opts.height) === null || _c === void 0 ? void 0 : _c.toString()) || '1280';
+        params.direct_v2 = '1';
+    }
+    return params;
+}
+/**
+ * Upload file via rupload with chunking.
+ */
+async function uploadFile(session, fileBuffer, options = {}) {
+    const { mimeType = 'video/mp4', fileName, chunkSize = DEFAULT_CHUNK_SIZE, signal, } = options;
+    validateFileInput(fileBuffer, mimeType);
+    const uploadId = Date.now().toString();
+    const name = `${uploadId}_0_${Math.floor(Math.random() * 9000000000 + 1000000000)}`;
+    const totalLength = fileBuffer.length;
+    const waterfallId = uuidv4();
+    const ruploadParams = buildRuploadParams(uploadId, mimeType, options);
+    const endpoint = mimeType.startsWith('image/')
+        ? `/rupload_igphoto/${name}`
+        : `/rupload_igvideo/${name}`;
+    // Start upload
+    let offset = 0;
+    const size = Math.max(64 * 1024, Math.min(4 * 1024 * 1024, chunkSize));
+    try {
+        while (offset < totalLength) {
+            const end = Math.min(offset + size, totalLength);
+            const chunk = fileBuffer.subarray(offset, end);
+            const headers = {
+                'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+                'X_FB_VIDEO_WATERFALL_ID': waterfallId,
+                'X-Entity-Type': mimeType,
+                'X-Entity-Name': name,
+                'X-Entity-Length': String(totalLength),
+                'Offset': String(offset),
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': String(chunk.length),
+                'Accept-Encoding': 'gzip',
+            };
+            const res = await session.request.send({
+                url: endpoint,
+                method: 'POST',
+                headers,
+                body: chunk,
+                signal,
+            });
+            if (!res)
+                throw new Error(`uploadFile: Empty response at offset ${offset}`);
+            offset = end;
+        }
+        // Finalize
+        const confirm = await session.request.send({
+            url: endpoint,
+            method: 'POST',
+            headers: {
+                'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+                'X_FB_VIDEO_WATERFALL_ID': waterfallId,
+                'X-Entity-Type': mimeType,
+                'Offset': String(totalLength),
+                'Content-Length': '0',
+            },
+            signal,
+        });
+        let serverUploadId = null;
+        if (confirm && confirm.body) {
+            try {
+                const body = typeof confirm.body === 'string' ? JSON.parse(confirm.body) : confirm.body;
+                serverUploadId = body.upload_id;
+            }
+            catch (e) { }
+        }
+        return serverUploadId || uploadId;
+    }
+    catch (err) {
+        throw new Error(`uploadFile: Upload failed — ${err.message}`);
+    }
+}
+module.exports = uploadFile;