VisibleMessageExporter.plugin.js

/**
 * @name VisibleMessageExporter
 * @author ConcertorHQ
 * @description Export visibly rendered Discord messages to TXT/JSON with a visible-message picker, density modes, auto-chunking, and attachment archiving.
 * @version 1.0.1
 */

module.exports = class test123 {
    constructor() {
        this.name = "VisibleMessageExporter";
        this.version = "1.0.1";
        this.unpatches = [];
        this.batchMessages = new Map();
        this.batchSequence = 0;
        this.multiSelectActive = false;
        this.multiSelectDensityState = "off";
        this.multiSelectDensityClassCompact = "test123-export-density-compact";
        this.multiSelectDensityClassTurbo = "test123-export-density-turbo";
        this.multiSelectDensityClassTurboPlus = "test123-export-density-turbo-plus";
        this.multiSelectDensityClassTextOnly = "test123-export-density-text-only";
        this.multiSelectDensityLegacyClasses = [
            "test123-export-density-mode",
            "test123-export-density-normal",
            "test123-export-density-ultra"
        ];
        this.multiSelectDensityTargetClass = "test123-density-target";
        this.multiSelectDensityTarget = null;
        this.multiSelectRecords = [];
        this.multiSelectSelected = new Map();
        this.multiSelectSequence = 0;
        this.multiSelectLastRecordKey = null;
        this.multiSelectLastElement = null;
        this.multiSelectRecordProperty = "__test123MultiSelectRecord";
        this.multiSelectElementKeys = new WeakMap();
        this.multiSelectNextElementKey = 0;
        this.multiSelectPanel = null;
        this.multiSelectStyle = null;
        this.multiSelectObserver = null;
        this.multiSelectObservedRoot = null;
        this.multiSelectClickHandler = null;
        this.multiSelectScanFrame = null;
        this.multiSelectRefreshTimer = null;
        this.multiSelectScrollHandler = null;
        this.multiSelectKeydownHandler = null;
        this.multiSelectCheckpointStep = 500;
        this.multiSelectLastCheckpointNotice = 0;
        this.multiSelectChunkSize = 500;
        this.multiSelectChunkOverlapCount = 20;
        this.multiSelectManifestChunks = [];
        this.multiSelectManifestFilename = "";
        this.multiSelectSessionTimestamp = "";
        this.multiSelectChunkCounter = 0;
        this.multiSelectChunkExportFolderName = "test123-export-chunks";
        this.multiSelectNodeFs = undefined;
        this.multiSelectLastFolderError = "";
        this.multiSelectChunkSaveInProgress = false;
        this.multiSelectAutoChunkPending = false;
        this.multiSelectAutoRunTimer = null;
        this.multiSelectAutoRunActive = false;
        this.multiSelectAutoRunDelayMs = 850;
        this.multiSelectAutoRunMaxSteps = 20;
        this.multiSelectAutoRunSteps = 0;
        this.multiSelectAutoRunNoProgressSteps = 0;
        this.multiSelectAutoChunkTimer = null;
        this.multiSelectAutoChunkActive = false;
        this.multiSelectAutoChunkTargetChunks = 1000;
        this.multiSelectAutoChunkDelayMs = 3000;
        this.multiSelectAutoChunkTurboDelayMs = 4000;
        this.multiSelectAutoChunkPostSaveDelayMs = 5000;
        this.multiSelectAutoChunkRestEveryChunks = 4;
        this.multiSelectAutoChunkRestDelayMs = 15000;
        this.multiSelectAutoChunkPollMs = 250;
        this.multiSelectAutoChunkMaxSaveWaitMs = 30000;
        this.multiSelectAutoChunkMaxSteps = 6000;
        this.multiSelectAutoChunkMaxNoProgressSteps = 5;
        this.multiSelectAutoChunkStartCounter = 0;
        this.multiSelectAutoChunkLastCounter = 0;
        this.multiSelectAutoChunkSteps = 0;
        this.multiSelectAutoChunkNoProgressSteps = 0;
        this.multiSelectAutoChunkSaveWaitMs = 0;
        this.multiSelectLastStepWorkMs = 0;
        this.multiSelectAutoChunkAdaptiveFactor = 4;
        this.multiSelectAutoChunkMaxStepDelayMs = 20000;
        this.multiSelectAutoSaveYieldMs = 1000;
        this.multiSelectMediaDownloadEnabled = true;
        this.multiSelectMediaFolderName = "media";
        this.multiSelectMediaQueue = [];
        this.multiSelectMediaActiveDownloads = 0;
        this.multiSelectMediaMaxConcurrent = 2;
        this.multiSelectMediaMaxBytes = 100 * 1024 * 1024;
        this.multiSelectMediaSeenUrls = new Set();
        this.multiSelectMediaStats = {saved: 0, failed: 0, skipped: 0};
    }

    start() {
        try {
            if (!window.BdApi?.ContextMenu?.patch || !window.BdApi?.ContextMenu?.buildItem) {
                throw new Error("BdApi.ContextMenu is not available.");
            }

            const unpatch = BdApi.ContextMenu.patch("message", this.patchMessageMenu.bind(this));
            this.unpatches.push(unpatch);
        }
        catch (error) {
            this.showError("Failed to start test123.", error);
        }
    }

    stop() {
        for (const unpatch of this.unpatches.splice(0)) {
            try {
                unpatch();
            }
            catch (error) {
                console.error("[test123] Failed to remove context-menu patch.", error);
            }
        }

        this.endMultiSelect(false);
        this.clearBatch(false);
    }

    patchMessageMenu(menuTree, props) {
        const message = props?.message;
        if (!message?.id) return;

        const itemConfigs = this.buildMessageMenuItems(props);
        const group = this.buildGroup(itemConfigs);

        if (group) {
            this.appendMenuItem(menuTree, group);
            return;
        }

        for (const itemConfig of itemConfigs) {
            this.appendMenuItem(menuTree, BdApi.ContextMenu.buildItem(itemConfig));
        }
    }

    buildMessageMenuItems(props) {
        const batchCount = this.batchMessages.size;
        const items = [
            {
                id: "test123-save-message",
                label: "Save Message as TXT",
                action: () => this.saveMessage(props)
            },
            {
                id: "test123-add-message-batch",
                label: "Add Message to TXT Batch",
                action: () => this.addMessageToBatch(props)
            },
            {
                id: "test123-open-visible-picker",
                label: "Open Visible Message Picker",
                action: () => this.startMultiSelect(props)
            },
            {
                id: "test123-save-batch",
                label: "Save TXT Batch",
                disabled: batchCount === 0,
                action: () => this.saveBatch()
            },
            {
                id: "test123-save-json-batch",
                label: "Save JSON Batch",
                disabled: batchCount === 0,
                action: () => this.saveJsonBatch()
            }
        ];

        if (batchCount > 0) {
            items.push({
                id: "test123-clear-batch",
                label: "Clear TXT Batch",
                action: () => this.clearBatch(true)
            });
        }

        return items;
    }

    buildGroup(items) {
        if (!BdApi.ContextMenu.buildMenuChildren) return null;

        const group = BdApi.ContextMenu.buildMenuChildren([{
            type: "group",
            items
        }]);

        return Array.isArray(group) ? group[0] : null;
    }

    appendMenuItem(menuTree, item) {
        const target = this.findMessageMenu(menuTree) || menuTree;
        if (!target?.props) return false;

        const children = target.props.children;
        if (Array.isArray(children)) {
            children.push(item);
            return true;
        }

        target.props.children = children ? [children, item] : [item];
        return true;
    }

    findMessageMenu(node) {
        if (!node || typeof node !== "object") return null;
        if (node.props?.navId === "message") return node;

        const children = node.props?.children;
        if (Array.isArray(children)) {
            for (const child of children) {
                const found = this.findMessageMenu(child);
                if (found) return found;
            }
            return null;
        }

        return this.findMessageMenu(children);
    }

    saveMessage(props) {
        try {
            const message = props?.message;
            if (!message?.id) throw new Error("No message data was available.");

            const text = this.formatMessageText(message, props);
            const filename = this.buildFilename(message);
            this.downloadTextFile(filename, text);
            this.showToast(`Saved ${filename}`, "success");
        }
        catch (error) {
            this.showError("Could not save this message.", error);
        }
    }

    addMessageToBatch(props) {
        try {
            const message = props?.message;
            if (!message?.id) throw new Error("No message data was available.");

            const id = String(message.id);
            const existing = this.batchMessages.get(id);
            const order = existing ? existing.order : this.batchSequence++;

            this.batchMessages.set(id, {
                order,
                details: this.formatMessageDetails(message, props),
                json: this.formatMessageJson(message, props),
                timestampMs: this.getTimestampMs(this.getMessageTimestampValue(message))
            });

            const action = existing ? "Updated" : "Added";
            this.showToast(`${action} message in TXT batch (${this.batchMessages.size}).`, "success");
        }
        catch (error) {
            this.showError("Could not add this message to the TXT batch.", error);
        }
    }

    saveBatch() {
        try {
            if (!this.batchMessages.size) {
                this.showToast("TXT batch is empty.", "info");
                return;
            }

            const records = this.getSortedBatchRecords();
            const text = this.formatBatchText(records);
            const filename = this.buildBatchFilename(records.length);

            this.downloadTextFile(filename, text);
            this.showToast(`Saved ${filename}`, "success");
        }
        catch (error) {
            this.showError("Could not save the TXT batch.", error);
        }
    }

    saveJsonBatch() {
        try {
            if (!this.batchMessages.size) {
                this.showToast("JSON batch is empty.", "info");
                return;
            }

            const records = this.getSortedBatchRecords();
            const payload = {
                exportedAt: new Date().toISOString(),
                count: records.length,
                messages: records.map(record => record.json)
            };
            const filename = this.buildJsonBatchFilename(records.length);

            this.downloadJsonFile(filename, payload);
            this.showToast(`Saved ${filename}`, "success");
        }
        catch (error) {
            this.showError("Could not save the JSON batch.", error);
        }
    }

    clearBatch(showToast = true) {
        const count = this.batchMessages.size;

        this.batchMessages.clear();
        this.batchSequence = 0;

        if (showToast && count) {
            this.showToast(`Cleared ${count} message${count === 1 ? "" : "s"} from TXT batch.`, "success");
        }
    }

    getSortedBatchRecords() {
        return Array.from(this.batchMessages.values()).sort((left, right) => {
            if (left.timestampMs != null && right.timestampMs != null && left.timestampMs !== right.timestampMs) {
                return left.timestampMs - right.timestampMs;
            }

            return left.order - right.order;
        });
    }

    formatMessageText(message, props) {
        const lines = [
            "Discord Message Export",
            "======================",
            `Saved At: ${new Date().toISOString()}`
        ];

        lines.push(...this.formatMessageDetails(message, props));

        return `${lines.join("\n")}\n`;
    }

    formatBatchText(records) {
        const lines = [
            "Discord Messages Batch Export",
            "=============================",
            `Saved At: ${new Date().toISOString()}`,
            `Count: ${records.length}`,
            ""
        ];

        records.forEach((record, index) => {
            lines.push(
                "------------------------------------------------------------",
                `Message ${index + 1} of ${records.length}`,
                "------------------------------------------------------------",
                ...record.details
            );

            if (index < records.length - 1) lines.push("");
        });

        return `${lines.join("\n")}\n`;
    }

    formatMessageDetails(message, props) {
        const author = message.author || props?.user || {};
        const authorTag = this.getAuthorTag(author);
        const authorUsername = this.getAuthorUsername(author);
        const authorId = this.firstValue(author.id, message.authorId, message.author_id);
        const guildId = this.firstValue(props?.guild?.id, props?.channel?.guild_id, props?.channel?.guildId, message.guild_id, message.guildId);
        const channelId = this.firstValue(props?.channel?.id, message.channel_id, message.channelId);
        const timestamp = this.formatTimestamp(this.getMessageTimestampValue(message));
        const editedTimestamp = this.formatTimestamp(this.firstValue(message.editedTimestamp, message.edited_at, message.editedAt));
        const content = this.valueToText(this.firstValue(message.content, message.messageContent, ""));
        const attachments = this.normalizeCollection(message.attachments);

        const lines = [
            `Message ID: ${message.id}`,
            `Guild ID: ${guildId || "Unavailable"}`,
            `Channel ID: ${channelId || "Unavailable"}`,
            `Author: ${authorTag || authorUsername || "Unavailable"}`,
            `Author Username: ${authorUsername || "Unavailable"}`,
            `Author Tag: ${authorTag || "Unavailable"}`,
            `Author ID: ${authorId || "Unavailable"}`,
            `Timestamp: ${timestamp || "Unavailable"}`
        ];

        if (editedTimestamp) lines.push(`Edited Timestamp: ${editedTimestamp}`);

        lines.push("", "Content:", content || "[No text content]");

        if (attachments.length) {
            lines.push("", "Attachments:");
            attachments.forEach((attachment, index) => {
                const label = this.firstValue(attachment.name, attachment.filename, attachment.id, `Attachment ${index + 1}`);
                const url = this.firstValue(attachment.url, attachment.proxy_url, attachment.proxyUrl);
                lines.push(`${index + 1}. ${label}${url ? ` - ${url}` : ""}`);
            });
        }

        return lines;
    }

    formatMessageJson(message, props) {
        const author = message.author || props?.user || {};
        const timestamp = this.formatTimestamp(this.getMessageTimestampValue(message));
        const editedTimestamp = this.formatTimestamp(this.firstValue(message.editedTimestamp, message.edited_at, message.editedAt));
        const content = this.valueToText(this.firstValue(message.content, message.messageContent, ""));
        const attachments = this.normalizeCollection(message.attachments).map(attachment => ({
            id: this.toStringOrNull(attachment?.id),
            name: this.toStringOrNull(this.firstValue(attachment?.name, attachment?.filename)),
            url: this.toStringOrNull(this.firstValue(attachment?.url, attachment?.proxy_url, attachment?.proxyUrl))
        }));

        return {
            messageId: this.toStringOrNull(message.id) || "",
            guildId: this.toStringOrNull(this.firstValue(props?.guild?.id, props?.channel?.guild_id, props?.channel?.guildId, message.guild_id, message.guildId)),
            channelId: this.toStringOrNull(this.firstValue(props?.channel?.id, message.channel_id, message.channelId)),
            author: {
                id: this.toStringOrNull(this.firstValue(author.id, message.authorId, message.author_id)),
                username: this.toStringOrNull(this.getAuthorUsername(author)),
                tag: this.toStringOrNull(this.getAuthorTag(author))
            },
            timestamp: timestamp || null,
            editedTimestamp: editedTimestamp || null,
            content,
            attachments
        };
    }

    startMultiSelect() {
        try {
            if (this.multiSelectActive) {
                this.refreshMultiSelectRecords(false);
                this.updateMultiSelectDensityButton();
                this.multiSelectPanel?.focus?.();
                this.showToast("Visible message picker is already open.", "info");
                return;
            }

            this.multiSelectActive = true;
            this.multiSelectDensityState = "off";
            this.multiSelectRecords = [];
            this.multiSelectSelected.clear();
            this.multiSelectSequence = 0;
            this.multiSelectLastRecordKey = null;
            this.multiSelectLastElement = null;
            this.multiSelectLastCheckpointNotice = 0;
            this.multiSelectSessionTimestamp = this.buildMultiSelectSessionTimestamp();
            this.multiSelectManifestChunks = [];
            this.multiSelectManifestFilename = "";
            this.multiSelectChunkCounter = 0;
            this.multiSelectChunkSaveInProgress = false;
            this.multiSelectAutoChunkPending = false;
            this.multiSelectAutoChunkStartCounter = 0;
            this.multiSelectAutoChunkLastCounter = 0;
            this.multiSelectAutoChunkSteps = 0;
            this.multiSelectAutoChunkNoProgressSteps = 0;
            this.multiSelectAutoChunkSaveWaitMs = 0;

            this.cleanupLegacyMultiSelectArtifacts();
            this.injectMultiSelectStyle();
            this.createMultiSelectPanel();
            this.setupMultiSelectAutoRefresh();
            this.setupMultiSelectKeyboardShortcuts();
            this.refreshMultiSelectRecords(false);
            this.showToast("Visible message picker opened.", "success");
        }
        catch (error) {
            this.endMultiSelect(false);
            this.showError("Could not open the visible message picker.", error);
        }
    }

    endMultiSelect(showToast = true) {
        const wasActive = this.multiSelectActive;

        if (this.multiSelectAutoRunActive || this.multiSelectAutoRunTimer) {
            this.stopMultiSelectAutoRun("picker closed", false);
        }
        if (this.multiSelectAutoChunkActive || this.multiSelectAutoChunkTimer) {
            this.stopMultiSelectAutoChunkRun("picker closed", false);
        }

        this.multiSelectActive = false;
        this.disableMultiSelectDensity();

        if (this.multiSelectClickHandler) {
            document.removeEventListener("click", this.multiSelectClickHandler, true);
            this.multiSelectClickHandler = null;
        }

        if (this.multiSelectScrollHandler) {
            document.removeEventListener("scroll", this.multiSelectScrollHandler, true);
            this.multiSelectScrollHandler = null;
        }

        if (this.multiSelectKeydownHandler) {
            document.removeEventListener("keydown", this.multiSelectKeydownHandler, true);
            this.multiSelectKeydownHandler = null;
        }

        if (this.multiSelectObserver) {
            this.multiSelectObserver.disconnect();
            this.multiSelectObserver = null;
            this.multiSelectObservedRoot = null;
        }

        if (this.multiSelectRefreshTimer) {
            window.clearTimeout(this.multiSelectRefreshTimer);
            this.multiSelectRefreshTimer = null;
        }

        if (this.multiSelectScanFrame) {
            cancelAnimationFrame(this.multiSelectScanFrame);
            this.multiSelectScanFrame = null;
        }

        this.cleanupLegacyMultiSelectArtifacts();

        if (this.multiSelectPanel) {
            this.multiSelectPanel.remove();
            this.multiSelectPanel = null;
        }

        if (this.multiSelectStyle) {
            this.multiSelectStyle.remove();
            this.multiSelectStyle = null;
        }

        this.multiSelectRecords = [];
        this.multiSelectSelected.clear();
        this.multiSelectSequence = 0;
        this.multiSelectLastRecordKey = null;
        this.multiSelectLastElement = null;
        this.multiSelectElementKeys = new WeakMap();
        this.multiSelectNextElementKey = 0;
        this.multiSelectLastCheckpointNotice = 0;
        this.multiSelectSessionTimestamp = "";
        this.multiSelectManifestChunks = [];
        this.multiSelectManifestFilename = "";
        this.multiSelectChunkCounter = 0;
        this.multiSelectChunkSaveInProgress = false;
        this.multiSelectAutoChunkPending = false;
        this.multiSelectAutoRunActive = false;
        this.multiSelectAutoRunSteps = 0;
        this.multiSelectAutoRunNoProgressSteps = 0;
        this.multiSelectAutoChunkActive = false;
        this.multiSelectAutoChunkStartCounter = 0;
        this.multiSelectAutoChunkLastCounter = 0;
        this.multiSelectAutoChunkSteps = 0;
        this.multiSelectAutoChunkNoProgressSteps = 0;
        this.multiSelectAutoChunkSaveWaitMs = 0;
        this.multiSelectMediaQueue = [];
        this.multiSelectMediaSeenUrls = new Set();

        if (showToast && wasActive) {
            this.showToast("Visible message picker closed.", "success");
        }
    }

    cleanupLegacyMultiSelectArtifacts() {
        document.querySelectorAll(".test123-select-control").forEach(control => control.remove());
        document.querySelectorAll(".test123-selectable-message, .test123-selected-message").forEach(element => {
            element.classList.remove("test123-selectable-message", "test123-selected-message");
            if (this.multiSelectRecordProperty && element[this.multiSelectRecordProperty]) {
                delete element[this.multiSelectRecordProperty];
            }
        });
        document.querySelectorAll(".test123-multi-panel, .test123-visible-picker").forEach(panel => {
            if (panel !== this.multiSelectPanel) panel.remove();
        });
        document.querySelectorAll(".test123-multi-select-style").forEach(style => {
            if (style !== this.multiSelectStyle) style.remove();
        });
        this.removeMultiSelectDensityClasses();
    }

    injectMultiSelectStyle() {
        if (this.multiSelectStyle) return;

        const style = document.createElement("style");
        style.className = "test123-multi-select-style";
        style.textContent = `
            .test123-visible-picker {
                background: #1e1f22;
                border: 1px solid #3f4147;
                border-radius: 8px;
                bottom: 18px;
                box-shadow: 0 8px 24px rgba(0, 0, 0, 0.45);
                color: #f2f3f5;
                display: flex;
                flex-direction: column;
                font: 13px/1.4 var(--font-primary, "gg sans", "Noto Sans", Arial, sans-serif);
                gap: 10px;
                max-height: min(560px, calc(100vh - 36px));
                max-width: min(460px, calc(100vw - 36px));
                min-width: min(420px, calc(100vw - 36px));
                padding: 12px;
                position: fixed;
                right: 18px;
                z-index: 2147483647;
            }

            .test123-picker-header {
                align-items: center;
                display: flex;
                justify-content: space-between;
                gap: 10px;
            }

            .test123-picker-title {
                font-size: 14px;
                font-weight: 700;
            }

            .test123-multi-count {
                color: #b5bac1;
                font-size: 12px;
                font-weight: 600;
                text-align: right;
                white-space: nowrap;
            }

            .test123-picker-actions {
                display: grid;
                gap: 6px;
                grid-template-columns: repeat(2, minmax(0, 1fr));
            }

            .test123-picker-action-primary {
                background: #5865f2 !important;
                border-color: #6975f4 !important;
                color: #ffffff !important;
                font-weight: 700;
            }

            .test123-picker-preview-title {
                color: #b5bac1;
                font-size: 12px;
                font-weight: 700;
                text-transform: uppercase;
            }

            .test123-picker-hint {
                color: #949ba4;
                font-size: 11px;
                line-height: 1.3;
            }

            .test123-folder-status {
                background: #2b2d31;
                border: 1px solid #f0b232;
                border-radius: 4px;
                color: #ffe8a3;
                font-size: 11px;
                line-height: 1.3;
                padding: 6px 8px;
            }

            .test123-folder-status[data-silent="true"] {
                border-color: #3ba55d;
                color: #d3f9d8;
            }

            .test123-multi-button {
                background: #313338;
                border: 1px solid #4e5058;
                border-radius: 4px;
                color: #f2f3f5;
                cursor: pointer;
                font: inherit;
                min-height: 28px;
                overflow-wrap: anywhere;
                padding: 4px 8px;
            }

            .test123-multi-button:focus-visible,
            .test123-picker-preview-row:focus-within {
                outline: 2px solid #00a8fc;
                outline-offset: 2px;
            }

            .test123-multi-button:hover {
                background: #3f4147;
            }

            .test123-multi-button:disabled {
                cursor: not-allowed;
                opacity: 0.55;
            }

            .test123-density-active {
                background: #2d7d46 !important;
                border-color: #3ba55d !important;
                color: #ffffff !important;
                font-weight: 700;
            }

            .test123-auto-active {
                background: #da373c !important;
                border-color: #f23f42 !important;
                color: #ffffff !important;
                font-weight: 700;
            }

            .test123-picker-preview {
                border: 1px solid #3f4147;
                border-radius: 6px;
                display: flex;
                flex-direction: column;
                max-height: 280px;
                overflow: auto;
            }

            .test123-picker-preview-empty {
                color: #b5bac1;
                padding: 10px;
            }

            .test123-picker-preview-row {
                align-items: flex-start;
                border-bottom: 1px solid #2b2d31;
                cursor: pointer;
                display: grid;
                gap: 8px;
                grid-template-columns: 18px minmax(0, 1fr);
                padding: 8px;
            }

            .test123-picker-preview-row:last-child {
                border-bottom: 0;
            }

            .test123-picker-preview-row:hover {
                background: #2b2d31;
            }

            .test123-picker-preview-checkbox {
                cursor: pointer;
                height: 16px;
                margin: 2px 0 0;
                width: 16px;
            }

            .test123-picker-preview-text {
                overflow-wrap: anywhere;
                white-space: normal;
            }

            .test123-picker-preview-meta {
                color: #949ba4;
                display: block;
                font-size: 11px;
                margin-top: 2px;
            }

            .test123-density-target.test123-export-density-compact [class*="messageListItem"],
            .test123-density-target.test123-export-density-compact [class*="message__"] {
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                padding-bottom: 1px !important;
                padding-top: 1px !important;
            }

            .test123-density-target.test123-export-density-compact [id*="message-content-"],
            .test123-density-target.test123-export-density-compact [class*="markup"] {
                font-size: 0.85em !important;
                line-height: 1.16 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
            }

            .test123-density-target.test123-export-density-compact [class*="contents"] {
                margin-top: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-compact [class*="avatar"] {
                height: 20px !important;
                margin-top: 0 !important;
                opacity: 0.65 !important;
                width: 20px !important;
            }

            .test123-density-target.test123-export-density-compact [class*="header"],
            .test123-density-target.test123-export-density-compact [class*="timestamp"],
            .test123-density-target.test123-export-density-compact [class*="username"],
            .test123-density-target.test123-export-density-compact [class*="botTag"],
            .test123-density-target.test123-export-density-compact [class*="repliedMessage"] {
                font-size: 0.78em !important;
                line-height: 1.12 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                margin-right: 4px !important;
                opacity: 0.72 !important;
            }

            .test123-density-target.test123-export-density-compact [class*="reactions"],
            .test123-density-target.test123-export-density-compact [class*="embed"],
            .test123-density-target.test123-export-density-compact [class*="Embed"],
            .test123-density-target.test123-export-density-compact [class*="embedFull"],
            .test123-density-target.test123-export-density-compact [class*="embedWrapper"],
            .test123-density-target.test123-export-density-compact [class*="gridContainer"],
            .test123-density-target.test123-export-density-compact [class*="article"],
            .test123-density-target.test123-export-density-compact [class*="media"],
            .test123-density-target.test123-export-density-compact [class*="Media"],
            .test123-density-target.test123-export-density-compact [class*="thumbnail"],
            .test123-density-target.test123-export-density-compact [class*="Thumbnail"],
            .test123-density-target.test123-export-density-compact [class*="image"],
            .test123-density-target.test123-export-density-compact [class*="Image"],
            .test123-density-target.test123-export-density-compact [class*="carousel"],
            .test123-density-target.test123-export-density-compact [class*="Carousel"],
            .test123-density-target.test123-export-density-compact [class*="imageWrapper"],
            .test123-density-target.test123-export-density-compact [class*="ImageWrapper"],
            .test123-density-target.test123-export-density-compact [class*="mediaAttachmentsContainer"],
            .test123-density-target.test123-export-density-compact [class*="oneByOneGrid"],
            .test123-density-target.test123-export-density-compact [class*="clickableMedia"],
            .test123-density-target.test123-export-density-compact [class*="visualMedia"],
            .test123-density-target.test123-export-density-compact [class*="visualMediaItemContainer"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-compact [id*="message-content-"] {
                display: block !important;
                opacity: 1 !important;
                visibility: visible !important;
            }

            .test123-density-target.test123-export-density-turbo [class*="messageListItem"],
            .test123-density-target.test123-export-density-turbo [class*="message__"] {
                min-height: 0 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-turbo [class*="message__"] {
                padding-left: 28px !important;
                padding-right: 12px !important;
            }

            .test123-density-target.test123-export-density-turbo [id*="message-content-"],
            .test123-density-target.test123-export-density-turbo [class*="markup"] {
                font-size: 0.72em !important;
                line-height: 1.1 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
                white-space: pre-wrap !important;
            }

            .test123-density-target.test123-export-density-turbo [id*="message-content-"] > *,
            .test123-density-target.test123-export-density-turbo [class*="markup"] > * {
                margin-bottom: 0 !important;
                margin-top: 0 !important;
            }

            .test123-density-target.test123-export-density-turbo [class*="contents"] {
                margin-top: 0 !important;
                min-height: 0 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-turbo [class*="avatar"] {
                height: 14px !important;
                margin-top: 0 !important;
                opacity: 0.42 !important;
                width: 14px !important;
            }

            .test123-density-target.test123-export-density-turbo [class*="avatarDecoration"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-turbo [class*="header"],
            .test123-density-target.test123-export-density-turbo [class*="timestamp"],
            .test123-density-target.test123-export-density-turbo [class*="username"],
            .test123-density-target.test123-export-density-turbo [class*="botTag"],
            .test123-density-target.test123-export-density-turbo [class*="repliedMessage"] {
                font-size: 0.64em !important;
                line-height: 1.06 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                margin-right: 2px !important;
                opacity: 0.36 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-turbo [class*="reactions"],
            .test123-density-target.test123-export-density-turbo [class*="embed"],
            .test123-density-target.test123-export-density-turbo [class*="Embed"],
            .test123-density-target.test123-export-density-turbo [class*="embedFull"],
            .test123-density-target.test123-export-density-turbo [class*="embedWrapper"],
            .test123-density-target.test123-export-density-turbo [class*="gridContainer"],
            .test123-density-target.test123-export-density-turbo [class*="article"],
            .test123-density-target.test123-export-density-turbo [class*="media"],
            .test123-density-target.test123-export-density-turbo [class*="Media"],
            .test123-density-target.test123-export-density-turbo [class*="thumbnail"],
            .test123-density-target.test123-export-density-turbo [class*="Thumbnail"],
            .test123-density-target.test123-export-density-turbo [class*="image"],
            .test123-density-target.test123-export-density-turbo [class*="Image"],
            .test123-density-target.test123-export-density-turbo [class*="carousel"],
            .test123-density-target.test123-export-density-turbo [class*="Carousel"],
            .test123-density-target.test123-export-density-turbo [class*="imageWrapper"],
            .test123-density-target.test123-export-density-turbo [class*="ImageWrapper"],
            .test123-density-target.test123-export-density-turbo [class*="mediaAttachmentsContainer"],
            .test123-density-target.test123-export-density-turbo [class*="oneByOneGrid"],
            .test123-density-target.test123-export-density-turbo [class*="clickableMedia"],
            .test123-density-target.test123-export-density-turbo [class*="visualMedia"],
            .test123-density-target.test123-export-density-turbo [class*="visualMediaItemContainer"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-turbo [id*="message-content-"] {
                display: block !important;
                opacity: 1 !important;
                visibility: visible !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [class*="messageListItem"],
            .test123-density-target.test123-export-density-turbo-plus [class*="message__"] {
                min-height: 0 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [class*="message__"] {
                padding-left: 8px !important;
                padding-right: 8px !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [id*="message-content-"],
            .test123-density-target.test123-export-density-turbo-plus [class*="markup"] {
                font-size: 0.53em !important;
                line-height: 1.0 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
                white-space: pre-wrap !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [id*="message-content-"] > *,
            .test123-density-target.test123-export-density-turbo-plus [class*="markup"] > * {
                margin-bottom: 0 !important;
                margin-top: 0 !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [class*="contents"] {
                margin-top: 0 !important;
                min-height: 0 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [class*="avatar"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [class*="avatarDecoration"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [class*="header"],
            .test123-density-target.test123-export-density-turbo-plus [class*="timestamp"],
            .test123-density-target.test123-export-density-turbo-plus [class*="username"],
            .test123-density-target.test123-export-density-turbo-plus [class*="botTag"],
            .test123-density-target.test123-export-density-turbo-plus [class*="repliedMessage"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [class*="reactions"],
            .test123-density-target.test123-export-density-turbo-plus [class*="embed"],
            .test123-density-target.test123-export-density-turbo-plus [class*="Embed"],
            .test123-density-target.test123-export-density-turbo-plus [class*="embedFull"],
            .test123-density-target.test123-export-density-turbo-plus [class*="embedWrapper"],
            .test123-density-target.test123-export-density-turbo-plus [class*="gridContainer"],
            .test123-density-target.test123-export-density-turbo-plus [class*="article"],
            .test123-density-target.test123-export-density-turbo-plus [class*="media"],
            .test123-density-target.test123-export-density-turbo-plus [class*="Media"],
            .test123-density-target.test123-export-density-turbo-plus [class*="thumbnail"],
            .test123-density-target.test123-export-density-turbo-plus [class*="Thumbnail"],
            .test123-density-target.test123-export-density-turbo-plus [class*="image"],
            .test123-density-target.test123-export-density-turbo-plus [class*="Image"],
            .test123-density-target.test123-export-density-turbo-plus [class*="carousel"],
            .test123-density-target.test123-export-density-turbo-plus [class*="Carousel"],
            .test123-density-target.test123-export-density-turbo-plus [class*="imageWrapper"],
            .test123-density-target.test123-export-density-turbo-plus [class*="ImageWrapper"],
            .test123-density-target.test123-export-density-turbo-plus [class*="mediaAttachmentsContainer"],
            .test123-density-target.test123-export-density-turbo-plus [class*="oneByOneGrid"],
            .test123-density-target.test123-export-density-turbo-plus [class*="clickableMedia"],
            .test123-density-target.test123-export-density-turbo-plus [class*="visualMedia"],
            .test123-density-target.test123-export-density-turbo-plus [class*="visualMediaItemContainer"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-turbo-plus [id*="message-content-"] {
                display: block !important;
                opacity: 1 !important;
                visibility: visible !important;
            }

            .test123-density-target.test123-export-density-text-only [class*="messageListItem"],
            .test123-density-target.test123-export-density-text-only [class*="message__"] {
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                padding-bottom: 1px !important;
                padding-top: 1px !important;
            }

            .test123-density-target.test123-export-density-text-only [id*="message-content-"],
            .test123-density-target.test123-export-density-text-only [class*="markup"] {
                font-size: 10px !important;
                line-height: 1.1 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
                white-space: pre-wrap !important;
            }

            .test123-density-target.test123-export-density-text-only [class*="contents"] {
                margin-top: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-text-only [class*="avatar"] {
                height: 16px !important;
                margin-top: 0 !important;
                opacity: 0.35 !important;
                width: 16px !important;
            }

            .test123-density-target.test123-export-density-text-only [class*="avatarDecoration"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-text-only [class*="header"],
            .test123-density-target.test123-export-density-text-only [class*="timestamp"],
            .test123-density-target.test123-export-density-text-only [class*="username"],
            .test123-density-target.test123-export-density-text-only [class*="botTag"],
            .test123-density-target.test123-export-density-text-only [class*="repliedMessage"] {
                font-size: 8px !important;
                line-height: 1.1 !important;
                margin-bottom: 0 !important;
                margin-top: 0 !important;
                opacity: 0.45 !important;
                padding-bottom: 0 !important;
                padding-top: 0 !important;
            }

            .test123-density-target.test123-export-density-text-only [class*="reactions"],
            .test123-density-target.test123-export-density-text-only [class*="embed"],
            .test123-density-target.test123-export-density-text-only [class*="Embed"],
            .test123-density-target.test123-export-density-text-only [class*="embedFull"],
            .test123-density-target.test123-export-density-text-only [class*="embedWrapper"],
            .test123-density-target.test123-export-density-text-only [class*="gridContainer"],
            .test123-density-target.test123-export-density-text-only [class*="article"],
            .test123-density-target.test123-export-density-text-only [class*="media"],
            .test123-density-target.test123-export-density-text-only [class*="Media"],
            .test123-density-target.test123-export-density-text-only [class*="thumbnail"],
            .test123-density-target.test123-export-density-text-only [class*="Thumbnail"],
            .test123-density-target.test123-export-density-text-only [class*="image"],
            .test123-density-target.test123-export-density-text-only [class*="Image"],
            .test123-density-target.test123-export-density-text-only [class*="carousel"],
            .test123-density-target.test123-export-density-text-only [class*="Carousel"],
            .test123-density-target.test123-export-density-text-only [class*="imageWrapper"],
            .test123-density-target.test123-export-density-text-only [class*="ImageWrapper"],
            .test123-density-target.test123-export-density-text-only [class*="mediaAttachmentsContainer"],
            .test123-density-target.test123-export-density-text-only [class*="oneByOneGrid"],
            .test123-density-target.test123-export-density-text-only [class*="clickableMedia"],
            .test123-density-target.test123-export-density-text-only [class*="visualMedia"],
            .test123-density-target.test123-export-density-text-only [class*="visualMediaItemContainer"] {
                display: none !important;
            }

            .test123-density-target.test123-export-density-text-only [id*="message-content-"] {
                display: block !important;
                opacity: 1 !important;
                visibility: visible !important;
            }

            /* File attachment cards stay visible (compacted) in all density modes
               so file-upload messages keep a nonzero height and their download
               links get captured. Media previews remain hidden. */
            .test123-density-target [class*="messageAccessories"] {
                margin: 0 !important;
                padding: 0 !important;
            }

            .test123-density-target [class*="attachment"] {
                font-size: 9px !important;
                line-height: 1.1 !important;
                margin: 0 !important;
                max-width: 320px !important;
                padding: 1px 4px !important;
            }

            .test123-density-target [class*="attachment"] img,
            .test123-density-target [class*="attachment"] svg {
                height: 10px !important;
                width: 10px !important;
            }

            /* Media (charts/images) collapse to a thin strip instead of display:none.
               Fully hidden media made image-only messages zero-height (skipped by the
               scanner) and could leave lazy-loaded src attributes unpopulated, so the
               image URL was never captured. The doubled class keeps specificity equal
               to the per-density hide rules so these later rules win. */
            .test123-density-target.test123-density-target [class*="mediaAttachmentsContainer"],
            .test123-density-target.test123-density-target [class*="oneByOneGrid"],
            .test123-density-target.test123-density-target [class*="visualMediaItemContainer"],
            .test123-density-target.test123-density-target [class*="clickableMedia"],
            .test123-density-target.test123-density-target [class*="visualMedia"],
            .test123-density-target.test123-density-target [class*="imageWrapper"],
            .test123-density-target.test123-density-target [class*="ImageWrapper"],
            .test123-density-target.test123-density-target [class*="carousel"],
            .test123-density-target.test123-density-target [class*="Carousel"],
            .test123-density-target.test123-density-target [class*="gridContainer"],
            .test123-density-target.test123-density-target [class*="media"],
            .test123-density-target.test123-density-target [class*="Media"],
            .test123-density-target.test123-density-target [class*="image"],
            .test123-density-target.test123-density-target [class*="Image"],
            .test123-density-target.test123-density-target [class*="thumbnail"],
            .test123-density-target.test123-density-target [class*="Thumbnail"] {
                display: block !important;
                height: 14px !important;
                margin: 0 !important;
                max-width: 200px !important;
                opacity: 0.55 !important;
                overflow: hidden !important;
                padding: 0 !important;
            }

            .test123-density-target.test123-density-target [class*="imageWrapper"] img,
            .test123-density-target.test123-density-target [class*="clickableMedia"] img,
            .test123-density-target.test123-density-target [class*="visualMedia"] img {
                height: 14px !important;
                object-fit: cover !important;
                width: auto !important;
            }
        `;

        document.head.appendChild(style);
        this.multiSelectStyle = style;
    }

    createMultiSelectPanel() {
        if (this.multiSelectPanel) return;

        const panel = document.createElement("div");
        panel.className = "test123-visible-picker";
        panel.tabIndex = -1;
        panel.setAttribute("role", "region");
        panel.setAttribute("aria-label", "Visible message picker");

        const header = document.createElement("div");
        header.className = "test123-picker-header";

        const title = document.createElement("div");
        title.className = "test123-picker-title";
        title.textContent = "Visible Message Picker";

        const count = document.createElement("span");
        count.className = "test123-multi-count";
        count.textContent = "0 selected / 0 visible now / 0 new if selected / 0 dupes / 0 media/links";

        header.append(title, count);

        const actions = document.createElement("div");
        actions.className = "test123-picker-actions";

        const selectVisible = this.createMultiSelectPanelButton("Select Visible", () => this.selectVisibleForMultiSelect());
        selectVisible.classList.add("test123-picker-action-primary");
        const selectDown = this.createMultiSelectPanelButton("Select + Down", () => this.selectVisibleAndScroll(1));
        const density = this.createMultiSelectPanelButton("Density Off", () => this.toggleMultiSelectDensity());
        const autoChunk = this.createMultiSelectPanelButton("Auto 1000 Chunks", () => this.toggleMultiSelectAutoChunkRun());
        const chunkFolder = this.createMultiSelectPanelButton("Chunk Folder", () => this.showMultiSelectChunkFolderLocation());
        const saveRemainder = this.createMultiSelectPanelButton("Save Remainder", () => this.saveMultiSelectChunk());
        const clear = this.createMultiSelectPanelButton("Clear", () => this.clearMultiSelect(true));
        const close = this.createMultiSelectPanelButton("Close", () => this.endMultiSelect(true));

        selectVisible.dataset.action = "select-visible";
        selectDown.dataset.action = "select-down";
        autoChunk.dataset.action = "auto-chunk";
        density.dataset.action = "density";
        chunkFolder.dataset.action = "chunk-folder";
        saveRemainder.dataset.action = "save-chunk";
        saveRemainder.title = "Save the currently selected messages as the final JSON chunk, even if fewer than 500 are selected.";
        saveRemainder.setAttribute("aria-label", "Save the selected remainder as a JSON chunk");
        clear.dataset.action = "clear";

        actions.append(selectVisible, density, selectDown, autoChunk, chunkFolder, saveRemainder, clear, close);

        const hint = document.createElement("div");
        hint.className = "test123-picker-hint";
        hint.textContent = "A select visible | S select + down | Shift+S select + up | H Auto 1000 Chunks/Stop | P save remainder | D density | R refresh | Esc close";

        const folderStatus = document.createElement("div");
        folderStatus.className = "test123-folder-status";
        folderStatus.dataset.role = "folder-status";
        folderStatus.textContent = this.getMultiSelectFolderStatusText();

        const previewTitle = document.createElement("div");
        previewTitle.className = "test123-picker-preview-title";
        previewTitle.textContent = "Visible preview";

        const preview = document.createElement("div");
        preview.className = "test123-picker-preview";
        preview.setAttribute("role", "list");

        panel.append(header, actions, folderStatus, hint, previewTitle, preview);
        document.body.appendChild(panel);
        this.multiSelectPanel = panel;
        this.updateMultiSelectDensityButton();
        this.updateMultiSelectFolderButton();
        this.updateMultiSelectAutoRunButton();
        this.updateMultiSelectAutoChunkButton();
    }

    createMultiSelectPanelButton(label, action) {
        const button = document.createElement("button");
        button.type = "button";
        button.className = "test123-multi-button";
        button.textContent = label;
        button.addEventListener("click", event => {
            event.preventDefault();
            event.stopPropagation();
            action();
        });
        return button;
    }

    showMultiSelectChunkFolderLocation() {
        const exportDir = this.getMultiSelectChunkExportDir();
        if (!exportDir) {
            this.showDownloadsFallbackToast("Plugin chunk folder unavailable.");
            return;
        }

        const nativePath = exportDir.replace(/\//g, "\\");
        try {
            this.getNodeFs()?.mkdirSync?.(exportDir, {recursive: true});
        }
        catch (_) { /* opening still worth attempting */ }

        const copied = this.copyTextToClipboard(nativePath);
        const opened = this.openPathInExplorer(nativePath);

        if (opened) {
            this.showToast(`Opened chunk folder in Explorer${copied ? " (path copied)" : ""}.`, "success");
        }
        else if (copied) {
            this.showToast(`Could not open Explorer; path copied: ${nativePath}`, "warning");
        }
        else {
            this.showToast(`Auto chunks save to ${nativePath}`, "info");
        }
    }

    openPathInExplorer(path) {
        try {
            if (window.DiscordNative?.fileManager?.showItemInFolder) {
                window.DiscordNative.fileManager.showItemInFolder(path);
                return true;
            }
        }
        catch (error) {
            console.warn("[test123] DiscordNative showItemInFolder failed.", error);
        }

        try {
            const shell = require("electron")?.shell;
            if (shell?.openPath) {
                shell.openPath(path);
                return true;
            }
        }
        catch (error) {
            console.warn("[test123] electron shell.openPath failed.", error);
        }

        return false;
    }

    copyTextToClipboard(text) {
        try {
            if (window.DiscordNative?.clipboard?.copy) {
                window.DiscordNative.clipboard.copy(text);
                return true;
            }
        }
        catch (_) { /* try browser clipboard next */ }

        try {
            navigator.clipboard?.writeText?.(text);
            return true;
        }
        catch (_) {
            return false;
        }
    }

    setupMultiSelectAutoRefresh() {
        if (this.multiSelectScrollHandler) {
            document.removeEventListener("scroll", this.multiSelectScrollHandler, true);
        }

        this.multiSelectScrollHandler = event => {
            if (this.multiSelectPanel && event?.target && this.multiSelectPanel.contains(event.target)) return;
            this.scheduleMultiSelectPreviewRefresh();
        };
        document.addEventListener("scroll", this.multiSelectScrollHandler, {capture: true, passive: true});

        this.observeMultiSelectChatRoot();
    }

    observeMultiSelectChatRoot(chatRoot = this.findMultiSelectChatRoot()) {
        if (this.multiSelectObserver && this.multiSelectObservedRoot === chatRoot && chatRoot?.isConnected) return;

        if (this.multiSelectObserver) {
            this.multiSelectObserver.disconnect();
            this.multiSelectObserver = null;
        }

        this.multiSelectObservedRoot = null;
        if (!window.MutationObserver || !chatRoot) return;

        this.multiSelectObserver = new MutationObserver(mutations => {
            if (this.hasRelevantMultiSelectMutation(mutations)) {
                this.scheduleMultiSelectPreviewRefresh();
            }
        });
        this.multiSelectObserver.observe(chatRoot, {childList: true, subtree: true});
        this.multiSelectObservedRoot = chatRoot;
    }

    setupMultiSelectKeyboardShortcuts() {
        if (this.multiSelectKeydownHandler) {
            document.removeEventListener("keydown", this.multiSelectKeydownHandler, true);
        }

        this.multiSelectKeydownHandler = event => this.handleMultiSelectKeydown(event);
        document.addEventListener("keydown", this.multiSelectKeydownHandler, true);
    }

    scheduleMultiSelectPreviewRefresh(delayMs = 300) {
        if (!this.multiSelectActive) return;
        // The auto-chunk runner does its own scans each step; scroll/mutation
        // triggered rescans on top of that just double the DOM work.
        if (this.multiSelectAutoChunkActive || this.multiSelectAutoRunActive) return;

        if (this.multiSelectRefreshTimer) window.clearTimeout(this.multiSelectRefreshTimer);

        this.multiSelectRefreshTimer = window.setTimeout(() => {
            this.multiSelectRefreshTimer = null;
            if (this.multiSelectActive) this.refreshMultiSelectRecords(false);
        }, delayMs);
    }

    hasRelevantMultiSelectMutation(mutations) {
        for (const mutation of mutations) {
            const nodes = [...mutation.addedNodes, ...mutation.removedNodes];
            for (const node of nodes) {
                if (this.isMultiSelectRelevantNode(node)) return true;
            }
        }

        return false;
    }

    isMultiSelectRelevantNode(node) {
        if (!node || node.nodeType !== 1) return false;
        if (this.multiSelectPanel && (node === this.multiSelectPanel || this.multiSelectPanel.contains(node))) return false;

        return Boolean(
            node.matches?.('[id*="message-content-"], [data-list-id="chat-messages"], [role="log"]') ||
            node.querySelector?.('[id*="message-content-"], [data-list-id="chat-messages"], [role="log"]')
        );
    }

    findMultiSelectChatRoot() {
        if (this.isMultiSelectChatRoot(this.multiSelectDensityTarget)) return this.multiSelectDensityTarget;
        if (this.isMultiSelectChatRoot(this.multiSelectObservedRoot)) return this.multiSelectObservedRoot;

        const selectors = ['[data-list-id="chat-messages"]', '[role="log"]'];
        for (const selector of selectors) {
            const roots = Array.from(document.querySelectorAll(selector));
            const root = roots.find(candidate => candidate.querySelector?.('[id*="message-content-"]'));
            if (root) return root;
        }

        const content = document.querySelector('[id*="message-content-"]');
        return content?.closest?.('[data-list-id="chat-messages"], [role="log"], [class*="chatContent"], [class*="messagesWrapper"], main') || null;
    }

    isMultiSelectChatRoot(element) {
        return Boolean(
            element?.isConnected &&
            element.matches?.('[data-list-id="chat-messages"], [role="log"], [class*="chatContent"], [class*="messagesWrapper"], main') &&
            element.querySelector?.('[id*="message-content-"]')
        );
    }

    handleMultiSelectKeydown(event) {
        if (!this.multiSelectActive || event.defaultPrevented || event.repeat) return;
        if (event.altKey || event.ctrlKey || event.metaKey) return;
        if (this.isEditableShortcutTarget(event.target)) return;

        const key = event.key === "Escape" ? "escape" : String(event.key || "").toLowerCase();
        if (key === "s") {
            event.preventDefault();
            event.stopPropagation();
            this.selectVisibleAndScroll(event.shiftKey ? -1 : 1);
            return;
        }

        const actions = {
            a: () => this.selectVisibleForMultiSelect(),
            d: () => this.toggleMultiSelectDensity(),
            g: () => this.toggleMultiSelectAutoRun(),
            h: () => this.toggleMultiSelectAutoChunkRun(),
            r: () => this.refreshMultiSelectRecords(true),
            p: () => this.saveMultiSelectChunk(),
            j: () => this.saveMultiSelectJson(),
            t: () => this.saveMultiSelectTxt(),
            c: () => this.clearMultiSelect(true),
            escape: () => this.endMultiSelect(true)
        };
        const action = actions[key];
        if (!action) return;

        event.preventDefault();
        event.stopPropagation();
        action();
    }

    isEditableShortcutTarget(target) {
        let element = target?.nodeType === 1 ? target : target?.parentElement;

        while (element) {
            const tagName = element.tagName?.toLowerCase();
            if (tagName === "input" || tagName === "textarea" || tagName === "select" || element.isContentEditable) return true;
            element = element.parentElement;
        }

        return false;
    }

    refreshMultiSelectRecords(showToast = false) {
        if (!this.multiSelectActive) return;

        const chatRoot = this.findMultiSelectChatRoot();
        this.observeMultiSelectChatRoot(chatRoot);
        if (this.multiSelectDensityState !== "off") this.syncMultiSelectDensityTarget(chatRoot);

        this.multiSelectRecords = this.scanVisibleMessageNodes(chatRoot);
        this.reconcileVisiblePickerSelections();
        this.updateMultiSelectPanel();

        if (showToast) {
            this.showToast(`Found ${this.multiSelectRecords.length} visible message${this.multiSelectRecords.length === 1 ? "" : "s"}.`, "info");
        }
    }

    selectVisibleForMultiSelect(showToast = true) {
        const stats = this.addVisibleMessagesToMultiSelect(showToast);
        this.maybeAutoSaveMultiSelectChunk(stats);
        return stats;
    }

    addVisibleMessagesToMultiSelect(showToast = true) {
        const stats = {
            added: 0,
            refreshed: 0,
            total: this.multiSelectSelected.size,
            visible: this.multiSelectRecords.length
        };

        try {
            if (!this.multiSelectActive) return stats;

            const chatRoot = this.findMultiSelectChatRoot();
            this.observeMultiSelectChatRoot(chatRoot);
            if (this.multiSelectDensityState !== "off") this.syncMultiSelectDensityTarget(chatRoot);

            this.multiSelectRecords = this.scanVisibleMessageNodes(chatRoot);
            stats.visible = this.multiSelectRecords.length;

            if (!this.multiSelectRecords.length) {
                this.updateMultiSelectPanel();
                if (showToast) this.showToast("No visible message-content nodes found.", "info");
                return stats;
            }

            for (const record of this.multiSelectRecords) {
                const match = this.findMatchingMultiSelectSelection(record);
                const existing = match?.selected;
                if (match && match.key !== record.key) this.multiSelectSelected.delete(match.key);

                this.multiSelectSelected.set(record.key, {
                    key: record.key,
                    order: existing?.order ?? this.multiSelectSequence++,
                    messageId: record.messageId || existing?.messageId || null,
                    text: record.text,
                    links: record.links || existing?.links || [],
                    selectedAt: existing?.selectedAt || new Date().toISOString(),
                    autoChunkEligible: true
                });

                if (existing) stats.refreshed++;
                else stats.added++;
            }

            stats.total = this.multiSelectSelected.size;
            this.updateMultiSelectPanel();
            if (showToast) {
                this.showToast(`Selected ${stats.added} new / ${stats.refreshed} dupes refreshed / ${stats.total} total. Scroll, then press A or Select Visible again.`, stats.added || stats.refreshed ? "success" : "info");
            }

            return stats;
        }
        catch (error) {
            this.showError("Could not select visible messages.", error);
            return stats;
        }
    }

    selectVisibleAndScroll(direction = 1, showToast = true) {
        if (!this.multiSelectActive) return null;

        const stats = this.addVisibleMessagesToMultiSelect(false);
        const scrollTarget = this.findMultiSelectScrollTarget();
        const scrollAmount = this.getMultiSelectScrollAmount(scrollTarget) * (direction < 0 ? -1 : 1);
        const directionLabel = direction < 0 ? "up" : "down";

        this.scrollMultiSelectTarget(scrollTarget, scrollAmount);
        this.scheduleMultiSelectPreviewRefresh(350);
        if (showToast) {
            this.showToast(`Selected ${stats.added} new / ${stats.refreshed} dupes, scrolled ${directionLabel}.`, stats.added || stats.refreshed ? "success" : "info");
        }
        this.maybeAutoSaveMultiSelectChunk(stats);
        return stats;
    }

    findMultiSelectScrollTarget(chatRoot = this.findMultiSelectChatRoot()) {
        const candidates = [];
        const addCandidate = element => {
            if (element && !candidates.includes(element)) candidates.push(element);
        };

        addCandidate(chatRoot);
        addCandidate(chatRoot?.closest?.('[data-list-id="chat-messages"], [role="log"]'));
        addCandidate(chatRoot?.parentElement);

        const content = document.querySelector('[id*="message-content-"]');
        addCandidate(content?.closest?.('[data-list-id="chat-messages"], [role="log"]'));
        addCandidate(content?.closest?.('[class*="chatContent"], [class*="messagesWrapper"], main'));

        for (const candidate of candidates) {
            let current = candidate;
            while (current && current !== document.body) {
                if (this.isScrollableElement(current)) return current;
                current = current.parentElement;
            }
        }

        return window;
    }

    isScrollableElement(element) {
        if (!element || element === window || element === document || element === document.body) return false;

        const style = window.getComputedStyle?.(element);
        const overflowY = style?.overflowY || "";
        const canScroll = element.scrollHeight > element.clientHeight + 16;

        return canScroll && /auto|scroll|overlay/i.test(overflowY);
    }

    getMultiSelectScrollAmount(scrollTarget) {
        const viewportHeight = scrollTarget === window ? window.innerHeight : scrollTarget?.clientHeight;
        return Math.max(240, Math.round((viewportHeight || window.innerHeight || 600) * 0.9));
    }

    scrollMultiSelectTarget(scrollTarget, deltaY) {
        const options = {top: deltaY, left: 0, behavior: "auto"};

        if (scrollTarget === window || !scrollTarget) {
            window.scrollBy(options);
        }
        else if (typeof scrollTarget.scrollBy === "function") {
            scrollTarget.scrollBy(options);
        }
        else {
            scrollTarget.scrollTop += deltaY;
        }
    }

    reconcileVisiblePickerSelections() {
        for (const record of this.multiSelectRecords) {
            const match = this.findMatchingMultiSelectSelection(record);
            if (!match) continue;

            const selected = {
                ...match.selected,
                key: record.key,
                messageId: record.messageId || match.selected.messageId || null,
                text: record.text,
                links: record.links || match.selected.links || []
            };

            if (match.key !== record.key) this.multiSelectSelected.delete(match.key);
            this.multiSelectSelected.set(record.key, selected);
        }
    }

    scanVisibleMessageNodes(chatRoot = this.findMultiSelectChatRoot()) {
        const searchRoot = chatRoot || document;
        const rawRecords = Array.from(searchRoot.querySelectorAll('[id*="message-content-"]'))
            .map(content => {
                // Visibility is checked on the whole message element, not the text
                // node: attachment-only messages (file uploads, PDFs, scripts) have
                // an empty zero-height content node but still carry file links.
                const element = this.getSingleMessageElementFromContent(content) || content;
                if (!this.isVisibleElement(element)) return null;

                return {
                    content,
                    element,
                    messageId: this.parseMessageIdFromCandidate(content, element),
                    text: this.extractVisibleMessageText(element),
                    links: this.extractVisibleMessageLinks(element)
                };
            })
            .filter(Boolean);

        rawRecords.sort((left, right) => this.compareDocumentOrder(left.element, right.element));

        const records = [];
        const seenKeys = new Set();
        const seenElements = new Set();

        for (const rawRecord of rawRecords) {
            if (seenElements.has(rawRecord.element)) continue;
            if (this.overlapsSeenElement(rawRecord.element, seenElements)) continue;

            const visibleIndex = records.length + 1;
            const key = this.getMultiSelectRecordKey(rawRecord.element, rawRecord.messageId, rawRecord.text, visibleIndex);
            if (seenKeys.has(key)) continue;

            seenKeys.add(key);
            seenElements.add(rawRecord.element);
            records.push({
                ...rawRecord,
                key,
                visibleIndex
            });
        }

        return records;
    }

    getSingleMessageElementFromContent(content) {
        let element = content;
        let current = content;

        while (current?.parentElement && current.parentElement !== document.body) {
            const parent = current.parentElement;
            if (this.isMessageRangeBoundary(parent)) break;

            const contentNodes = this.getMessageContentElements(parent);
            if (contentNodes.length !== 1 || contentNodes[0] !== content) break;

            element = parent;
            current = parent;
        }

        return element;
    }

    getMessageContentElements(element) {
        const contentNodes = [];

        if (element?.matches?.('[id*="message-content-"]')) contentNodes.push(element);
        contentNodes.push(...Array.from(element?.querySelectorAll?.('[id*="message-content-"]') || []));

        return contentNodes;
    }

    isMessageRangeBoundary(element) {
        return Boolean(element?.matches?.('[data-list-id="chat-messages"], [class*="chatContent"], [class*="messagesWrapper"], [role="log"], main'));
    }

    overlapsSeenElement(element, seenElements) {
        for (const seenElement of seenElements) {
            if (element === seenElement) continue;
            if (element.contains?.(seenElement) || seenElement.contains?.(element)) return true;
        }

        return false;
    }

    parseMessageIdFromCandidate(candidate, element) {
        // Discord's DOM is not public API; read from the message-content node first
        // so grouped message wrappers do not collapse separate visible messages.
        const values = [
            candidate?.id,
            candidate?.getAttribute?.("data-list-item-id"),
            candidate?.dataset?.listItemId,
            element?.id,
            element?.getAttribute?.("data-list-item-id"),
            element?.dataset?.listItemId,
            element?.querySelector?.('[id*="message-content-"]')?.id,
            element?.querySelector?.('[data-list-item-id^="chat-messages___"]')?.getAttribute("data-list-item-id")
        ];

        for (const value of values) {
            const parsed = this.extractLastSnowflake(value);
            if (parsed) return parsed;
        }

        return null;
    }

    extractLastSnowflake(value) {
        if (!value) return null;

        const matches = String(value).match(/\d{15,25}/g);
        return matches?.length ? matches[matches.length - 1] : null;
    }

    getMultiSelectRecordKey(element, messageId, text = "") {
        if (messageId) return `message:${messageId}`;

        const textKey = this.getMultiSelectTextRecordKey(text || this.extractVisibleMessageText(element));
        if (textKey) return textKey;

        return `element:${this.getMultiSelectElementKey(element)}`;
    }

    getMultiSelectTextRecordKey(text) {
        const normalizedText = this.normalizePickerKeyText(text);
        return normalizedText ? `text:${normalizedText}` : "";
    }

    getMultiSelectElementKey(element) {
        if (!element) return "unknown";

        let key = this.multiSelectElementKeys.get(element);
        if (!key) {
            key = String(++this.multiSelectNextElementKey);
            this.multiSelectElementKeys.set(element, key);
        }

        return key;
    }

    normalizePickerKeyText(text) {
        return String(text || "")
            .replace(/\s+/g, " ")
            .trim()
            .slice(0, 240);
    }

    isVisibleElement(element) {
        const rect = element.getBoundingClientRect?.();
        if (!rect || rect.width <= 0 || rect.height <= 0) return false;

        return rect.bottom >= 0 && rect.top <= window.innerHeight && rect.right >= 0 && rect.left <= window.innerWidth;
    }

    compareDocumentOrder(left, right) {
        if (left === right) return 0;

        const position = left.compareDocumentPosition(right);
        if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
        if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
        return 0;
    }

    findMatchingMultiSelectSelection(record) {
        if (!record) return null;

        const direct = this.multiSelectSelected.get(record.key);
        if (direct) return {key: record.key, selected: direct};

        const recordTextKey = record.messageId ? "" : this.getMultiSelectTextRecordKey(record.text);

        for (const [key, selected] of this.multiSelectSelected) {
            if (record.messageId && selected.messageId === record.messageId) return {key, selected};
            if (!record.messageId && !selected.messageId && recordTextKey && this.getMultiSelectTextRecordKey(selected.text) === recordTextKey) return {key, selected};
        }

        return null;
    }

    toggleMultiSelectDensity() {
        if (!this.multiSelectActive) return;

        this.multiSelectDensityState = this.getNextMultiSelectDensityState();
        this.applyMultiSelectDensityState();
        this.updateMultiSelectDensityButton();
        this.scheduleMultiSelectPreviewRefresh(320);
        const warning = ["turbo", "turbo-plus", "text-only"].includes(this.multiSelectDensityState) ? " Warning: high density can crash Discord on weaker machines — Compact is the safe default." : "";
        this.showToast(`Density ${this.getMultiSelectDensityLabel().toLowerCase()}.${warning}`, "info");
    }

    getNextMultiSelectDensityState() {
        if (this.multiSelectDensityState === "off") return "compact";
        if (this.multiSelectDensityState === "compact") return "turbo";
        if (this.multiSelectDensityState === "turbo") return "turbo-plus";
        if (this.multiSelectDensityState === "turbo-plus") return "text-only";
        return "off";
    }

    applyMultiSelectDensityState() {
        this.removeMultiSelectDensityClasses();

        if (!this.multiSelectActive) return;

        const densityClass = this.getMultiSelectDensityClass();
        if (!densityClass) return;

        this.syncMultiSelectDensityTarget();
    }

    removeMultiSelectDensityClasses() {
        document.body?.classList.remove(...this.getMultiSelectDensityCleanupClasses());
        this.removeMultiSelectDensityTargetClasses();
    }

    removeMultiSelectDensityTargetClasses() {
        if (document?.querySelectorAll) {
            const classes = this.getMultiSelectDensityCleanupClasses();
            const selector = classes.map(className => `.${className}`).join(", ");
            document.querySelectorAll(selector).forEach(element => {
                element.classList.remove(...classes);
            });
        }
        this.multiSelectDensityTarget = null;
    }

    getMultiSelectDensityCleanupClasses() {
        return [
            this.multiSelectDensityTargetClass,
            this.multiSelectDensityClassCompact,
            this.multiSelectDensityClassTurbo,
            this.multiSelectDensityClassTurboPlus,
            this.multiSelectDensityClassTextOnly,
            ...this.multiSelectDensityLegacyClasses
        ];
    }

    syncMultiSelectDensityTarget(chatRoot = this.findMultiSelectChatRoot()) {
        const densityClass = this.getMultiSelectDensityClass();
        if (!this.multiSelectActive || !densityClass || !chatRoot) {
            this.removeMultiSelectDensityTargetClasses();
            return null;
        }

        if (this.multiSelectDensityTarget !== chatRoot) {
            this.removeMultiSelectDensityTargetClasses();
        }

        chatRoot.classList.add(this.multiSelectDensityTargetClass, densityClass);
        chatRoot.classList.remove(
            ...[
                this.multiSelectDensityClassCompact,
                this.multiSelectDensityClassTurbo,
                this.multiSelectDensityClassTurboPlus,
                this.multiSelectDensityClassTextOnly,
                ...this.multiSelectDensityLegacyClasses
            ].filter(className => className !== densityClass)
        );
        this.multiSelectDensityTarget = chatRoot;
        return chatRoot;
    }

    getMultiSelectDensityClass() {
        if (this.multiSelectDensityState === "compact") return this.multiSelectDensityClassCompact;
        if (this.multiSelectDensityState === "turbo") return this.multiSelectDensityClassTurbo;
        if (this.multiSelectDensityState === "turbo-plus") return this.multiSelectDensityClassTurboPlus;
        if (this.multiSelectDensityState === "text-only") return this.multiSelectDensityClassTextOnly;
        return "";
    }

    disableMultiSelectDensity() {
        this.multiSelectDensityState = "off";
        this.removeMultiSelectDensityClasses();
        this.updateMultiSelectDensityButton();
    }

    updateMultiSelectDensityButton() {
        const button = this.multiSelectPanel?.querySelector?.('[data-action="density"]');
        if (!button) return;

        const isActive = this.multiSelectDensityState !== "off";
        button.textContent = `Density ${this.getMultiSelectDensityLabel()}`;
        button.classList.toggle("test123-density-active", isActive);
        button.dataset.densityState = this.multiSelectDensityState;
        button.setAttribute("aria-pressed", isActive ? "true" : "false");
        button.setAttribute("aria-label", "Cycle density: off, compact, turbo, turbo plus, text-only");
        button.title = ["turbo", "turbo-plus", "text-only"].includes(this.multiSelectDensityState) ? "Warning: high density modes can crash Discord on weaker machines. Compact is the safe default." : "Cycle visible message density.";
    }

    updateMultiSelectFolderButton() {
        const button = this.multiSelectPanel?.querySelector?.('[data-action="chunk-folder"]');
        const status = this.multiSelectPanel?.querySelector?.('[data-role="folder-status"]');
        const exportDir = this.getMultiSelectChunkExportDir();
        const silentReady = Boolean(exportDir && !this.multiSelectLastFolderError);
        const statusText = this.getMultiSelectFolderStatusText();
        const fallbackTitle = this.multiSelectLastFolderError
            ? `Plugin folder write failed; Downloads fallback may prompt. ${this.multiSelectLastFolderError}`
            : "Plugin chunk folder unavailable; Downloads fallback may prompt.";

        if (status) {
            status.textContent = statusText;
            status.dataset.silent = silentReady ? "true" : "false";
        }

        if (!button) return;

        button.textContent = silentReady ? "Chunk Folder" : "Chunk Fallback";
        button.classList.toggle("test123-density-active", silentReady);
        button.setAttribute(
            "aria-label",
            silentReady ? `Auto chunks save to ${exportDir}` : fallbackTitle
        );
        button.title = silentReady ? `Auto chunks save to ${exportDir}` : fallbackTitle;
    }

    getMultiSelectChunkExportDir() {
        const pluginFolder = this.valueToText(window.BdApi?.Plugins?.folder).trim().replace(/[\\/]+$/, "");
        if (!pluginFolder) return "";
        return `${pluginFolder}/${this.multiSelectChunkExportFolderName}`;
    }

    getNodeFs() {
        if (this.multiSelectNodeFs !== undefined) return this.multiSelectNodeFs;

        try {
            this.multiSelectNodeFs = require("fs");
        }
        catch (error) {
            this.multiSelectNodeFs = null;
            this.multiSelectLastFolderError = `BetterDiscord fs unavailable: ${this.formatErrorForToast(error)}`;
            console.warn("[test123] BetterDiscord fs polyfill unavailable; using Downloads fallback.", error);
        }

        return this.multiSelectNodeFs;
    }

    getMultiSelectFolderStatusText() {
        const exportDir = this.getMultiSelectChunkExportDir();
        if (!exportDir) return "Chunk autosave folder unavailable; fallback uses Downloads and may prompt";
        if (this.multiSelectLastFolderError) return `Chunk autosave fallback: ${this.multiSelectLastFolderError}; Downloads may prompt`;
        return `Chunk autosave target: ${exportDir}`;
    }

    showDownloadsFallbackToast(reason) {
        const prefix = reason ? `${reason} ` : "";
        this.showToast(`${prefix}Downloads fallback may prompt.`, "warning");
    }

    formatErrorForToast(error) {
        if (!error) return "unknown error";
        const name = this.valueToText(error.name).trim();
        const message = this.valueToText(error.message).trim();
        if (name && message) return `${name}: ${message}`;
        return name || message || this.valueToText(error).trim() || "unknown error";
    }

    getMultiSelectDensityLabel() {
        if (this.multiSelectDensityState === "compact") return "Compact";
        if (this.multiSelectDensityState === "turbo") return "Turbo";
        if (this.multiSelectDensityState === "turbo-plus") return "Turbo+";
        if (this.multiSelectDensityState === "text-only") return "Text-Only";
        return "Off";
    }

    clearMultiSelect(showToast = true) {
        if (this.multiSelectAutoRunActive || this.multiSelectAutoRunTimer) {
            this.stopMultiSelectAutoRun("selection cleared", false);
        }
        if (this.multiSelectAutoChunkActive || this.multiSelectAutoChunkTimer) {
            this.stopMultiSelectAutoChunkRun("selection cleared", false);
        }

        const count = this.multiSelectSelected.size;

        this.multiSelectSelected.clear();
        this.multiSelectLastRecordKey = null;
        this.multiSelectLastElement = null;
        this.multiSelectLastCheckpointNotice = 0;
        this.updateMultiSelectPanel();

        if (showToast && count) {
            this.showToast(`Cleared ${count} selected message${count === 1 ? "" : "s"}.`, "success");
        }
    }

    maybeShowMultiSelectCheckpointNotice() {
        const count = this.multiSelectSelected.size;
        const step = this.multiSelectCheckpointStep;
        if (!step || count < step) return;

        const checkpoint = this.getMultiSelectCheckpointForCount(count);
        if (checkpoint <= this.multiSelectLastCheckpointNotice) return;

        this.multiSelectLastCheckpointNotice = checkpoint;
        this.showToast(`Chunk checkpoint: ${count} selected. Auto chunk export saves JSON every ${this.multiSelectChunkSize} messages.`, "warning");
    }

    getMultiSelectCheckpointForCount(count) {
        const step = this.multiSelectCheckpointStep;
        return step ? Math.floor(count / step) * step : 0;
    }

    toggleMultiSelectAutoRun() {
        if (this.multiSelectAutoRunActive || this.multiSelectAutoRunTimer) {
            this.stopMultiSelectAutoRun("stopped by user", true);
            return;
        }

        this.startMultiSelectAutoRun();
    }

    startMultiSelectAutoRun() {
        if (!this.multiSelectActive) return;

        if (this.multiSelectAutoChunkActive || this.multiSelectAutoChunkTimer) {
            this.stopMultiSelectAutoChunkRun("auto up started", false);
        }

        this.multiSelectAutoRunActive = true;
        this.multiSelectAutoRunSteps = 0;
        this.multiSelectAutoRunNoProgressSteps = 0;
        this.updateMultiSelectAutoRunButton();
        this.showToast(`Auto Up 20 started. It will stop after ${this.multiSelectAutoRunMaxSteps} scroll steps or 3 no-progress steps.`, "info");
        this.runMultiSelectAutoRunStep();
    }

    runMultiSelectAutoRunStep() {
        if (!this.multiSelectAutoRunActive || !this.multiSelectActive) {
            this.stopMultiSelectAutoRun("picker closed", false);
            return;
        }

        if (this.multiSelectAutoRunSteps >= this.multiSelectAutoRunMaxSteps) {
            this.stopMultiSelectAutoRun(`reached ${this.multiSelectAutoRunMaxSteps} steps`, true);
            return;
        }

        const stats = this.selectVisibleAndScroll(-1, false) || {added: 0, refreshed: 0};
        this.multiSelectAutoRunSteps++;
        this.multiSelectAutoRunNoProgressSteps = stats.added > 0 ? 0 : this.multiSelectAutoRunNoProgressSteps + 1;

        if (this.multiSelectAutoRunNoProgressSteps >= 3) {
            this.stopMultiSelectAutoRun("stopped after 3 no-progress steps", true);
            return;
        }

        this.updateMultiSelectAutoRunButton();
        this.multiSelectAutoRunTimer = window.setTimeout(() => {
            this.multiSelectAutoRunTimer = null;
            this.runMultiSelectAutoRunStep();
        }, this.multiSelectAutoRunDelayMs);
    }

    stopMultiSelectAutoRun(reason = "stopped", showToast = true) {
        const wasRunning = this.multiSelectAutoRunActive || this.multiSelectAutoRunTimer;
        if (this.multiSelectAutoRunTimer) {
            window.clearTimeout(this.multiSelectAutoRunTimer);
            this.multiSelectAutoRunTimer = null;
        }

        this.multiSelectAutoRunActive = false;
        const steps = this.multiSelectAutoRunSteps;
        this.updateMultiSelectAutoRunButton();

        if (showToast && wasRunning) {
            this.showToast(`Auto Up 20 ${reason}: ${steps} step${steps === 1 ? "" : "s"}, ${this.multiSelectSelected.size} selected.`, "info");
        }
    }

    updateMultiSelectAutoRunButton() {
        const button = this.multiSelectPanel?.querySelector?.('[data-action="auto-run"]');
        if (!button) return;

        const running = Boolean(this.multiSelectAutoRunActive || this.multiSelectAutoRunTimer);
        const remaining = Math.max(0, this.multiSelectAutoRunMaxSteps - this.multiSelectAutoRunSteps);
        button.textContent = running ? `Stop Auto ${remaining}` : `Auto Up ${this.multiSelectAutoRunMaxSteps}`;
        button.classList.toggle("test123-density-active", running);
        button.setAttribute("aria-pressed", running ? "true" : "false");
        button.setAttribute(
            "aria-label",
            running ? "Stop automatic visible select and scroll up" : `Start ${this.multiSelectAutoRunMaxSteps} visible select and scroll up steps`
        );
        button.title = running
            ? "Stop automatic visible select and scroll up."
            : `Run up to ${this.multiSelectAutoRunMaxSteps} visible select and scroll up steps.`;
    }

    toggleMultiSelectAutoChunkRun() {
        if (this.multiSelectAutoChunkActive || this.multiSelectAutoChunkTimer) {
            this.stopMultiSelectAutoChunkRun("stopped by user", true);
            return;
        }

        this.startMultiSelectAutoChunkRun();
    }

    startMultiSelectAutoChunkRun() {
        if (!this.multiSelectActive) return;

        if (this.multiSelectAutoRunActive || this.multiSelectAutoRunTimer) {
            this.stopMultiSelectAutoRun("auto chunk started", false);
        }

        this.multiSelectAutoChunkActive = true;
        this.multiSelectAutoChunkStartCounter = this.multiSelectChunkCounter;
        this.multiSelectAutoChunkLastCounter = this.multiSelectChunkCounter;
        this.multiSelectAutoChunkSteps = 0;
        this.multiSelectAutoChunkNoProgressSteps = 0;
        this.multiSelectAutoChunkSaveWaitMs = 0;
        this.updateMultiSelectAutoChunkButton();
        this.showToast(`Auto ${this.multiSelectAutoChunkTargetChunks} Chunks started. ${this.getMultiSelectAutoChunkStepDelay()}ms scroll delay, ${this.multiSelectAutoChunkPostSaveDelayMs}ms after saves, ${this.multiSelectAutoChunkRestDelayMs}ms rest every ${this.multiSelectAutoChunkRestEveryChunks} chunks.`, "info");
        this.runMultiSelectAutoChunkRunStep();
    }

    runMultiSelectAutoChunkRunStep() {
        if (!this.multiSelectAutoChunkActive || !this.multiSelectActive) {
            this.stopMultiSelectAutoChunkRun("picker closed", false);
            return;
        }

        const savedChunks = this.getMultiSelectAutoChunkSavedCount();
        if (savedChunks >= this.multiSelectAutoChunkTargetChunks) {
            this.stopMultiSelectAutoChunkRun(`saved ${savedChunks} chunk${savedChunks === 1 ? "" : "s"}`, true);
            return;
        }

        if (this.multiSelectAutoChunkSteps >= this.multiSelectAutoChunkMaxSteps) {
            this.stopMultiSelectAutoChunkRun(`reached ${this.multiSelectAutoChunkMaxSteps} steps`, true);
            return;
        }

        if (this.multiSelectChunkSaveInProgress) {
            this.multiSelectAutoChunkSaveWaitMs += this.multiSelectAutoChunkPollMs;
            if (this.multiSelectAutoChunkSaveWaitMs >= this.multiSelectAutoChunkMaxSaveWaitMs) {
                this.stopMultiSelectAutoChunkRun("chunk save timed out", true);
                return;
            }

            this.scheduleMultiSelectAutoChunkRun(this.multiSelectAutoChunkPollMs);
            return;
        }

        this.multiSelectAutoChunkSaveWaitMs = 0;
        if (this.multiSelectChunkCounter !== this.multiSelectAutoChunkLastCounter) {
            this.multiSelectAutoChunkLastCounter = this.multiSelectChunkCounter;
            this.multiSelectAutoChunkNoProgressSteps = 0;
            this.updateMultiSelectAutoChunkButton();
            this.scheduleMultiSelectAutoChunkRun(this.getMultiSelectAutoChunkPostSaveDelay());
            return;
        }

        const stepStart = performance.now();
        const stats = this.selectVisibleAndScroll(-1, false) || {added: 0, refreshed: 0};
        this.multiSelectLastStepWorkMs = performance.now() - stepStart;
        this.multiSelectAutoChunkSteps++;
        this.multiSelectAutoChunkNoProgressSteps = stats.added > 0 ? 0 : this.multiSelectAutoChunkNoProgressSteps + 1;

        if (this.multiSelectAutoChunkNoProgressSteps >= this.multiSelectAutoChunkMaxNoProgressSteps) {
            this.stopMultiSelectAutoChunkRun(`stopped after ${this.multiSelectAutoChunkMaxNoProgressSteps} no-progress steps`, true);
            return;
        }

        this.updateMultiSelectAutoChunkButton();
        this.scheduleMultiSelectAutoChunkRun(this.getMultiSelectAutoChunkStepDelay());
    }

    scheduleMultiSelectAutoChunkRun(delayMs) {
        if (this.multiSelectAutoChunkTimer) window.clearTimeout(this.multiSelectAutoChunkTimer);

        this.multiSelectAutoChunkTimer = window.setTimeout(() => {
            this.multiSelectAutoChunkTimer = null;
            this.runMultiSelectAutoChunkRunStep();
        }, delayMs);
    }

    getMultiSelectAutoChunkStepDelay() {
        const base = (
            this.multiSelectDensityState === "turbo" ||
            this.multiSelectDensityState === "turbo-plus" ||
            this.multiSelectDensityState === "text-only"
        )
            ? Math.max(this.multiSelectAutoChunkDelayMs, this.multiSelectAutoChunkTurboDelayMs)
            : this.multiSelectAutoChunkDelayMs;

        // Adaptive pacing: dense modes make each step process far more DOM, so pace
        // by measured step cost instead of a fixed delay. Keeps compact fast and
        // stops turbo modes from outrunning the renderer.
        const adaptive = Math.round(this.multiSelectLastStepWorkMs * this.multiSelectAutoChunkAdaptiveFactor);
        return Math.min(this.multiSelectAutoChunkMaxStepDelayMs, Math.max(base, adaptive));
    }

    getMultiSelectAutoChunkPostSaveDelay() {
        const savedChunks = this.getMultiSelectAutoChunkSavedCount();
        if (
            savedChunks > 0 &&
            this.multiSelectAutoChunkRestEveryChunks > 0 &&
            savedChunks % this.multiSelectAutoChunkRestEveryChunks === 0
        ) {
            return this.multiSelectAutoChunkRestDelayMs;
        }

        return this.multiSelectAutoChunkPostSaveDelayMs;
    }

    stopMultiSelectAutoChunkRun(reason = "stopped", showToast = true) {
        const wasRunning = this.multiSelectAutoChunkActive || this.multiSelectAutoChunkTimer;
        if (this.multiSelectAutoChunkTimer) {
            window.clearTimeout(this.multiSelectAutoChunkTimer);
            this.multiSelectAutoChunkTimer = null;
        }

        const savedChunks = this.getMultiSelectAutoChunkSavedCount();
        const steps = this.multiSelectAutoChunkSteps;
        this.multiSelectAutoChunkActive = false;
        this.multiSelectAutoChunkSaveWaitMs = 0;
        this.updateMultiSelectAutoChunkButton();

        if (showToast && wasRunning) {
            this.showToast(`Auto ${this.multiSelectAutoChunkTargetChunks} Chunks ${reason}: ${savedChunks}/${this.multiSelectAutoChunkTargetChunks} chunks, ${steps} step${steps === 1 ? "" : "s"}, ${this.multiSelectSelected.size} selected.`, "info");
        }
    }

    getMultiSelectAutoChunkSavedCount() {
        return Math.max(0, this.multiSelectChunkCounter - this.multiSelectAutoChunkStartCounter);
    }

    updateMultiSelectAutoChunkButton() {
        const button = this.multiSelectPanel?.querySelector?.('[data-action="auto-chunk"]');
        if (!button) return;

        const running = Boolean(this.multiSelectAutoChunkActive || this.multiSelectAutoChunkTimer);
        const savedChunks = this.getMultiSelectAutoChunkSavedCount();
        const remaining = Math.max(0, this.multiSelectAutoChunkTargetChunks - savedChunks);
        button.textContent = running ? `Stop Chunks ${remaining}` : `Auto ${this.multiSelectAutoChunkTargetChunks} Chunks`;
        button.classList.toggle("test123-density-active", running);
        button.setAttribute("aria-pressed", running ? "true" : "false");
        button.setAttribute(
            "aria-label",
            running ? "Stop automatic chunk export" : `Start automatic export for ${this.multiSelectAutoChunkTargetChunks} chunks`
        );
        button.title = running
            ? `Stop automatic chunk export. Saved ${savedChunks}/${this.multiSelectAutoChunkTargetChunks} chunks this run.`
            : `Select and scroll up until ${this.multiSelectAutoChunkTargetChunks} JSON chunks have saved.`;
    }

    updateMultiSelectPanel() {
        if (!this.multiSelectPanel) return;

        this.updateMultiSelectDensityButton();
        this.updateMultiSelectFolderButton();
        this.updateMultiSelectAutoRunButton();
        this.updateMultiSelectAutoChunkButton();

        const count = this.multiSelectSelected.size;
        const label = this.multiSelectPanel.querySelector(".test123-multi-count");
        const buttons = this.multiSelectPanel.querySelectorAll('[data-action="save-txt"], [data-action="save-json"], [data-action="save-txt-clear"], [data-action="save-json-clear"], [data-action="save-chunk"], [data-action="clear"]');
        const preview = this.multiSelectPanel.querySelector(".test123-picker-preview");

        if (label) label.textContent = this.buildMultiSelectStatusText();
        buttons.forEach(button => {
            button.disabled = count === 0;
        });

        if (!preview) return;

        preview.replaceChildren();
        if (this.multiSelectAutoChunkActive || this.multiSelectAutoRunActive) {
            const busy = document.createElement("div");
            busy.className = "test123-picker-preview-empty";
            busy.textContent = `Auto run active — preview paused (${count} selected).`;
            preview.appendChild(busy);
            return;
        }
        if (!this.multiSelectRecords.length) {
            const empty = document.createElement("div");
            empty.className = "test123-picker-preview-empty";
            empty.textContent = "No visible message-content nodes found. Scroll Discord manually, then refresh.";
            preview.appendChild(empty);
            return;
        }

        for (const record of this.multiSelectRecords.slice(0, 60)) {
            preview.appendChild(this.createVisiblePickerPreviewRow(record));
        }
    }

    buildMultiSelectStatusText() {
        const selectedCount = this.multiSelectSelected.size;
        const visibleCount = this.multiSelectRecords.length;
        const visibleSelectedCount = this.multiSelectRecords.filter(record => this.findMatchingMultiSelectSelection(record)).length;
        const newIfSelectedCount = Math.max(0, visibleCount - visibleSelectedCount);
        let mediaLinkCount = 0;
        for (const selected of this.multiSelectSelected.values()) {
            mediaLinkCount += Array.isArray(selected.links) ? selected.links.length : 0;
        }

        const parts = [
            `${selectedCount} selected`,
            `${visibleCount} visible now`,
            `${newIfSelectedCount} new if selected`,
            `${visibleSelectedCount} dupes`,
            `${mediaLinkCount} media/links`
        ];

        return parts.join(" / ");
    }

    createVisiblePickerPreviewRow(record) {
        const row = document.createElement("label");
        row.className = "test123-picker-preview-row";
        row.setAttribute("role", "listitem");

        const checkbox = document.createElement("input");
        checkbox.type = "checkbox";
        checkbox.className = "test123-picker-preview-checkbox";
        checkbox.checked = Boolean(this.findMatchingMultiSelectSelection(record));
        checkbox.addEventListener("change", event => {
            event.stopPropagation();
            this.toggleVisiblePickerRecord(record, checkbox.checked);
        });

        const body = document.createElement("span");
        body.className = "test123-picker-preview-text";
        body.textContent = this.buildPickerPreviewText(record.text);

        const meta = document.createElement("span");
        meta.className = "test123-picker-preview-meta";
        const metaParts = [
            record.messageId ? `Message ID: ${record.messageId}` : `Fallback: visible #${record.visibleIndex}`
        ];
        if (record.links?.length) metaParts.push(`${record.links.length} link${record.links.length === 1 ? "" : "s"}`);
        meta.textContent = metaParts.join(" / ");
        body.appendChild(meta);

        row.append(checkbox, body);
        return row;
    }

    toggleVisiblePickerRecord(record, shouldSelect) {
        const match = this.findMatchingMultiSelectSelection(record);

        if (shouldSelect) {
            const existing = match?.selected;
            if (match && match.key !== record.key) this.multiSelectSelected.delete(match.key);

            this.multiSelectSelected.set(record.key, {
                key: record.key,
                order: existing?.order ?? this.multiSelectSequence++,
                messageId: record.messageId || existing?.messageId || null,
                text: record.text,
                links: record.links || existing?.links || [],
                selectedAt: existing?.selectedAt || new Date().toISOString(),
                autoChunkEligible: false
            });
        }
        else if (match) {
            this.multiSelectSelected.delete(match.key);
        }

        this.updateMultiSelectPanel();
        if (shouldSelect) this.maybeShowMultiSelectCheckpointNotice();
    }

    buildPickerPreviewText(text) {
        const normalized = String(text || "[No visible text]").replace(/\s+/g, " ").trim();
        return normalized.length > 80 ? `${normalized.slice(0, 77)}...` : normalized;
    }

    getSortedMultiSelectMessages() {
        return Array.from(this.multiSelectSelected.values())
            .sort((left, right) => left.order - right.order)
            .map((record, index) => ({
                key: record.key,
                index: index + 1,
                messageId: record.messageId,
                text: record.text,
                links: Array.isArray(record.links) ? record.links : [],
                selectedAt: record.selectedAt,
                autoChunkEligible: Boolean(record.autoChunkEligible)
            }));
    }

    saveMultiSelectTxt() {
        try {
            const messages = this.getSortedMultiSelectMessages();
            if (!messages.length) {
                this.showToast("No messages selected.", "info");
                return false;
            }

            const exportedAt = new Date().toISOString();
            const lines = [
                "Discord Visible Selection Export",
                "================================",
                `Exported At: ${exportedAt}`,
                'Source: visible-picker',
                `Count: ${messages.length}`,
                ""
            ];

            messages.forEach((message, index) => {
                lines.push(
                    "------------------------------------------------------------",
                    `Message ${index + 1} of ${messages.length}`,
                    "------------------------------------------------------------",
                    `Index: ${message.index}`,
                    `Message ID: ${message.messageId || "Unavailable"}`,
                    `Selected At: ${message.selectedAt}`,
                    "",
                    "Text:",
                    message.text || "[No visible text]"
                );

                if (message.links?.length) {
                    lines.push("", "Links:");
                    message.links.forEach((link, linkIndex) => {
                        lines.push(`${linkIndex + 1}. ${link}`);
                    });
                }

                if (index < messages.length - 1) lines.push("");
            });

            const filename = this.buildMultiSelectFilename(messages.length, "txt");
            this.downloadTextFile(filename, `${lines.join("\n")}\n`);
            this.showToast(`Saved ${filename}`, "success");
            return true;
        }
        catch (error) {
            this.showError("Could not save the selected messages as TXT.", error);
            return false;
        }
    }

    saveMultiSelectJson() {
        try {
            const messages = this.getSortedMultiSelectMessages();
            if (!messages.length) {
                this.showToast("No messages selected.", "info");
                return false;
            }

            const payload = {
                exportedAt: new Date().toISOString(),
                count: messages.length,
                source: "visible-picker",
                messages: messages.map(message => ({
                    index: message.index,
                    messageId: message.messageId,
                    text: message.text,
                    links: message.links,
                    selectedAt: message.selectedAt
                }))
            };
            const filename = this.buildMultiSelectFilename(messages.length, "json");

            this.downloadJsonFile(filename, payload);
            this.showToast(`Saved ${filename}`, "success");
            return true;
        }
        catch (error) {
            this.showError("Could not save the selected messages as JSON.", error);
            return false;
        }
    }

    saveMultiSelectTxtAndClear() {
        const saved = this.saveMultiSelectTxt();
        if (saved) this.clearMultiSelect(true);
        return saved;
    }

    saveMultiSelectJsonAndClear() {
        const saved = this.saveMultiSelectJson();
        if (saved) this.clearMultiSelect(true);
        return saved;
    }

    async saveMultiSelectChunk() {
        if (this.multiSelectChunkSaveInProgress) {
            this.showToast("Chunk save already in progress.", "info");
            return false;
        }

        const messages = this.getSortedMultiSelectMessages();
        if (!messages.length) {
            this.showToast("No messages selected.", "info");
            return false;
        }

        const chunkMessages = messages.slice(0, this.multiSelectChunkSize);
        this.multiSelectChunkSaveInProgress = true;
        try {
            return await this.writeAndClearMultiSelectChunk(chunkMessages, false);
        }
        catch (error) {
            this.showError("Could not save the selected chunk.", error);
            return false;
        }
        finally {
            this.multiSelectChunkSaveInProgress = false;
        }
    }

    maybeAutoSaveMultiSelectChunk(stats) {
        if (!this.multiSelectActive || !stats || (!stats.added && !stats.refreshed)) return;
        if (this.getAutoChunkEligibleMultiSelectMessages().length < this.multiSelectChunkSize) return;

        this.runMultiSelectAutoChunkSave();
    }

    async runMultiSelectAutoChunkSave() {
        if (this.multiSelectChunkSaveInProgress) {
            this.multiSelectAutoChunkPending = true;
            return;
        }

        this.multiSelectChunkSaveInProgress = true;
        try {
            while (this.multiSelectActive) {
                this.multiSelectAutoChunkPending = false;
                const eligibleMessages = this.getAutoChunkEligibleMultiSelectMessages();
                if (eligibleMessages.length < this.multiSelectChunkSize) break;

                const saved = await this.writeAndClearMultiSelectChunk(
                    eligibleMessages.slice(0, this.multiSelectChunkSize),
                    true
                );
                if (!saved) break;

                // Yield between consecutive saves so back-to-back chunk writes
                // (common in turbo density) do not stall the renderer.
                await this.sleepMultiSelect(this.multiSelectAutoSaveYieldMs);
            }
        }
        catch (error) {
            this.showError("Could not auto-save the selected chunk.", error);
        }
        finally {
            this.multiSelectChunkSaveInProgress = false;
            if (this.multiSelectAutoChunkPending && this.multiSelectActive) {
                this.multiSelectAutoChunkPending = false;
                this.runMultiSelectAutoChunkSave();
            }
        }
    }

    sleepMultiSelect(ms) {
        return new Promise(resolve => window.setTimeout(resolve, ms));
    }

    // Discord CDN attachment URLs are signed and expire (~24h). The client
    // re-signs them on every fetch, but exported links are static snapshots,
    // so attachment bytes are downloaded at chunk-save time while the
    // signature is still valid. Attachments of selected messages only.
    queueChunkMediaDownloads(messages, partNumber) {
        if (!this.multiSelectMediaDownloadEnabled || !this.getNodeFs() || !this.getMultiSelectChunkExportDir()) return;

        let queued = 0;
        for (const message of messages) {
            for (const link of message.links || []) {
                if (!this.isDiscordAttachmentUrl(link)) continue;

                const urlKey = String(link).split("?")[0];
                if (this.multiSelectMediaSeenUrls.has(urlKey)) continue;

                this.multiSelectMediaSeenUrls.add(urlKey);
                this.multiSelectMediaQueue.push({url: link, partNumber, messageId: message.messageId || null});
                queued++;
            }
        }

        if (queued) this.pumpMultiSelectMediaQueue();
    }

    isDiscordAttachmentUrl(link) {
        try {
            const url = new URL(String(link || ""));
            const validHost = /(^|\.)(cdn\.discordapp\.com|media\.discordapp\.net)$/i.test(url.hostname);
            return validHost && /^\/attachments\//.test(url.pathname);
        }
        catch (_) {
            return false;
        }
    }

    pumpMultiSelectMediaQueue() {
        while (this.multiSelectMediaActiveDownloads < this.multiSelectMediaMaxConcurrent && this.multiSelectMediaQueue.length) {
            const item = this.multiSelectMediaQueue.shift();
            this.multiSelectMediaActiveDownloads++;
            this.downloadChunkMediaItem(item).finally(() => {
                this.multiSelectMediaActiveDownloads--;
                this.pumpMultiSelectMediaQueue();
            });
        }

        if (!this.multiSelectMediaQueue.length && !this.multiSelectMediaActiveDownloads) {
            this.maybeToastMediaDownloadSummary();
        }
    }

    async downloadChunkMediaItem(item) {
        try {
            const fs = this.getNodeFs();
            const exportDir = this.getMultiSelectChunkExportDir();
            if (!fs || !exportDir) throw new Error("Chunk folder unavailable.");

            const response = await fetch(item.url);
            if (!response.ok) throw new Error(`HTTP ${response.status}`);

            const buffer = await response.arrayBuffer();
            if (buffer.byteLength > this.multiSelectMediaMaxBytes) {
                this.multiSelectMediaStats.skipped++;
                console.warn(`[test123] Skipped oversized attachment (${buffer.byteLength} bytes): ${item.url}`);
                return;
            }

            const mediaDir = `${exportDir}/${this.multiSelectMediaFolderName}`;
            fs.mkdirSync(mediaDir, {recursive: true});
            fs.writeFileSync(`${mediaDir}/${this.buildChunkMediaFilename(item)}`, new Uint8Array(buffer));
            this.multiSelectMediaStats.saved++;
        }
        catch (error) {
            this.multiSelectMediaStats.failed++;
            console.warn(`[test123] Could not download attachment: ${item.url}`, error);
        }
    }

    buildChunkMediaFilename(item) {
        let attachmentId = "";
        let baseName = "attachment";

        try {
            const parts = new URL(item.url).pathname.split("/").filter(Boolean);
            // /attachments/<channelId>/<attachmentId>/<filename>
            attachmentId = parts[2] || "";
            baseName = decodeURIComponent(parts[3] || baseName);
        }
        catch (_) { /* keep defaults */ }

        const part = String(item.partNumber || 0).padStart(3, "0");
        const idPart = attachmentId ? `-${attachmentId}` : "";
        return this.sanitizeFilename(`part-${part}${idPart}-${baseName}`, `part-${part}-attachment`);
    }

    maybeToastMediaDownloadSummary() {
        const {saved, failed, skipped} = this.multiSelectMediaStats;
        if (!saved && !failed && !skipped) return;

        const parts = [`${saved} saved`];
        if (failed) parts.push(`${failed} failed`);
        if (skipped) parts.push(`${skipped} skipped`);
        this.showToast(`Attachment downloads: ${parts.join(", ")} (${this.multiSelectMediaFolderName}/ in chunk folder).`, failed ? "warning" : "success");
        this.multiSelectMediaStats = {saved: 0, failed: 0, skipped: 0};
    }

    getAutoChunkEligibleMultiSelectMessages() {
        return this.getSortedMultiSelectMessages().filter(message => message.autoChunkEligible);
    }

    async writeAndClearMultiSelectChunk(messages, isAuto) {
        if (!messages.length) return false;

        const partNumber = this.multiSelectChunkCounter + 1;
        const filename = this.buildMultiSelectChunkFilename(messages.length, partNumber);
        const payload = this.buildMultiSelectChunkPayload(messages, partNumber);
        const destination = await this.saveMultiSelectChunkPayload(filename, payload);
        if (!destination) return false;

        this.multiSelectChunkCounter = partNumber;
        const overlapKept = isAuto ? Math.min(this.multiSelectChunkOverlapCount, Math.max(0, messages.length - 1)) : 0;
        this.recordMultiSelectManifestChunk(filename, messages, partNumber, destination, overlapKept);
        this.queueChunkMediaDownloads(messages, partNumber);

        const messagesToRemove = overlapKept ? messages.slice(0, Math.max(0, messages.length - overlapKept)) : messages;
        this.removeMultiSelectMessages(messagesToRemove);

        const remaining = this.multiSelectSelected.size;
        const prefix = isAuto ? "Auto-saved chunk" : "Saved chunk";
        const overlapText = overlapKept ? ` Kept ${overlapKept} overlap.` : "";
        const suffix = remaining ? `${remaining} selected remain.` : "Selection cleared.";
        this.showToast(`${prefix} ${filename} to ${destination}; cleared ${messagesToRemove.length}.${overlapText} ${suffix}`, "success");
        return true;
    }

    buildMultiSelectChunkPayload(messages, partNumber) {
        return {
            exportedAt: new Date().toISOString(),
            count: messages.length,
            source: "visible-picker",
            sessionTimestamp: this.multiSelectSessionTimestamp || this.buildMultiSelectSessionTimestamp(),
            chunkPart: partNumber,
            chunkSize: this.multiSelectChunkSize,
            overlapCount: this.multiSelectChunkOverlapCount,
            messages: messages.map((message, index) => ({
                index: index + 1,
                messageId: message.messageId,
                text: message.text,
                links: message.links,
                selectedAt: message.selectedAt
            }))
        };
    }

    async saveMultiSelectChunkPayload(filename, payload) {
        const exportDir = this.writeJsonToPluginChunkFolder(filename, payload);
        if (exportDir) return exportDir;

        this.updateMultiSelectFolderButton();
        this.showDownloadsFallbackToast(`Plugin folder write failed: ${this.multiSelectLastFolderError || "unknown error"}.`);

        try {
            this.downloadJsonFile(filename, payload);
            return "Downloads fallback";
        }
        catch (error) {
            this.showError("Could not save the selected chunk.", error);
            return "";
        }
    }

    writeJsonToPluginChunkFolder(filename, payload) {
        try {
            const fs = this.getNodeFs();
            if (!fs) throw new Error(this.multiSelectLastFolderError || "BetterDiscord fs polyfill is unavailable.");

            const exportDir = this.getMultiSelectChunkExportDir();
            if (!exportDir) throw new Error("BdApi.Plugins.folder is unavailable.");

            const safeFilename = this.sanitizeFilename(filename, "discord-visible-picker-chunk.json");
            const jsonText = `${JSON.stringify(payload, null, 2)}\n`;

            fs.mkdirSync(exportDir, {recursive: true});
            fs.writeFileSync(`${exportDir}/${safeFilename}`, jsonText, "utf8");
            this.multiSelectLastFolderError = "";
            this.updateMultiSelectFolderButton();
            return exportDir;
        }
        catch (error) {
            this.multiSelectLastFolderError = this.formatErrorForToast(error);
            console.warn("[test123] Could not write chunk to plugin folder; using Downloads fallback.", error);
            return "";
        }
    }

    recordMultiSelectManifestChunk(filename, messages, partNumber, destination, overlapKept) {
        if (!destination || destination === "Downloads fallback") return;

        this.multiSelectManifestChunks.push(
            this.buildMultiSelectManifestChunk(filename, messages, partNumber, destination, overlapKept)
        );
        this.writeMultiSelectSessionManifest();
    }

    buildMultiSelectManifestChunk(filename, messages, partNumber, destination, overlapKept) {
        const first = messages[0] || {};
        const last = messages[messages.length - 1] || {};

        return {
            savedAt: new Date().toISOString(),
            filename,
            part: partNumber,
            count: messages.length,
            overlapFromPrevious: partNumber > 1 && overlapKept ? Math.min(overlapKept, messages.length) : 0,
            overlapKept,
            destination,
            firstMessageId: first.messageId || null,
            lastMessageId: last.messageId || null,
            firstTextHash: this.hashMultiSelectText(first.text),
            lastTextHash: this.hashMultiSelectText(last.text),
            firstSelectedAt: first.selectedAt || null,
            lastSelectedAt: last.selectedAt || null
        };
    }

    writeMultiSelectSessionManifest() {
        const filename = this.getMultiSelectSessionManifestFilename();
        const payload = this.buildMultiSelectSessionManifestPayload();
        this.writeJsonManifestToPluginFolder(filename, payload);
    }

    getMultiSelectSessionManifestFilename() {
        if (!this.multiSelectManifestFilename) {
            const sessionTimestamp = this.multiSelectSessionTimestamp || this.buildMultiSelectSessionTimestamp();
            this.multiSelectManifestFilename = this.sanitizeFilename(
                `discord-visible-picker-session-${sessionTimestamp}-manifest.json`,
                "discord-visible-picker-session-manifest.json"
            );
        }

        return this.multiSelectManifestFilename;
    }

    buildMultiSelectSessionManifestPayload() {
        const chunks = this.multiSelectManifestChunks.slice();

        return {
            manifestVersion: 1,
            pluginName: this.name,
            pluginVersion: this.version,
            source: "visible-picker",
            sessionTimestamp: this.multiSelectSessionTimestamp || this.buildMultiSelectSessionTimestamp(),
            updatedAt: new Date().toISOString(),
            chunkSize: this.multiSelectChunkSize,
            overlapCount: this.multiSelectChunkOverlapCount,
            autoTargetChunks: this.multiSelectAutoChunkTargetChunks,
            scrollDelayMs: this.multiSelectAutoChunkDelayMs,
            turboScrollDelayMs: this.multiSelectAutoChunkTurboDelayMs,
            effectiveScrollDelayMs: this.getMultiSelectAutoChunkStepDelay(),
            postSaveDelayMs: this.multiSelectAutoChunkPostSaveDelayMs,
            restEveryChunks: this.multiSelectAutoChunkRestEveryChunks,
            restDelayMs: this.multiSelectAutoChunkRestDelayMs,
            chunkCount: chunks.length,
            totalChunkMessages: chunks.reduce((total, chunk) => total + (chunk.count || 0), 0),
            estimatedUniqueMessages: chunks.reduce((total, chunk) => total + Math.max(0, (chunk.count || 0) - (chunk.overlapFromPrevious || 0)), 0),
            chunks
        };
    }

    writeJsonManifestToPluginFolder(filename, payload) {
        try {
            const fs = this.getNodeFs();
            if (!fs) throw new Error(this.multiSelectLastFolderError || "BetterDiscord fs polyfill is unavailable.");

            const exportDir = this.getMultiSelectChunkExportDir();
            if (!exportDir) throw new Error("BdApi.Plugins.folder is unavailable.");

            const safeFilename = this.sanitizeFilename(filename, "discord-visible-picker-session-manifest.json");
            fs.mkdirSync(exportDir, {recursive: true});
            fs.writeFileSync(`${exportDir}/${safeFilename}`, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
            return exportDir;
        }
        catch (error) {
            console.warn("[test123] Could not write export manifest.", error);
            return "";
        }
    }

    hashMultiSelectText(text) {
        const value = this.valueToText(text);
        let hash = 2166136261;

        for (let index = 0; index < value.length; index++) {
            hash ^= value.charCodeAt(index);
            hash = Math.imul(hash, 16777619);
        }

        return (hash >>> 0).toString(16).padStart(8, "0");
    }

    removeMultiSelectMessages(messages) {
        for (const message of messages) {
            if (message.key && this.multiSelectSelected.delete(message.key)) continue;

            for (const [key, selected] of this.multiSelectSelected) {
                const sameMessage = message.messageId && selected.messageId === message.messageId;
                const sameFallback = !message.messageId && !selected.messageId && selected.selectedAt === message.selectedAt && selected.text === message.text;
                if (!sameMessage && !sameFallback) continue;

                this.multiSelectSelected.delete(key);
                break;
            }
        }

        this.multiSelectLastRecordKey = null;
        this.multiSelectLastElement = null;
        this.multiSelectLastCheckpointNotice = this.getMultiSelectCheckpointForCount(this.multiSelectSelected.size);
        this.updateMultiSelectPanel();
    }

    extractVisibleMessageText(element) {
        const source = element.querySelector?.('[id*="message-content-"]') || element;
        const clone = source.cloneNode(true);

        clone.querySelectorAll?.(".test123-select-control").forEach(control => control.remove());
        clone.querySelectorAll?.(".test123-visible-picker, .test123-multi-panel").forEach(control => control.remove());

        const text = (clone.innerText || clone.textContent || "")
            .replace(/[ \t]+\n/g, "\n")
            .replace(/\n{3,}/g, "\n\n")
            .trim();

        const fileNames = this.extractAttachmentFileNames(element);
        if (!fileNames.length) return text;

        const fileLine = `[Files: ${fileNames.join(", ")}]`;
        return text ? `${text}\n${fileLine}` : fileLine;
    }

    extractAttachmentFileNames(element) {
        const names = [];
        const seen = new Set();

        for (const node of element?.querySelectorAll?.('[class*="attachment"] [class*="fileName"], [class*="attachment"] a[href]') || []) {
            const name = String(node.textContent || "").replace(/\s+/g, " ").trim();
            if (!name || name.length > 200 || seen.has(name)) continue;
            seen.add(name);
            names.push(name);
        }

        return names;
    }

    extractVisibleMessageLinks(element) {
        const links = [];
        const seen = new Set();
        const linkSelector = "a[href], img[src], video[src], source[src], [data-safe-src], [data-src], [srcset]";
        const nodes = Array.from(element?.querySelectorAll?.(linkSelector) || []);
        if (element?.matches?.(linkSelector)) nodes.unshift(element);

        const addLink = value => {
            const link = this.normalizeDomLink(value);
            if (!link || seen.has(link)) return;
            seen.add(link);
            links.push(link);
        };

        for (const node of nodes) {
            if (node.matches?.("a[href]")) addLink(node.getAttribute("href"));
            if (node.matches?.("img[src]")) addLink(node.getAttribute("src"));
            if (node.matches?.("video[src]")) addLink(node.getAttribute("src"));
            if (node.matches?.("source[src]")) addLink(node.getAttribute("src"));
            addLink(node.getAttribute("data-safe-src"));
            addLink(node.getAttribute("data-src"));
            this.parseSrcsetLinks(node.getAttribute("srcset")).forEach(addLink);
        }

        return links;
    }

    parseSrcsetLinks(value) {
        return String(value || "")
            .split(",")
            .map(candidate => candidate.trim().split(/\s+/)[0])
            .filter(Boolean);
    }

    normalizeDomLink(value) {
        const link = String(value || "").trim();
        if (!link || link === "#") return "";
        if (/^javascript:/i.test(link)) return "";
        if (/^\/assets\//i.test(link)) return "";
        return link;
    }

    downloadTextFile(filename, text, type = "text/plain;charset=utf-8") {
        const blob = new Blob([text], {type});
        const objectUrl = URL.createObjectURL(blob);
        const anchor = document.createElement("a");

        anchor.href = objectUrl;
        anchor.download = filename;
        anchor.style.display = "none";
        document.body.appendChild(anchor);
        anchor.click();
        anchor.remove();

        window.setTimeout(() => URL.revokeObjectURL(objectUrl), 1000);
    }

    downloadJsonFile(filename, payload) {
        this.downloadTextFile(filename, `${JSON.stringify(payload, null, 2)}\n`, "application/json;charset=utf-8");
    }

    buildFilename(message) {
        const timestamp = this.formatTimestamp(this.getMessageTimestampValue(message));
        const timestampPart = timestamp ? timestamp.replace(/[:.]/g, "-") : new Date().toISOString().replace(/[:.]/g, "-");
        const raw = `discord-message-${message.id || timestampPart}-${timestampPart}.txt`;
        const safe = raw.replace(/[<>:"/\\|?*\x00-\x1F]/g, "-").replace(/\s+/g, "_").replace(/-+/g, "-");

        return safe.slice(0, 180).replace(/\.+$/, "") || "discord-message.txt";
    }

    buildBatchFilename(count) {
        const timestampPart = new Date().toISOString().replace(/[:.]/g, "-");
        const raw = `discord-messages-${count}-${timestampPart}.txt`;
        const safe = raw.replace(/[<>:"/\\|?*\x00-\x1F]/g, "-").replace(/\s+/g, "_").replace(/-+/g, "-");

        return safe.slice(0, 180).replace(/\.+$/, "") || "discord-messages.txt";
    }

    buildJsonBatchFilename(count) {
        const timestampPart = new Date().toISOString().replace(/[:.]/g, "-");
        const raw = `discord-messages-${count}-${timestampPart}.json`;
        const safe = raw.replace(/[<>:"/\\|?*\x00-\x1F]/g, "-").replace(/\s+/g, "_").replace(/-+/g, "-");

        return safe.slice(0, 180).replace(/\.+$/, "") || "discord-messages.json";
    }

    buildMultiSelectFilename(count, extension) {
        const timestampPart = new Date().toISOString().replace(/[:.]/g, "-");
        const raw = `discord-visible-picker-${count}-${timestampPart}.${extension}`;
        const safe = raw.replace(/[<>:"/\\|?*\x00-\x1F]/g, "-").replace(/\s+/g, "_").replace(/-+/g, "-");

        return safe.slice(0, 180).replace(/\.+$/, "") || `discord-visible-picker.${extension}`;
    }

    buildMultiSelectSessionTimestamp() {
        return new Date().toISOString().replace(/[:.]/g, "-");
    }

    buildMultiSelectChunkFilename(count, partNumber) {
        if (!this.multiSelectSessionTimestamp) this.multiSelectSessionTimestamp = this.buildMultiSelectSessionTimestamp();

        const part = String(partNumber || 1).padStart(3, "0");
        const countPart = String(count || 0).padStart(3, "0");
        const raw = `discord-visible-picker-session-${this.multiSelectSessionTimestamp}-part-${part}-${countPart}.json`;

        return this.sanitizeFilename(raw, `discord-visible-picker-session-${this.multiSelectSessionTimestamp}-part-${part}.json`);
    }

    sanitizeFilename(raw, fallback) {
        const safe = this.valueToText(raw)
            .replace(/[<>:"/\\|?*\x00-\x1F]/g, "-")
            .replace(/\s+/g, "_")
            .replace(/-+/g, "-");

        return safe.slice(0, 180).replace(/\.+$/, "") || fallback;
    }

    getAuthorTag(author) {
        if (!author) return "";
        if (author.tag) return author.tag;

        const username = this.getAuthorUsername(author);
        const discriminator = author.discriminator;

        if (!username) return "";
        if (discriminator && discriminator !== "0") return `${username}#${discriminator}`;
        return username;
    }

    getAuthorUsername(author) {
        if (!author) return "";
        return this.firstValue(author.username, author.globalName, author.global_name, author.displayName) || "";
    }

    normalizeCollection(value) {
        if (!value) return [];
        if (Array.isArray(value)) return value;
        if (typeof value.toArray === "function") return value.toArray();
        if (typeof value.values === "function") return Array.from(value.values());
        if (typeof value === "object") return Object.values(value);
        return [];
    }

    getMessageTimestampValue(message) {
        return this.firstValue(message.timestamp, message.createdAt, message.created_at, message.createdTimestamp);
    }

    getTimestampMs(value) {
        if (!value) return null;

        try {
            if (value instanceof Date) return this.normalizeTimestampMs(value.getTime());
            if (typeof value === "number") return this.normalizeTimestampMs(value);
            if (typeof value === "string") {
                const parsed = new Date(value).getTime();
                return Number.isNaN(parsed) ? null : parsed;
            }
            if (value._d instanceof Date) return this.normalizeTimestampMs(value._d.getTime());
            if (typeof value.toDate === "function") return this.normalizeTimestampMs(value.toDate().getTime());
            if (typeof value.valueOf === "function") {
                const numeric = value.valueOf();
                if (typeof numeric === "number" && Number.isFinite(numeric)) return this.normalizeTimestampMs(numeric);
            }
            if (typeof value.toISOString === "function") {
                const parsed = new Date(value.toISOString()).getTime();
                return Number.isNaN(parsed) ? null : parsed;
            }
        }
        catch (_) {
            return null;
        }

        return null;
    }

    normalizeTimestampMs(value) {
        if (!Number.isFinite(value)) return null;
        return value < 100000000000 ? value * 1000 : value;
    }

    formatTimestamp(value) {
        if (!value) return "";

        try {
            if (value instanceof Date) return value.toISOString();
            if (typeof value === "number") return new Date(value).toISOString();
            if (typeof value === "string") {
                const parsed = new Date(value);
                return Number.isNaN(parsed.getTime()) ? value : parsed.toISOString();
            }
            if (value._d instanceof Date) return value._d.toISOString();
            if (typeof value.toDate === "function") return value.toDate().toISOString();
            if (typeof value.toISOString === "function") return value.toISOString();
        }
        catch (_) {
            return String(value);
        }

        return String(value);
    }

    valueToText(value) {
        if (value == null) return "";
        if (typeof value === "string") return value;
        if (typeof value === "number" || typeof value === "boolean") return String(value);

        try {
            return JSON.stringify(value, null, 2);
        }
        catch (_) {
            return String(value);
        }
    }

    firstValue(...values) {
        return values.find(value => value !== undefined && value !== null && value !== "");
    }

    toStringOrNull(value) {
        return value === undefined || value === null || value === "" ? null : String(value);
    }

    showToast(message, type = "info") {
        if (BdApi.UI?.showToast) BdApi.UI.showToast(message, {type});
    }

    showError(message, error) {
        console.error(`[test123] ${message}`, error);

        const detail = error?.message || String(error);
        if (BdApi.UI?.showToast) BdApi.UI.showToast(message, {type: "error"});
        if (BdApi.UI?.alert) BdApi.UI.alert("test123", `${message}\n\n${detail}`);
    }
};