@sequent-org/moodboard 1.4.58 → 1.4.60

package/src/tools/object-tools/selection/TextEditorInteractionController.js

@@ -8,6 +8,7 @@ import {
     showStaticTextAfterEditing,
     updateGlobalTextEditorHandlesLayer,
 } from './TextEditorLifecycleRegistry.js';
+import { unregisterEditorListeners } from './InlineEditorListenersRegistry.js';
 
 export function applyTextEditorCaretFromClick({ create, objectId, object, textarea }) {
     try {
@@ -286,6 +287,12 @@ export function bindTextEditorInteractions(controller, {
     const keydownHandler = (e) => {
         const isList = listType && listType !== 'none';
         if (e.key === 'Enter') {
+            // В записке Enter переносит каретку на новую строку (нативное поведение
+            // textarea), а не завершает ввод. Завершение — по клику вне записки (blur)
+            // или по Escape. Высота поля пересчитывается через 'input' → updateNoteEditor.
+            if (isNote) {
+                return;
+            }
             if (isList && !e.shiftKey) {
                 e.preventDefault();
                 const start = textarea.selectionStart;
@@ -359,6 +366,10 @@ export function bindTextEditorInteractions(controller, {
     };
 
     const caretUpdateHandler = () => {
+        // _caretSuppressed выставляется registerRegularTextEditorSync на время зума:
+        // не перерисовываем каретку, пока она должна быть скрыта (избегаем мигания
+        // каретки старого размера в промежуточных кадрах при Ctrl±).
+        if (controller.textEditor && controller.textEditor._caretSuppressed) return;
         if (controller.textEditor && controller.textEditor.caret) {
             updateCustomCaret(textarea, controller.textEditor.caret);
         }
@@ -444,6 +455,9 @@ export function closeTextEditorFromState(controller, commit) {
         }
     }
 
+    if (Array.isArray(controller.textEditor._listeners)) {
+        try { unregisterEditorListeners(controller.eventBus, controller.textEditor._listeners); } catch (_) {}
+    }
     if (typeof removeDomListeners === 'function') {
         try { removeDomListeners(); } catch (_) {}
     }

package/src/tools/object-tools/selection/TextEditorLifecycleRegistry.js

@@ -71,6 +71,13 @@ export function cleanupActiveTextEditor(controller, wrapper) {
             unregisterEditorListeners(controller.eventBus, controller.textEditor._listeners);
         }
     } catch (_) {}
+    // Снимаем таймер дебаунса и флаг подавления каретки (редактор мог закрыться в процессе зума)
+    try {
+        if (typeof controller.textEditor?._caretHideTimer === 'function') {
+            controller.textEditor._caretHideTimer();
+        }
+        if (controller.textEditor) controller.textEditor._caretSuppressed = false;
+    } catch (_) {}
 
     wrapper.remove();
     controller.textEditor = {

package/src/tools/object-tools/selection/TextEditorPositioningService.js

@@ -71,9 +71,10 @@ export function positionRegularTextEditor({
     } catch (_) {}
 
     const leftPx = Math.round(baseLeftPx - padLeft);
-    const topPx = create
-        ? Math.round(baseTopPx - padTop - (lineHeightPx / 2))
-        : Math.round(baseTopPx + staticPadTop - padTop + 1);
+    // Верх текста редактора привязываем к точке клика (= верх рамки ручек и будущего
+    // статического текста). Прежний create-якорь `- lineHeightPx/2` (центрирование каретки
+    // по клику) поднимал текст на пол-строки выше рамки mb-handles-box-obj_.
+    const topPx = Math.round(baseTopPx + staticPadTop - padTop + 1);
 
     wrapper.style.left = `${leftPx}px`;
     wrapper.style.top = `${topPx}px`;

package/src/tools/object-tools/selection/TextEditorSyncService.js

@@ -1,7 +1,33 @@
+import * as PIXI from 'pixi.js';
 import { Events } from '../../../core/events/Events.js';
 import { registerEditorListeners } from './InlineEditorListenersRegistry.js';
 import { computeTextRightPadPx } from '../../../services/text/TextBoxMetrics.js';
 
+// Измеряет ширину текста textarea по реальным глифам через скрытый span.
+// Возвращает ширину самой длинной строки в CSS-px (white-space: pre — без переносов),
+// либо 0, если измерение невозможно (jsdom без layout).
+function measureTextareaContentWidth(textarea, value) {
+    if (!value) return 0;
+    try {
+        if (typeof document === 'undefined' || !window.getComputedStyle) return 0;
+        const cs = window.getComputedStyle(textarea);
+        const m = document.createElement('span');
+        m.style.cssText = 'position:absolute;visibility:hidden;white-space:pre;top:-9999px;left:-9999px;padding:0;margin:0;';
+        m.style.fontFamily = cs.fontFamily;
+        m.style.fontSize = cs.fontSize;
+        m.style.fontWeight = cs.fontWeight;
+        m.style.fontStyle = cs.fontStyle;
+        m.style.letterSpacing = cs.letterSpacing;
+        m.textContent = value;
+        document.body.appendChild(m);
+        const w = m.getBoundingClientRect().width;
+        m.remove();
+        return Number.isFinite(w) ? w : 0;
+    } catch (_) {
+        return 0;
+    }
+}
+
 export function createRegularTextAutoSize({
     textarea,
     wrapper,
@@ -9,27 +35,75 @@ export function createRegularTextAutoSize({
     minHBound,
     onSizeChange,
 }) {
-    return () => {
+    // Минимальные границы хранятся в мутабельном объекте: при зуме они
+    // пересчитываются (см. createRegularTextEditorUpdater), чтобы рамка
+    // редактора масштабировалась так же, как статический .mb-text.
+    const bounds = { minW: minWBound, minH: minHBound };
+    // Видимый текст рисует backdrop. applyEditorSizing проставляет ему фиксированную
+    // высоту в px на момент открытия; без пересчёта при зуме увеличенные глифы
+    // обрезаются снизу (overflow: hidden). Держим размеры backdrop равными textarea.
+    const backdrop = wrapper.querySelector('.moodboard-text-backdrop');
+
+    const autoSize = () => {
         textarea.style.width = 'auto';
         textarea.style.height = 'auto';
 
         const fontPx = parseFloat(textarea.style.fontSize) || 16;
         const rightPad = computeTextRightPadPx(fontPx);
-        const naturalW = Math.max(1, Math.ceil(textarea.scrollWidth + rightPad));
-        const targetW = Math.round(Math.max(minWBound, naturalW));
+        const value = typeof textarea.value === 'string' ? textarea.value : '';
+        // Ширину контента меряем отдельным скрытым span, а НЕ textarea.scrollWidth:
+        // у textarea при width:auto ширина определяется атрибутом cols (~20 символов),
+        // поэтому scrollWidth не сжимается до реального текста и рамка остаётся широкой.
+        // span с white-space:pre отдаёт ширину самой длинной строки по тем же глифам.
+        const contentW = measureTextareaContentWidth(textarea, value);
+        const naturalW = Math.max(1, Math.ceil(contentW + rightPad));
+        // bounds.minW (ширина плейсхолдера/исходного бокса) применяется только к пустому
+        // полю, чтобы плейсхолдер не обрезался. Как только введён текст — рамка облегает
+        // контент; иначе ширина залипает на ширине плейсхолдера и не совпадает со
+        // статическим .mb-text после выхода из редактора (рамка скачком сужается).
+        const widthFloor = value.length ? 1 : bounds.minW;
+        const targetW = Math.round(Math.max(widthFloor, naturalW));
         textarea.style.width = `${targetW}px`;
         wrapper.style.width = `${targetW}px`;
 
-        textarea.style.height = 'auto';
-        const naturalH = Math.max(1, Math.ceil(textarea.scrollHeight));
-        const targetH = Math.round(Math.max(minHBound, naturalH));
+        // Высоту считаем ДЕТЕРМИНИРОВАННО — число строк × line-height + вертикальные
+        // паддинги — а НЕ через textarea.scrollHeight. При быстром zoom-out Chromium
+        // держит устаревшую (бо́льшую) высоту строки в scrollHeight даже после
+        // форсированного reflow, и последний autoSize за серию колёс фиксировал
+        // завышенную высоту: под текстом оставался пустой зазор, не уходивший до blur.
+        // Текст в поле не переносится (white-space: pre, ширина по контенту), поэтому
+        // число визуальных строк = число переводов строки.
+        let lhRatio = parseFloat(textarea.style.lineHeight);
+        if (!isFinite(lhRatio) || lhRatio <= 0 || lhRatio > 4) lhRatio = 1.2;
+        const cs = (typeof window !== 'undefined' && window.getComputedStyle)
+            ? window.getComputedStyle(textarea)
+            : null;
+        const padV = cs
+            ? ((parseFloat(cs.paddingTop) || 0) + (parseFloat(cs.paddingBottom) || 0))
+            : 0;
+        const lineCount = value.length ? (value.split('\n').length) : 1;
+        const naturalH = Math.max(1, Math.ceil(lineCount * fontPx * lhRatio + padV));
+        const targetH = Math.round(Math.max(bounds.minH, naturalH));
         textarea.style.height = `${targetH}px`;
         wrapper.style.height = `${targetH}px`;
 
+        if (backdrop) {
+            backdrop.style.width = `${targetW}px`;
+            backdrop.style.height = `${targetH}px`;
+        }
+
         if (typeof onSizeChange === 'function') {
             onSizeChange({ widthPx: targetW, heightPx: targetH });
         }
     };
+
+    autoSize.getBounds = () => ({ minW: bounds.minW, minH: bounds.minH });
+    autoSize.setBounds = ({ minW, minH }) => {
+        if (typeof minW === 'number' && isFinite(minW)) bounds.minW = minW;
+        if (typeof minH === 'number' && isFinite(minH)) bounds.minH = minH;
+    };
+
+    return autoSize;
 }
 
 export function createNoteEditorUpdater(controller, {
@@ -76,6 +150,15 @@ export function createNoteEditorUpdater(controller, {
             textarea.style.height = `${heightPx}px`;
             wrapper.style.height = `${heightPx}px`;
 
+            // backdrop рисует видимые глифы и имеет фиксированную высоту в px с момента
+            // открытия (applyEditorSizing — одна строка). Без синхронизации с textarea
+            // многострочный ввод (Enter) обрезается снизу (overflow: hidden).
+            const backdrop = wrapper.querySelector('.moodboard-text-backdrop');
+            if (backdrop) {
+                backdrop.style.width = `${widthPx}px`;
+                backdrop.style.height = `${heightPx}px`;
+            }
+
             const left = Math.round(screenNow.x + (sizeNow.width * scaleCss) / 2 - (widthPx / 2));
             const top = Math.round(screenNow.y + (sizeNow.height * scaleCss) / 2 - (heightPx / 2));
             wrapper.style.left = `${left}px`;
@@ -86,6 +169,177 @@ export function createNoteEditorUpdater(controller, {
     };
 }
 
+// Держит inline-редактор обычного текста выровненным по объекту при зуме/пэне.
+// Позиция считается напрямую от мирового трансформа (как в HtmlTextLayer.updateOne),
+// поэтому не зависит от порядка обработчиков событий относительно статического слоя.
+// Шрифт и line-height масштабируются пропорционально текущему зуму от значений на момент
+// открытия редактора (baseFontPxAtOpen / sCssAtOpen) — сохраняется вертикальное выравнивание.
+export function createRegularTextEditorUpdater(controller, {
+    objectId,
+    position,
+    view,
+    textarea,
+    wrapper,
+    autoSize,
+    baseFontPxAtOpen,
+    sCssAtOpen,
+}) {
+    const baseWorldFont = (baseFontPxAtOpen && sCssAtOpen) ? (baseFontPxAtOpen / sCssAtOpen) : null;
+    // Базовые минимальные границы рамки на момент открытия редактора (в CSS-px при sCssAtOpen).
+    // Захватываются лениво при первом обновлении и масштабируются под текущий зум.
+    let baseBounds = null;
+
+    return () => {
+        try {
+            const worldLayer = controller.textEditor.world || (controller.app?.stage);
+            if (!worldLayer || !view || !view.parentElement) {
+                return;
+            }
+            const res = (controller.app?.renderer?.resolution) || 1;
+            const scaleX = worldLayer.scale?.x || 1;
+            const sCssNow = scaleX / res;
+
+            const backdrop = wrapper.querySelector('.moodboard-text-backdrop');
+            const getCs = (typeof window !== 'undefined' && window.getComputedStyle)
+                ? window.getComputedStyle.bind(window)
+                : null;
+
+            // Актуальная мировая позиция (top-left); fallback на исходную для нового текста.
+            const posReq = { objectId, position: null };
+            controller.eventBus.emit(Events.Tool.GetObjectPosition, posReq);
+            const pos = posReq.position || position;
+
+            const containerRect = view.parentElement.getBoundingClientRect();
+            const viewRect = view.getBoundingClientRect();
+            const offsetLeft = viewRect.left - containerRect.left;
+            const offsetTop = viewRect.top - containerRect.top;
+            const tl = worldLayer.toGlobal(new PIXI.Point(pos.x, pos.y));
+            const baseLeft = Math.round(offsetLeft + tl.x);
+            const baseTop = Math.round(offsetTop + tl.y);
+
+            // Перемасштабируем только font-size. line-height задан безразмерным
+            // коэффициентом (applyTextStyles, например "1.34") и масштабируется браузером
+            // вместе с font-size без округления — точно как в статическом HtmlTextLayer.
+            // Прежний код читал этот коэффициент как пиксели (parseFloat → 1.34) и
+            // схлопывал строку до ~1px, из-за чего текст «уезжал» вверх при зуме.
+            const prevFont = parseFloat(textarea.style.fontSize) || baseFontPxAtOpen || 16;
+            const fontSizePx = baseWorldFont
+                ? Math.max(1, Math.round(baseWorldFont * sCssNow))
+                : prevFont;
+            textarea.style.fontSize = `${fontSizePx}px`;
+            if (backdrop) {
+                backdrop.style.fontSize = `${fontSizePx}px`;
+            }
+
+            // Пересчитываем min-height по текущему шрифту. applyEditorSizing проставляет
+            // фиксированный min-height в px на момент открытия; без пересчёта при отдалении
+            // scrollHeight не может стать меньше него, и высота рамки не уменьшается вслед
+            // за текстом (рамка остаётся высокой при мелком шрифте).
+            let lhRatio = parseFloat(textarea.style.lineHeight);
+            if (!isFinite(lhRatio) || lhRatio <= 0 || lhRatio > 4) lhRatio = 1.2;
+            const lineMinPx = Math.max(1, Math.round(fontSizePx * lhRatio));
+            textarea.style.minHeight = `${lineMinPx}px`;
+            if (backdrop) {
+                backdrop.style.minHeight = `${lineMinPx}px`;
+            }
+
+            // Смещение обёртки на паддинги textarea + паддинг статического .mb-text (для list/markdown).
+            const taCs = getCs ? getCs(textarea) : null;
+            const padTop = taCs ? (parseFloat(taCs.paddingTop) || 0) : 0;
+            const padLeft = taCs ? (parseFloat(taCs.paddingLeft) || 0) : 0;
+            let staticPadTop = 0;
+            try {
+                const layer = (typeof window !== 'undefined') ? window.moodboardHtmlTextLayer : null;
+                const el = (layer && objectId) ? layer.idToEl.get(objectId) : null;
+                if (el && getCs) {
+                    const sp = parseFloat(getCs(el).paddingTop);
+                    if (isFinite(sp) && sp > 0) staticPadTop = sp;
+                }
+            } catch (_) {}
+
+            const leftPx = Math.round(baseLeft - padLeft);
+            const topPx = Math.round(baseTop + staticPadTop - padTop + 1);
+            wrapper.style.left = `${leftPx}px`;
+            wrapper.style.top = `${topPx}px`;
+            controller.textEditor._cssLeftPx = leftPx;
+            controller.textEditor._cssTopPx = topPx;
+
+            if (typeof autoSize === 'function') {
+                // Масштабируем минимальные границы рамки пропорционально зуму, чтобы
+                // при отдалении поле уменьшалось вместе с текстом (как статический слой),
+                // а не оставалось зафиксированным в px на момент открытия.
+                if (sCssAtOpen
+                    && typeof autoSize.getBounds === 'function'
+                    && typeof autoSize.setBounds === 'function') {
+                    if (!baseBounds) baseBounds = autoSize.getBounds();
+                    const zoomRatio = sCssNow / sCssAtOpen;
+                    if (isFinite(zoomRatio) && zoomRatio > 0) {
+                        autoSize.setBounds({
+                            minW: Math.max(1, Math.round(baseBounds.minW * zoomRatio)),
+                            minH: Math.max(1, Math.round(baseBounds.minH * zoomRatio)),
+                        });
+                    }
+                }
+                autoSize();
+            }
+        } catch (_) {}
+    };
+}
+
+export function registerRegularTextEditorSync(controller, { updateEditor, updateCaret }) {
+    // Таймер дебаунса: скрываем каретку на время зума, показываем через 150 мс тишины.
+    // Во время серии событий ZoomPercent/Viewport.Changed каретка остаётся скрытой,
+    // что убирает артефакт «каретка осталась старого размера» при промежуточных кадрах.
+    let caretHideTimer = null;
+    const CARET_SHOW_DELAY_MS = 150;
+
+    const onZoom = () => {
+        updateEditor();
+        if (typeof updateCaret === 'function') {
+            if (caretHideTimer !== null) {
+                clearTimeout(caretHideTimer);
+                caretHideTimer = null;
+            }
+            // Скрываем каретку и блокируем caretUpdateHandler через флаг,
+            // чтобы selectionchange не перерисовал её в промежуточных кадрах.
+            try {
+                if (controller.textEditor) controller.textEditor._caretSuppressed = true;
+                const caret = controller.textEditor && controller.textEditor.caret;
+                if (caret) caret.style.display = 'none';
+            } catch (_) {}
+            // Показываем и пересчитываем после завершения серии зума
+            caretHideTimer = setTimeout(() => {
+                caretHideTimer = null;
+                try {
+                    if (controller.textEditor) controller.textEditor._caretSuppressed = false;
+                    updateCaret();
+                } catch (_) {}
+            }, CARET_SHOW_DELAY_MS);
+        }
+    };
+
+    const onViewportChange = () => updateEditor();
+
+    // Только зум/пэн/вьюпорт: ResizeUpdate сюда подключать нельзя — autoSize внутри
+    // updateEditor эмитит ResizeUpdate, что создало бы рекурсивную петлю.
+    const listeners = [
+        [Events.UI.ZoomPercent, onZoom],
+        [Events.Tool.PanUpdate, onViewportChange],
+        [Events.Viewport.Changed, onViewportChange],
+    ];
+
+    registerEditorListeners(controller.eventBus, listeners);
+    controller.textEditor._listeners = listeners;
+    // Сохраняем ссылку на таймер для очистки при закрытии редактора
+    controller.textEditor._caretHideTimer = () => {
+        if (caretHideTimer !== null) {
+            clearTimeout(caretHideTimer);
+            caretHideTimer = null;
+        }
+    };
+    return listeners;
+}
+
 export function registerNoteEditorSync(controller, { objectId, updateNoteEditor }) {
     const onZoom = () => updateNoteEditor();
     const onPan = () => updateNoteEditor();

package/src/tools/object-tools/selection/TextInlineEditorController.js

@@ -24,7 +24,12 @@ import {
     measureTextEditorPlaceholderWidth,
 } from './TextEditorDomFactory.js';
 import { setupNoteInlineEditor } from './NoteInlineEditorController.js';
-import { createRegularTextAutoSize } from './TextEditorSyncService.js';
+import {
+    createRegularTextAutoSize,
+    createRegularTextEditorUpdater,
+    registerRegularTextEditorSync,
+} from './TextEditorSyncService.js';
+import { updateCustomCaret } from './TextEditorCaretService.js';
 import { TEXT_BOX_BOTTOM_PAD_PX } from '../../../services/text/TextBoxMetrics.js';
 import { buildHtmlWithRanges } from '../../../ui/HtmlTextLayer.js';
 
@@ -441,10 +446,14 @@ export function openTextEditor(object, create = false) {
     // Синхронизируем стартовый размер шрифта textarea с текущим зумом (как HtmlTextLayer)
     // Используем ранее вычисленный effectiveFontPx (до вставки в DOM), если он есть в замыкании
     textarea.style.fontSize = `${effectiveFontPx}px`;
-    const initialWpx = regularEditorVisualBox?.width
-        || (initialSize ? Math.max(1, (initialSize.width || 0) * s / viewRes) : null);
-    const initialHpx = regularEditorVisualBox?.height
-        || (initialSize ? Math.max(1, (initialSize.height || 0) * s / viewRes) : null);
+    // Высоту/ширину поля при входе в редактор берём как максимум из видимого DOM-бокса
+    // и размера в состоянии объекта. DOM-бокс .mb-text к этому моменту может быть схлопнут
+    // до высоты контента (auto), тогда как в состоянии хранится вручную заданная высота рамки —
+    // её и нужно сохранить, иначе поле ввода схлопывается до одной строки.
+    const stateWpx = initialSize ? Math.max(1, (initialSize.width || 0) * s / viewRes) : 0;
+    const stateHpx = initialSize ? Math.max(1, (initialSize.height || 0) * s / viewRes) : 0;
+    const initialWpx = Math.max(regularEditorVisualBox?.width || 0, stateWpx) || null;
+    const initialHpx = Math.max(regularEditorVisualBox?.height || 0, stateHpx) || null;
 
     // Определяем минимальные границы для всех типов объектов
     let minWBound = initialWpx || 120; // базово близко к призраку
@@ -477,6 +486,12 @@ export function openTextEditor(object, create = false) {
             wrapper.style.width = `${initialWpx}px`;
         }
         if (initialHpx) {
+            // Стартовую высоту ставим, чтобы не было вспышки при открытии, но minHBound НЕ
+            // поднимаем до obj.height: высота поля авто-подгоняется под контент (как статический
+            // .mb-text). Прежнее `minHBound = max(minHBound, initialHpx)` фиксировало рамку на
+            // высоте obj.height; при завышенном obj.height поле оставалось высоким (пустой зазор
+            // под текстом), особенно при зуме — baseBounds кэшировал завышенный minH и масштабировал
+            // его. Обычный текст не имеет ручной высоты, поэтому фиксировать её не нужно.
             textarea.style.height = `${initialHpx}px`;
             wrapper.style.height = `${initialHpx}px`;
         }
@@ -576,6 +591,30 @@ export function openTextEditor(object, create = false) {
         finalize,
         listType: properties.listType || 'none',
     });
+
+    // Обычный текст: держим редактор выровненным по объекту и масштабируем шрифт при зуме/пэне.
+    // Вертикальный якорь редактора унифицирован (см. positionRegularTextEditor), поэтому sync
+    // безопасен и для сессии создания — без него только что созданный текст не масштабировался при зуме.
+    // Записки используют собственный registerNoteEditorSync, фигуре синхронизация не нужна.
+    if (!isNote && !isShape && objectId) {
+        const updateRegularTextEditor = createRegularTextEditorUpdater(this, {
+            objectId,
+            position,
+            view,
+            textarea,
+            wrapper,
+            autoSize,
+            baseFontPxAtOpen: effectiveFontPx,
+            sCssAtOpen: s / viewRes,
+        });
+        const updateCaretAfterZoom = () => {
+            updateCustomCaret(textarea, this.textEditor && this.textEditor.caret);
+        };
+        registerRegularTextEditorSync(this, {
+            updateEditor: updateRegularTextEditor,
+            updateCaret: updateCaretAfterZoom,
+        });
+    }
 }
 
 export function closeTextEditor(commit) {

package/src/ui/HtmlTextLayer.js

@@ -9,6 +9,7 @@ import {
     resolveLineHeightRatio,
     computeTextRightPadPx,
     resolveStaticTextPadding,
+    computeSingleLineCenterDelta,
     TEXT_BOX_BOTTOM_PAD_PX,
 } from '../services/text/TextBoxMetrics.js';
 
@@ -761,16 +762,26 @@ export class HtmlTextLayer {
             }
         } catch (_) {}
 
-        // Гарантируем, что высота соответствует контенту (особенно после смены font-size)
+        // Высота текстового бокса всегда равна высоте контента: рамка облегает строки,
+        // под текстом нет пустого зазора. Высоту объекта (logHeight = round(h*s)) здесь
+        // НЕ учитываем — иначе единожды завышенный obj.height (дефолт при создании или
+        // остаток от прежнего многострочного текста) залипал, и появлялся зазор после зума.
         try {
             el.style.height = 'auto';
-            // Добавим небольшой нижний отступ для хвостов букв, чтобы не отсекались (например, у «з»)
-            const hCss = Math.max(1, Math.round(el.scrollHeight + TEXT_BOX_BOTTOM_PAD_PX));
+            // Для обычного однострочного текста центрируем видимые буквы по вертикали:
+            // line-box резервирует сверху место под прописные/выносные, которого строчный
+            // текст не занимает, поэтому буквы кажутся прижатыми к низу рамки. centerDelta
+            // уравнивает верхний и нижний зазоры вокруг глифов. Для markdown/списков и в
+            // окружении без layout (jsdom) дельта = null → сохраняем прежний нижний отступ
+            // TEXT_BOX_BOTTOM_PAD_PX под хвосты букв (например, «з», «у»).
+            const centerDelta = (!isMarkdown && !useList)
+                ? computeSingleLineCenterDelta(el)
+                : null;
+            const extra = (centerDelta === null) ? TEXT_BOX_BOTTOM_PAD_PX : centerDelta;
+            const hCss = Math.max(1, Math.round(el.scrollHeight + extra));
             el.style.height = `${hCss}px`;
-            // Обновим высоту для лога, если её ещё не устанавливали
-            if (!logHeight) {
-                logHeight = hCss;
-            }
+            // Обновим высоту для лога
+            logHeight = hCss;
         } catch (_) {}
         
         console.log(`🔍 HtmlTextLayer: позиция обновлена для ${objectId}:`, {
@@ -910,19 +921,26 @@ export class HtmlTextLayer {
             // Измеряем фактическую высоту HTML-текста
             el.style.height = 'auto';
             const measured = Math.max(1, Math.round(el.scrollHeight));
-            el.style.height = `${measured}px`;
-            // Пересчитываем мировую высоту и отправляем обновление размера через события ResizeUpdate
+            
             const world = this.core.pixi.worldLayer || this.core.pixi.app.stage;
             const s = world?.scale?.x || 1;
             const res = (this.core?.pixi?.app?.renderer?.resolution) || 1;
-            const worldH = (measured * res) / s;
-            // Узнаём текущую ширину в мире
+            const worldH_auto = (measured * res) / s;
+            
+            const currentWorldH = obj?.height || 0;
+            // Высота объекта всегда подгоняется под контент (и вверх, и вниз): без сжатия
+            // единожды завышенная высота залипала и давала пустой зазор под текстом.
+            const finalWorldH = worldH_auto;
+            const finalCssH = Math.round((finalWorldH * s) / res);
+            
+            el.style.height = `${finalCssH}px`;
+            
             const worldW = obj?.width || 0;
             const position = obj?.position || null;
-            if (worldW > 0 && position) {
+            if (worldW > 0 && position && finalWorldH !== currentWorldH) {
                 this.core.eventBus.emit(Events.Tool.ResizeUpdate, {
                     object: objectId,
-                    size: { width: worldW, height: worldH },
+                    size: { width: worldW, height: finalWorldH },
                     position
                 });
             }

package/src/ui/animation/HoverLiftController.js

@@ -172,6 +172,26 @@ export class HoverLiftController {
         this._entries.delete(pixiObject);
     }
 
+    /**
+     * Текущая визуальная hover-трансформация объекта относительно его базы.
+     * Нужна, чтобы внешние оверлеи (подсветка коннектора) совпадали с
+     * масштабированным/приподнятым на hover объектом.
+     * @param {import('pixi.js').DisplayObject} pixiObject
+     * @returns {{ scaleMulX: number, scaleMulY: number, centerX: number, centerY: number } | null}
+     */
+    getVisualTransform(pixiObject) {
+        const entry = this._entries.get(pixiObject);
+        if (!entry) return null;
+        const baseScaleX = entry.baseScaleX || 1;
+        const baseScaleY = entry.baseScaleY || 1;
+        return {
+            scaleMulX: (pixiObject.scale?.x ?? baseScaleX) / baseScaleX,
+            scaleMulY: (pixiObject.scale?.y ?? baseScaleY) / baseScaleY,
+            centerX: pixiObject.x,
+            centerY: pixiObject.y,
+        };
+    }
+
     /** Обновить базовые значения после внешнего resize/move */
     syncBase(pixiObject) {
         const entry = this._entries.get(pixiObject);

package/src/ui/chat/ChatWindow.js

@@ -972,6 +972,43 @@ export class ChatWindow {
         });
     }
 
+    _placeGeneratedVideoOnBoard(result, skeletonWorld = null) {
+        if (!this._boardCore?.eventBus) return;
+        const src = result?.videoUrl;
+        if (!src) {
+            if (this._refs?.errorBlock) {
+                this._refs.errorBlock.textContent = 'Видео сгенерировано, но ссылка отсутствует.';
+                this._refs.errorBlock.classList.add('is-visible');
+            }
+            return;
+        }
+
+        const world = this._boardCore.pixi?.worldLayer || this._boardCore.pixi?.app?.stage;
+        const s = world?.scale?.x || 1;
+
+        // Приоритет — мировая точка скелетона: видео приземляется туда, где была заглушка,
+        // даже если пользователь панорамировал/зумил во время генерации.
+        let x;
+        let y;
+        if (skeletonWorld) {
+            x = Math.round(skeletonWorld.x * s + (world?.x || 0));
+            y = Math.round(skeletonWorld.y * s + (world?.y || 0));
+        } else {
+            const composerRect = this._refs?.composer?.getBoundingClientRect?.();
+            x = composerRect ? Math.round(composerRect.left + composerRect.width / 2) : 400;
+            y = composerRect ? Math.round(composerRect.top - 200) : 200;
+        }
+
+        this._boardCore.eventBus.emit(Events.UI.PasteVideoAt, {
+            x,
+            y,
+            src,
+            mimeType: result?.mimeType || 'video/mp4',
+            poster: null,
+            skipUpload: true
+        });
+    }
+
     _clearBoardSelection() {
         if (typeof this._boardCore?.selectTool?.clearSelection === 'function') {
             this._boardCore.selectTool.clearSelection();
@@ -1227,15 +1264,9 @@ export class ChatWindow {
         }
         if (state.status === 'done') {
             this._composer?.setStreaming(false);
+            const skeletonWorld = this._videoSkeletonWorld;
             this._clearVideoSkeleton();
-            // Тип объекта «видео» на доске не существует. Событие Events.UI.PasteImageAt
-            // ожидает data URL картинки — видео-URL несовместим. Размещение на доске
-            // выходит за рамки текущей фазы (нет объекта типа video).
-            console.info('[ChatWindow] Видео готово. Размещение на доске не поддерживается: нет объекта типа video.', state.result?.videoUrl);
-            if (this._refs?.errorBlock) {
-                this._refs.errorBlock.textContent = 'Видео сгенерировано. Размещение на доске появится в следующей фазе.';
-                this._refs.errorBlock.classList.add('is-visible');
-            }
+            this._placeGeneratedVideoOnBoard(state.result, skeletonWorld);
         }
         if (state.status === 'error') {
             this._composer?.setStreaming(false);

package/src/ui/comments/CommentThreadPopover.js

@@ -136,7 +136,9 @@ export class CommentThreadPopover {
             position: 'absolute',
             inset: '0',
             pointerEvents: 'none',
-            zIndex: 26,
+            // Выше панелей свойств (text-properties-layer = 10050, *PropertiesPanel = 10000),
+            // иначе открытый поверх объекта попап комментария оказывается под тулбаром свойств.
+            zIndex: 10060,
         });
         this.container.appendChild(this.layer);