fca-phantom 1.0.0

package/phantom/datastore/models/types/index.d.ts

@@ -0,0 +1,498 @@
+/// <reference types="node" />
+import { ReadStream } from "fs";
+import { EventEmitter } from "events";
+
+declare module "fca-marin" {
+    export type UserID = string;
+    export type ThreadID = string;
+    export type MessageID = string;
+    export type Callback<T = any> = (err: any, result?: T) => void;
+
+    export interface Coordinates {
+        latitude: number;
+        longitude: number;
+    }
+
+    export interface Mention {
+        tag: string;
+        id: UserID;
+        fromIndex?: number;
+    }
+
+    export interface Reaction {
+        reaction: string;
+        userID: UserID;
+    }
+
+    export interface StickerPackInfo {
+        id: string;
+        name: string;
+        thumbnail?: string;
+    }
+
+    export interface StickerInfo {
+        type: "sticker";
+        ID: string;
+        url?: string;
+        animatedUrl?: string;
+        packID?: string;
+        label: string;
+        stickerID: string;
+    }
+
+    export interface AddedStickerPackInfo {
+        id: string;
+        name: string;
+        in_sticker_tray: boolean;
+        artist?: string;
+        preview_image?: { uri: string };
+        thumbnail_image?: { uri: string };
+    }
+
+    export interface CommentMessage {
+        body: string;
+        attachment?: ReadStream[];
+        mentions?: Mention[];
+        url?: string;
+        sticker?: string;
+    }
+
+    export interface CommentResult {
+        id: string;
+        url: string;
+        count: number;
+    }
+
+    export interface ShareResult {
+        postID: string;
+        url: string;
+    }
+
+    export interface Attachment {
+        type: "photo" | "animated_image" | "video" | "audio" | "file" | "sticker" | "share" | "location" | "unknown";
+        ID: string;
+        filename: string;
+        url?: string;
+        name?: string;
+    }
+
+    export interface PhotoAttachment extends Attachment {
+        type: "photo";
+        thumbnailUrl: string;
+        previewUrl: string;
+        previewWidth: number;
+        previewHeight: number;
+        largePreviewUrl: string;
+        largePreviewWidth: number;
+        largePreviewHeight: number;
+        width: number;
+        height: number;
+    }
+
+    export interface VideoAttachment extends Attachment {
+        type: "video";
+        duration: number;
+        width: number;
+        height: number;
+        previewUrl: string;
+        previewWidth: number;
+        previewHeight: number;
+        videoType: "file_attachment" | "native_video" | "unknown";
+    }
+
+    export interface AudioAttachment extends Attachment {
+        type: "audio";
+        duration: number;
+        audioType: string;
+        isVoiceMail: boolean;
+    }
+
+    export interface FileAttachment extends Attachment {
+        type: "file";
+        isMalicious: boolean;
+        contentType: string;
+    }
+
+    export interface StickerAttachment extends Attachment {
+        type: "sticker";
+        packID: string;
+        spriteUrl?: string;
+        spriteUrl2x?: string;
+        width: number;
+        height: number;
+        caption: string;
+        description: string;
+        frameCount: number;
+        frameRate: number;
+        framesPerRow: number;
+        framesPerCol: number;
+    }
+
+    export interface ShareAttachment extends Attachment {
+        type: "share";
+        title: string;
+        description?: string;
+        source?: string;
+        image?: string;
+        width?: number;
+        height?: number;
+        playable?: boolean;
+        subattachments?: any[];
+        properties: Record<string, any>;
+    }
+
+    export type AnyAttachment =
+        | PhotoAttachment
+        | VideoAttachment
+        | AudioAttachment
+        | FileAttachment
+        | StickerAttachment
+        | ShareAttachment;
+
+    export interface MessageReply {
+        messageID: MessageID;
+        senderID: UserID;
+        body: string;
+        attachments: AnyAttachment[];
+        timestamp: string;
+        isReply: true;
+    }
+
+    export interface Message {
+        type: "message";
+        senderID: UserID;
+        body: string;
+        threadID: ThreadID;
+        messageID: MessageID;
+        attachments: AnyAttachment[];
+        mentions: Record<string, string>;
+        timestamp: string;
+        isGroup: boolean;
+        participantIDs?: UserID[];
+        messageReply?: MessageReply;
+        isUnread?: boolean;
+        reactions?: Reaction[];
+    }
+
+    export interface Event {
+        type: "event";
+        threadID: ThreadID;
+        logMessageType: string;
+        logMessageData: any;
+        logMessageBody: string;
+        timestamp: string;
+        author: UserID;
+    }
+
+    export interface TypingIndicator {
+        type: "typ";
+        isTyping: boolean;
+        from: UserID;
+        threadID: ThreadID;
+        fromMobile: boolean;
+    }
+
+    export interface UnsendMessageEvent {
+        type: "unsend";
+        messageID: MessageID;
+        threadID: ThreadID;
+        senderID: UserID;
+        deletionTimestamp: string;
+    }
+
+    export interface EmojiEvent {
+        type: "change_thread_emoji";
+        threadID: ThreadID;
+        author: UserID;
+        emoji: string;
+    }
+
+    export interface GroupNameEvent {
+        type: "change_thread_name";
+        threadID: ThreadID;
+        author: UserID;
+        name: string;
+    }
+
+    export interface NicknameEvent {
+        type: "change_thread_nickname";
+        threadID: ThreadID;
+        author: UserID;
+        participantID: UserID;
+        nickname: string;
+    }
+
+    export type ListenEvent = Message | Event | TypingIndicator;
+
+    export interface UserInfo {
+        id: UserID;
+        name: string;
+        firstName: string;
+        lastName?: string;
+        vanity: string;
+        profileUrl: string;
+        profilePicUrl: string;
+        gender: string;
+        type: "user" | "page";
+        isFriend: boolean;
+        isBirthday: boolean;
+        bio?: string;
+        live_city?: string;
+        followers?: string;
+        following?: string;
+        coverPhoto?: string;
+    }
+
+    export interface ThreadInfo {
+        threadID: ThreadID;
+        threadName?: string;
+        participantIDs: UserID[];
+        userInfo: UserInfo[];
+        unreadCount: number;
+        messageCount: number;
+        imageSrc?: string;
+        timestamp: string;
+        muteUntil: number;
+        isGroup: boolean;
+        isArchived: boolean;
+        isSubscribed: boolean;
+        folder: string;
+        nicknames: Record<UserID, string>;
+        adminIDs: UserID[];
+        emoji?: string;
+        color?: string;
+        canReply: boolean;
+        inviteLink: {
+            enable: boolean;
+            link: string | null;
+        };
+    }
+
+    export interface MessageObject {
+        body?: string;
+        attachment?: ReadStream | ReadStream[];
+        sticker?: string;
+        emoji?: string;
+        emojiSize?: "small" | "medium" | "large";
+        mentions?: Mention[];
+        edit?: [string, number][];
+        url?: string;
+        location?: Coordinates;
+    }
+
+    export interface FriendInfo {
+        alternateName: string;
+        firstName: string;
+        gender: string;
+        userID: UserID;
+        isFriend: boolean;
+        fullName: string;
+        profilePicture: string;
+        type: string;
+        profileUrl: string;
+        vanity: string;
+        isBirthday: boolean;
+    }
+
+    export interface HealthStatus {
+        mqttConnected: boolean;
+        autoReconnect: boolean;
+        tokenRefresh: {
+            lastRefresh: number;
+            nextRefresh: number;
+            failureCount: number;
+        };
+        rateLimiter: {
+            activeRequests: number;
+            maxConcurrentRequests: number;
+            maxRequestsPerMinute: number;
+            threadCooldowns: number;
+            endpointCooldowns: number;
+            errorCacheSize: number;
+        } | null;
+    }
+
+    export interface API {
+        setOptions(options: LoginOptions): void;
+        getAppState(): any[];
+        getCurrentUserID(): UserID;
+        getHealthStatus(): HealthStatus;
+
+        listen(callback: (err: any, event: ListenEvent) => void): EventEmitter;
+
+        listenMqtt(callback: (err: any, event: ListenEvent) => void): void;
+
+        sendMessage(
+            message: string | MessageObject,
+            threadID: ThreadID,
+            replyToMessage?: MessageID | Callback<Message>,
+            callback?: Callback<Message>,
+        ): Promise<Message> | void;
+
+        sendMessageMqtt(
+            message: string | MessageObject,
+            threadID: ThreadID,
+            replyToMessage?: MessageID,
+            callback?: Callback<Message>,
+        ): void;
+
+        editMessage(text: string, messageID: MessageID, callback?: Callback): void;
+
+        unsendMessage(messageID: MessageID, threadID: ThreadID, callback?: Callback<UnsendMessageEvent>): Promise<UnsendMessageEvent>;
+
+        forwardMessage(messageID: MessageID, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        deleteMessage(messageIDs: MessageID | MessageID[], callback?: Callback): Promise<void>;
+
+        setMessageReaction(reaction: string, messageID: MessageID, callback?: Callback, forceCustomReaction?: boolean): Promise<void>;
+        setMessageReactionMqtt(reaction: string, messageID: MessageID, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        shareContact(text: string, senderID: UserID, threadID: ThreadID, callback?: Callback): void;
+        shareContact(senderID: UserID, threadID: ThreadID, callback?: Callback): void;
+        resolvePhotoUrl(photoID: string, callback?: Callback<string>): Promise<string>;
+
+        pinMessage(action: "pin" | "unpin", threadID: ThreadID, messageID: MessageID): Promise<any>;
+        pinMessage(action: "list", threadID: ThreadID): Promise<Message[]>;
+
+        markAsRead(threadID: ThreadID, read?: boolean, callback?: Callback): Promise<any>;
+        markAsReadAll(callback?: Callback): Promise<void>;
+        markAsSeen(timestamp?: number, callback?: Callback): Promise<void>;
+        markAsDelivered(threadID: ThreadID, messageID: MessageID, callback?: Callback): Promise<void>;
+
+        muteThread(threadID: ThreadID, muteSeconds: number, callback?: Callback): Promise<void>;
+
+        sendTypingIndicator(sendTyping: boolean, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        getThreadInfo(threadID: ThreadID, callback?: Callback<ThreadInfo>): Promise<ThreadInfo>;
+        getThreadInfo(threadID: ThreadID[], callback?: Callback<Record<ThreadID, ThreadInfo>>): Promise<Record<ThreadID, ThreadInfo>>;
+
+        getThreadList(limit: number, timestamp: number | null, tags: string[], callback?: Callback<ThreadInfo[]>): Promise<ThreadInfo[]>;
+        getThreadHistory(threadID: ThreadID, amount: number, timestamp: number | null, callback?: Callback<Message[]>): Promise<Message[]>;
+        getThreadPictures(threadID: ThreadID, offset: number, limit: number, callback?: Callback<string[]>): Promise<string[]>;
+
+        getMessage(messageID: MessageID, callback?: Callback<Message>): Promise<Message>;
+
+        getUserInfo(id: UserID, usePayload?: boolean, callback?: Callback<UserInfo>): Promise<UserInfo>;
+        getUserInfo(id: UserID[], usePayload?: boolean, callback?: Callback<Record<UserID, UserInfo>>): Promise<Record<UserID, UserInfo>>;
+        getUserInfoV2(id: UserID, callback?: Callback<UserInfo>): Promise<UserInfo>;
+        getUserID(name: string, callback?: Callback<{ userID: UserID; [key: string]: any }[]>): Promise<{ userID: UserID; [key: string]: any }[]>;
+
+        getFriendsList(callback?: Callback<Record<UserID, FriendInfo>>): Promise<Record<UserID, FriendInfo>>;
+
+        searchForThread(name: string, callback?: Callback<ThreadInfo[]>): Promise<ThreadInfo[]>;
+
+        createNewGroup(participantIDs: UserID[], groupName?: string, callback?: Callback<ThreadID>): Promise<ThreadID>;
+
+        addUserToGroup(userID: UserID, threadID: ThreadID, callback?: Callback): Promise<void>;
+        removeUserFromGroup(userID: UserID, threadID: ThreadID, callback?: Callback): Promise<void>;
+        changeAdminStatus(threadID: ThreadID, userID: UserID, adminStatus: boolean, callback?: Callback): Promise<void>;
+
+        changeGroupImage(image: ReadStream, threadID: ThreadID, callback?: Callback): Promise<void>;
+        changeThreadColor(color: string, threadID: ThreadID, callback?: Callback): Promise<void>;
+        changeThreadEmoji(emoji: string, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        changeArchivedStatus(threadID: ThreadID | ThreadID[], archive: boolean, callback?: Callback): Promise<void>;
+        changeBlockedStatus(userID: UserID, block: boolean, callback?: Callback): Promise<void>;
+
+        changeAvatar(image: ReadStream, callback?: Callback): Promise<void>;
+        changeBio(bio: string, publish: boolean, callback?: Callback): Promise<void>;
+
+        handleMessageRequest(threadID: ThreadID | ThreadID[], accept: boolean, callback?: Callback): Promise<void>;
+
+        deleteThread(threadID: ThreadID | ThreadID[], callback?: Callback): Promise<void>;
+
+        createPoll(title: string, threadID: ThreadID, options?: Record<string, boolean>, callback?: Callback): Promise<void>;
+
+        logout(callback?: (err: any) => void): Promise<void>;
+
+        addExternalModule(moduleObj: Record<string, Function>): void;
+        getAccess(authCode?: string, callback?: Callback<string>): Promise<string>;
+
+        httpGet(url: string, form?: any, customHeader?: any, callback?: Callback<string>, notAPI?: boolean): Promise<string>;
+        httpPost(url: string, form?: any, customHeader?: any, callback?: Callback<string>, notAPI?: boolean): Promise<string>;
+        httpPostFormData(url: string, form?: any, customHeader?: any, callback?: Callback<string>, notAPI?: boolean): Promise<string>;
+
+        getTheme(threadID: ThreadID): Promise<any[]>;
+        getThemeInfo(threadID: ThreadID): Promise<{ threadName?: string; color?: string; emoji?: string; [key: string]: any }>;
+        setThreadTheme(threadID: ThreadID, themeID: string, callback?: Callback): Promise<void>;
+        setThreadThemeMqtt(threadID: ThreadID, themeID: string, callback?: Callback): Promise<void>;
+        createAITheme(prompt: string): Promise<{ id: string; [key: string]: any }[]>;
+
+        follow(senderID: UserID, follow: boolean, callback?: Callback): void;
+        unfriend(userID: UserID, callback?: Callback): Promise<void>;
+        friend(userID: UserID, callback?: Callback): Promise<void>;
+
+        emoji(emoji: string, threadID?: ThreadID, callback?: Callback<EmojiEvent>): Promise<EmojiEvent>;
+        gcname(newName: string, threadID?: ThreadID, callback?: Callback<GroupNameEvent>): Promise<GroupNameEvent>;
+        nickname(nickname: string, threadID: ThreadID, participantID: UserID, callback?: Callback<NicknameEvent>): Promise<NicknameEvent>;
+        theme(newName: string, threadID?: ThreadID, callback?: Callback<GroupNameEvent>): Promise<GroupNameEvent>;
+
+        comment(msg: string | CommentMessage, postID: string, replyCommentID?: string, callback?: Callback<CommentResult>): Promise<CommentResult>;
+        share(text: string, postID: string, callback?: Callback<ShareResult>): Promise<ShareResult>;
+        share(postID: string, callback?: Callback<ShareResult>): Promise<ShareResult>;
+
+        stickers: {
+            search(query: string): Promise<StickerInfo[]>;
+            listPacks(): Promise<StickerPackInfo[]>;
+            getStorePacks(): Promise<StickerPackInfo[]>;
+            listAllPacks(): Promise<StickerPackInfo[]>;
+            addPack(packID: string): Promise<AddedStickerPackInfo>;
+            getStickersInPack(packID: string): Promise<StickerInfo[]>;
+            getAiStickers(options?: { limit?: number }): Promise<StickerInfo[]>;
+        };
+
+        e2ee: {
+            enable(): void;
+            disable(): void;
+            isEnabled(): boolean;
+            getPublicKey(): string;
+            setPeerKey(threadID: ThreadID, peerPublicKeyB64: string): void;
+            clearPeerKey(threadID: ThreadID): void;
+            hasPeer(threadID: ThreadID): boolean;
+            encrypt(threadID: ThreadID, text: string): string;
+            decrypt(threadID: ThreadID, armored: string): string | null;
+        };
+
+        getBotInfo(callback?: Callback): Promise<any>;
+        getUserInfoV2(userID: UserID, callback?: Callback<UserInfo>): Promise<UserInfo>;
+
+        [key: string]: any;
+    }
+
+    export interface LoginCredentials {
+        appState?: any;
+        email?: string;
+        password?: string;
+    }
+
+    export interface LoginOptions {
+        online?: boolean;
+        selfListen?: boolean;
+        listenEvents?: boolean;
+        updatePresence?: boolean;
+        forceLogin?: boolean;
+        autoMarkDelivery?: boolean;
+        autoMarkRead?: boolean;
+        listenTyping?: boolean;
+        proxy?: string;
+        autoReconnect?: boolean;
+        userAgent?: string;
+        emitReady?: boolean;
+        randomUserAgent?: boolean;
+        bypassRegion?: string;
+        simulateTyping?: boolean;
+        maxConcurrentRequests?: number;
+        maxRequestsPerMinute?: number;
+        requestCooldownMs?: number;
+        errorCacheTtlMs?: number;
+        stealthMode?: boolean;
+        persona?: "desktop" | "android" | "mobile";
+        logging?: boolean;
+    }
+
+    export function login(
+        credentials: LoginCredentials,
+        options: LoginOptions | Callback<API>,
+        callback?: Callback<API>
+    ): Promise<API> | void;
+}

package/phantom/datastore/schema.js

@@ -0,0 +1,167 @@
+"use strict";
+
+const { getType } = require("./models/matrix/logger");
+
+const THREAD_COLORS = [
+    "#0084ff","#44bec7","#ffc300","#fa3c4c","#d696bb",
+    "#6699cc","#13cf13","#ff7e29","#e68585","#7646ff",
+    "#20cef5","#67b868","#d4a88c","#ff5ca1","#a695c7",
+];
+
+const KNOWN_THREAD_TYPES = new Set(["USER", "GROUP", "ROOM", "MULTI", "MARKETPLACE"]);
+const REACTION_TYPES     = new Set(["❤", "😍", "😆", "😮", "😢", "😡", "👍", "👎", "🙏", "💩", "🎉", "🔥", ""]);
+
+function _pick(obj, keys, fallback = null) {
+    if (!obj) return fallback;
+    for (const k of keys) {
+        if (obj[k] !== undefined && obj[k] !== null) return obj[k];
+    }
+    return fallback;
+}
+
+function buildUser(raw) {
+    const type = raw.type || getType(raw.id);
+    return {
+        id:               String(raw.id || ""),
+        userID:           String(raw.id || raw.userId || ""),
+        name:             raw.name || raw.full_name || "",
+        firstName:        raw.first_name || (raw.name || "").split(" ")[0] || "",
+        lastName:         raw.last_name  || "",
+        alternateName:    raw.alternate_name || "",
+        gender:           raw.gender?.value || raw.gender || null,
+        url:              raw.url  || null,
+        profilePicture:   raw.big_image_src?.uri || raw.profile_pic || raw.profile_picture?.uri || null,
+        profilePicSmall:  raw.small_image_src?.uri || null,
+        type,
+        isVerified:       raw.is_verified ?? false,
+        isEmployee:       raw.is_employee ?? false,
+        isFriend:         raw.is_friend   ?? false,
+        isBirthday:       raw.is_birthday ?? false,
+        vanity:           raw.vanity || raw.username || null,
+        followers:        raw.followers_count || 0,
+        thumbsrc:         raw.thumbSrc || null,
+        resolvedAt:       Date.now(),
+    };
+}
+
+function buildMessage(raw, extras = {}) {
+    const atts = (raw.blob_attachments || raw.attachments || []).filter(Boolean);
+
+    const mentions = {};
+    if (raw.message?.text && Array.isArray(raw.mentioned_users)) {
+        const text = raw.message.text;
+        raw.mentioned_users.forEach(u => {
+            const offset = u.entity?.offset ?? u.offset;
+            const len    = u.entity?.length ?? u.length;
+            const id     = u.entity?.id     || u.id;
+            if (id != null && offset != null && len != null) {
+                mentions[String(id)] = text.substr(Number(offset), Number(len));
+            }
+        });
+    }
+
+    const reactions = {};
+    if (Array.isArray(raw.message_reactions)) {
+        for (const r of raw.message_reactions) {
+            const uid = String(r.user?.id || r.user_id || "");
+            const rx  = r.reaction || "";
+            if (uid) reactions[uid] = REACTION_TYPES.has(rx) ? rx : rx;
+        }
+    }
+
+    return {
+        type:          "message",
+        senderID:      String(raw.message_sender?.id || raw.actor_id || extras.senderID || ""),
+        body:          raw.message?.text || raw.body || "",
+        threadID:      String(raw.thread_key?.thread_fbid || raw.thread_key?.other_user_id || extras.threadID || ""),
+        messageID:     raw.message_id    || raw.id || "",
+        clientOffset:  raw.client_message_id || raw.offline_threading_id || null,
+        timestamp:     raw.timestamp_precise ? Number(raw.timestamp_precise) : (raw.timestamp || Date.now()),
+        isEdited:      raw.has_been_edited || !!raw.edit_count,
+        isUnsent:      raw.is_unsent || false,
+        isSponsored:   raw.is_sponsored || false,
+        isForwarded:   raw.is_forwarded || false,
+        attachments:   atts,
+        mentions,
+        reactions,
+        sticker:       raw.sticker ? { id: raw.sticker.id } : null,
+        metadata:      {
+            appID:     raw.app_id     || null,
+            isHidden:  raw.is_hidden  ?? false,
+            isBotResponse: raw.is_automated || false,
+        },
+    };
+}
+
+function buildThread(raw, users = {}) {
+    const threadID    = String(raw.thread_key?.thread_fbid || raw.thread_key?.other_user_id || raw.threadID || "");
+    const isGroup     = !!raw.thread_key?.thread_fbid;
+    const rawType     = raw.thread_type || (isGroup ? "GROUP" : "USER");
+    const threadType  = KNOWN_THREAD_TYPES.has(rawType) ? rawType : "USER";
+
+    const participantIDs = (raw.all_participants?.nodes || raw.participants || [])
+        .map(p => String(p.messaging_actor?.id || p.id || p))
+        .filter(Boolean);
+
+    const participants = {};
+    for (const [uid, u] of Object.entries(users)) {
+        if (participantIDs.includes(uid)) participants[uid] = u;
+    }
+
+    const colorRaw = raw.customization_info?.outgoing_bubble_color || raw.color;
+    const color    = colorRaw ? `#${colorRaw.replace(/^#/, "")}` : THREAD_COLORS[0];
+
+    const emoji = raw.customization_info?.emoji || null;
+
+    const nicknames = {};
+    for (const n of (raw.customization_info?.participant_customizations || [])) {
+        const uid  = String(n.participant_id || "");
+        const nick = n.nickname;
+        if (uid && nick) nicknames[uid] = nick;
+    }
+
+    return {
+        threadID,
+        name:              raw.name   || raw.thread_name || "",
+        snippet:           raw.last_message?.nodes?.[0]?.message?.text || raw.snippet || "",
+        snippetSenderID:   String(raw.last_message?.nodes?.[0]?.message_sender?.id || ""),
+        unreadCount:       Number(raw.unread_count || 0),
+        messageCount:      Number(raw.message_count || raw.messages_count || 0),
+        serverTimestamp:   Number(raw.last_message?.nodes?.[0]?.timestamp_precise || raw.timestamp || Date.now()),
+        lastMessageTime:   Number(raw.last_message?.nodes?.[0]?.timestamp_precise || raw.timestamp || Date.now()),
+        imageSrc:          raw.image?.uri || raw.icon || null,
+        isArchived:        raw.has_viewer_archived ?? raw.is_archived ?? false,
+        isSubscribed:      raw.is_viewer_subscribed ?? true,
+        isMuted:           raw.mute_until != null,
+        canReply:          raw.can_reply  ?? true,
+        color,
+        emoji,
+        nicknames,
+        isGroup,
+        threadType,
+        adminIDs:          (raw.thread_admins || []).map(a => String(a.id || a)),
+        participantIDs,
+        participants,
+        updatedAt:         Date.now(),
+    };
+}
+
+function validateMessage(msg, strict = false) {
+    const errs = [];
+    if (!msg)                                   errs.push("message is null/undefined");
+    if (!msg?.senderID)                         errs.push("missing senderID");
+    if (typeof msg?.body !== "string")          errs.push("body must be a string");
+    if (!msg?.threadID)                         errs.push("missing threadID");
+    if (strict && !msg?.messageID)              errs.push("missing messageID");
+    return { valid: errs.length === 0, errors: errs };
+}
+
+module.exports = {
+    buildUser,
+    buildMessage,
+    buildThread,
+    validateMessage,
+    THREAD_COLORS,
+    KNOWN_THREAD_TYPES,
+    REACTION_TYPES,
+};