fca-neokex-fix 1.0.1

package/src/utils/formatters/data/formatAttachment.js

@@ -0,0 +1,370 @@
+"use strict";
+
+const url = require("url");
+const querystring = require("querystring");
+const { getType } = require("../../constants");
+
+function getExtension(original_extension, fullFileName = "") {
+    if (original_extension) {
+        return original_extension;
+    } else {
+        const extension = fullFileName.split(".").pop();
+        return (extension === fullFileName) ? "" : extension;
+    }
+}
+
+function _formatAttachment(attachment1, attachment2) {
+    const blob_attachment = attachment1.mercury || attachment1.blob_attachment || attachment1.sticker_attachment;
+    let type_attachment = blob_attachment && blob_attachment.__typename ? blob_attachment.__typename : attachment1.attach_type;
+
+    if (type_attachment == null && attachment1.id != null && attachment1.extensible_attachment == null) {
+        return {
+            type: "share",
+            ID: attachment1.id,
+            url: attachment1.href,
+            title: "Shared Content",
+            description: "Unsupported shared content.",
+            source: null,
+            isUnrecognized: true
+        };
+    }
+    
+    if (!attachment1.attach_type && attachment1.imageMetadata) {
+        return {
+            type: 'photo',
+            ID: attachment1.fbid,
+            filename: attachment1.filename,
+            fileSize: Number(attachment1.fileSize || 0),
+            mimeType: attachment1.mimeType,
+            width: attachment1.imageMetadata.width,
+            height: attachment1.imageMetadata.height,
+            url: null,
+            thumbnailUrl: null,
+            previewUrl: null,
+            largePreviewUrl: null,
+            name: attachment1.filename
+        };
+    }
+
+    attachment2 = attachment2 || { id: "", image_data: {} };
+    attachment1 = attachment1.mercury || attachment1;
+    let blob = attachment1.blob_attachment || attachment1.sticker_attachment;
+    let type = blob && blob.__typename ? blob.__typename : attachment1.attach_type;
+
+    if (!type && attachment1.sticker_attachment) {
+        type = "StickerAttachment";
+        blob = attachment1.sticker_attachment;
+    } else if (!type && attachment1.extensible_attachment) {
+        if (attachment1.extensible_attachment.story_attachment?.target?.__typename === "MessageLocation") {
+            type = "MessageLocation";
+        } else {
+            type = "ExtensibleAttachment";
+        }
+        blob = attachment1.extensible_attachment;
+    }
+
+    switch (type) {
+        case "sticker":
+            return {
+                type: "sticker",
+                ID: attachment1.metadata?.stickerID?.toString() || "",
+                url: attachment1.url || null,
+                packID: attachment1.metadata?.packID?.toString() || "",
+                spriteUrl: attachment1.metadata?.spriteURI || null,
+                spriteUrl2x: attachment1.metadata?.spriteURI2x || null,
+                width: attachment1.metadata?.width || 0,
+                height: attachment1.metadata?.height || 0,
+                caption: attachment2?.caption || null,
+                description: attachment2?.description || null,
+                frameCount: attachment1.metadata?.frameCount || 0,
+                frameRate: attachment1.metadata?.frameRate || 0,
+                framesPerRow: attachment1.metadata?.framesPerRow || 0,
+                framesPerCol: attachment1.metadata?.framesPerCol || 0,
+                stickerID: attachment1.metadata?.stickerID?.toString() || "",
+                spriteURI: attachment1.metadata?.spriteURI || null,
+                spriteURI2x: attachment1.metadata?.spriteURI2x || null
+            };
+        case "file":
+            return {
+                type: "file",
+                filename: attachment1.name || "",
+                ID: attachment2?.id?.toString() || "",
+                url: attachment1.url || null,
+                isMalicious: attachment2?.is_malicious || false,
+                contentType: attachment2?.mime_type || "",
+                name: attachment1.name || "",
+                mimeType: attachment2?.mime_type || "",
+                fileSize: attachment2?.file_size || 0
+            };
+        case "photo":
+            const dimensions = attachment1.metadata?.dimensions?.split(",") || ["0", "0"];
+            return {
+                type: "photo",
+                ID: attachment1.metadata?.fbid?.toString() || "",
+                filename: attachment1.fileName || "",
+                thumbnailUrl: attachment1.thumbnail_url || null,
+                previewUrl: attachment1.preview_url || null,
+                previewWidth: attachment1.preview_width || 0,
+                previewHeight: attachment1.preview_height || 0,
+                largePreviewUrl: attachment1.large_preview_url || null,
+                largePreviewWidth: attachment1.large_preview_width || 0,
+                largePreviewHeight: attachment1.large_preview_height || 0,
+                url: attachment1.metadata?.url || null,
+                width: dimensions[0] || "0",
+                height: dimensions[1] || "0",
+                name: attachment1.fileName || ""
+            };
+        case "animated_image":
+            return {
+                type: "animated_image",
+                ID: attachment2?.id?.toString() || "",
+                filename: attachment2?.filename || "",
+                previewUrl: attachment1?.preview_url || null,
+                previewWidth: attachment1?.preview_width || 0,
+                previewHeight: attachment1?.preview_height || 0,
+                url: attachment2?.image_data?.url || null,
+                width: attachment2?.image_data?.width || 0,
+                height: attachment2?.image_data?.height || 0,
+                name: attachment1?.name || "",
+                facebookUrl: attachment1?.url || null,
+                thumbnailUrl: attachment1?.thumbnail_url || null,
+                mimeType: attachment2?.mime_type || "",
+                rawGifImage: attachment2?.image_data?.raw_gif_image || null,
+                rawWebpImage: attachment2?.image_data?.raw_webp_image || null,
+                animatedGifUrl: attachment2?.image_data?.animated_gif_url || null,
+                animatedGifPreviewUrl: attachment2?.image_data?.animated_gif_preview_url || null,
+                animatedWebpUrl: attachment2?.image_data?.animated_webp_url || null,
+                animatedWebpPreviewUrl: attachment2?.image_data?.animated_webp_preview_url || null
+            };
+        case "share":
+            return {
+                type: "share",
+                ID: attachment1.share?.share_id?.toString() || "",
+                url: attachment2?.href || null,
+                title: attachment1.share?.title || null,
+                description: attachment1.share?.description || null,
+                source: attachment1.share?.source || null,
+                image: attachment1.share?.media?.image || null,
+                width: attachment1.share?.media?.image_size?.width || null,
+                height: attachment1.share?.media?.image_size?.height || null,
+                playable: attachment1.share?.media?.playable || false,
+                duration: attachment1.share?.media?.duration || 0,
+                subattachments: attachment1.share?.subattachments || [],
+                properties: {},
+                animatedImageSize: attachment1.share?.media?.animated_image_size || null,
+                facebookUrl: attachment1.share?.uri || null,
+                target: attachment1.share?.target || null,
+                styleList: attachment1.share?.style_list || null
+            };
+        case "video":
+            return {
+                type: "video",
+                ID: attachment1.metadata?.fbid?.toString() || "",
+                filename: attachment1.name || "",
+                previewUrl: attachment1.preview_url || null,
+                previewWidth: attachment1.preview_width || 0,
+                previewHeight: attachment1.preview_height || 0,
+                url: attachment1.url || null,
+                width: attachment1.metadata?.dimensions?.width || 0,
+                height: attachment1.metadata?.dimensions?.height || 0,
+                duration: attachment1.metadata?.duration || 0,
+                videoType: "unknown",
+                thumbnailUrl: attachment1.thumbnail_url || null
+            };
+        case "error":
+            return {
+                type: "error",
+                attachment1: attachment1,
+                attachment2: attachment2
+            };
+        case "MessageImage":
+            return {
+                type: "photo",
+                ID: blob.legacy_attachment_id,
+                filename: blob.filename,
+                thumbnailUrl: blob.thumbnail.uri,
+                previewUrl: blob.preview.uri,
+                previewWidth: blob.preview.width,
+                previewHeight: blob.preview.height,
+                largePreviewUrl: blob.large_preview.uri,
+                largePreviewWidth: blob.large_preview.width,
+                largePreviewHeight: blob.large_preview.height,
+                url: blob.large_preview.uri,
+                width: blob.original_dimensions.x,
+                height: blob.original_dimensions.y,
+                name: blob.filename
+            };
+        case "MessageAnimatedImage":
+            return {
+                type: "animated_image",
+                ID: blob.legacy_attachment_id,
+                filename: blob.filename,
+                previewUrl: blob.preview_image.uri,
+                previewWidth: blob.preview_image.width,
+                previewHeight: blob.preview_image.height,
+                url: blob.animated_image.uri,
+                width: blob.animated_image.width,
+                height: blob.animated_image.height,
+                thumbnailUrl: blob.preview_image.uri,
+                name: blob.filename,
+                facebookUrl: blob.animated_image.uri,
+                rawGifImage: blob.animated_image.uri,
+                animatedGifUrl: blob.animated_image.uri,
+                animatedGifPreviewUrl: blob.preview_image.uri,
+                animatedWebpUrl: blob.animated_image.uri,
+                animatedWebpPreviewUrl: blob.preview_image.uri
+            };
+        case "MessageVideo":
+            return {
+                type: "video",
+                filename: blob.filename,
+                ID: blob.legacy_attachment_id,
+                previewUrl: blob.large_image.uri,
+                previewWidth: blob.large_image.width,
+                previewHeight: blob.large_image.height,
+                url: blob.playable_url,
+                width: blob.original_dimensions.x,
+                height: blob.original_dimensions.y,
+                duration: blob.playable_duration_in_ms,
+                videoType: blob.video_type.toLowerCase(),
+                thumbnailUrl: blob.large_image.uri
+            };
+        case "MessageFile":
+            return {
+                type: "file",
+                filename: blob.filename,
+                ID: blob.message_file_fbid,
+                url: blob.url,
+                isMalicious: blob.is_malicious,
+                contentType: blob.content_type,
+                name: blob.filename,
+                mimeType: blob.content_type || "",
+                fileSize: -1
+            };
+        case "MessageAudio":
+            return {
+                type: "audio",
+                filename: blob.filename,
+                ID: blob.url_shimhash,
+                audioType: blob.audio_type,
+                duration: blob.playable_duration_in_ms,
+                url: blob.playable_url,
+                isVoiceMail: blob.is_voicemail
+            };
+        case "Sticker":
+        case "StickerAttachment":
+            return {
+                type: "sticker",
+                ID: blob.id,
+                url: blob.url,
+                packID: blob.pack ? blob.pack.id : null,
+                spriteUrl: blob.sprite_image,
+                spriteUrl2x: blob.sprite_image_2x,
+                width: blob.width,
+                height: blob.height,
+                caption: blob.label,
+                description: blob.label,
+                frameCount: blob.frame_count,
+                frameRate: blob.frame_rate,
+                framesPerRow: blob.frames_per_row,
+                framesPerCol: blob.frames_per_column,
+                stickerID: blob.id,
+                spriteURI: blob.sprite_image,
+                spriteURI2x: blob.sprite_image_2x
+            };
+        case "MessageLocation":
+            const urlAttach = blob.story_attachment.url;
+            const mediaAttach = blob.story_attachment.media;
+            
+            let u, where1, address, latitude, longitude, imageUrl, width, height;
+            
+            try {
+                u = querystring.parse(url.parse(urlAttach).query).u;
+                where1 = querystring.parse(url.parse(u).query).where1;
+                address = where1.split(", ");
+                latitude = Number.parseFloat(address[0]);
+                longitude = Number.parseFloat(address[1]);
+            } catch (err) {
+                latitude = undefined;
+                longitude = undefined;
+            }
+            
+            if (mediaAttach && mediaAttach.image) {
+                imageUrl = mediaAttach.image.uri;
+                width = mediaAttach.image.width;
+                height = mediaAttach.image.height;
+            }
+            
+            return {
+                type: "location",
+                ID: blob.legacy_attachment_id,
+                latitude: latitude,
+                longitude: longitude,
+                image: imageUrl,
+                width: width,
+                height: height,
+                url: u || urlAttach,
+                address: where1,
+                facebookUrl: blob.story_attachment.url,
+                target: blob.story_attachment.target,
+                styleList: blob.story_attachment.style_list
+            };
+        case "ExtensibleAttachment":
+            const story = blob.story_attachment;
+            return {
+                type: "share",
+                ID: blob.legacy_attachment_id,
+                url: story?.url || null,
+                title: story?.title_with_entities?.text || null,
+                description: story?.description?.text || null,
+                source: story?.source?.text || null,
+                image: story?.media?.image?.uri || null,
+                width: story?.media?.image?.width || null,
+                height: story?.media?.image?.height || null,
+                playable: story?.media?.is_playable || false,
+                duration: story?.media?.playable_duration_in_ms || 0,
+                playableUrl: story?.media?.playable_url || null,
+                subattachments: story?.subattachments || [],
+                properties: (story?.properties || []).reduce((obj, cur) => {
+                    if (cur && cur.key && cur.value) {
+                        obj[cur.key] = cur.value.text || cur.value;
+                    }
+                    return obj;
+                }, {}),
+                facebookUrl: story?.url || null,
+                target: story?.target || null,
+                styleList: story?.style_list || null
+            };
+        default:
+            try {
+                throw new Error(
+                    "Unrecognized attachment type: " + type +
+                    "\nattachment1: " + JSON.stringify(attachment1, null, 2) +
+                    "\nattachment2: " + JSON.stringify(attachment2, null, 2)
+                );
+            } catch (err) {
+                return {
+                    type: "unknown",
+                    error: err.message,
+                    rawAttachment1: attachment1,
+                    rawAttachment2: attachment2
+                };
+            }
+    }
+}
+
+function formatAttachment(attachments, attachmentIds, attachmentMap, shareMap) {
+    attachmentMap = shareMap || attachmentMap;
+    return attachments ?
+        attachments.map((val, i) => {
+            if (!attachmentMap || !attachmentIds || !attachmentMap[attachmentIds[i]]) {
+                return _formatAttachment(val);
+            }
+            return _formatAttachment(val, attachmentMap[attachmentIds[i]]);
+        }) : [];
+}
+
+module.exports = {
+    _formatAttachment,
+    formatAttachment
+};

package/src/utils/formatters/data/formatDelta.js

@@ -0,0 +1,153 @@
+"use strict";
+
+const formatID = require('../value/formatID');
+const { _formatAttachment } = require('./formatAttachment');
+
+function getAdminTextMessageType(type) {
+    switch (type) {
+        case 'unpin_messages_v2': return 'log:unpin-message';
+        case 'pin_messages_v2': return 'log:pin-message';
+        case "change_thread_theme": return "log:thread-color";
+        case "change_thread_icon":
+        case 'change_thread_quick_reaction': return "log:thread-icon";
+        case "change_thread_nickname": return "log:user-nickname";
+        case "change_thread_admins": return "log:thread-admins";
+        case "group_poll": return "log:thread-poll";
+        case "change_thread_approval_mode": return "log:thread-approval-mode";
+        case "messenger_call_log":
+        case "participant_joined_group_call": return "log:thread-call";
+        default: return type;
+    }
+}
+
+function formatDeltaMessage(m) {
+    const md = m.delta.messageMetadata;
+    const mentions = {};
+    
+    // Try multiple sources for mentions data (Facebook changed format multiple times)
+    let mdata = [];
+    
+    // Method 1: data.prng (old format)
+    if (m.delta.data?.prng) {
+        try {
+            mdata = JSON.parse(m.delta.data.prng);
+        } catch (e) {}
+    }
+    
+    // Method 2: data.mentions (newer format)
+    if (mdata.length === 0 && m.delta.data?.mentions) {
+        try {
+            mdata = JSON.parse(m.delta.data.mentions);
+        } catch (e) {}
+    }
+    
+    // Method 3: messageMetadata.ranges (latest format)
+    if (mdata.length === 0 && md.ranges) {
+        try {
+            mdata = md.ranges.map(r => ({
+                i: r.entity?.id || r.mentionID || r.id,
+                o: r.offset,
+                l: r.length
+            }));
+        } catch (e) {}
+    }
+    
+    // Method 4: delta.mentions directly
+    if (mdata.length === 0 && m.delta.mentions) {
+        try {
+            if (Array.isArray(m.delta.mentions)) {
+                mdata = m.delta.mentions.map(mention => ({
+                    i: mention.id || mention.i,
+                    o: mention.offset || mention.o,
+                    l: mention.length || mention.l
+                }));
+            }
+        } catch (e) {}
+    }
+    
+    // Build mentions object
+    for (const mention of mdata) {
+        if (mention.i && m.delta.body) {
+            mentions[mention.i] = m.delta.body.substring(mention.o, mention.o + mention.l);
+        }
+    }
+
+    const messageReply = m.delta.messageReply ? {
+        messageID: m.delta.messageReply.messageID,
+        senderID: formatID(m.delta.messageReply.senderID),
+        body: m.delta.messageReply.body,
+        attachments: m.delta.messageReply.attachments,
+        timestamp: m.delta.messageReply.timestamp,
+        isReply: true
+    } : null;
+
+    return {
+        type: "message",
+        senderID: formatID(md.actorFbId.toString()),
+        body: m.delta.body || "",
+        threadID: formatID((md.threadKey.threadFbId || md.threadKey.otherUserFbId).toString()),
+        messageID: md.messageId,
+        offlineThreadingId: md.offlineThreadingId,
+        attachments: (m.delta.attachments || []).map(v => _formatAttachment(v)),
+        mentions: mentions,
+        timestamp: md.timestamp,
+        isGroup: !!md.threadKey.threadFbId,
+        participantIDs: m.delta.participants,
+        messageReply: messageReply
+    };
+}
+
+function formatDeltaEvent(m) {
+    let logMessageType;
+    let logMessageData;
+
+    switch (m.class) {
+        case "AdminTextMessage":
+            logMessageData = m.untypedData;
+            logMessageType = getAdminTextMessageType(m.type);
+            break;
+        case "ThreadName":
+            logMessageType = "log:thread-name";
+            logMessageData = { name: m.name };
+            break;
+        case "ParticipantsAddedToGroupThread":
+            logMessageType = "log:subscribe";
+            logMessageData = { addedParticipants: m.addedParticipants };
+            break;
+        case "ParticipantLeftGroupThread":
+            logMessageType = "log:unsubscribe";
+            logMessageData = { leftParticipantFbId: m.leftParticipantFbId };
+            break;
+        default:
+            logMessageType = m.class;
+            logMessageData = m;
+    }
+
+    return {
+        type: "event",
+        threadID: formatID((m.messageMetadata.threadKey.threadFbId || m.messageMetadata.threadKey.otherUserFbId).toString()),
+        messageID: m.messageMetadata.messageId.toString(),
+        logMessageType,
+        logMessageData,
+        logMessageBody: m.messageMetadata.adminText,
+        timestamp: m.messageMetadata.timestamp,
+        author: m.messageMetadata.actorFbId,
+        participantIDs: m.participants
+    };
+}
+
+function formatDeltaReadReceipt(delta) {
+    return {
+        reader: (delta.threadKey.otherUserFbId || delta.actorFbId).toString(),
+        time: delta.actionTimestampMs,
+        threadID: formatID((delta.threadKey.otherUserFbId || delta.threadKey.threadFbId).toString()),
+        type: "read_receipt"
+    };
+}
+
+module.exports = {
+    formatDeltaMessage,
+    formatDeltaEvent,
+    formatDeltaReadReceipt,
+    getAdminTextMessageType
+};

package/src/utils/formatters/index.js

@@ -0,0 +1,159 @@
+"use strict";
+
+const stream = require("stream");
+const formatID = require('./value/formatID');
+const formatDate = require('./value/formatDate');
+const formatCookie = require('./value/formatCookie');
+const { _formatAttachment, formatAttachment } = require('./data/formatAttachment');
+const { formatDeltaMessage, formatDeltaEvent, formatDeltaReadReceipt, getAdminTextMessageType } = require('./data/formatDelta');
+
+function isReadableStream(obj) {
+    return obj instanceof stream.Stream && typeof obj._read == "function" && typeof obj._readableState == "object";
+}
+
+function decodeClientPayload(payload) {
+    return JSON.parse(String.fromCharCode.apply(null, payload));
+}
+
+function formatMessage(m) {
+    const originalMessage = m.message ? m.message : m;
+    const obj = {
+        type: "message",
+        senderName: originalMessage.sender_name,
+        senderID: formatID(originalMessage.sender_fbid.toString()),
+        participantNames: originalMessage.group_thread_info?.participant_names || [originalMessage.sender_name.split(" ")[0]],
+        participantIDs: originalMessage.group_thread_info?.participant_ids.map(v => formatID(v.toString())) || [formatID(originalMessage.sender_fbid)],
+        body: originalMessage.body || "",
+        threadID: formatID((originalMessage.thread_fbid || originalMessage.other_user_fbid).toString()),
+        threadName: originalMessage.group_thread_info?.name || originalMessage.sender_name,
+        location: originalMessage.coordinates || null,
+        messageID: originalMessage.mid?.toString() || originalMessage.message_id,
+        attachments: formatAttachment(originalMessage.attachments, originalMessage.attachmentIds, originalMessage.attachment_map, originalMessage.share_map),
+        timestamp: originalMessage.timestamp,
+        tags: originalMessage.tags,
+        reactions: originalMessage.reactions || [],
+        isUnread: originalMessage.is_unread
+    };
+    if (m.type === "pages_messaging") obj.pageID = m.realtime_viewer_fbid.toString();
+    obj.isGroup = obj.participantIDs.length > 2;
+    return obj;
+}
+
+function formatEvent(m) {
+    const originalMessage = m.message ? m.message : m;
+    let logMessageType = originalMessage.log_message_type;
+    let logMessageData;
+    if (logMessageType === "log:generic-admin-text") {
+        logMessageData = originalMessage.log_message_data.untypedData;
+        logMessageType = getAdminTextMessageType(originalMessage.log_message_data.message_type);
+    } else {
+        logMessageData = originalMessage.log_message_data;
+    }
+    return {
+        ...formatMessage(originalMessage),
+        type: "event",
+        logMessageType,
+        logMessageData,
+        logMessageBody: originalMessage.log_message_body
+    };
+}
+
+function formatHistoryMessage(m) {
+    return m.action_type === "ma-type:log-message" ? formatEvent(m) : formatMessage(m);
+}
+
+function formatTyp(event) {
+    return {
+        isTyping: !!event.st,
+        from: event.from.toString(),
+        threadID: formatID((event.to || event.thread_fbid || event.from).toString()),
+        fromMobile: event.hasOwnProperty("from_mobile") ? event.from_mobile : true,
+        userID: (event.realtime_viewer_fbid || event.from).toString(),
+        type: "typ"
+    };
+}
+
+function formatReadReceipt(event) {
+    return {
+        reader: event.reader.toString(),
+        time: event.time,
+        threadID: formatID((event.thread_fbid || event.reader).toString()),
+        type: "read_receipt"
+    };
+}
+
+function formatRead(event) {
+    return {
+        threadID: formatID(((event.chat_ids && event.chat_ids[0]) || (event.thread_fbids && event.thread_fbids[0])).toString()),
+        time: event.timestamp,
+        type: "read"
+    };
+}
+
+function formatThread(data) {
+    return {
+        threadID: formatID(data.thread_fbid.toString()),
+        participants: data.participants.map(p => formatID(p)),
+        participantIDs: data.participants.map(p => formatID(p)),
+        name: data.name,
+        nicknames: data.custom_nickname,
+        snippet: data.snippet,
+        snippetSender: formatID((data.snippet_sender || "").toString()),
+        unreadCount: data.unread_count,
+        messageCount: data.message_count,
+        imageSrc: data.image_src,
+        timestamp: data.timestamp,
+        muteUntil: data.mute_until,
+        isGroup: data.thread_type === 2,
+        isArchived: data.is_archived,
+        canReply: data.can_reply,
+        lastMessageTimestamp: data.last_message_timestamp,
+        lastReadTimestamp: data.last_read_timestamp,
+        emoji: data.custom_like_icon,
+        color: data.custom_color,
+        adminIDs: data.admin_ids,
+        threadType: data.thread_type
+    };
+}
+
+function formatPresence(presence, userID) {
+    return {
+        type: "presence",
+        timestamp: presence.la * 1000,
+        userID: userID,
+        statuses: presence.a
+    };
+}
+
+function formatProxyPresence(presence, userID) {
+    if (presence.lat === undefined || presence.p === undefined) return null;
+    return {
+        type: "presence",
+        timestamp: presence.lat * 1000,
+        userID: userID,
+        statuses: presence.p
+    };
+}
+
+module.exports = {
+    isReadableStream,
+    formatID,
+    formatDate,
+    formatCookie,
+    formatAttachment,
+    _formatAttachment,
+    formatDeltaMessage,
+    formatMessage,
+    formatEvent,
+    formatHistoryMessage,
+    getAdminTextMessageType,
+    formatDeltaEvent,
+    formatTyp,
+    formatDeltaReadReceipt,
+    formatReadReceipt,
+    formatRead,
+    formatThread,
+    formatProxyPresence,
+    formatPresence,
+    decodeClientPayload,
+};