@sequent-org/moodboard 1.3.1 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequent-org/moodboard",
-  "version": "1.3.1",
+  "version": "1.3.4",
   "type": "module",
   "description": "Interactive moodboard",
   "main": "./src/index.js",

package/src/core/events/Events.js

@@ -65,6 +65,7 @@ export const Events = {
 		ZoomFit: 'ui:zoom:fit',
 		ZoomSelection: 'ui:zoom:selection',
 		ZoomPercent: 'ui:zoom:percent',
+		RevitShowInModel: 'ui:revit:show-in-model',
 		MinimapGetData: 'ui:minimap:get-data',
 		MinimapCenterOn: 'ui:minimap:center-on',
 		TextEditStart: 'ui:text:edit:start',

package/src/core/flows/ClipboardFlow.js

@@ -1,7 +1,24 @@
 import { Events } from '../events/Events.js';
 import { PasteObjectCommand } from '../commands/index.js';
+import { RevitScreenshotMetadataService } from '../../services/RevitScreenshotMetadataService.js';
 
 export function setupClipboardFlow(core) {
+    const revitMetadataService = new RevitScreenshotMetadataService(console);
+
+    const resolveRevitImagePayload = async (src, context = {}) => {
+        const meta = await revitMetadataService.extractFromImageSource(src, context);
+        if (meta.hasMetadata && meta.payload) {
+            return {
+                type: 'revit-screenshot-img',
+                properties: { view: meta.payload }
+            };
+        }
+        return {
+            type: 'image',
+            properties: {}
+        };
+    };
+
     core.eventBus.on(Events.UI.CopyObject, ({ objectId }) => {
         if (!objectId) return;
         core.copyObject(objectId);
@@ -189,7 +206,7 @@ export function setupClipboardFlow(core) {
         const worldX = (screenX - (world?.x || 0)) / s;
         const worldY = (screenY - (world?.y || 0)) / s;
 
-        const placeWithAspect = (natW, natH) => {
+        const placeWithAspect = async (natW, natH) => {
             let w = 300;
             let h = 200;
             if (natW > 0 && natH > 0) {
@@ -197,19 +214,34 @@ export function setupClipboardFlow(core) {
                 w = 300;
                 h = Math.max(1, Math.round(w / ar));
             }
-            const properties = { src, name, width: w, height: h };
+            const revitPayload = await resolveRevitImagePayload(src, {
+                source: 'clipboard:paste-image',
+                name
+            });
+            const properties = {
+                src,
+                name,
+                width: w,
+                height: h,
+                ...revitPayload.properties
+            };
             const extraData = imageId ? { imageId } : {};
-            core.createObject('image', { x: Math.round(worldX - Math.round(w / 2)), y: Math.round(worldY - Math.round(h / 2)) }, properties, extraData);
+            core.createObject(
+                revitPayload.type,
+                { x: Math.round(worldX - Math.round(w / 2)), y: Math.round(worldY - Math.round(h / 2)) },
+                properties,
+                extraData
+            );
         };
 
         try {
             const img = new Image();
             img.decoding = 'async';
-            img.onload = () => placeWithAspect(img.naturalWidth || 0, img.naturalHeight || 0);
-            img.onerror = () => placeWithAspect(0, 0);
+            img.onload = () => { void placeWithAspect(img.naturalWidth || 0, img.naturalHeight || 0); };
+            img.onerror = () => { void placeWithAspect(0, 0); };
             img.src = src;
         } catch (_) {
-            placeWithAspect(0, 0);
+            void placeWithAspect(0, 0);
         }
     });
 
@@ -220,7 +252,7 @@ export function setupClipboardFlow(core) {
         const worldX = (x - (world?.x || 0)) / s;
         const worldY = (y - (world?.y || 0)) / s;
 
-        const placeWithAspect = (natW, natH) => {
+        const placeWithAspect = async (natW, natH) => {
             let w = 300;
             let h = 200;
             if (natW > 0 && natH > 0) {
@@ -228,19 +260,34 @@ export function setupClipboardFlow(core) {
                 w = 300;
                 h = Math.max(1, Math.round(w / ar));
             }
-            const properties = { src, name, width: w, height: h };
+            const revitPayload = await resolveRevitImagePayload(src, {
+                source: 'clipboard:paste-image-at',
+                name
+            });
+            const properties = {
+                src,
+                name,
+                width: w,
+                height: h,
+                ...revitPayload.properties
+            };
             const extraData = imageId ? { imageId } : {};
-            core.createObject('image', { x: Math.round(worldX - Math.round(w / 2)), y: Math.round(worldY - Math.round(h / 2)) }, properties, extraData);
+            core.createObject(
+                revitPayload.type,
+                { x: Math.round(worldX - Math.round(w / 2)), y: Math.round(worldY - Math.round(h / 2)) },
+                properties,
+                extraData
+            );
         };
 
         try {
             const img = new Image();
             img.decoding = 'async';
-            img.onload = () => placeWithAspect(img.naturalWidth || 0, img.naturalHeight || 0);
-            img.onerror = () => placeWithAspect(0, 0);
+            img.onload = () => { void placeWithAspect(img.naturalWidth || 0, img.naturalHeight || 0); };
+            img.onerror = () => { void placeWithAspect(0, 0); };
             img.src = src;
         } catch (_) {
-            placeWithAspect(0, 0);
+            void placeWithAspect(0, 0);
         }
     });
 

package/src/core/flows/RevitFlow.js

@@ -0,0 +1,15 @@
+import { Events } from '../events/Events.js';
+import { RevitNavigationService } from '../../services/RevitNavigationService.js';
+
+export function setupRevitFlow(core) {
+    const navigationService = new RevitNavigationService();
+
+    core.eventBus.on(Events.UI.RevitShowInModel, async ({ objectId, view }) => {
+        if (!view || typeof view !== 'string') {
+            return;
+        }
+
+        await navigationService.showInModel(view, { objectId });
+    });
+}
+

package/src/core/index.js

@@ -15,6 +15,7 @@ import { setupTransformFlow } from './flows/TransformFlow.js';
 import { setupClipboardFlow, setupClipboardKeyboardFlow } from './flows/ClipboardFlow.js';
 import { setupObjectLifecycleFlow } from './flows/ObjectLifecycleFlow.js';
 import { setupLayerAndViewportFlow } from './flows/LayerAndViewportFlow.js';
+import { setupRevitFlow } from './flows/RevitFlow.js';
 import { setupSaveFlow } from './flows/SaveFlow.js';
 
 export class CoreMoodBoard {
@@ -123,6 +124,7 @@ export class CoreMoodBoard {
         setupLayerAndViewportFlow(this);
         setupTransformFlow(this);
         setupObjectLifecycleFlow(this);
+        setupRevitFlow(this);
     }
 
     /**

package/src/moodboard/ActionHandler.js

@@ -20,6 +20,7 @@ export class ActionHandler {
             case 'drawing':
             case 'emoji':
             case 'image':
+            case 'revit-screenshot-img':
             case 'comment':
             case 'file':
                 // Передаем imageId как extraData для изображений, fileId для файлов

package/src/objects/ImageObject.js

@@ -31,10 +31,16 @@ export class ImageObject {
             const sy = this.height / texH;
             this.sprite.scale.set(sx, sy);
             // Обновим метаданные базовых размеров
+            const prevMb = this.sprite._mb || {};
             this.sprite._mb = {
-                ...(this.sprite._mb || {}),
-                type: 'image',
-                properties: { src, baseW: texW, baseH: texH }
+                ...prevMb,
+                type: this.objectData?.type || prevMb.type || 'image',
+                properties: {
+                    ...(prevMb.properties || {}),
+                    src,
+                    baseW: texW,
+                    baseH: texH
+                }
             };
         };
 

package/src/objects/ObjectFactory.js

@@ -4,6 +4,7 @@ import { DrawingObject } from './DrawingObject.js';
 import { TextObject } from './TextObject.js';
 import { EmojiObject } from './EmojiObject.js';
 import { ImageObject } from './ImageObject.js';
+import { RevitScreenshotImageObject } from './RevitScreenshotImageObject.js';
 import { CommentObject } from './CommentObject.js';
 import { NoteObject } from './NoteObject.js';
 import { FileObject } from './FileObject.js';
@@ -21,6 +22,7 @@ export class ObjectFactory {
         ['simple-text', TextObject],
         ['emoji', EmojiObject],
         ['image', ImageObject],
+        ['revit-screenshot-img', RevitScreenshotImageObject],
         ['comment', CommentObject],
         ['note', NoteObject],
         ['file', FileObject]

package/src/objects/RevitScreenshotImageObject.js

@@ -0,0 +1,9 @@
+import { ImageObject } from './ImageObject.js';
+
+/**
+ * RevitScreenshotImageObject
+ * Специализированный тип для скриншотов Revit.
+ * Визуально и по трансформациям полностью повторяет ImageObject.
+ */
+export class RevitScreenshotImageObject extends ImageObject {}
+

package/src/services/RevitNavigationService.js

@@ -0,0 +1,59 @@
+export class RevitNavigationService {
+    constructor(_logger = console, options = {}) {
+        this.host = options.host || '127.0.0.1';
+        this.portStart = Number.isFinite(options.portStart) ? options.portStart : 11210;
+        this.portEnd = Number.isFinite(options.portEnd) ? options.portEnd : 11220;
+        this.requestTimeoutMs = Number.isFinite(options.requestTimeoutMs) ? options.requestTimeoutMs : 1500;
+    }
+
+    async showInModel(payload, _context = {}) {
+        if (!payload || typeof payload !== 'string') {
+            return { ok: false, reason: 'invalid-payload', attempts: [] };
+        }
+
+        const attempts = [];
+        for (let port = this.portStart; port <= this.portEnd; port += 1) {
+            const url = `http://${this.host}:${port}`;
+            const result = await this._postWithTimeout(url, payload);
+            attempts.push({ port, ...result });
+            if (result.ok) {
+                return { ok: true, port, attempts };
+            }
+        }
+
+        return { ok: false, reason: 'no-port-accepted', attempts };
+    }
+
+    async _postWithTimeout(url, payload) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            try { controller.abort(); } catch (_) {}
+        }, this.requestTimeoutMs);
+
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'text/plain;charset=utf-8'
+                },
+                body: payload,
+                signal: controller.signal
+            });
+            const responseText = await response.text().catch(() => '');
+            return {
+                ok: response.ok,
+                status: response.status,
+                responsePreview: responseText.slice(0, 120)
+            };
+        } catch (error) {
+            return {
+                ok: false,
+                status: null,
+                error: error?.message || String(error)
+            };
+        } finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+

package/src/services/RevitScreenshotMetadataService.js

@@ -0,0 +1,112 @@
+export class RevitScreenshotMetadataService {
+    constructor(_logger = console, _options = {}) {
+        this.startToken = 'START_TEXT_';
+        this.endToken = '_END_TEXT';
+    }
+
+    async extractFromFile(file, _context = {}) {
+        if (!file) return this._emptyResult('no-file');
+        return this.extractFromBlob(file);
+    }
+
+    async extractFromImageSource(src, _context = {}) {
+        if (!src || typeof src !== 'string') return this._emptyResult('no-src');
+        try {
+            const response = await fetch(src);
+            if (!response.ok) {
+                return this._emptyResult('source-fetch-failed');
+            }
+            const blob = await response.blob();
+            return this.extractFromBlob(blob);
+        } catch (_) {
+            return this._emptyResult('source-fetch-error');
+        }
+    }
+
+    async extractFromBlob(blob) {
+        if (!blob) return this._emptyResult('no-blob');
+
+        let bitmap = null;
+        let canvas = null;
+        try {
+            bitmap = await createImageBitmap(blob);
+            canvas = document.createElement('canvas');
+            canvas.width = bitmap.width;
+            canvas.height = bitmap.height;
+
+            const ctx = canvas.getContext('2d', { willReadFrequently: true });
+            if (!ctx) return this._emptyResult('no-2d-context');
+            ctx.drawImage(bitmap, 0, 0);
+
+            const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);
+            return this._extractPayloadFromRgba(data, canvas.width, canvas.height);
+        } catch (_) {
+            return this._emptyResult('decode-error');
+        } finally {
+            if (bitmap && typeof bitmap.close === 'function') {
+                try { bitmap.close(); } catch (_) {}
+            }
+            if (canvas) {
+                canvas.width = 0;
+                canvas.height = 0;
+            }
+        }
+    }
+
+    _extractPayloadFromRgba(rgbaData, width, height) {
+        let stream = '';
+        for (let i = 0; i < rgbaData.length; i += 4) {
+            const r = rgbaData[i];
+            const g = rgbaData[i + 1];
+            const b = rgbaData[i + 2];
+            const byte = (r & 0x07) | ((g & 0x07) << 3) | ((b & 0x03) << 6);
+            if (byte === 0) continue;
+            stream += String.fromCharCode(byte);
+        }
+
+        const start = stream.indexOf(this.startToken);
+        const end = stream.indexOf(this.endToken, start + this.startToken.length);
+
+        if (start === -1 || end === -1 || end <= start) {
+            return this._emptyResult('tokens-not-found', { start, end, width, height });
+        }
+
+        const rawPayload = stream.slice(start + this.startToken.length, end);
+        if (!rawPayload || rawPayload.length === 0) {
+            return this._emptyResult('empty-payload', { start, end, width, height });
+        }
+
+        const bytes = Uint8Array.from([...rawPayload].map((ch) => ch.charCodeAt(0)));
+        let payload = rawPayload;
+        try {
+            payload = new TextDecoder('utf-8', { fatal: false }).decode(bytes);
+        } catch (_) {
+            payload = rawPayload;
+        }
+
+        return {
+            hasMetadata: true,
+            payload,
+            payloadLength: payload.length,
+            start,
+            end,
+            width,
+            height,
+            reason: null
+        };
+    }
+
+    _emptyResult(reason, extra = {}) {
+        return {
+            hasMetadata: false,
+            payload: null,
+            payloadLength: 0,
+            start: extra.start ?? -1,
+            end: extra.end ?? -1,
+            width: extra.width ?? null,
+            height: extra.height ?? null,
+            reason
+        };
+    }
+}
+

package/src/tools/manager/ToolEventRouter.js

@@ -17,6 +17,85 @@ function rememberCursorPosition(manager, event) {
     manager.eventBus.emit(Events.UI.CursorMove, { x: event.x, y: event.y });
 }
 
+function nowMs() {
+    if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+        return performance.now();
+    }
+    return Date.now();
+}
+
+function isDropDebugEnabled() {
+    try {
+        if (typeof window === 'undefined') return false;
+        if (window.__MB_DND_DEBUG__ === true) return true;
+        if (window.localStorage && typeof window.localStorage.getItem === 'function') {
+            return window.localStorage.getItem('mb:dnd:debug') === '1';
+        }
+    } catch (_) {}
+    return false;
+}
+
+function createDropDiagnostics() {
+    return {
+        enabled: isDropDebugEnabled(),
+        dropId: `drop-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+        startedAt: nowMs()
+    };
+}
+
+function logDropDebug(diagnostics, stage, payload = {}) {
+    if (!diagnostics?.enabled) return;
+    try {
+        const elapsedMs = Math.round(nowMs() - diagnostics.startedAt);
+        console.debug('[moodboard:dnd]', {
+            dropId: diagnostics.dropId,
+            stage,
+            elapsedMs,
+            ...payload
+        });
+    } catch (_) {}
+}
+
+const DROP_LIMITS = {
+    maxFilesPerDrop: 50,
+    maxFileSizeBytes: 50 * 1024 * 1024
+};
+
+function showDropWarning(manager, message, diagnostics, extra = {}) {
+    logDropDebug(diagnostics, 'drop_warning', { message, ...extra });
+    try {
+        const ws = (typeof window !== 'undefined' && window.moodboard && window.moodboard.workspaceManager)
+            ? window.moodboard.workspaceManager
+            : null;
+        if (ws && typeof ws.showNotification === 'function') {
+            ws.showNotification(message);
+        }
+    } catch (_) {}
+}
+
+async function mapWithConcurrency(items, limit, iterator) {
+    const safeLimit = Math.max(1, Number.isFinite(limit) ? Math.floor(limit) : 1);
+    const results = new Array(items.length);
+    let nextIndex = 0;
+
+    const worker = async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            if (currentIndex >= items.length) return;
+            results[currentIndex] = await iterator(items[currentIndex], currentIndex);
+        }
+    };
+
+    const workers = [];
+    const workersCount = Math.min(safeLimit, items.length);
+    for (let i = 0; i < workersCount; i += 1) {
+        workers.push(worker());
+    }
+    await Promise.all(workers);
+    return results;
+}
+
 export class ToolEventRouter {
     static handleMouseDown(manager, event) {
         if (!manager.activeTool) return;
@@ -142,6 +221,10 @@ export class ToolEventRouter {
 
     static async handleDrop(manager, event) {
         event.preventDefault();
+        const diagnostics = createDropDiagnostics();
+        manager._dropSessionSeq = (manager._dropSessionSeq || 0) + 1;
+        const dropSession = manager._dropSessionSeq;
+        const isCurrentDrop = () => manager._dropSessionSeq === dropSession;
 
         const rect = manager.container.getBoundingClientRect();
         const x = event.clientX - rect.left;
@@ -150,9 +233,51 @@ export class ToolEventRouter {
         manager.eventBus.emit(Events.UI.CursorMove, { x, y });
 
         const dt = event.dataTransfer;
-        if (!dt) return;
+        if (!dt) {
+            logDropDebug(diagnostics, 'drop_no_data_transfer');
+            return;
+        }
+        logDropDebug(diagnostics, 'drop_received', {
+            localX: Math.round(x),
+            localY: Math.round(y),
+            filesCount: dt.files ? dt.files.length : 0
+        });
+
+        const toWorldPosition = (screenX, screenY) => {
+            const world = manager.core?.pixi?.worldLayer || manager.core?.pixi?.app?.stage;
+            const scale = world?.scale?.x || 1;
+            if (!world) {
+                return { x: Math.round(screenX), y: Math.round(screenY) };
+            }
+            return {
+                x: Math.round((screenX - (world.x || 0)) / scale),
+                y: Math.round((screenY - (world.y || 0)) / scale)
+            };
+        };
+        const getFanOffset = (offsetIndex) => {
+            if (offsetIndex <= 0) return { dx: 0, dy: 0 };
+            const step = 25;
+            const directions = [
+                { x: 1, y: 0 },
+                { x: 1, y: 1 },
+                { x: 0, y: 1 },
+                { x: -1, y: 1 },
+                { x: -1, y: 0 },
+                { x: -1, y: -1 },
+                { x: 0, y: -1 },
+                { x: 1, y: -1 }
+            ];
+            const index = offsetIndex - 1;
+            const direction = directions[index % directions.length];
+            const ring = Math.floor(index / directions.length) + 1;
+            return { dx: direction.x * step * ring, dy: direction.y * step * ring };
+        };
 
         const emitAt = (src, name, imageId = null, offsetIndex = 0) => {
+            if (!isCurrentDrop()) {
+                logDropDebug(diagnostics, 'emit_skipped_stale_drop', { route: 'image', offsetIndex });
+                return;
+            }
             const offset = 25 * offsetIndex;
             manager.eventBus.emit(Events.UI.PasteImageAt, {
                 x: x + offset,
@@ -164,45 +289,123 @@ export class ToolEventRouter {
         };
 
         const files = dt.files ? Array.from(dt.files) : [];
-        const imageFiles = files.filter((file) => file.type && file.type.startsWith('image/'));
+        let limitedFiles = files;
+        if (limitedFiles.length > DROP_LIMITS.maxFilesPerDrop) {
+            showDropWarning(
+                manager,
+                `Обработаны первые ${DROP_LIMITS.maxFilesPerDrop} файлов из ${limitedFiles.length}`,
+                diagnostics,
+                { filesCount: limitedFiles.length, maxFilesPerDrop: DROP_LIMITS.maxFilesPerDrop }
+            );
+            limitedFiles = limitedFiles.slice(0, DROP_LIMITS.maxFilesPerDrop);
+        }
+        const oversized = limitedFiles.filter((file) => (file?.size || 0) > DROP_LIMITS.maxFileSizeBytes);
+        if (oversized.length > 0) {
+            showDropWarning(
+                manager,
+                `Пропущено ${oversized.length} файлов: размер каждого должен быть не более 50 МБ`,
+                diagnostics,
+                { oversizedCount: oversized.length, maxFileSizeBytes: DROP_LIMITS.maxFileSizeBytes }
+            );
+            limitedFiles = limitedFiles.filter((file) => (file?.size || 0) <= DROP_LIMITS.maxFileSizeBytes);
+        }
+
+        const imageFiles = limitedFiles.filter((file) => file.type && file.type.startsWith('image/'));
         if (imageFiles.length > 0) {
-            let index = 0;
-            for (const file of imageFiles) {
+            logDropDebug(diagnostics, 'route_image_files', { count: imageFiles.length });
+            const imagePlacements = await mapWithConcurrency(imageFiles, 2, async (file, index) => {
+                logDropDebug(diagnostics, 'image_upload_start', {
+                    fileName: file.name || 'image',
+                    fileSize: file.size || 0,
+                    mimeType: file.type || null
+                });
                 try {
                     if (manager.core && manager.core.imageUploadService) {
                         const uploadResult = await manager.core.imageUploadService.uploadImage(file, file.name || 'image');
-                        emitAt(uploadResult.url, uploadResult.name, uploadResult.imageId || uploadResult.id, index++);
+                        if (!isCurrentDrop()) {
+                            logDropDebug(diagnostics, 'image_upload_stale_drop_ignored', {
+                                fileName: uploadResult?.name || file.name || 'image'
+                            });
+                            return null;
+                        }
+                        logDropDebug(diagnostics, 'image_upload_success', {
+                            fileName: uploadResult?.name || file.name || 'image',
+                            imageId: uploadResult?.imageId || uploadResult?.id || null
+                        });
+                        return {
+                            src: uploadResult.url,
+                            name: uploadResult.name,
+                            imageId: uploadResult.imageId || uploadResult.id || null,
+                            index
+                        };
                     } else {
-                        await new Promise((resolve) => {
+                        const localSrc = await new Promise((resolve) => {
                             const reader = new FileReader();
                             reader.onload = () => {
-                                emitAt(reader.result, file.name || 'image', null, index++);
-                                resolve();
+                                resolve(reader.result);
                             };
                             reader.readAsDataURL(file);
                         });
+                        if (!isCurrentDrop()) {
+                            logDropDebug(diagnostics, 'image_local_fallback_stale_drop_ignored', {
+                                fileName: file.name || 'image'
+                            });
+                            return null;
+                        }
+                        logDropDebug(diagnostics, 'image_local_fallback_success', {
+                            fileName: file.name || 'image'
+                        });
+                        return {
+                            src: localSrc,
+                            name: file.name || 'image',
+                            imageId: null,
+                            index
+                        };
                     }
                 } catch (error) {
                     console.warn('Ошибка загрузки изображения через drag-and-drop:', error);
-                    await new Promise((resolve) => {
+                    logDropDebug(diagnostics, 'image_upload_error', {
+                        fileName: file.name || 'image',
+                        message: error?.message || String(error)
+                    });
+                    const fallbackSrc = await new Promise((resolve) => {
                         const reader = new FileReader();
                         reader.onload = () => {
-                            emitAt(reader.result, file.name || 'image', null, index++);
-                            resolve();
+                            resolve(reader.result);
                         };
                         reader.readAsDataURL(file);
                     });
+                    if (!isCurrentDrop()) {
+                        logDropDebug(diagnostics, 'image_error_fallback_stale_drop_ignored', {
+                            fileName: file.name || 'image'
+                        });
+                        return null;
+                    }
+                    logDropDebug(diagnostics, 'image_error_fallback_success', {
+                        fileName: file.name || 'image'
+                    });
+                    return {
+                        src: fallbackSrc,
+                        name: file.name || 'image',
+                        imageId: null,
+                        index
+                    };
                 }
+            });
+            for (const placement of imagePlacements) {
+                if (!placement) continue;
+                emitAt(placement.src, placement.name, placement.imageId, placement.index);
             }
+            logDropDebug(diagnostics, 'drop_done', { route: 'image_files', itemsProcessed: imageFiles.length });
             return;
         }
 
-        const nonImageFiles = files.filter((file) => !file.type || !file.type.startsWith('image/'));
+        const nonImageFiles = limitedFiles.filter((file) => !file.type || !file.type.startsWith('image/'));
         if (nonImageFiles.length > 0) {
-            let index = 0;
-            for (const file of nonImageFiles) {
-                const offset = 25 * index++;
-                const position = { x: x + offset, y: y + offset };
+            logDropDebug(diagnostics, 'route_non_image_files', { count: nonImageFiles.length });
+            const filePlacements = await mapWithConcurrency(nonImageFiles, 2, async (file, index) => {
+                const fanOffset = getFanOffset(index);
+                const worldPoint = toWorldPosition(x + fanOffset.dx, y + fanOffset.dy);
                 const fallbackProps = {
                     fileName: file.name || 'file',
                     fileSize: file.size || 0,
@@ -212,13 +415,40 @@ export class ToolEventRouter {
                     width: 120,
                     height: 140
                 };
+                const position = {
+                    x: Math.round(worldPoint.x - fallbackProps.width / 2),
+                    y: Math.round(worldPoint.y - fallbackProps.height / 2)
+                };
+                logDropDebug(diagnostics, 'file_prepare', {
+                    fileName: fallbackProps.fileName,
+                    worldX: worldPoint.x,
+                    worldY: worldPoint.y,
+                    placeX: position.x,
+                    placeY: position.y
+                });
                 try {
                     if (manager.core && manager.core.fileUploadService) {
                         const uploadResult = await manager.core.fileUploadService.uploadFile(file, file.name || 'file');
-                        manager.eventBus.emit(Events.UI.ToolbarAction, {
+                        if (!isCurrentDrop()) {
+                            logDropDebug(diagnostics, 'file_upload_stale_drop_ignored', {
+                                fileName: uploadResult?.name || fallbackProps.fileName
+                            });
+                            return null;
+                        }
+                        const objectWidth = fallbackProps.width;
+                        const objectHeight = fallbackProps.height;
+                        const centeredPosition = {
+                            x: Math.round(worldPoint.x - objectWidth / 2),
+                            y: Math.round(worldPoint.y - objectHeight / 2)
+                        };
+                        logDropDebug(diagnostics, 'file_upload_success', {
+                            fileName: uploadResult?.name || fallbackProps.fileName,
+                            fileId: uploadResult?.fileId || uploadResult?.id || null
+                        });
+                        return {
                             type: 'file',
                             id: 'file',
-                            position,
+                            position: centeredPosition,
                             properties: {
                                 fileName: uploadResult.name,
                                 fileSize: uploadResult.size,
@@ -229,35 +459,65 @@ export class ToolEventRouter {
                                 height: 140
                             },
                             fileId: uploadResult.fileId || uploadResult.id || null
-                        });
+                        };
                     } else {
-                        manager.eventBus.emit(Events.UI.ToolbarAction, {
+                        if (!isCurrentDrop()) {
+                            logDropDebug(diagnostics, 'file_local_fallback_stale_drop_ignored', {
+                                fileName: fallbackProps.fileName
+                            });
+                            return null;
+                        }
+                        logDropDebug(diagnostics, 'file_local_fallback_success', {
+                            fileName: fallbackProps.fileName
+                        });
+                        return {
                             type: 'file',
                             id: 'file',
                             position,
                             properties: fallbackProps
-                        });
+                        };
                     }
                 } catch (error) {
                     console.warn('Ошибка загрузки файла через drag-and-drop:', error);
-                    manager.eventBus.emit(Events.UI.ToolbarAction, {
+                    logDropDebug(diagnostics, 'file_upload_error', {
+                        fileName: fallbackProps.fileName,
+                        message: error?.message || String(error)
+                    });
+                    if (!isCurrentDrop()) {
+                        logDropDebug(diagnostics, 'file_error_fallback_stale_drop_ignored', {
+                            fileName: fallbackProps.fileName
+                        });
+                        return null;
+                    }
+                    logDropDebug(diagnostics, 'file_error_fallback_success', {
+                        fileName: fallbackProps.fileName
+                    });
+                    return {
                         type: 'file',
                         id: 'file',
                         position,
                         properties: fallbackProps
-                    });
+                    };
                 }
+            });
+            for (const actionPayload of filePlacements) {
+                if (!actionPayload) continue;
+                if (!isCurrentDrop()) break;
+                manager.eventBus.emit(Events.UI.ToolbarAction, actionPayload);
             }
+            logDropDebug(diagnostics, 'drop_done', { route: 'non_image_files', itemsProcessed: nonImageFiles.length });
             return;
         }
 
         const html = dt.getData('text/html');
         if (html && html.includes('<img')) {
+            logDropDebug(diagnostics, 'route_html_image');
             const match = html.match(/<img[^>]*src\s*=\s*"([^"]+)"/i);
             if (match && match[1]) {
                 const url = match[1];
                 if (/^data:image\//i.test(url)) {
                     emitAt(url, 'clipboard-image.png');
+                    logDropDebug(diagnostics, 'drop_done', { route: 'html_data_image' });
                     return;
                 }
                 if (/^https?:\/\//i.test(url)) {
@@ -270,8 +530,10 @@ export class ToolEventRouter {
                             reader.readAsDataURL(blob);
                         });
                         emitAt(dataUrl, url.split('/').pop() || 'image');
+                        logDropDebug(diagnostics, 'drop_done', { route: 'html_http_image_fetched' });
                     } catch (_) {
                         emitAt(url, url.split('/').pop() || 'image');
+                        logDropDebug(diagnostics, 'drop_done', { route: 'html_http_image_direct' });
                     }
                     return;
                 }
@@ -280,6 +542,7 @@ export class ToolEventRouter {
 
         const uriList = dt.getData('text/uri-list') || '';
         if (uriList) {
+            logDropDebug(diagnostics, 'route_uri_list');
             const lines = uriList.split('\n').filter((line) => !!line && !line.startsWith('#'));
             const urls = lines.filter((line) => /^https?:\/\//i.test(line));
             let index = 0;
@@ -299,17 +562,22 @@ export class ToolEventRouter {
                     emitAt(url, url.split('/').pop() || 'image', index++);
                 }
             }
-            if (index > 0) return;
+            if (index > 0) {
+                logDropDebug(diagnostics, 'drop_done', { route: 'uri_list_images', itemsProcessed: index });
+                return;
+            }
         }
 
         const text = dt.getData('text/plain') || '';
         if (text) {
+            logDropDebug(diagnostics, 'route_text_plain');
             const trimmed = text.trim();
             const isDataUrl = /^data:image\//i.test(trimmed);
             const isHttpUrl = /^https?:\/\//i.test(trimmed);
             const looksLikeImage = /(png|jpe?g|gif|webp|bmp|svg)(\?.*)?$/i.test(trimmed);
             if (isDataUrl) {
                 emitAt(trimmed, 'clipboard-image.png');
+                logDropDebug(diagnostics, 'drop_done', { route: 'text_data_image' });
                 return;
             }
             if (isHttpUrl && looksLikeImage) {
@@ -322,11 +590,14 @@ export class ToolEventRouter {
                         reader.readAsDataURL(blob);
                     });
                     emitAt(dataUrl, trimmed.split('/').pop() || 'image');
+                    logDropDebug(diagnostics, 'drop_done', { route: 'text_http_image_fetched' });
                 } catch (_) {
                     emitAt(trimmed, trimmed.split('/').pop() || 'image');
+                    logDropDebug(diagnostics, 'drop_done', { route: 'text_http_image_direct' });
                 }
             }
         }
+        logDropDebug(diagnostics, 'drop_done', { route: 'no_supported_payload' });
     }
 
     static handleKeyDown(manager, event) {

package/src/tools/object-tools/PlacementTool.js

@@ -17,6 +17,7 @@ const _scaledICursorSvg = (() => {
 
 const TEXT_CURSOR = `url("data:image/svg+xml;charset=utf-8,${encodeURIComponent(_scaledICursorSvg)}") 0 0, text`;
 import { Events } from '../../core/events/Events.js';
+import { RevitScreenshotMetadataService } from '../../services/RevitScreenshotMetadataService.js';
 import { GhostController } from './placement/GhostController.js';
 import { PlacementPayloadFactory } from './placement/PlacementPayloadFactory.js';
 import { PlacementInputRouter } from './placement/PlacementInputRouter.js';
@@ -42,6 +43,7 @@ export class PlacementTool extends BaseTool {
         this.eventsBridge = new PlacementEventsBridge(this);
         this.sessionStore = new PlacementSessionStore(this);
         this.coordinateResolver = new PlacementCoordinateResolver(this);
+        this.revitMetadataService = new RevitScreenshotMetadataService(console);
         this.sessionStore.initialize();
         // Оригинальные стили курсора PIXI, чтобы можно было временно переопределить pointer/default для текстового инструмента
         this._origCursorStyles = null;
@@ -297,6 +299,13 @@ export class PlacementTool extends BaseTool {
         if (!this.selectedImage) return;
         
         const worldPoint = this._toWorld(event.x, event.y);
+        const metadataResult = await this.revitMetadataService.extractFromFile(this.selectedImage.file, {
+            source: 'place:image-tool',
+            fileName: this.selectedImage.fileName
+        });
+        const isRevitScreenshot = metadataResult.hasMetadata && !!metadataResult.payload;
+        const objectType = isRevitScreenshot ? 'revit-screenshot-img' : 'image';
+        const extraProperties = isRevitScreenshot ? { view: metadataResult.payload } : {};
         
         try {
             // Загружаем изображение на сервер
@@ -319,7 +328,7 @@ export class PlacementTool extends BaseTool {
             };
             
             // Создаем объект изображения с данными с сервера
-            this.payloadFactory.emitImageUploaded(position, uploadResult, targetW, targetH);
+            this.payloadFactory.emitImageUploaded(position, uploadResult, targetW, targetH, objectType, extraProperties);
             
         } catch (uploadError) {
             console.error('Ошибка загрузки изображения на сервер:', uploadError);
@@ -336,7 +345,7 @@ export class PlacementTool extends BaseTool {
                 y: Math.round(worldPoint.y - halfH) 
             };
             
-            this.payloadFactory.emitImageFallback(position, imageUrl, this.selectedImage.fileName, targetW, targetH);
+            this.payloadFactory.emitImageFallback(position, imageUrl, this.selectedImage.fileName, targetW, targetH, objectType, extraProperties);
             
             // Показываем предупреждение пользователю
             alert('Ошибка загрузки изображения на сервер. Изображение добавлено локально.');

package/src/tools/object-tools/placement/PlacementPayloadFactory.js

@@ -47,31 +47,33 @@ export class PlacementPayloadFactory {
         });
     }
 
-    emitImageUploaded(position, uploadResult, width, height) {
+    emitImageUploaded(position, uploadResult, width, height, objectType = 'image', extraProperties = {}) {
         this.host.eventBus.emit(Events.UI.ToolbarAction, {
-            type: 'image',
-            id: 'image',
+            type: objectType,
+            id: objectType,
             position,
             properties: {
                 src: uploadResult.url,
                 name: uploadResult.name,
                 width,
-                height
+                height,
+                ...extraProperties
             },
             imageId: uploadResult.imageId || uploadResult.id
         });
     }
 
-    emitImageFallback(position, imageUrl, fileName, width, height) {
+    emitImageFallback(position, imageUrl, fileName, width, height, objectType = 'image', extraProperties = {}) {
         this.host.eventBus.emit(Events.UI.ToolbarAction, {
-            type: 'image',
-            id: 'image',
+            type: objectType,
+            id: objectType,
             position,
             properties: {
                 src: imageUrl,
                 name: fileName,
                 width,
-                height
+                height,
+                ...extraProperties
             }
         });
     }

package/src/ui/handles/HandlesDomRenderer.js

@@ -2,6 +2,7 @@ import { Events } from '../../core/events/Events.js';
 import { createRotatedResizeCursor } from '../../tools/object-tools/selection/CursorController.js';
 
 const HANDLES_ACCENT_COLOR = '#80D8FF';
+const REVIT_SHOW_IN_MODEL_ICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" aria-hidden="true" focusable="false"><path d="M384 64C366.3 64 352 78.3 352 96C352 113.7 366.3 128 384 128L466.7 128L265.3 329.4C252.8 341.9 252.8 362.2 265.3 374.7C277.8 387.2 298.1 387.2 310.6 374.7L512 173.3L512 256C512 273.7 526.3 288 544 288C561.7 288 576 273.7 576 256L576 96C576 78.3 561.7 64 544 64L384 64zM144 160C99.8 160 64 195.8 64 240L64 496C64 540.2 99.8 576 144 576L400 576C444.2 576 480 540.2 480 496L480 416C480 398.3 465.7 384 448 384C430.3 384 416 398.3 416 416L416 496C416 504.8 408.8 512 400 512L144 512C135.2 512 128 504.8 128 496L128 240C128 231.2 135.2 224 144 224L224 224C241.7 224 256 209.7 256 192C256 174.3 241.7 160 224 160L144 160z"/></svg>';
 
 export class HandlesDomRenderer {
     constructor(host, rotateIconSvg) {
@@ -35,12 +36,16 @@ export class HandlesDomRenderer {
 
         let isFileTarget = false;
         let isFrameTarget = false;
+        let isRevitScreenshotTarget = false;
+        let revitViewPayload = null;
         if (id !== '__group__') {
             const req = { objectId: id, pixiObject: null };
             this.host.eventBus.emit(Events.Tool.GetObjectPixi, req);
             const mbType = req.pixiObject && req.pixiObject._mb && req.pixiObject._mb.type;
             isFileTarget = mbType === 'file';
             isFrameTarget = mbType === 'frame';
+            isRevitScreenshotTarget = mbType === 'revit-screenshot-img';
+            revitViewPayload = req.pixiObject?._mb?.properties?.view || null;
         }
 
         const left = cssRect.left;
@@ -185,6 +190,28 @@ export class HandlesDomRenderer {
         }
         box.appendChild(rotateHandle);
 
+        if (isRevitScreenshotTarget && typeof revitViewPayload === 'string' && revitViewPayload.length > 0) {
+            const showInModelButton = document.createElement('button');
+            showInModelButton.type = 'button';
+            showInModelButton.className = 'mb-revit-show-in-model';
+            showInModelButton.innerHTML = `${REVIT_SHOW_IN_MODEL_ICON_SVG}<span>показать в моделе</span>`;
+            showInModelButton.style.left = `${Math.round(left + width / 2)}px`;
+            showInModelButton.style.top = `${Math.round(top - 34)}px`;
+            showInModelButton.addEventListener('mousedown', (evt) => {
+                evt.preventDefault();
+                evt.stopPropagation();
+            });
+            showInModelButton.addEventListener('click', (evt) => {
+                evt.preventDefault();
+                evt.stopPropagation();
+                this.host.eventBus.emit(Events.UI.RevitShowInModel, {
+                    objectId: id,
+                    view: revitViewPayload
+                });
+            });
+            this.host.layer.appendChild(showInModelButton);
+        }
+
         this.host.visible = true;
         this.host.target = { type: id === '__group__' ? 'group' : 'single', id, bounds: worldBounds };
     }

package/src/ui/styles/workspace.css

@@ -297,6 +297,39 @@
     justify-content: center;
 }
 
+.mb-revit-show-in-model {
+    position: absolute;
+    transform: translate(-50%, -100%);
+    height: 28px;
+    padding: 0 10px;
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    border: 1px solid #bcd5e2;
+    border-radius: 8px;
+    background: #ffffff;
+    color: #0f3b52;
+    font-size: 12px;
+    font-weight: 500;
+    white-space: nowrap;
+    pointer-events: auto;
+    z-index: 18;
+    cursor: pointer;
+    box-shadow: 0 6px 16px rgba(0, 0, 0, 0.14);
+}
+
+.mb-revit-show-in-model svg {
+    width: 12px;
+    height: 12px;
+    display: block;
+    fill: currentColor;
+    flex: 0 0 auto;
+}
+
+.mb-revit-show-in-model:hover {
+    background: #f1f8fc;
+}
+
 /* Text editor overlay */
 .moodboard-text-editor {
     position: absolute;