Meridian Paint — растровый редактор

Документ приложения по соглашениям раздела 8 библии (docs/00-foundation.md). Версия 0.1 · 2026-10-03 · фаза 4 · редакция: Home и выше (инструмент «Снимок» — см. «Вопросы к библии»). Цвет приложения --app-paint #C2309B, значок — капля-кисть, формат документа .mpi (urn:meridian:office:paint:1), код ядра — kernel/crates/meridian-raster/, оболочка — shell/src/paint/.

1. Назначение и аналоги

1.1 Назначение

Meridian Paint — растровый редактор для повседневных задач «нарисовать, поправить, вырезать, подписать, снять экран»: скриншоты с пометками, обработка фотографий для документов и презентаций, иллюстрации для Write/Slides/Notes, пиксельная графика, значки, обложки, простые анимации. Это не замена Photoshop и не Krita для художников: слои, маски, выделения, коррекции и фильтры — да; CMYK-допечатная подготовка, 3D, видео, узлы композитинга — нет.

Paint работает в двух ролях:

1.2 Аналоги

1.3 Чем лучше Paint и Paint.NET

1.4 Границы продукта (чего не делаем)

• CMYK как рабочее пространство документа (только конвертация при экспорте в PDF/TIFF — P2).
• Узловой композитинг, 3D, видео, векторный редактор (это Draw).
• Нейросетевые функции (удаление фона, апскейл) — через Meridian Assist (фаза 7), не в ядре Paint.

2. Функции

Приоритеты: P0 — без этого нельзя выпустить Paint 1.0; P1 — в 1.x; P2 — позже.

2.1 Создание, открытие, захват экрана

2.2 Инструменты рисования

Вертикальная колонка инструментов (см. PT-01). У каждого инструмента — панель «Свойства инструмента» (PT-05).

Общие свойства: цвета основной/фоновый (X — поменять, D — чёрный/белый), режим наложения мазка, «рисовать только в выделении», сглаживание (антиалиасинг) вкл/выкл, «сохранить прозрачность» (lock alpha).

2.3 Выделение

2.4 Трансформации, обрезка, холст

2.5 Слои

2.6 Коррекции (меню «Изображение → Коррекция», применяются к слою или как корректирующий слой)

2.7 Фильтры (меню «Фильтры», все с предпросмотром на холсте и в диалоге, см. PT-11)

2.8 Цвет

2.9 Вид, навигация, направляющие

2.10 История, автосохранение, восстановление

2.11 Анимация (кадры)

2.12 Печать и экспорт

2.13 Доступность

2.14 Интеграция с пакетом и расширяемость

• Встроенное редактирование из Write/Slides/Notes/Draw (см. 1.1) — P0.
• «Вставить скриншот» в любом приложении пакета открывает наложение Paint (Вставка → Снимок экрана) — P0.
• Hub: быстрый просмотр изображений (без открытия Paint), «Открыть в Paint» — P0.
• Скрипты MeridianScript (раздел 6): фильтры, пакетная обработка, свои инструменты (P1), панели (P2) — P0 для API ядра.
• Плагины фильтров — только через MeridianScript и WASM-модули (песочница), без нативных DLL — P1.
• Кисти: импорт .abr (Photoshop, версии 6+), .gbr/.gih (GIMP), .myb? (MyPaint — P2), .kpp (Krita, частично P2) — P1.

3. Экраны

Обозначения: PT-NN. Макеты — mockups/paint.html, каждый экран — <section class="screen">. Каркас окна — по разделу 5.3 библии: заголовок, ribbon (вкладки «Файл · Главная · Выделение · Слой · Изображение · Фильтры · Вид · Скрипты»), навигационная панель слева заменена колонкой инструментов (40 px, две колонки по 20 px в компактном режиме), холст, боковая панель справа, строка состояния.

PT-01 Главное окно

┌──────────────────────────────────────────────────────────────────────────────────┐
│ ● Безымянный-1.mpi — Meridian Paint                      [поиск ⌘K]  [☁] [👤]   │
├──────────────────────────────────────────────────────────────────────────────────┤
│ Файл  Главная  Выделение  Слой  Изображение  Фильтры  Вид  Скрипты     [⌄]       │
│ [Буфер] [Инструменты] [Кисть: размер жёсткость непрозр.] [Цвет] [Коррекции] [Снимок] │
├────┬──────────────────────────────────────────────────────────┬──────────────────┤
│ P  │  ◦ Безымянный-1 ×  │ фото.jpg ×  │ +                      │ Слои  Цвет  Ист. │
│ B  ├──────────────────────────────────────────────────────────┤──────────────────│
│ E  │ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ Normal ▾ 100 % │
│ G  │ ▒▒┌──────────────────────────────────────────────┐▒▒▒▒▒▒ │ 🔒 ▢ 👁 Текст    │
│ T  │ ▒▒│ ░░░░░░ холст на «шахматке» ░░░░░░░░░░░░░░░░░░ │▒▒▒▒▒▒ │ 👁 ▣ Фигуры     │
│ U  │ ▒▒│ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │▒▒▒▒▒▒ │ 👁 ▣ Слой 1     │
│ M  │ ▒▒│ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │▒▒▒▒▒▒ │ 👁 ▣ Фон     🔒 │
│ L  │ ▒▒└──────────────────────────────────────────────┘▒▒▒▒▒▒ │──────────────────│
│ W  │ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ Свойства инстр.  │
│ V  │                                                          │ Навигатор        │
│ …  │                                                          │                  │
├────┴──────────────────────────────────────────────────────────┴──────────────────┤
│ 1920×1080 px · 8 бит sRGB · Слой 1 · X: 412 Y: 230 · RGB 34 120 200 · [▭ 100 % ▾] · ↻0° │
└──────────────────────────────────────────────────────────────────────────────────┘

PT-02 Панель «Слои»

• Шапка: режим наложения (выпадающий список с группами и предпросмотром при наведении), непрозрачность (ползунок + поле), блокировки (4 значка), фильтр по типу, поиск по имени.
• Список: строка слоя — глаз, миниатюра (40 px, «шахматка»), миниатюра маски (если есть, со связью-цепочкой), имя (двойной щелчок — переименовать), значки типа (T — текст, ✎ — вектор, ◐ — корректирующий, ▸ — группа с раскрытием), цветовая метка (полоска слева), замок.
• Перетаскивание: порядок, в группу/из группы, между документами; Ctrl при перетаскивании — копия.
• Низ панели: новый слой, новая группа, маска, корректирующий слой (меню), дублировать, удалить; выделение нескольких (Ctrl/Shift) — групповые операции.
• Контекстное меню: все операции 2.5 + «Свойства слоя» (PT-21).

PT-03 Панель «Цвет»

• Верх: большой образец основного/фонового цвета, кнопка «поменять», «сброс».
• Селектор: режимы «Круг» (кольцо H + треугольник SV), «Квадрат» (H-полоса + SV), «Ползунки» (RGB / HSV / HSL / LAB / OKLCH / CMYK-проба), «HEX» (#RRGGBBAA, вставка из буфера), «Образцы».
• Образцы: сетка 16 px, группы (палитра документа, «Недавние», «Пользовательские», «Material», …), добавление текущего (+), импорт/экспорт, создать из изображения.
• Индикатор «вне охвата» (для документов с профилем ≠ sRGB) и «вне sRGB» при экспорте.

PT-04 Панель «История»

• Список действий: значок операции, имя («Кисть», «Гауссово размытие σ=4», «Новый слой»), миниатюра (опционально); текущее состояние выделено; записи ниже текущей — серые (redo).
• Снимки (snapshots) вверху: «Исходное», пользовательские (кнопка «фотоаппарат»).
• Низ: «Создать снимок», «Удалить», «Очистить историю» (освободить память), показатель памяти истории.

PT-05 Панель «Свойства инструмента»

Содержимое зависит от инструмента (см. 2.2). Общие элементы: предустановки инструмента (сохранить/загрузить), «Сбросить инструмент». Для кисти: предпросмотр мазка 200×60 px, кривые нажима (мини-редактор), выбор формы (галерея кистей, импорт), стабилизатор (ползунок + «режим верёвки» P1).

PT-06 Панель «Навигатор»

Миниатюра композита (обновляется с задержкой 100 мс), рамка вида (перетаскиваемая), ползунок масштаба, кнопки «по ширине/по размеру/100 %», поле угла поворота вида.

PT-07 Диалог «Новый»

PT-08 Диалог «Размер изображения»

Поля: ширина/высота (px, %, мм при ppi), пропорции (замок), разрешение, «пересчитать пиксели» (resample) вкл/выкл, метод (Автоматически / Ближайший / Билинейный / Бикубический / Lanczos-3 / Box / Mitchell), предпросмотр фрагмента 1:1 с ползунком «до/после», итоговый размер в памяти.

PT-09 Диалог «Размер холста»

Поля: текущий размер, новый размер (абсолютно/относительно), якорь (сетка 3×3 со стрелками), цвет расширения (фон/прозрачный/цвет), «обрезать слои, выходящие за холст» (выкл по умолчанию).

PT-10 Диалог «Поворот холста»

90° по/против часовой, 180°, произвольный (поле угла, −360…360, слайдер), «расширить холст» / «обрезать», метод интерполяции, цвет фона, предпросмотр.

PT-11 Диалог фильтра (общий каркас)

• Левая часть: параметры (ползунок + числовое поле + «связать»), предустановки (выпадающий список, сохранить/удалить), «Сброс».
• Правая часть: предпросмотр — фрагмент 1:1 (перетаскиваемый) с кнопкой «до/после» и переключатель «на холсте» (рендер в реальном времени на видимой области — на GPU где возможно).
• Низ: «Применить к: слой / выделение / как корректирующий слой (где применимо)», OK/Отмена, время расчёта последнего предпросмотра (для диагностики).
• Отзывчивость: предпросмотр считается на уменьшенной копии, если полный расчёт > 100 мс; полный — в фоне с индикатором.

PT-12 Диалог «Экспорт»

• Формат (PNG/JPEG/WebP/GIF/BMP/TIFF/ICO/PSD/PDF/AVIF/HEIC(macOS)/SVG(вектор)), настройки сжатия: JPEG — качество 0–100, прогрессивный, субдискретизация 4:4:4/4:2:0, оптимизация Хаффмана; PNG — уровень, 8-бит палитра (с дизерингом), чересстрочный; WebP — lossy/lossless, качество, метод 0–6; GIF — палитра, дизеринг, прозрачность, анимация; TIFF — сжатие LZW/ZIP/none, многостраничный; ICO — набор размеров (16/24/32/48/64/128/256); PDF — ICC, страницы.
• Метаданные: EXIF (сохранить/удалить/удалить геопозицию), XMP, ICC (встроить/преобразовать в sRGB).
• Масштаб при экспорте (×0,5, ×2, в px), «обрезать по содержимому».
• Предпросмотр «до/после» с оценкой размера файла (пересчёт при изменении параметров, в фоне).
• Кнопки: «Экспорт», «Экспорт и открыть папку», «Копировать в буфер».

PT-13 Снимок экрана — наложение выбора области

• Полноэкранное полупрозрачное окно (затемнение 40 %) на каждом мониторе, курсор-перекрестие, лупа 120×120 (×8) с координатами и цветом под курсором, подсказка «Выделите область · Enter — снять · Esc — отмена · Пробел — переместить».
• Рамка выделения с размером (например «1280 × 720») и маркерами изменения; привязка к окнам/элементам (Windows UIAutomation, macOS Accessibility, X11 — только окна); Alt — без привязки; Shift — квадрат.
• Режимы в верхней плавающей панели: Область · Окно · Экран · Произвольная форма (лассо) · Задержка (0/3/5/10 с) · Курсор вкл/выкл · После снимка: «мини-редактор» / «в Paint» / «в буфер» / «сохранить».
• Мини-редактор (режим «Снимок»): компактное окно с изображением и панелью: стрелка, прямоугольник, эллипс, маркер, карандаш, номер-кружок (автонумерация), текст, размытие/пикселизация области, обрезка, отмена; кнопки «Копировать», «Сохранить» (папка снимков, имя по шаблону Снимок {дата} {время}.png), «Открыть в Paint», «Поделиться».

PT-14 Контекстная вкладка «Текст» и панель текста

Шрифт (с предпросмотром, недавние), размер, стиль, цвет, обводка (цвет/ширина), выравнивание, межстрочный, межбуквенный, направление, «абзацный/строчный», сглаживание (нет/серое/субпиксельное — последнее выкл. для прозрачных слоёв), «Растрировать». Редактирование — прямо на холсте (каретка, выделение, IME).

PT-15 Рамка трансформации

Маркеры 8 шт. + центр вращения (перетаскиваемый), угол/масштаб/наклон в контекстной вкладке с полями ввода, кнопки «Применить ✓ / Отмена ✗», предпросмотр интерполяции («черновой» на GPU билинейный, финальный — выбранный метод).

PT-16 Панель «Кадры»

Горизонтальная лента миниатюр кадров, длительность под каждым, кнопки «Новый кадр / Дублировать / Удалить / Воспроизвести / Калька / fps», режим «слой = кадр».

PT-17 Редактор градиента

Полоса градиента с точками цвета (снизу) и прозрачности (сверху), поля положения/цвета/прозрачности, тип интерполяции, предустановки, «инвертировать», «дизеринг».

PT-18 Печать

Общий диалог Meridian Print с предпросмотром листа: принтер, формат, ориентация, масштаб (по размеру / 100 % при DPI / произвольный %), положение (центр / координаты), копии, цвет/ч-б.

PT-19 Параметры Paint

Разделы: Общие (единицы, поведение буфера, автосохранение), Интерфейс (цвет «шахматки», раскладка панелей), Производительность (лимит памяти истории, тайлы на GPU, число потоков, папка кэша), Планшет (API: Windows Ink / WinTab; кривая нажима глобальная; тест), Цвет (рабочее пространство по умолчанию, политика профилей, профиль монитора), Снимки (папка, шаблон имени, формат, глобальные клавиши), Курсоры (контур кисти/перекрестие).

PT-20 Галерея кистей

Сетка предпросмотров мазков, группы (Основные, Текстурные, Пиксельные, Пользовательские), импорт .abr/.gbr/.gih, создание кисти из выделения, свойства кисти (форма, интервал, динамика).

PT-21 Свойства слоя / корректирующего слоя

Общие: имя, цветовая метка, режим, непрозрачность, блокировки, обтравочная маска. Для корректирующего — панель параметров коррекции (как в PT-11, но без OK — изменения применяются сразу, неразрушающе).

PT-22 Диалоги выделения

«Растушёвка» (радиус), «Расширить/Сузить» (px), «Граница» (ширина), «Сгладить» (радиус), «Обводка» (ширина, цвет, положение, режим), «Заливка» (цвет/узор/содержимое), «Цветовой диапазон» (пипетки, размытость, предпросмотр маски).

PT-23 Несоответствие профиля / назначение профиля

При открытии файла с профилем, отличным от рабочего: «Использовать встроенный · Преобразовать в рабочее · Игнорировать (назначить рабочее)», флажок «запомнить». Диалог «Преобразовать в профиль»: профиль, намерение, компенсация чёрной точки, предпросмотр.

PT-24 Восстановление после сбоя

Список несохранённых документов с миниатюрами и временем, «Восстановить все / выбранные / удалить».

4. Модель данных

4.1 Иерархия

Image (документ)
 ├── meta: размер холста, DPI, цветовое пространство (ICC), глубина, фон, направляющие, сетка
 ├── layers: дерево LayerNode (корневая группа)
 │    ├── RasterLayer  → TileMap (разреженные тайлы 256×256, премультиплицированный RGBA)
 │    ├── TextLayer    → TextModel (из Write) + кэш растра (TileMap)
 │    ├── VectorLayer  → Scene (из Draw) + кэш растра
 │    ├── AdjustmentLayer → Adjustment (параметры) + LUT-кэш
 │    └── GroupLayer   → children + кэш композита группы
 │    (у каждого: mask: Option<MaskMap>, opacity, blend, flags, offset, bounds)
 ├── selection: Option<MaskMap> (8/16 бит, покрытие 0..1) + bounds + «муравьи» (контур, кэш)
 ├── channels: сохранённые выделения (имя → MaskMap)
 ├── frames: Option<Animation> (кадры → наборы видимости, длительности)
 ├── history: HistoryStack (команды + снимки тайлов)
 └── caches: projection (композит), below/above-кэши активного слоя, GPU-текстуры

4.2 Тайлы и слои (Rust)

// kernel/crates/meridian-raster/src/tile.rs

pub const TILE: usize = 256;
pub const TILE_PIXELS: usize = TILE * TILE;

/// Премультиплицированный 8-бит пиксель в sRGB-кодировке / Premultiplied 8-bit sRGB-encoded pixel
#[repr(C)] #[derive(Clone, Copy, Default, PartialEq)]
pub struct Rgba8 { pub r: u8, pub g: u8, pub b: u8, pub a: u8 }

/// Премультиплицированный 16-бит float (half) линейный пиксель / Premultiplied linear f16 pixel
#[repr(C)] #[derive(Clone, Copy, Default, PartialEq)]
pub struct Rgba16F { pub r: f16, pub g: f16, pub b: f16, pub a: f16 }

/// Данные тайла. Неизменяемы: запись = копирование при записи (Arc::make_mut).
/// Tile payload. Immutable: writes go through copy-on-write (Arc::make_mut).
pub enum TileData {
    U8(Box<[Rgba8; TILE_PIXELS]>),
    F16(Box<[Rgba16F; TILE_PIXELS]>),
}

#[derive(Clone)]
pub struct Tile(pub Arc<TileData>);

/// Координаты тайла в пространстве слоя (могут быть отрицательными — холст бесконечный)
/// Tile coordinates in layer space (may be negative — canvas is unbounded)
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
pub struct TileKey { pub tx: i32, pub ty: i32 }

#[derive(Clone, Default)]
pub struct TileMap {
    pub depth: Depth,                       // U8 | F16
    pub tiles: HashMap<TileKey, Tile>,      // отсутствие ключа = прозрачный тайл / missing = transparent
    pub bounds: Option<IRect>,              // ограничивающий прямоугольник непустых пикселей (ленивое уточнение)
}

impl TileMap {
    /// Получить изменяемый тайл: создаёт пустой, если нет; клонирует, если разделяется с историей
    /// Get a mutable tile: creates empty if absent; clones if shared with history
    pub fn tile_mut(&mut self, key: TileKey, undo: &mut UndoRecorder) -> &mut TileData {
        let depth = self.depth;
        let tile = self.tiles.entry(key).or_insert_with(|| Tile::empty(depth));
        undo.remember(key, tile.clone());          // старый Arc сохраняется — нулевое копирование / old Arc kept — zero copy
        Arc::make_mut(&mut tile.0)                 // копирование только если Arc разделён / clones only when shared
    }

    pub fn read(&self, key: TileKey) -> Option<&TileData> { self.tiles.get(key).map(|t| &*t.0) }

    /// Пробежать по тайлам, пересекающим прямоугольник / Iterate tiles intersecting a rect
    pub fn keys_in(&self, r: IRect) -> impl Iterator<Item = TileKey> {
        let (x0, y0) = (r.x0.div_euclid(TILE as i32), r.y0.div_euclid(TILE as i32));
        let (x1, y1) = ((r.x1 - 1).div_euclid(TILE as i32), (r.y1 - 1).div_euclid(TILE as i32));
        (y0..=y1).flat_map(move |ty| (x0..=x1).map(move |tx| TileKey { tx, ty }))
    }
}

// kernel/crates/meridian-raster/src/layer.rs

pub type LayerId = u64;

pub struct LayerNode {
    pub id: LayerId,
    pub name: String,
    pub kind: LayerKind,
    pub visible: bool,
    pub opacity: f32,                 // 0..1
    pub blend: BlendMode,
    pub mask: Option<Mask>,           // маска слоя / layer mask
    pub mask_enabled: bool,
    pub mask_linked: bool,            // перемещается вместе со слоем / moves with the layer
    pub clip_to_below: bool,          // обтравочная маска / clipping mask
    pub locks: Locks,                 // pixels | alpha | position | all
    pub offset: IVec2,                // смещение содержимого относительно холста / content offset vs canvas
    pub color_tag: Option<ColorTag>,
    pub alt_text: Option<String>,
}

pub enum LayerKind {
    Raster(TileMap),
    Text { model: TextModel, transform: Affine, cache: RefCell<Option<TileMap>> },
    Vector { scene: Scene, cache: RefCell<Option<TileMap>> },
    Adjustment { adj: Adjustment, lut: RefCell<Option<Lut>> },
    Group { children: Vec<LayerNode>, pass_through: bool, cache: RefCell<Option<TileMap>> },
}

pub struct Mask { pub map: MaskMap, pub offset: IVec2, pub default: f32 /* значение вне тайлов: 1 = показать */ }

/// Маска: один канал покрытия / Mask: single coverage channel
pub struct MaskMap { pub depth: Depth, pub tiles: HashMap<TileKey, Arc<MaskTile>> }

pub enum Adjustment {
    BrightnessContrast { brightness: f32, contrast: f32, legacy: bool },
    Levels { per_channel: [LevelsChannel; 4] },
    Curves { per_channel: [CurveSpline; 4] },
    ColorBalance { shadows: Vec3, midtones: Vec3, highlights: Vec3, preserve_luminosity: bool },
    HueSaturation { master: Hsl, ranges: [HslRange; 6], colorize: Option<Hsl> },
    BlackWhite { weights: [f32; 6] },
    Invert, Threshold(u8), Posterize(u8),
    GradientMap(Gradient), PhotoFilter { color: Rgb, density: f32 }, Vibrance { vibrance: f32, saturation: f32 },
}

// kernel/crates/meridian-raster/src/image.rs

pub struct Image {
    pub width: u32, pub height: u32,
    pub dpi: f32,
    pub color: ColorSpaceInfo,        // профиль ICC (байты + разобранный), название, намерение / ICC profile, name, intent
    pub depth: Depth,
    pub linear_blend: bool,           // смешивать в линейном пространстве / blend in linear light
    pub root: LayerNode,              // корневая группа / root group
    pub active: Vec<LayerId>,         // выбранные слои / selected layers
    pub selection: Selection,
    pub channels: Vec<(String, MaskMap)>,
    pub guides: Vec<Guide>, pub grid: GridSettings,
    pub frames: Option<Animation>,
    pub history: History,
    pub meta: DocMeta,                // Dublin Core + EXIF/XMP, alt-text
    caches: Caches,
}

pub struct Selection { pub mask: Option<MaskMap>, pub bounds: Option<IRect>, pub outline: RefCell<Option<Outline>> }

pub struct Animation { pub frames: Vec<Frame>, pub fps_cap: u16, pub loops: u16 /* 0 = бесконечно */ }
pub struct Frame { pub name: String, pub duration_ms: u32, pub visible: HashSet<LayerId>, pub group: Option<LayerId> }

Инварианты:

• Тайлы неизменяемы; любая запись идёт через tile_mut, который фиксирует старую версию в текущей записи истории. Две истории (документа и мазка-предпросмотра) не пересекаются.
• bounds слоя — надмножество реальных непустых пикселей; уточняется лениво фоновой задачей (подсчёт пустых тайлов), пустые тайлы удаляются из карты.
• Слой может быть больше холста; холст — лишь область экспорта и композитинга по умолчанию.
• Все цвета в тайлах премультиплицированы; непремультиплицированное представление нужно только для формул разделённых режимов наложения, цветокоррекций и экспорта (делим на α с защитой от 0).
• 8-бит хранится в sRGB-кодировке (значения 0–255 — гамма-кодированные), 16-бит float — линейные.

4.3 История

pub struct History { pub entries: Vec<HistoryEntry>, pub cursor: usize, pub snapshots: Vec<Snapshot>, pub mem_limit: usize, pub mem_used: usize }

pub struct HistoryEntry {
    pub label: String, pub icon: IconId,
    pub tiles: Vec<(LayerId, TileKey, Option<Tile>)>,  // старая версия тайла (None = тайла не было) / old tile version
    pub masks: Vec<(LayerId, TileKey, Option<Arc<MaskTile>>)>,
    pub structural: Option<StructuralDiff>,             // слои/порядок/свойства/выделение/холст — обратимые команды
    pub redo_tiles: Vec<(LayerId, TileKey, Option<Tile>)>, // заполняется при undo / filled on undo
    pub spilled: Option<PathBuf>,                        // сброшено на диск / spilled to disk
}

Структурные изменения (переименование, порядок, режим, размер холста, выделение) описываются обратимыми командами (apply/revert), пиксельные — снимками тайлов. Память: при превышении mem_limit самые старые записи сериализуются в recovery/<uuid>/hist-NNN.bin (LZ4), при нехватке диска — удаляются с начала.

4.4 Формат документа .mpi

ZIP-пакет по правилам MOP (раздел 3.1 библии):

mimetype                      application/vnd.meridian.paint (stored, первый элемент)
manifest.xml                  список частей, версия формата
meta.xml                      Dublin Core, alt-text, EXIF/XMP (как есть), история изменений (кратко)
image.xml                     структура документа (ниже)
layers/<id>.png               растровые слои 8 бит (PNG, RGBA непремультиплицированный, с iCCP = рабочий профиль)
layers/<id>.exr               слои 16 бит (OpenEXR half, PIZ/ZIP, линейный, премультиплированный — стандарт EXR)
masks/<id>.png                маски (PNG, 8 бит серый / 16 бит для F16-документов)
text/<id>.xml                 текстовые слои (разметка Write: тот же text-model, `urn:meridian:office:write:1`)
vector/<id>.xml               векторные слои (разметка Draw: `urn:meridian:office:draw:1`)
channels/<name>.png           сохранённые выделения
mergedimage.png               композит (для просмотра другими приложениями, Hub, проводника)
thumbnail.png                 256×256
settings.xml                  вид (масштаб, положение), раскладка панелей, активный слой
history/                      опционально: снимки состояний
scripts/                      опционально: скрипты документа (не запускаются без разрешения)

image.xml (сокращённый пример):

<image xmlns="urn:meridian:office:paint:1" version="1.0"
       width="1920" height="1080" dpi="96" depth="u8" colorspace="sRGB" icc="meta/sRGB.icc" linear-blend="false">
  <layers>
    <layer id="7" type="text" name="Заголовок" visible="true" opacity="1" blend="normal" x="120" y="80"
           src="text/7.xml" rasterized="layers/7.png"/>
    <group id="5" name="Пометки" blend="normal" opacity="0.9" pass-through="false">
      <layer id="6" type="vector" name="Стрелки" src="vector/6.xml" rasterized="layers/6.png"/>
      <layer id="4" type="adjustment" name="Кривые" kind="curves" clip="true">
        <curves channel="rgb" points="0,0 64,48 192,210 255,255" spline="monotone"/>
      </layer>
    </group>
    <layer id="2" type="raster" name="Слой 1" x="-40" y="12" src="layers/2.png" lock="alpha">
      <mask src="masks/2.png" enabled="true" linked="true" default="1"/>
    </layer>
    <layer id="1" type="raster" name="Фон" src="layers/1.png" lock="all"/>
  </layers>
  <selection src="channels/_selection.png" x="300" y="200"/>
  <guides><h y="540"/><v x="960"/></guides>
  <grid step="32" sub="4" visible="false" snap="true"/>
  <frames fps-cap="30" loops="0">
    <frame name="1" duration="100" layers="1 2"/><frame name="2" duration="100" layers="1 6"/>
  </frames>
</image>

Правила: rasterized у текстовых/векторных слоёв — растровая копия для чтения старыми версиями и для mergedimage.png; неизвестные элементы и атрибуты сохраняются при пересохранении; слои хранятся обрезанными по bounds с координатами x/y (экономия); PNG пишется с iCCP; EXR — с chromaticities рабочего пространства.

4.5 Кэши композитинга

Рисование на активном слое: result(tile) = above ⊕ (layer ⊕_blend below) только для dirty-тайлов мазка — стоимость не зависит от числа слоёв (ключ к критерию «20 слоёв < 16 мс»).

5. Алгоритмы

5.1 Композитинг слоёв с режимами наложения и масками

Обозначения: Cs, αs — цвет и альфа источника (слой, непремультиплицированный), Cb, αb — фон (backdrop), B(Cb, Cs) — функция смешивания режима, m — значение маски (0..1), o — непрозрачность слоя. Эффективная альфа источника: αs' = αs · m · o.

Общая формула (W3C Compositing and Blending Level 1, совместима с PDF/Photoshop):

Cs'  = (1 − αb) · Cs + αb · B(Cb, Cs)          // цвет источника с учётом смешивания с фоном
Co   = αs' · Cs' + αb · (1 − αs') · Cb           // премультиплированный результат (source-over)
αo   = αs' + αb · (1 − αs')

Для прочих операторов Porter–Duff (Fa, Fb — коэффициенты):

co = Fa · αs · Cs' + Fb · αb · Cb, αo = Fa · αs + Fb · αb (премультиплированный выход; для Plus — clamp).

Разделённые режимы B(Cb, Cs) (по каналам, значения 0..1):

Неразделённые (по всем каналам сразу):

Lum(C)      = 0.3·R + 0.59·G + 0.11·B
ClipColor(C): l = Lum(C); n = min(R,G,B); x = max(R,G,B)
              если n < 0: C = l + (C − l)·l / (l − n)
              если x > 1: C = l + (C − l)·(1 − l) / (x − l)
SetLum(C, l) = ClipColor(C + (l − Lum(C)))
Sat(C)      = max(R,G,B) − min(R,G,B)
SetSat(C, s): для упорядоченных Cmax ≥ Cmid ≥ Cmin:
              если Cmax > Cmin: Cmid = (Cmid − Cmin)·s / (Cmax − Cmin); Cmax = s; иначе Cmid = Cmax = 0; Cmin = 0

Hue:        B = SetLum(SetSat(Cs, Sat(Cb)), Lum(Cb))
Saturation: B = SetLum(SetSat(Cb, Sat(Cs)), Lum(Cb))
Color:      B = SetLum(Cs, Lum(Cb))
Luminosity: B = SetLum(Cb, Lum(Cs))

Группы: изолированная группа компонуется в прозрачный буфер (backdrop = 0), затем результат накладывается на фон с режимом/непрозрачностью/маской группы. Pass-through группа: дети компонуются прямо на текущий фон; непрозрачность группы в этом режиме = интерполяция между фоном и результатом (lerp(backdrop, result, o)). Обтравочная маска: αs' = αs · m · o · αbelow, где αbelow — альфа базового слоя. Корректирующий слой: B = f_adj(Cb) (LUT или функция), Cs' = B, αs' = m · o — то есть коррекция смешивается с фоном по маске и непрозрачности.

Псевдокод композитинга одного тайла:

/// Композитинг стека слоёв в один тайл / Composite a layer stack into one tile
fn composite_tile(stack: &[LayerRef], key: TileKey, out: &mut TileF32, clip: Option<&TileF32>) {
    out.clear();                                                   // backdrop = прозрачный / transparent
    for layer in stack.iter().filter(|l| l.visible && l.opacity > 0.0) {
        let src: Cow<TileF32> = match &layer.kind {
            Raster(map)        => map.read_f32(key, layer.offset),         // перевод в f32, учёт смещения
            Text{..}|Vector{..} => layer.rasterized(key),                   // из кэша / from cache
            Adjustment{adj,..} => adj.apply_tile(out),                      // f(backdrop)
            Group{children, pass_through: false, ..} => group_cache_or(|| composite_tile(children, key, &mut tmp, None)),
            Group{children, pass_through: true, ..}  => { composite_pass_through(children, key, out, layer); continue; }
        };
        let mask = layer.mask_tile(key);                                     // Option<&MaskTileF32>
        let base_alpha = layer.clip_to_below.then(|| clip_alpha_below(stack, layer, key));
        blend_into(out, &src, layer.blend, layer.opacity, mask, base_alpha.as_ref());
    }
}

#[inline]
fn blend_pixel(cb: Rgba, cs: Rgba, mode: BlendMode, a_mul: f32) -> Rgba {
    let a_s = cs.a * a_mul;                     // αs' = αs·m·o(·αbelow)
    if a_s <= 0.0 { return cb; }
    let (cs_u, cb_u) = (cs.unpremul(), cb.unpremul());
    let b = if mode.is_separable() { mode.separable(cb_u.rgb, cs_u.rgb) } else { mode.non_separable(cb_u.rgb, cs_u.rgb) };
    let cs_p = (1.0 - cb.a) * cs_u.rgb + cb.a * b;        // Cs'
    let co   = a_s * cs_p + cb.a * (1.0 - a_s) * cb_u.rgb; // премультиплированный / premultiplied
    let ao   = a_s + cb.a * (1.0 - a_s);
    Rgba { r: co.x, g: co.y, b: co.z, a: ao }
}

Реализация: внутренняя точность f32 (SIMD через std::simd/wide, 8 пикселей за раз), для 8-бит документов Normal/Multiply/Screen — специализированные целочисленные пути ((a·b + 127) / 255 через (t + (t >> 8)) >> 8). Тайлы распараллелены через rayon. На GPU (Skia): Porter–Duff и 16 разделённых/неразделённых режимов — SkBlendMode; остальные (Linear Burn, Vivid/Linear/Pin Light, Hard Mix, Subtract, Divide, Darker/Lighter Color, Dissolve) — SkRuntimeEffect (SkSL) с теми же формулами; результат CPU и GPU сверяется снимочными тестами (допуск 1/255).

5.2 Кисть на основе дабов

Входные события (InputSample { pos: Vec2, pressure: f32 (0..1), tilt: Vec2, rotation: f32, t: f64 }) приходят из Qt (QTabletEvent/QPointerEvent) с частотой до 240 Гц в выделенный поток ввода; мышь — нажим 1.0.

Конвейер мазка:

1. Стабилизатор (one-euro фильтр, Casiez et al. 2012) по pos отдельно по x и y; параметры из ползунка «стабилизатор» s∈[0,1]: min_cutoff = lerp(1.5, 0.05, s) Гц, beta = lerp(0.1, 0.001, s), d_cutoff = 1.

pub struct OneEuro { min_cutoff: f32, beta: f32, d_cutoff: f32, x_prev: Option<f32>, dx_prev: f32, t_prev: f64 }
impl OneEuro {
    fn alpha(cutoff: f32, dt: f32) -> f32 { let tau = 1.0 / (2.0 * PI * cutoff); 1.0 / (1.0 + tau / dt) }
    pub fn filter(&mut self, x: f32, t: f64) -> f32 {
        let Some(xp) = self.x_prev else { self.x_prev = Some(x); self.t_prev = t; return x; };
        let dt = ((t - self.t_prev) as f32).max(1e-4);
        let dx = (x - xp) / dt;                                         // скорость / velocity
        let edx = lerp(self.dx_prev, dx, Self::alpha(self.d_cutoff, dt));
        let cutoff = self.min_cutoff + self.beta * edx.abs();           // быстрее движение — меньше запаздывание
        let xh = lerp(xp, x, Self::alpha(cutoff, dt));
        self.x_prev = Some(xh); self.dx_prev = edx; self.t_prev = t; xh
    }
}

Режим «верёвка» (P1): даб ставится, только когда курсор отошёл от последней точки на радиус r_rope.

2. Сглаживание пути: сглаженные точки P₀…Pₙ соединяются сплайном Catmull-Rom (centripetal, α = 0,5) по четвёркам (Pᵢ₋₁, Pᵢ, Pᵢ₊₁, Pᵢ₊₂); сегмент Pᵢ→Pᵢ₊₁ дискретизируется по длине дуги (накопленная длина L сохраняется между сегментами, чтобы интервал не «сбивался» на стыках). Нажим/наклон интерполируются линейно вдоль сегмента.

3. Размещение дабов: интервал spacing = max(0.01, s) · diameter(pressure); даб ставится при L ≥ next, next += spacing. Параметры даба по кривым: d = d_max · curve_size(p), opacity = o · curve_opacity(p), flow = f · curve_flow(p), угол = фиксированный / по направлению / по наклону; разброс (scatter) — смещение по нормали на U(−k, k)·d; джиттер размера/угла.

4. Растеризация даба в буфер мазка (отдельный TileMap на время мазка, та же глубина): для круглой кисти с жёсткостью h:

r   = d / 2;  dist = |p − c| (с учётом эллиптичности и угла: p' = R(−θ)·(p − c) / (1, roundness))
cov = dist ≤ r·h ? 1 : smoothstep(r, r·h, dist)       // мягкая граница / soft edge
cov *= aa(dist, r)                                     // субпиксельное покрытие по площади: clamp(r − dist + 0.5, 0, 1)
value = cov · flow

Для кистей-изображений — сэмплирование маски с билинейной интерполяцией, субпиксельное смещение центра учитывается (нет «дрожания» при медленных мазках). Текстура кисти (P1) умножает value на выборку из текстуры (в координатах холста).

5. Накопление в буфере мазка: два режима — «обычный» (buf = max(buf, value) по альфе: повторные дабы не накапливаются сверх opacity, как кисть Photoshop) и «аэрограф/накопление» (buf = buf + value·(1 − buf)). Цвет дабов в буфере — текущий цвет (премультиплированный на альфу покрытия).

6. Наложение на слой: layer = blend(layer, buf · opacity, mode) только для dirty-тайлов, с учётом выделения (маска выделения умножает альфу) и блокировки альфы (lock alpha: результат альфы = альфа слоя). На экране до завершения мазка показывается above ⊕ (buf ⊕ layer) ⊕ below — слой не трогается; при отпускании — одно применение, одна запись истории.

Ластик = кисть с режимом Destination-out; штамп = кисть, у которой цвет даба берётся из источника (смещение Δ = dst − src, образец со слоя или композита, билинейная выборка при дробном смещении); осветление/затемнение/размытие/резкость/губка = кисть, где value управляет силой локального фильтра, применяемого к пикселям под дабом (выборка из «снимка» слоя до мазка, чтобы фильтр не накапливался многократно за один проход).

Производительность: даб растеризуется только в пересекаемые тайлы (обычно 1–4), буфер мазка и слой — в rayon-задачах; поток ввода не блокируется рендером (очередь событий с таймстемпами; при отставании рендер обрабатывает пачку, не теряя дабы). Цель: 10 000 дабов/с при диаметре 50 px без просадок.

5.3 Заливка (сканлайн flood fill)

/// Заливка с допуском, 4/8-связность, результат — маска покрытия (0/255), затем сглаживание края
/// Scanline flood fill with tolerance; returns coverage mask, then optional edge anti-aliasing
pub fn flood_fill(src: &dyn PixelSource, seed: IVec2, tol: Tolerance, conn8: bool, limit: IRect) -> MaskMap {
    let seed_color = src.get(seed);
    let similar = |p: IVec2| tol.matches(seed_color, src.get(p));   // RGB max-abs / евклид / ΔE в LAB
    let mut mask = MaskMap::new(Depth::U8);
    let mut stack: Vec<(i32, i32, i32, i32)> = vec![(seed.x, seed.x, seed.y, 1), (seed.x, seed.x, seed.y - 1, -1)];
    while let Some((x1, x2, y, dy)) = stack.pop() {
        if y < limit.y0 || y >= limit.y1 { continue; }
        let mut x = x1;
        // расширение влево от x1 / extend left of x1
        if !mask.get(x, y) && similar((x, y).into()) {
            while x > limit.x0 && !mask.get(x - 1, y) && similar((x - 1, y).into()) { x -= 1; }
            if x < x1 { stack.push((x, x1 - 1, y - dy, -dy)); }        // "перелив" назад / U-turn
        }
        let mut start = x;
        while start <= x2 {
            // заполнить сегмент вправо / fill run to the right
            while start < limit.x1 && !mask.get(start, y) && similar((start, y).into()) { mask.set(start, y); start += 1; }
            let run_end = start - 1;
            if run_end >= x { stack.push((x, run_end, y + dy, dy)); }
            if start - 1 > x2 { stack.push((x2 + 1, start - 1, y - dy, -dy)); }
            start += 1;
            while start <= x2 && !similar((start, y).into()) { start += 1; }
            x = start;
            if conn8 && run_end >= x1 - 1 && run_end < x2 + 1 {        // 8-связность: диагональные соседи
                stack.push((run_end.max(x1 - 1), (run_end + 1).min(x2 + 1), y + dy, dy));
            }
        }
    }
    mask
}

• Допуск: Tolerance::Rgb(t) — max(|ΔR|,|ΔG|,|ΔB|,|Δα|) ≤ t; Tolerance::Lab(ΔE) — CIE76 в LAB (быстро) или CIEDE2000 (опция); цвет сравнивается непремультиплированным; прозрачные пиксели сравниваются по альфе.
• «Все слои» — PixelSource = projection, иначе активный слой. «Глобально» — без связности: mask[p] = similar(p) для всего прямоугольника.
• Сглаживание края: маска → blur(0.5 px) → порог-гладкость (значения 0..255 как покрытие) — заливка без «лесенки». Закрытие разрывов (P1): морфологическое закрытие границы не-similar радиусом N перед заливкой.
• Заливка применяется как layer = over(layer, color · mask) (или узор/градиент через маску), с учётом выделения.
• Волшебная палочка: та же функция, результат идёт в Selection с операцией (новое/+/−/∩); «мягкость» (fuzziness, для «По цвету») даёт градиентную маску: cov = clamp(1 − (ΔE − t)/(f), 0, 1).
• Ограничение limit — холст либо объединение bounds слоёв (Alt — без ограничения холстом).

5.4 Быстрое выделение (GrabCut-подобное, P2)

1. Пользователь проводит мазок «объект» (и при необходимости «фон»); начальная тримап: мазок — точно объект, прямоугольник вокруг с полями 20 % — «вероятно фон», остальное — точно фон.
2. Работа на уменьшенной копии (≤ 1 Мпикс; масштаб s), в цветовом пространстве LAB.
3. GMM по 5 компонент для объекта и фона (k-means инициализация, 2 итерации EM на каждом шаге).
4. Граф: узлы — пиксели, рёбра к соседям (8-связность) с весом w = γ · exp(−β · ‖cᵢ − cⱼ‖²) / dist, β = 1 / (2·⟨‖cᵢ − cⱼ‖²⟩), γ = 50; t-рёбра — −log P(c | GMM_fg/bg), точные метки — бесконечные.
5. Min-cut (Boykov–Kolmogorov, crate maxflow/своя реализация), 3–5 итераций «GMM → cut».
6. Уточнение границы на полном разрешении: guided filter (радиус 8, ε = 1e-3) по маске в полосе ±4·s px от границы → мягкая маска; «+/−» мазки добавляют/убирают метки и пересчитывают только затронутую область.

5.5 Трансформации с ресамплингом

Обратное отображение: для каждого пикселя назначения q вычисляем p = M⁻¹·q (аффинная 3×2 или гомография 3×3 с делением на w), сэмплируем источник ядром K:

При уменьшении (масштаб < 1) ядро расширяется в 1/scale раз (предфильтрация, эквивалент area-averaging для Box); для сильных уменьшений — сначала мип-уровни (box ×2 до ближайшей степени двойки), затем выбранное ядро. Сэмплирование — премультиплированных значений (иначе ореолы у прозрачных краёв); результат клампится, для Lanczos/бикубического — опционально «без звона» (clamp к min/max соседей 2×2).

/// Ресамплинг слоя обратным отображением / Resample a layer by inverse mapping
pub fn transform(src: &TileMap, m: &Mat3, kernel: Kernel, dst_rect: IRect, out: &mut TileMap) {
    let inv = m.inverse();
    let (sx, sy) = m.scale_factors();                         // для предфильтра / for prefilter width
    let (kw, kh) = (kernel.radius() / sx.min(1.0), kernel.radius() / sy.min(1.0));
    out.keys_in(dst_rect).par_bridge().for_each(|key| {
        let tile = out.tile_mut_parallel(key);
        for (py, px) in tile.pixels() {
            let q = Vec2::new(px as f32 + 0.5, py as f32 + 0.5);
            let p = inv.apply_point(q);                          // p = M⁻¹·q (с делением на w) / with w-division
            tile.set(px, py, sample(src, p, kernel, kw, kh));    // Σ K(dx)K(dy)·src / Σ K·K
        }
    });
}

Предпросмотр во время перетаскивания — на GPU (Skia drawImage с матрицей, билинейно + мипмапы); финальный ресамплинг — CPU по выбранному ядру (или GPU-шейдер с тем же ядром, P1), одна запись истории.

5.6 Разделяемое размытие по Гауссу и box-blur ×3

Ядро 1D: g(i) = exp(−i² / 2σ²) / Σ, радиус r = ⌈3σ⌉; два прохода (горизонталь, вертикаль) по тайлам с апроном r (читаем соседние тайлы), промежуточный буфер f32. Края: «продление» (clamp) для холста, прозрачность — для слоя (размытие премультиплированных значений, чтобы прозрачные области не темнили).

Для σ ≥ 2.5 (r ≥ 8) — три последовательных box-blur (скользящая сумма, O(1) на пиксель независимо от σ), ширины по Kovesi (2010):

/// Ширины трёх боксов, приближающих гаусс с σ / Box widths approximating a Gaussian of sigma
fn boxes_for_gauss(sigma: f32, n: usize) -> Vec<usize> {
    let w_ideal = (12.0 * sigma * sigma / n as f32 + 1.0).sqrt();
    let mut wl = w_ideal.floor() as usize; if wl % 2 == 0 { wl -= 1; }
    let wu = wl + 2;
    let m_ideal = (12.0 * sigma * sigma - (n * wl * wl + 4 * n * wl + 3 * n) as f32) / (-4.0 * wl as f32 - 4.0);
    let m = m_ideal.round() as usize;
    (0..n).map(|i| if i < m { wl } else { wu }).collect()
}

/// Один проход бокса по строке скользящей суммой / One box pass along a row via running sum
fn box_row(src: &[f32], dst: &mut [f32], r: usize) {
    let n = src.len(); let inv = 1.0 / (2 * r + 1) as f32;
    let mut acc: f32 = src[0] * (r as f32 + 1.0) + src[1..=r.min(n - 1)].iter().sum::<f32>(); // clamp-край
    for i in 0..n {
        let add = src[(i + r + 1).min(n - 1)]; let sub = src[i.saturating_sub(r + 1).max(0)];
        dst[i] = acc * inv; acc += add - sub;
    }
}

Погрешность приближения относительно истинного гаусса < 1 % (3 бокса), визуально неотличимо. Движение (motion blur): усреднение вдоль направления — та же скользящая сумма по повёрнутой решётке (с билинейной выборкой). Радиальное (зум/вращение): N выборок (адаптивно 8–64 по радиусу) вдоль траектории от центра. На GPU (предпросмотр): Skia ImageFilters::blur (сам реализует разделяемый гаусс).

5.7 Нерезкая маска и резкость

blurred = gauss(src, radius)                      // radius — σ в px
diff    = src − blurred
out     = |diff| > threshold/255 ? src + amount · diff : src     // amount 0..5 (0–500 %)

Порог применяется к яркости (Lum), чтобы не усиливать шум в гладких областях; клампинг по каналам; для 16-бит — без клампа выше 1 (сохраняем HDR). «Резкость» = нерезкая маска с radius = 1, amount = 0,5. High pass: out = 0.5 + diff (серый с деталями) — для наложения в режиме Overlay.

5.8 Медианный фильтр (удаление шума, «пыль и царапины»)

Алгоритм Перро–Эбера (Perreault & Hébert, 2007) — O(1) на пиксель: для каждого столбца ведётся гистограмма окна высотой 2r+1; гистограмма ядра = сумма 2r+1 столбцовых гистограмм, обновляемая при сдвиге вправо (добавить столбец справа, убрать слева). Для 8 бит — двухуровневая гистограмма (16 «грубых» + 256 «тонких» корзин), медиана — поиск по грубому уровню, затем по тонкому. 16-бит float — квантование в 12 бит для гистограммы, затем точное значение из окна (select_nth_unstable по 2r+1 ≤ 31 — быстро) — компромисс точности/скорости. Каналы обрабатываются независимо (RGB) или по яркости с переносом цветности (опция «сохранять цвет»). «Пыль и царапины»: out = |src − median| > threshold ? median : src.

5.9 Уровни, кривые, автоуровни через LUT

/// Построение LUT уровней / Build a levels LUT
fn levels_lut(ch: &LevelsChannel) -> Lut {             // in_lo, in_hi, gamma, out_lo, out_hi в 0..1
    Lut::from_fn(|x| {
        let t = ((x - ch.in_lo) / (ch.in_hi - ch.in_lo).max(1e-6)).clamp(0.0, 1.0);
        let g = t.powf(1.0 / ch.gamma);
        ch.out_lo + g * (ch.out_hi - ch.out_lo)
    })
}

• LUT: 256 записей (8 бит) или 4096 с линейной интерполяцией между узлами (16 бит float; значения > 1 — экстраполяция по последнему сегменту). Канал RGB (мастер) применяется после индивидуальных каналов.
• Кривые: точки (x, y) → монотонный кубический сплайн Фрича–Карлсона (нет перелётов) → выборка в LUT; режим «карандаш» — прямая запись LUT с последующим сглаживанием.
• Автоуровни: гистограмма каждого канала (по выделению, если есть), отсечение clip_lo = clip_hi = 0,1 % пикселей с каждой стороны → in_lo, in_hi; автоконтраст — те же пороги, но по яркости (единые для каналов — не меняет цвет); автоцвет — автоуровни + сдвиг средних так, чтобы средний серый (медиана по каналам) стал нейтральным (gamma подбирается бинарным поиском).
• Коррекции применяются к непремультиплированным значениям; в 8-бит с дизерингом (упорядоченный 4×4, амплитуда ½ LSB) против полос.
• Корректирующий слой хранит LUT в кэше, инвалидирует при изменении параметров; стек нескольких LUT-коррекций подряд сворачивается в одну LUT (композиция функций) — экономия на 16-бит.

5.10 Преобразования цветовых пространств

sRGB → линейный:  c ≤ 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055)^2.4
линейный → sRGB:  c ≤ 0.0031308 ? 12.92·c : 1.055·c^(1/2.4) − 0.055
линейный sRGB (D65) → XYZ:  [0.4124 0.3576 0.1805; 0.2126 0.7152 0.0722; 0.0193 0.1192 0.9505] · [R G B]ᵀ
XYZ → LAB (D65: Xn=0.9505, Yn=1.0, Zn=1.089):
   f(t) = t > (6/29)³ ? t^(1/3) : t / (3·(6/29)²) + 4/29
   L = 116·f(Y/Yn) − 16;  a = 500·(f(X/Xn) − f(Y/Yn));  b = 200·(f(Y/Yn) − f(Z/Zn))
ΔE76 = √(ΔL² + Δa² + Δb²);  ΔE2000 — по Sharma et al. (для «точного» допуска)
OKLab/OKLCH (Björn Ottosson) — для круга цвета и интерполяции градиентов (равномернее LAB по оттенку)

• 8-бит ↔︎ линейный: таблицы 256 → f32 и обратная 4096 → u8 с дизерингом.
• Display P3 / Adobe RGB: матрицы RGB→XYZ из профилей (через lcms2: cmsCreateTransform с намерением, BPC), кэшируем преобразование как 3D-LUT 33³ для фильтров и предпросмотра (точность ΔE < 0,5), точный путь — при экспорте.
• Отображение: композит (в пространстве документа) → профиль монитора (из ОС: Windows ICM GetICMProfile, macOS NSScreen.colorSpace, Linux _ICC_PROFILE/colord) → GPU-шейдер с 3D-LUT (Skia SkColorSpace для матричных профилей, свой шейдер для LUT-профилей).
• Политика: «smart» — не трогать байты изображения при открытии (сохраняем встроенный профиль), конверсия только по выбору пользователя; экспорт — встроить профиль документа или преобразовать в sRGB (по умолчанию для JPEG/WebP/GIF — sRGB без профиля, для PNG/TIFF/PSD/PDF — встроить).

5.11 Квантование и дизеринг при экспорте в GIF / PNG-8 / ICO

1. Квантование — октодерево (Gervautz–Purgathofer): вставка пикселей в дерево глубиной 8 по битам RGB, при превышении max_colors (≤ 255 при прозрачности) слияние самых «дешёвых» узлов (минимальная сумма пикселей на уровне с наибольшей глубиной); альтернатива — median cut (опция, лучше для градиентов); для анимации — глобальная палитра по всем кадрам (выборка ≤ 2 Мпикс), локальная — если кадр отклоняется (ΔE_mean > 4).
2. Дизеринг — Флойд–Стайнберг с серпантинным обходом, распределение ошибки 7/16 → (x+1,y), 3/16 → (x−1,y+1), 5/16 → (x,y+1), 1/16 → (x+1,y+1); ошибка в линейном пространстве (меньше артефактов); сила 0–100 %; альтернативы: упорядоченный (Bayer 8×8) для пиксель-арта, без дизеринга.
3. Поиск ближайшего цвета палитры — k-d дерево по RGB (или LAB при «точном» режиме), кэш последних 64.
4. Прозрачность: порог альфы (по умолчанию 128) → индекс прозрачного цвета; для WebP/APNG — полная альфа.
5. Анимация: оптимизация кадров — ограничивающий прямоугольник изменений относительно предыдущего (disposal «не удалять»), неизменённые пиксели внутри прямоугольника → прозрачный индекс (если delta экономит > 10 %); длительность в сотых секунды (GIF) — округление с накоплением ошибки.

fn floyd_steinberg(img: &mut [Vec3], w: usize, h: usize, pal: &Palette, strength: f32) -> Vec<u8> {
    let mut out = vec![0u8; w * h];
    for y in 0..h {
        let ltr = y % 2 == 0;                                                 // серпантин / serpentine
        let xs: Box<dyn Iterator<Item = usize>> = if ltr { Box::new(0..w) } else { Box::new((0..w).rev()) };
        for x in xs {
            let old = img[y * w + x];
            let idx = pal.nearest(old); let new = pal.color(idx); out[y * w + x] = idx as u8;
            let err = (old - new) * strength;
            let dx: isize = if ltr { 1 } else { -1 };
            diffuse(img, w, h, x as isize + dx, y as isize, err * (7.0 / 16.0));
            diffuse(img, w, h, x as isize - dx, y as isize + 1, err * (3.0 / 16.0));
            diffuse(img, w, h, x as isize,      y as isize + 1, err * (5.0 / 16.0));
            diffuse(img, w, h, x as isize + dx, y as isize + 1, err * (1.0 / 16.0));
        }
    }
    out
}

5.12 Undo через diff тайлов

• Каждая команда получает UndoRecorder; первое изменение тайла в рамках команды фиксирует его старый Arc (см. tile_mut): это O(1), без копирования — копируется сам тайл при Arc::make_mut, только если его ещё кто-то держит (история или кэш). Повторные изменения того же тайла в той же команде не фиксируются.
• Undo: для каждой записи (layer, key, old) текущий тайл кладётся в redo_tiles, старый возвращается в карту (None → удаление тайла). Redo — симметрично. Структурные изменения — revert() команд в обратном порядке. Dirty-регион = объединение тайлов → перекомпозитинг и обновление GPU-текстур.
• Память: mem_used считает уникальные Arc (тайл, разделяемый с текущим состоянием, не считается). При превышении лимита: самые старые записи сериализуются на диск (LZ4, в фоне), затем удаляются; панель «История» отражает это (серая «корзина» у записей, которые уже недоступны).
• Длинный мазок = одна запись (все тайлы, которых он коснулся). Фильтр на весь холст 8000×8000 8 бит = до 1024 тайлов × 256 КБ = 256 МБ — допустимо; для 16 бит (512 МБ) — предупреждение при лимите.
• Снимки (snapshots) панели «История» — просто ссылки на Arc-тайлы всех слоёв на момент снимка (O(число тайлов), без копирования).
• Автосохранение каждые 2 с пишет в журнал восстановления те же diff-записи (тайлы в LZ4) + структурные команды в CBOR; после удачного сохранения .mpi журнал обнуляется.

5.13 Рендер на GPU через Skia

• Поверхность холста — SkSurface на GPU-контексте Qt (QRhi → Metal/Vulkan/D3D12/OpenGL через skia-safe gpu::DirectContext); при отсутствии GPU — CPU-растр Skia (тот же код).
• Тайлы projection загружаются как текстуры в атласы 4096×4096 (256 тайлов на атлас, RGBA8 или RGBA16F); dirty-тайлы — updateTexture по прямоугольнику; LRU-вытеснение невидимых; бюджет VRAM 512 МБ (настройка).
• Кадр: canvas.concat(view_matrix) (масштаб, поворот, панорамирование, HiDPI); «шахматка» — SkShader (повтор 16×16, в экранных координатах, не масштабируется); затем видимые тайлы (cull по видимому прямоугольнику в координатах холста) рисуются drawImageRect с SkSamplingOptions: при масштабе < 100 % — mipmap linear (мипы генерирует Skia для атласа — при зуме 1 % 8000×8000 не читается целиком), 100 % — nearest, > 100 % — nearest + при ≥ 800 % наложение пиксельной сетки (линии 1 px через drawPath).
• Активный мазок: буфер мазка отрисовывается отдельной текстурой поверх below, затем above — без перекомпозитинга CPU (три слоя текстур: below / stroke+layer / above; на CPU считаем только dirty-тайлы слоя+мазка).
• Оверлеи (выделение-«муравьи», направляющие, рамки трансформации, курсор кисти) — векторный слой Skia поверх, анимация муравьёв — смещение dash phase 60 fps без перерисовки тайлов.
• Цветовое управление: поверхность с SkColorSpace документа → при презентации Skia преобразует к пространству окна (SkSurfaceProps + SkColorSpace экрана); для LUT-профилей — финальный проход своим SkSL.
• Предпросмотр фильтров на GPU: SkImageFilters (blur, color matrix, LUT через SkRuntimeShader) на видимую область с запасом 64 px; окончательный расчёт — CPU-алгоритм (единая точность результата), расхождение допускается только в предпросмотре.
• Кадр ≤ 16 мс: измеряем frame_time, при превышении — понижаем качество предпросмотра (билинейный вместо Lanczos, предпросмотр в половинном разрешении).

5.14 Вид: масштаб и поворот холста

Матрица вида V = T(center_screen) · S(zoom · dpr) · R(θ) · T(−center_canvas); все координаты событий переводятся V⁻¹ в пространство холста (дробные — кисть рисует с субпиксельной точностью). Зум к курсору: center_canvas фиксируется под курсором (c' = c + (p_canvas − c)·(1 − z_old/z_new)). Ступени зума: 1, 2, 3, 4, 5, 6.25, 8.33, 12.5, 16.7, 25, 33.3, 50, 66.7, 100, 150, 200, 300, 400, 600, 800, 1200, 1600, 2400, 3200, 4800, 6400 %; колесо с Ctrl — плавно (×1.1 на тик). Поворот — любой угол, привязка к 15° при Shift, индикатор угла в строке состояния; линейки при повороте скрываются (как в Krita). Отражение вида — S(−1, 1). Пиксельная сетка/направляющие рисуются в экранных координатах после преобразования точек (1 px линии).

5.15 Чтение PSD и ORA, запись PSD (базово)

PSD (Adobe Photoshop File Format Specification; PSB — те же структуры с 64-бит длинами, P1):

Чтение каналов: PackBits построчно (таблица длин строк), ZIP через flate2; 16-бит — big-endian u16 → f16 линейный (PSD 16-бит хранит гамма-кодированные значения → линеаризуем через профиль), 32-бит — float линейный; CMYK/Lab → RGB через lcms2 (встроенный профиль или стандартный «U.S. Web Coated SWOP»/Lab D50); Indexed/Bitmap/Duotone — разворачиваем в RGB. Слои с «clipping» → clip_to_below; lsct — восстанавливаем дерево групп (стек: «закрытая/открытая папка» начинает группу, «bounding divider» завершает). Режимы без аналога (smud — Dissolve есть; fsub/fdiv — Subtract/Divide есть) — все 27 отображаются.

Запись PSD (базово): RGB 8/16 бит, растровые слои (текст/вектор/коррекции — растрируются, с сохранением имени), группы (lsct), маски, режимы, непрозрачность, клиппинг, luni-имена, lyid, ICC (1039), DPI (1005), композит в Image Data (чтобы файл открывался везде), сжатие RLE. Файл > 2 ГБ или сторона > 30 000 — PSB (P1).

ORA (OpenRaster, спецификация freedesktop):

mimetype             image/openraster
stack.xml            <image w h xres yres> <stack> <layer src opacity visibility composite-op x y name/> …
data/*.png           слои (PNG)
mergedimage.png      композит
Thumbnails/thumbnail.png

composite-op: svg:src-over, svg:multiply, svg:screen, svg:overlay, svg:darken, svg:lighten, svg:color-dodge, svg:color-burn, svg:hard-light, svg:soft-light, svg:difference, svg:color, svg:luminosity, svg:hue, svg:saturation, svg:plus, svg:dst-in, svg:dst-out, svg:src-atop, svg:dst-atop ↔︎ наши режимы один-в-один; вложенные <stack> — группы (isolation="isolate|auto" → pass-through), opacity, visibility, x/y; расширения .mpi при записи ORA теряются (маски — применяются или в data/ отдельным PNG с атрибутом mask — не стандарт; пишем применёнными), предупреждение при экспорте.

XCF (GIMP, чтение): версии до 12, слои, группы, маски, режимы (legacy и default), свойства, 8/16/32 бит, precision; аналогично PSD — таблица соответствия режимов, непереносимое — предупреждение.

5.16 Снимки экрана — платформенные API

Общий сценарий: capture(target: Area|Window|Screen, delay) -> Frame { pixels, scale, color_profile, cursor? }; наложение выбора области — отдельное окно Qt Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint на каждом экране с предварительно снятым кадром (так область выбирается по «замороженному» экрану, как в Snipping Tool), на Wayland — только через портал (кадр экрана → наше окно с кадром). Глобальная клавиша: Windows — RegisterHotKey (в Hub-брокере), macOS — CGEventTap/Carbon RegisterEventHotKey (нужны права «Универсальный доступ» только для перехвата — используем Carbon без них), Linux — org.freedesktop.portal.GlobalShortcuts (Wayland), XGrabKey (X11). «Снимок» живёт в Hub-брокере (всегда запущен в трее по желанию) и открывает лёгкое окно мини-редактора; полный Paint — по кнопке.

5.17 Градиенты, текст и фигуры

• Градиент: параметризация t(p) — линейный: t = ((p − a)·(b − a)) / |b − a|²; радиальный: t = |p − c| / r; конический: t = atan2(p − c)/2π; отражённый: t = |2·lin − 1|; ромбовидный: max(|dx|, |dy|) / r; режим повтора (clamp/repeat/reflect); цвет = интерполяция стопов в выбранном пространстве (sRGB / линейный / OKLab — по умолчанию OKLab), стопы прозрачности отдельно; дизеринг (синий шум 64×64) против полос в 8 бит; заливка через выделение; на GPU — Skia Shader::linear_gradient для предпросмотра, CPU — финал.
• Текстовый слой: TextModel (абзацы, прогоны, стили) → text-layout (шейпинг HarfBuzz, переносы, bidi) → глифы → растрирование Skia в кэш-TileMap (сглаживание серое; субпиксельное — только на непрозрачном фоне), трансформация слоя — аффинная (растр перерисовывается из векторных контуров — без потери качества); обводка — SkPaint::Stroke вторым проходом под заливкой.
• Векторный слой: Scene из Draw (узлы: Path с заливкой/обводкой, стрелки как маркеры); растрирование — Skia в кэш; редактирование узлов — инструментом Draw в режиме Paint (общая панель свойств фигуры); «Растрировать» переводит слой в Raster и чистит модель; экспорт SVG — только векторные/текстовые слои.

5.18 Прочие фильтры (сводно)

6. MeridianScript API

Пространство имён paint в MeridianScript (QuickJS-ng, TypeScript-типы в meridian-script/types/paint.d.ts). Все тяжёлые операции асинхронны (Promise), выполняются в ядре с отменой через AbortSignal; доступ к пикселям — через типизированные массивы (копия региона, без прямого указателя в тайлы).

declare namespace paint {
  function activeImage(): Image | null;
  function images(): Image[];
  function newImage(opts: NewImageOptions): Image;
  function open(path: string, opts?: { asLayersInto?: Image; colorPolicy?: "keep" | "convert" | "ignore" }): Promise<Image>;
  function fromClipboard(): Promise<Image | null>;
  function screenshot(opts: { target: "area" | "window" | "screen"; delayMs?: number; cursor?: boolean; windowTitle?: string }): Promise<Image>;
  const brushes: BrushLibrary;            // галерея кистей / brush gallery
  const palettes: PaletteLibrary;
  const ui: PaintUi;                      // диалоги параметров, прогресс, панели (общий Shell API)
}

interface NewImageOptions { width: number; height: number; dpi?: number; depth?: "u8" | "f16";
  colorSpace?: "sRGB" | "DisplayP3" | "AdobeRGB" | "linear-sRGB" | { icc: ArrayBuffer }; background?: Color | "transparent"; }

interface Image {
  readonly id: string; readonly path: string | null; readonly modified: boolean;
  width: number; height: number; dpi: number; readonly depth: "u8" | "f16"; readonly colorSpace: ColorSpaceInfo;
  readonly layers: LayerList;                       // корневая группа / root group
  activeLayer: Layer; selection: Selection; readonly history: History; readonly frames: FrameList;
  guides: Guide[]; grid: GridSettings; meta: DocMeta;

  resize(w: number, h: number, opts?: { method?: Interp; keepDpi?: boolean }): Promise<void>;
  resizeCanvas(w: number, h: number, anchor?: Anchor, fill?: Color | "transparent"): void;
  rotate(deg: number, opts?: { expand?: boolean; method?: Interp }): Promise<void>;
  flip(axis: "h" | "v"): void;
  crop(rect: Rect): void;  trim(mode?: "transparent" | "color"): void;
  flatten(): Layer;  mergeVisible(): Layer;
  convertDepth(depth: "u8" | "f16", dither?: boolean): Promise<void>;
  convertProfile(target: ColorSpaceInfo, intent?: Intent, bpc?: boolean): Promise<void>;
  composite(rect?: Rect): Promise<Bitmap>;          // плоский результат / flattened result
  save(): Promise<void>;  saveAs(path: string): Promise<void>;
  export(path: string, opts?: ExportOptions): Promise<{ bytes: number }>;
  toBlob(format: ExportFormat, opts?: ExportOptions): Promise<Uint8Array>;
  close(discard?: boolean): void;
}

type Interp = "nearest" | "bilinear" | "bicubic" | "lanczos3" | "box" | "mitchell";
type BlendMode = "normal" | "dissolve" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "colorDodge" | "colorBurn"
  | "hardLight" | "softLight" | "difference" | "exclusion" | "linearDodge" | "linearBurn" | "vividLight" | "linearLight"
  | "pinLight" | "hardMix" | "subtract" | "divide" | "darkerColor" | "lighterColor" | "hue" | "saturation" | "color"
  | "luminosity" | "clear" | "source" | "destination" | "srcIn" | "dstIn" | "srcOut" | "dstOut" | "srcAtop" | "dstAtop" | "xor" | "plus";

interface LayerList extends Iterable<Layer> {
  readonly length: number; at(i: number): Layer; byName(name: string): Layer | null; byId(id: string): Layer | null;
  add(kind: "raster", opts?: { name?: string; index?: number }): RasterLayer;
  addText(text: string, opts?: TextLayerOptions): TextLayer;
  addVector(opts?: { name?: string }): VectorLayer;
  addAdjustment(adj: AdjustmentSpec, opts?: { name?: string; clip?: boolean }): AdjustmentLayer;
  addGroup(name?: string, children?: Layer[]): GroupLayer;
  remove(layer: Layer): void;  move(layer: Layer, index: number, parent?: GroupLayer): void;
}

interface Layer {
  readonly id: string; readonly kind: "raster" | "text" | "vector" | "adjustment" | "group";
  name: string; visible: boolean; opacity: number; blendMode: BlendMode; locks: Locks; colorTag: ColorTag | null;
  readonly parent: GroupLayer | null; readonly bounds: Rect | null; offset: Point; altText: string | null;
  mask: Mask | null;  clipToBelow: boolean;
  addMask(from?: "selection" | "alpha" | "white" | "black" | Bitmap): Mask;
  duplicate(): Layer;  mergeDown(): Layer;  rasterize(): RasterLayer;
  move(dx: number, dy: number): void;
  transform(m: Matrix, opts?: { method?: Interp }): Promise<void>;
  applyFilter(name: FilterName, params?: object, opts?: { selectionOnly?: boolean }): Promise<void>;
  adjust(adj: AdjustmentSpec): Promise<void>;
}

interface RasterLayer extends Layer {
  getPixels(rect: Rect): PixelBuffer;               // копия, непремультиплированные / copy, straight alpha
  putPixels(rect: Rect, buf: PixelBuffer): void;     // одна запись истории / one history entry
  getPixel(x: number, y: number): Color;  setPixel(x: number, y: number, c: Color): void;
  fill(color: Color | Gradient | Pattern, opts?: { selectionOnly?: boolean; mode?: BlendMode; opacity?: number }): void;
  floodFill(x: number, y: number, color: Color, opts?: { tolerance?: number; space?: "rgb" | "lab"; conn8?: boolean; allLayers?: boolean; global?: boolean }): void;
  stroke(points: StrokePoint[], brush: BrushSpec, color: Color): Promise<void>;  // программный мазок / programmatic stroke
  clear(rect?: Rect): void;
}
interface PixelBuffer { width: number; height: number; depth: "u8" | "f16"; data: Uint8ClampedArray | Float32Array; }
interface StrokePoint { x: number; y: number; pressure?: number; tiltX?: number; tiltY?: number; t?: number; }

interface TextLayer extends Layer { text: string; font: FontSpec; color: Color; align: "left" | "center" | "right" | "justify"; box: Rect | null; lineHeight: number; stroke?: { color: Color; width: number }; }
interface VectorLayer extends Layer { readonly shapes: ShapeList; addRect(r: Rect, style?: ShapeStyle): Shape; addEllipse(r: Rect, style?: ShapeStyle): Shape; addLine(a: Point, b: Point, style?: ShapeStyle & { arrowEnd?: ArrowKind; arrowStart?: ArrowKind }): Shape; addPath(svgPathData: string, style?: ShapeStyle): Shape; importSvg(svg: string): void; }
interface AdjustmentLayer extends Layer { params: AdjustmentSpec; }
interface GroupLayer extends Layer { readonly children: LayerList; passThrough: boolean; }

type AdjustmentSpec =
  | { type: "brightnessContrast"; brightness: number; contrast: number; legacy?: boolean }
  | { type: "levels"; channel?: "rgb" | "r" | "g" | "b" | "a"; inLow: number; gamma: number; inHigh: number; outLow?: number; outHigh?: number }
  | { type: "curves"; channel?: "rgb" | "r" | "g" | "b"; points: [number, number][]; spline?: "monotone" | "linear" }
  | { type: "colorBalance"; shadows?: [number, number, number]; midtones?: [number, number, number]; highlights?: [number, number, number]; preserveLuminosity?: boolean }
  | { type: "hueSaturation"; hue: number; saturation: number; lightness: number; range?: "master" | "reds" | "yellows" | "greens" | "cyans" | "blues" | "magentas"; colorize?: boolean }
  | { type: "desaturate"; method?: "luminosity" | "lightness" | "average" | "max" | { weights: number[] } }
  | { type: "invert" } | { type: "posterize"; levels: number } | { type: "threshold"; level: number }
  | { type: "autoLevels"; clip?: number } | { type: "autoContrast" } | { type: "autoColor" };

type FilterName = "gaussianBlur" | "motionBlur" | "radialBlur" | "boxBlur" | "unsharpMask" | "sharpen" | "highPass"
  | "addNoise" | "median" | "dustScratches" | "pixelate" | "oilPaint" | "emboss" | "edges" | "vignette" | "wave" | "ripple"
  | "twirl" | "spherize" | "polar" | "offset" | "customKernel" | "minimum" | "maximum" | "clouds" | "perlin" | string /* скриптовые */;

interface Selection {
  readonly isEmpty: boolean; readonly bounds: Rect | null;
  all(): void; none(): void; invert(): void;
  rect(r: Rect, op?: SelOp): void; ellipse(r: Rect, op?: SelOp): void; polygon(pts: Point[], op?: SelOp): void;
  magicWand(x: number, y: number, opts?: { tolerance?: number; space?: "rgb" | "lab"; conn8?: boolean; allLayers?: boolean; global?: boolean }, op?: SelOp): void;
  byColor(color: Color, opts?: { tolerance?: number; fuzziness?: number }, op?: SelOp): void;
  fromMask(mask: Bitmap | Mask, op?: SelOp): void;  fromLayerAlpha(layer: Layer, op?: SelOp): void;
  feather(radius: number): void; grow(px: number): void; shrink(px: number): void; smooth(radius: number): void; border(width: number): void;
  stroke(opts: { width: number; color: Color; position?: "inside" | "center" | "outside"; layer?: RasterLayer }): void;
  fill(color: Color | Gradient | Pattern, layer?: RasterLayer): void;
  toMask(): Bitmap;  save(name: string): void;  load(name: string, op?: SelOp): void;
}
type SelOp = "replace" | "add" | "subtract" | "intersect";

declare namespace paint.filters {         // фильтры как функции над Bitmap (вне документа) / filters as pure functions over bitmaps
  function gaussianBlur(src: Bitmap, sigma: number): Promise<Bitmap>;
  function unsharpMask(src: Bitmap, p: { amount: number; radius: number; threshold?: number }): Promise<Bitmap>;
  function median(src: Bitmap, radius: number): Promise<Bitmap>;
  function resize(src: Bitmap, w: number, h: number, method?: Interp): Promise<Bitmap>;
  function quantize(src: Bitmap, colors: number, opts?: { dither?: "floydSteinberg" | "ordered" | "none"; method?: "octree" | "medianCut" }): Promise<IndexedBitmap>;
  function convertColorSpace(src: Bitmap, to: ColorSpaceInfo, intent?: Intent): Promise<Bitmap>;
  function register(name: string, fn: (src: PixelBuffer, params: object, ctx: FilterContext) => PixelBuffer | Promise<PixelBuffer>, ui?: ParamSchema): void; // свой фильтр в меню / custom filter in menu
}

Примеры:

// 1. Пакетная обработка папки: уменьшить до 1600 px по ширине, водяной знак, экспорт в WebP
// 1. Batch: resize to 1600 px wide, watermark, export WebP
import { fs, path } from "meridian/host";
const dir = await paint.ui.pickFolder("Папка с фотографиями");
for (const file of await fs.list(dir, { ext: ["jpg", "png", "heic"] })) {
  const img = await paint.open(file);
  const k = 1600 / img.width;
  await img.resize(1600, Math.round(img.height * k), { method: "lanczos3" });
  const wm = img.layers.addText("© Meridian", { font: { family: "Inter", size: 24, weight: 600 }, color: "#FFFFFFB3" });
  wm.move(img.width - wm.bounds!.width - 24, img.height - wm.bounds!.height - 24);
  wm.blendMode = "overlay";
  await img.export(path.join(dir, "web", path.stem(file) + ".webp"), { format: "webp", quality: 82, metadata: "strip", profile: "sRGB" });
  img.close(true);
}

// 2. Свой фильтр «Сепия с зерном» в меню Фильтры
// 2. Custom "Sepia + grain" filter in the Filters menu
paint.filters.register("sepiaGrain", async (src, { strength = 0.8, grain = 12 }, ctx) => {
  const out = ctx.clone(src);
  const d = out.data as Uint8ClampedArray; const rnd = ctx.random(ctx.seed);
  for (let i = 0; i < d.length; i += 4) {
    const [r, g, b] = [d[i], d[i + 1], d[i + 2]];
    const sr = 0.393 * r + 0.769 * g + 0.189 * b, sg = 0.349 * r + 0.686 * g + 0.168 * b, sb = 0.272 * r + 0.534 * g + 0.131 * b;
    const n = (rnd() - 0.5) * grain;
    d[i] = r + (sr - r) * strength + n; d[i + 1] = g + (sg - g) * strength + n; d[i + 2] = b + (sb - b) * strength + n;
  }
  return out;
}, { strength: { type: "slider", min: 0, max: 1, step: 0.01, default: 0.8, label: "Сила" }, grain: { type: "slider", min: 0, max: 64, default: 12, label: "Зерно" } });

// 3. Скриншот окна каждые 10 минут в Notes (журнал работы)
// 3. Window screenshot every 10 minutes into Notes (work log)
import { notes } from "meridian/apps";
setInterval(async () => {
  const shot = await paint.screenshot({ target: "screen", cursor: false });
  const png = await shot.toBlob("png");
  await notes.append("Журнал", { image: png, caption: new Date().toLocaleString() });
  shot.close(true);
}, 10 * 60 * 1000);

// 4. Выделить фон палочкой, инвертировать, вырезать объект на новый слой с растушёвкой
const img = paint.activeImage()!; const bg = img.activeLayer as RasterLayer;
img.selection.magicWand(2, 2, { tolerance: 24, space: "lab", conn8: true });
img.selection.invert(); img.selection.feather(1.5);
const cut = img.layers.add("raster", { name: "Объект" });
cut.putPixels(img.selection.bounds!, bg.getPixels(img.selection.bounds!));   // маска применяется автоматически / mask auto-applied
cut.addMask("selection");

Запись действий (макрорекордер) генерирует такой же код: каждое действие интерфейса имеет скриптовый эквивалент (paint.ui.record()), что служит и регрессионными тестами.

7. Форматы

Метаданные: EXIF/XMP/IPTC — чтение через kamadak-exif/свой XMP-парсер, хранение «как есть» в meta.xml, запись обратно при экспорте с правкой ориентации (всегда 1 после авто-поворота), DPI, ICC; опция «удалить геопозицию» и «удалить всё» в экспорте. Приоритет: PNG/JPEG/WebP/GIF/BMP/TIFF/ICO/ORA/.mpi/PSD(чтение)/ буфер — P0; XCF, HEIC, AVIF, SVG, RAW, PDF-импорт, PSD-запись — P1; JPEG XL, DDS, PSB — P1/P2.

8. Горячие клавиши

Схема по умолчанию — знакомая пользователям Photoshop/Paint.NET (на macOS Ctrl → ⌘, Alt → ⌥); схемы «GIMP», «Krita» и своя — в настройках. Полный список редактируется в «Параметры → Клавиши».

Примечание: конфликты, отмеченные стрелкой, разрешены в пользу привычки Photoshop; окончательная таблица фиксируется в docs/shell/keymap.md (общий реестр клавиш пакета).

9. Критерии готовности

10. Риски

11. Вопросы к библии

1. Инструмент «Снимок» и просмотр изображений в Free. Paint целиком — в Home (раздел 9.1). Предлагается выделить «Снимок экрана с пометками» и просмотр/конвертацию изображений (без слоёв) в Free как Feature::PaintSnip и Feature::PaintView: это точка входа для продаж Home и привычная системная функция.
2. Движок управления цветом. В стеке (раздел 4) не назван ICC-движок; Paint, PDF и Print нуждаются в общем: предлагается lcms2 (MIT) как часть Meridian Render/Codecs (kernel/crates/meridian-color/).
3. Глубина 32 бит float. Не планируется в Paint 1.0 (только 8 и 16 float); если HDR-рабочие процессы (EXR, HDR-скриншоты Windows) станут приоритетом — потребуется решение владельца.
4. Расширение .mpi совпадает с проприетарными расширениями некоторых программ (например, MapInfo); при регистрации ассоциаций файлов стоит это учесть (не блокер).
5. Общий реестр горячих клавиш (docs/shell/keymap.md) и общий диалог экспорта изображений для всех приложений (Slides/Draw экспортируют PNG/SVG тем же диалогом PT-12) — предлагается закрепить в Meridian Shell.