reedach-server 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dima Faller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE.md

@@ -0,0 +1,26 @@
+# Источники и сторонние лицензии
+
+## Словарь правил
+
+Правила и формулировки подсказок в `packages/core/src/rules.js` написаны для проекта
+самостоятельно. Идеи взяты из открытых статей об информационном стиле: Максим Ильяхов,
+Бюро Горбунова и другие авторы. Тексты статей в проект не копировались.
+
+Проект не связан с сервисом «Главред» и его авторами и не заменяет профессиональную редактуру.
+
+## Сторонние данные и программы
+
+Ядро (`packages/core`) не содержит сторонних данных и зависимостей.
+
+Сервер (`packages/server`) использует их как зависимости, не включая в этот репозиторий:
+
+| Компонент | Лицензия | Источник |
+|---|---|---|
+| Az.js — морфологический анализ | MIT | https://github.com/deNULL/Az.js |
+| Словари Az.js — данные OpenCorpora, сборка pymorphy2 | CC BY-SA | http://opencorpora.org |
+| dictionary-ru — словарь hunspell, © 1997–2008 Alexander I. Lebedev | BSD-3-Clause | https://github.com/wooorm/dictionaries |
+| dictionary-en — словарь hunspell на основе SCOWL | MIT AND BSD | https://github.com/wooorm/dictionaries |
+| hunspell — проверка орфографии, запускается как отдельная программа | GPL-2.0 / LGPL-2.1 / MPL-1.1 на выбор | https://hunspell.github.io |
+
+Словари OpenCorpora используются без изменений. Изменённые словари, если появятся,
+будут распространяться под той же лицензией CC BY-SA с указанием источника.

package/README.md

@@ -1,3 +1,126 @@
-# Temporary Holding Version
+# reedach-server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Сервер Reedach: орфография (hunspell), морфология (Az.js со словарями OpenCorpora) и
+подсказки по стилю из ядра `reedach` — одним запросом. Работает на вашем сервере,
+тексты никуда не уходят, не сохраняются и не пишутся в журнал.
+
+Подключить можно двумя способами:
+
+- **библиотекой** — вызывать `check()` прямо в своём Node-приложении, без отдельного сервиса;
+- **по HTTP** — запустить Docker-образ и отправлять запросы с сайта.
+
+Для орфографии нужна программа `hunspell` (в Alpine: `apk add hunspell`, в Debian и
+Ubuntu: `apt install hunspell`). В Docker-образе она уже есть.
+
+## Библиотекой
+
+```bash
+npm i reedach-server
+```
+
+```js
+import {check} from 'reedach-server';
+
+const {issues} = await check({
+  markdown: 'В настоящее время мы осуществляем доставку.',
+  ignore: ['Glaskraft'],          // слова автора: формы тоже принимаются
+  disable: ['intensifiers'],      // выключить правило по id или целую категорию
+});
+```
+
+## По HTTP
+
+```bash
+docker run -d -p 3000:3000 -e REEDACH_KEYS="длинный-ключ-сайта=https://ваш-сайт.ru; ключ-для-сервера-сайта" ghcr.io/dimafaller-en/reedach
+```
+
+Образ собран для amd64 и arm64. Собрать его самому из исходников: `docker build -t reedach .`
+в корне [репозитория](https://github.com/dimafaller-en/reedach).
+
+Без ключа сервер не запускается.
+
+### Ключи
+
+`REEDACH_KEYS` — список ключей через `;`. Каждый ключ не короче 16 символов. После `=`
+через запятую перечисляются сайты, со страниц которых этот ключ можно использовать
+прямо из браузера.
+
+- **Ключ с сайтами** работает со страниц этих сайтов и с любого сервера.
+- **Ключ без сайтов** работает только с сервера: браузер с ним получит отказ.
+
+Ключ в коде страницы виден любому посетителю, секретом он не является. Чужой сайт его
+использовать не сможет, но скрипт вне браузера сможет, а сдержат его только лимиты.
+Надёжнее отправлять запросы через сервер своего сайта и не открывать Reedach в интернет.
+
+### Запросы
+
+Ключ передаётся в заголовке `Authorization: Bearer <ключ>`, тело запроса — JSON.
+
+**`POST /v1/check`** — проверить текст. Передайте одно из трёх:
+
+| Поле | Что это | Куда указывают `start` и `end` |
+|---|---|---|
+| `markdown` | Markdown-текст | в исходный текст |
+| `text` | обычный текст, абзацы через пустую строку | в исходный текст |
+| `blocks` | `[{text, kind}]`, где `kind` — `p`, `li` или `h` | в текст блока номер `block` |
+
+Необязательные поля:
+
+- `ignore` — слова автора;
+- `disable` — id правил или категории, которые нужно выключить;
+- `checks` — какие проверки запускать: `spelling`, `morph`, `style` (по умолчанию все).
+
+Ответ:
+
+```json
+{"issues": [
+  {"start": 0, "end": 17, "id": "time-parasite-start", "category": "time", "label": "Паразит времени",
+   "message": "Вступление о нынешнем времени ничего не добавляет к предложению.", "fix": "…"},
+  {"start": 46, "end": 52, "id": "spelling", "category": "spelling", "label": "Орфография",
+   "word": "превет", "suggestions": ["привет", "…"], "message": "…", "fix": "…"}
+]}
+```
+
+Подбор вариантов исправления медленный, примерно 0,3 секунды на слово. Поэтому варианты
+приходят сразу только для первых десяти ошибок, а на всё отводится не больше трёх секунд.
+У остальных ошибок `suggestions: null`: варианты можно запросить отдельно, когда автор
+нажмёт на слово.
+
+**`POST /v1/suggest`** — `{"words": ["превет"]}` → `{"suggestions": {"превет": ["привет", …]}}`,
+до 20 слов за раз.
+
+**`GET /v1/rules`** — все правила с категориями и объяснениями, например для страницы
+настроек «какие проверки включены».
+
+**`GET /health`** — проверка, что сервер работает. Ключ не нужен.
+
+Ошибки приходят в виде `{"error": {"code": "…", "message": "…"}}`: 401 — нет ключа,
+403 — ключ не для этого сайта, 413 — слишком большой текст, 422 — неверные поля,
+503 — сервер занят (в заголовке `Retry-After` указано, через сколько секунд повторить).
+
+### Настройки
+
+| Переменная | По умолчанию | Что задаёт |
+|---|---|---|
+| `REEDACH_KEYS` | — (обязательно) | ключи доступа |
+| `PORT` | `3000` | порт |
+| `HOST` | `0.0.0.0` | адрес |
+| `REEDACH_MAX_BYTES` | `1000000` | максимальный размер запроса |
+| `REEDACH_CONCURRENCY` | `2` | сколько проверок идёт одновременно |
+| `REEDACH_QUEUE` | `20` | сколько запросов может ждать; остальные получат 503 |
+| `REEDACH_DEMO` | — | `1` — показывать страницу-пример по адресу `/demo/` |
+
+## Как устроена орфография
+
+Ошибки ищет короткий запуск `hunspell -l` на каждый запрос: это быстро, тысячи слов за
+доли секунды. Варианты подбирает один постоянно запущенный `hunspell -a`:
+
+- в него уходят только слова из букв, каждое отдельной строкой со служебным знаком в
+  начале, поэтому никакой текст не станет командой hunspell;
+- слова автора отсеиваются в Node и в hunspell не добавляются, поэтому между запросами
+  ничего не запоминается;
+- слова идут по одному, и ответы разных запросов не перепутаются;
+- зависший процесс убивается и запускается заново, а после 2000 слов процесс
+  перезапускается в любом случае.
+
+MIT, © 2026 Дима Фаллер. Сторонние словари и программы — в NOTICE.md.

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "reedach-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Сервер Reedach: орфография (hunspell), морфология (Az.js + OpenCorpora) и подсказки по стилю для русского текста — библиотекой или по HTTP",
+  "license": "MIT",
+  "author": "Dima Faller <dima@dimafaller.ru>",
+  "homepage": "https://github.com/dimafaller-en/reedach#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dimafaller-en/reedach.git",
+    "directory": "packages/server"
+  },
+  "bugs": "https://github.com/dimafaller-en/reedach/issues",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "bin": {
+    "reedach-server": "./src/cli.mjs"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    "NOTICE.md"
+  ],
+  "keywords": [
+    "russian",
+    "русский",
+    "spelling",
+    "hunspell",
+    "morphology",
+    "style",
+    "linter",
+    "api"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "az": "0.2.3",
+    "dictionary-en": "4.0.0",
+    "dictionary-ru": "3.0.0",
+    "reedach": "0.1.0"
+  },
+  "peerDependencies": {
+    "reedach-widget": "^0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "reedach-widget": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "start": "node src/cli.mjs",
+    "test": "node --test test/*.test.mjs"
+  }
+}

package/src/check.mjs

@@ -0,0 +1,55 @@
+import {checkStyle,sourceBlocks,textBlocks,mergeIssues,RULES,BUILTIN,CATEGORIES} from 'reedach';
+import {morphCheck,MORPH_RULES} from './morph.mjs';
+import {words,known,misspelled,Suggester} from './spell.mjs';
+// One check = spelling (hunspell) + morphology (Az.js) + dictionary style hints (reedach core), merged into one list.
+export const CHECKS=['spelling','morph','style'];
+const LIMITS={blocks:5000,blockChars:20000,suggestWords:10,suggestBudget:3000};
+const bad=message=>Object.assign(new Error(message),{status:422,code:'validation'});
+let shared=null;
+const suggester=()=>shared??=new Suggester();
+
+// Blocks from the caller: every UTF-16 unit keeps its own offset (emoji take two).
+const identity=b=>({text:b.text,kind:['h','li'].includes(b.kind)?b.kind:'p',map:Array.from({length:b.text.length},(_,i)=>i)});
+
+// input: {markdown | text | blocks:[{text,kind}], ignore:[own words], disable:[rule ids or categories], checks:[...]}
+// Markdown and text hints point into the source string; block hints carry `block` and point into that block's text.
+export async function check(input,{suggester:sg=suggester(),limits={}}={}){
+ const lim={...LIMITS,...limits},{markdown,text,blocks:raw}=input??{};
+ let blocks,blocksInput=false;
+ if(typeof markdown==='string')blocks=sourceBlocks(markdown);
+ else if(typeof text==='string')blocks=textBlocks(text);
+ else if(Array.isArray(raw)){blocksInput=true;if(raw.length>lim.blocks)throw bad('Слишком много блоков');blocks=raw.map(b=>{if(typeof b?.text!=='string')throw bad('У каждого блока должен быть текст');if(b.text.length>lim.blockChars)throw bad('Слишком длинный блок');return identity(b);});}
+ else throw bad('Передайте markdown, text или blocks');
+ const list=(v,name)=>{if(v==null)return [];if(!Array.isArray(v)||v.some(x=>typeof x!=='string'))throw bad('Поле '+name+' должно быть списком строк');return v.slice(0,5000);};
+ const ignore=list(input.ignore,'ignore'),disable=new Set(list(input.disable,'disable')),checks=new Set(input.checks==null?CHECKS:list(input.checks,'checks'));
+ const [spelling,morph]=await Promise.all([
+  checks.has('spelling')?findSpelling(blocks,ignore,sg,lim):[],
+  checks.has('morph')?morphCheck(blocks).catch(()=>[]):[],
+ ]);
+ const local=checks.has('style')?checkStyle(blocks):[];
+ const issues=mergeIssues(blocks,{spelling,style:morph,local}).filter(it=>!disable.has(it.id)&&!disable.has(it.category));
+ return {issues:blocksInput?issues.sort((a,b)=>a.block-b.block||a.start-b.start):issues.map(({block,...it})=>it)};
+}
+
+// Misspelled words minus own words; suggestions for the first few within a time budget, the rest get null (ask /v1/suggest).
+async function findSpelling(blocks,ignore,sg,lim){
+ const found=(await misspelled(words(blocks.map(b=>b.text).join('\n')))).filter(w=>!known(w,ignore));
+ const result=found.map(word=>({word,suggestions:null}));
+ const deadline=new Promise(resolve=>setTimeout(resolve,lim.suggestBudget).unref());
+ await Promise.race([deadline,Promise.all(result.slice(0,lim.suggestWords).map(item=>sg.suggest(item.word).then(s=>{item.suggestions=s;},()=>{})))]);
+ return result.map(item=>({...item,suggestions:item.suggestions&&[...item.suggestions]}));
+}
+
+export async function suggest(list,{suggester:sg=suggester()}={}){
+ if(!Array.isArray(list)||!list.length||list.length>20||list.some(w=>typeof w!=='string'))throw bad('Передайте от 1 до 20 слов');
+ const out={};for(const w of list)out[w]=await sg.suggest(w).catch(e=>{if(e.code==='busy')throw e;return [];});
+ return {suggestions:out};
+}
+
+// Rules for settings screens: id, category and the explanation, so a site can let authors switch checks off.
+export function rules(){
+ const pick=(id,r)=>({id,category:r.category,label:r.label||CATEGORIES[r.category]||r.category,message:r.message,fix:r.fix});
+ return {categories:{...CATEGORIES,spelling:'Орфография'},rules:[...RULES.map(r=>pick(r.id,r)),...Object.entries(BUILTIN).map(([id,r])=>pick(id,r)),...Object.entries(MORPH_RULES).map(([id,r])=>pick(id,r))]};
+}
+
+export function closeChecks(){shared?.close();shared=null;}

package/src/cli.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {createServer,parseKeys} from './http.mjs';
+import {closeChecks} from './check.mjs';
+// Settings come from the environment; without a key the server refuses to start.
+const env=process.env,num=(name,fallback)=>{const v=Number(env[name]);return Number.isFinite(v)&&v>0?v:fallback;};
+let keys,server;
+try{
+ keys=parseKeys(env.REEDACH_KEYS);if(!keys.length)throw new Error('Задайте REEDACH_KEYS: ключ=https://ваш-сайт.ru; второй-ключ');
+ server=createServer({keys,maxBytes:num('REEDACH_MAX_BYTES',1_000_000),concurrency:num('REEDACH_CONCURRENCY',2),queue:num('REEDACH_QUEUE',20),demo:env.REEDACH_DEMO==='1'});
+}catch(e){console.error('reedach: '+e.message);process.exit(1);}
+const port=num('PORT',3000),host=env.HOST||'0.0.0.0';
+server.listen(port,host,()=>console.log('reedach: слушаю '+host+':'+port+', ключей: '+keys.length+(env.REEDACH_DEMO==='1'?', пример: /demo/':'')));
+const stop=()=>{server.close(()=>process.exit(0));closeChecks();setTimeout(()=>process.exit(0),5000).unref();};
+process.on('SIGTERM',stop);process.on('SIGINT',stop);

package/src/http.mjs

@@ -0,0 +1,89 @@
+import http from 'node:http';
+import {readFileSync} from 'node:fs';
+import {fileURLToPath} from 'node:url';
+import {createHash,timingSafeEqual} from 'node:crypto';
+import {check,suggest,rules} from './check.mjs';
+// HTTP API. Every /v1 call needs a key. A key may list the sites whose pages can call it from the browser;
+// calls without an Origin header (from a site's own server) work with any valid key.
+// The server keeps nothing: texts are not stored and not logged.
+
+// "key1=https://a.ru,https://www.a.ru; key2" → [{key, origins}]. A key may itself contain "=" (base64):
+// the sites start only at "=http://" or "=https://".
+const origin=o=>{try{return new URL(o).origin;}catch{throw new Error('Неверный адрес сайта: '+o);}};
+export function parseKeys(value){
+ const keys=String(value??'').split(/[;\n]/).map(s=>s.trim()).filter(Boolean).map(entry=>{
+  const m=/^(.*?)=(https?:\/\/.*)$/i.exec(entry),key=(m?m[1]:entry).trim();
+  return {key,origins:m?m[2].split(/[,\s]+/).filter(Boolean).map(origin):[]};
+ });
+ for(const k of keys)if(k.key.length<16)throw new Error('Ключ доступа должен быть не короче 16 символов');
+ if(new Set(keys.map(k=>k.key)).size<keys.length)throw new Error('Один и тот же ключ указан дважды');
+ return keys;
+}
+const digest=s=>createHash('sha256').update(s).digest();
+const fail=(status,code,message)=>Object.assign(new Error(message),{status,code});
+
+// Demo page from reedach-widget: four fixed files read once, nothing else is served.
+function demoFiles(){
+ let base;try{base=import.meta.resolve('reedach-widget/package.json');}catch{throw new Error('Для страницы-примера установите пакет reedach-widget');}
+ const file=p=>fileURLToPath(new URL(p,base));
+ const types={html:'text/html; charset=utf-8',css:'text/css; charset=utf-8',js:'text/javascript; charset=utf-8'};
+ const map={'/demo/':'demo/index.html','/demo/demo.css':'demo/demo.css','/demo/demo.js':'demo/demo.js','/demo/reedach.min.js':'dist/reedach.min.js'};
+ return new Map(Object.entries(map).map(([url,p])=>[url,{body:readFileSync(file(p)),type:types[p.split('.').pop()]}]));
+}
+
+export function createServer({keys,maxBytes=1_000_000,concurrency=2,queue=20,demo=false}={}){
+ if(!keys?.length)throw new Error('Нужен хотя бы один ключ доступа');
+ const pages=demo?demoFiles():null;
+ const entries=keys.map(k=>({...k,hash:digest(k.key)})),siteOrigins=new Set(entries.flatMap(k=>k.origins));
+ const find=token=>{const h=digest(token);let hit=null;for(const k of entries)if(timingSafeEqual(h,k.hash))hit=k;return hit;};
+ let active=0;const waiting=[];
+ const slot=()=>{if(active<concurrency){active++;return Promise.resolve();}if(waiting.length>=queue)throw fail(503,'busy','Сервер занят, попробуйте позже');return new Promise(resolve=>waiting.push(resolve));};
+ const release=()=>{const next=waiting.shift();if(next)next();else active--;};
+
+ const server=http.createServer(async(req,res)=>{
+  const origin=req.headers.origin,headers={'content-type':'application/json; charset=utf-8','cache-control':'no-store','x-content-type-options':'nosniff'};
+  const send=(status,body,extra={})=>{if(res.headersSent)return;res.writeHead(status,{...headers,...extra});res.end(JSON.stringify(body));};
+  try{
+   const url=new URL(req.url,'http://localhost');
+   if(url.pathname==='/health'&&req.method==='GET')return send(200,{ok:true});
+   if(pages&&req.method==='GET'&&(url.pathname==='/demo'||pages.has(url.pathname))){
+    if(url.pathname==='/demo'){res.writeHead(308,{location:'/demo/'});return res.end();}
+    const page=pages.get(url.pathname);
+    res.writeHead(200,{'content-type':page.type,'cache-control':'no-cache','x-content-type-options':'nosniff','content-security-policy':"default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"});
+    return res.end(page.body);
+   }
+   if(req.method==='OPTIONS'){
+    if(!origin||!siteOrigins.has(origin))return send(403,{error:{code:'origin',message:'Этому сайту доступ не разрешён'}});
+    res.writeHead(204,{'access-control-allow-origin':origin,'access-control-allow-methods':'GET, POST','access-control-allow-headers':'authorization, content-type','access-control-max-age':'600',vary:'Origin'});return res.end();
+   }
+   const auth=/^Bearer\s+(\S+)$/i.exec(req.headers.authorization||''),key=auth&&find(auth[1]);
+   if(origin&&siteOrigins.has(origin))Object.assign(headers,{'access-control-allow-origin':origin,vary:'Origin'});
+   if(!key)throw fail(401,'unauthorized','Нужен ключ доступа');
+   if(origin&&!key.origins.includes(origin))throw fail(403,'origin','Этот ключ не работает на этом сайте');
+   if(url.pathname==='/v1/rules'&&req.method==='GET')return send(200,rules());
+   const route=url.pathname==='/v1/check'?b=>check(b):url.pathname==='/v1/suggest'?b=>suggest(b?.words):null;
+   if(!route)throw fail(404,'not_found','Нет такого адреса');
+   if(req.method!=='POST')throw fail(405,'method','Используйте POST');
+   if(!/^application\/json\b/i.test(req.headers['content-type']||''))throw fail(415,'content_type','Нужен JSON');
+   const body=await readJson(req,maxBytes);
+   await slot();
+   try{return send(200,await route(body));}finally{release();}
+  }catch(e){
+   const status=e.status||500;
+   if(status>=500&&e.code!=='busy'&&!e.code?.startsWith('spell_'))console.error('reedach:',e.code||e.name);
+   send(status,{error:{code:e.code||'internal',message:status===500?'Внутренняя ошибка':e.message}},e.code==='busy'?{'retry-after':'5'}:status===413?{connection:'close'}:{});
+  }
+ });
+ server.requestTimeout=30000;server.headersTimeout=10000;
+ return server;
+}
+
+function readJson(req,maxBytes){
+ return new Promise((resolve,reject)=>{
+  if(Number(req.headers['content-length'])>maxBytes)return reject(fail(413,'too_large','Слишком большой текст'));
+  const chunks=[];let size=0;
+  req.on('data',chunk=>{size+=chunk.length;if(size>maxBytes){chunks.length=0;reject(fail(413,'too_large','Слишком большой текст'));}else chunks.push(chunk);});
+  req.on('end',()=>{if(size>maxBytes)return;try{resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));}catch{reject(fail(400,'bad_json','Неверный JSON'));}});
+  req.on('error',reject);
+ });
+}

package/src/index.mjs

@@ -0,0 +1,5 @@
+// Reedach server as a library: call check() in your own process, or start the HTTP API with createServer().
+export {check,suggest,rules,closeChecks,CHECKS} from './check.mjs';
+export {createServer,parseKeys} from './http.mjs';
+export {morphCheck} from './morph.mjs';
+export {words,known,misspelled,Suggester} from './spell.mjs';

package/src/morph.mjs

@@ -0,0 +1,59 @@
+import {createRequire} from 'node:module';
+import path from 'node:path';
+// Style hints that need parts of speech: Az.js with the OpenCorpora dictionaries, loaded once on first use.
+const require=createRequire(import.meta.url),Az=require('az'),DICTS=path.join(path.dirname(require.resolve('az/package.json')),'dicts');
+let ready=null;
+const init=()=>ready??=new Promise((resolve,reject)=>Az.Morph.init(DICTS,error=>error?reject(error):resolve()));
+const cache=new Map();
+function parse(word){
+ const key=word.toLowerCase();let hit=cache.get(key);
+ if(!hit){let p;try{p=Az.Morph(key)[0];}catch{}hit={pos:p?.tag?.POS||'',cas:p?.tag?.CAse||'',lemma:String(p?.normalize()?.word||key),score:p?.score||0};if(cache.size>50000)cache.clear();cache.set(key,hit);}
+ return hit;
+}
+const RULES={
+ 'gerund-start':{category:'syntax',label:'Синтаксис',message:'Предложение начинается с деепричастного оборота: читателю приходится держать его в голове.',fix:'Начните с того, кто действует: не «Сделав работу, мы ушли», а «Мы сделали работу и ушли».'},
+ 'participle-stack':{category:'syntax',label:'Синтаксис',message:'Несколько причастных оборотов в одном предложении утяжеляют его.',fix:'Вынесите один оборот в отдельное предложение.'},
+ 'short-passive':{category:'passive',label:'Страдательный залог',message:'Краткое причастие прячет того, кто действует.',fix:'Назовите действующее лицо: не «решение принято», а «мы решили».'},
+ 'genitive-chain':{category:'nominalization',label:'Отглагольное',message:'Цепочка существительных в родительном падеже: смысл приходится распутывать.',fix:'Разорвите цепочку глаголом: не «проведение проверки выполнения работ», а «проверили, как сделана работа».'},
+ 'verb-chain':{category:'syntax',label:'Синтаксис',message:'Цепочка глаголов размывает действие.',fix:'Оставьте главный глагол: не «хотел бы начать делать», а «начну делать» или «делаю».'},
+ 'weak-verb-noun':{category:'bureaucratese',label:'Канцелярит',message:'Пустой глагол плюс отглагольное существительное звучат казённо.',fix:'Замените одним глаголом: не «осуществляем доставку», а «доставляем».'},
+ 'long-row':{category:'syntax',label:'Однородные',message:'Длинный ряд однородных слов: читатель не удержит все.',fix:'Оставьте два-три главных или превратите ряд в список.'},
+ 'adjective-pile':{category:'adjective',label:'Прилагательное',message:'Несколько прилагательных подряд перегружают фразу.',fix:'Оставьте одно, самое точное, или замените фактом.'},
+ 'start-repeat':{category:'repetition',label:'Повтор',message:'Третье предложение подряд начинается с того же слова: текст звучит монотонно.',fix:'Начните одно из предложений иначе или объедините их.'},
+ 'lemma-repeat':{category:'repetition',label:'Повтор',message:'Одно и то же слово дважды в предложении.',fix:'Замените повтор местоимением или перестройте фразу.'},
+};
+const WEAK=new Set(['осуществлять','осуществить','производить','произвести','проводить','провести','совершать','совершить','оказывать','оказать','выполнять','выполнить','обеспечивать','обеспечить','предоставлять','предоставить','принимать','принять','давать','дать']);
+const CHAIN_HEAD=new Set(['хотеть','мочь','начать','начинать','стать','пытаться','попытаться','собираться','решить','планировать']);
+const SKIP_REPEAT=new Set(['быть','мочь','это','этот','который','свой','весь','такой','тот','один','год','раз','так','как','что','когда','если','также','тоже','только','очень','уже','еще','ещё','друг','другой','какой','какой-то','каждый','самый','себя','чуть']);
+const NOMINAL=/(?:ние|тие|ство|ция|ка)$/;
+const sentences=text=>[...text.matchAll(/[^.!?…]+(?:[.!?…]+|$)/g)].map(m=>({start:m.index,text:m[0]})).filter(s=>s.text.trim());
+// blocks: [{text, kind}] → issues [{block,start,end,id,category,label,message,fix}]
+export async function morphCheck(blocks){
+ await init();
+ const issues=[],add=(block,start,end,id)=>issues.push({block,start,end,id,...RULES[id]});
+ blocks.forEach((b,i)=>{
+  if(typeof b?.text!=='string'||b.kind==='h')return;
+  const firsts=[];
+  for(const s of sentences(b.text)){
+   const words=[...s.text.matchAll(/[А-Яа-яЁё]+(?:-[А-Яа-яЁё]+)*/g)].map(m=>({w:m[0],start:s.start+m.index,end:s.start+m.index+m[0].length,...parse(m[0])}));
+   if(!words.length)continue;
+   firsts.push(words[0]);
+   const gap=(a,b)=>s.text.slice(a.end-s.start,b.start-s.start);
+   if(words[0].pos==='GRND'){const comma=s.text.indexOf(',',words[0].end-s.start);add(i,words[0].start,comma>0?s.start+comma:words[0].end,'gerund-start');}
+   const prtf=words.filter(w=>w.pos==='PRTF');if(prtf.length>=2)add(i,prtf[1].start,prtf[1].end,'participle-stack');
+   words.forEach((w,k)=>{
+    if(w.pos==='PRTS'&&w.score>=0.5&&!/^(?:был|была|было|были|будет|будут)$/i.test(words[k-1]?.w||''))add(i,w.start,w.end,'short-passive');
+    if(w.pos==='VERB'&&WEAK.has(w.lemma)){const n=words.slice(k+1,k+3).find(x=>x.pos==='NOUN');if(n&&NOMINAL.test(n.lemma)&&n.lemma!=='участие'||n&&w.lemma.startsWith('при')&&n.lemma==='участие')add(i,w.start,n.end,'weak-verb-noun');}
+   });
+   for(let k=0;k<words.length;){let j=k;if(words[k].pos==='NOUN')while(j+1<words.length&&words[j+1].pos==='NOUN'&&words[j+1].cas==='gent'&&/^\s+$/.test(gap(words[j],words[j+1])))j++;if(j-k>=2){add(i,words[k].start,words[j].end,'genitive-chain');k=j+1;}else k++;}
+   for(let k=0;k<words.length;k++){const head=words[k];if(!(head.pos==='VERB'&&CHAIN_HEAD.has(head.lemma)))continue;let j=k+1;if(words[j]?.w==='бы')j++;let n=0;while(words[j+n]?.pos==='INFN')n++;if(n>=2){add(i,head.start,words[j+n-1].end,'verb-chain');k=j+n;}}
+   for(let k=0;k<words.length;){const pos=words[k].pos;let j=k;if(['VERB','ADJF','NOUN','INFN'].includes(pos))while(j+1<words.length&&words[j+1].pos===pos&&/^\s*(?:,|и|или|,\s*и)\s*$/.test(gap(words[j],words[j+1])))j++;if(j-k>=3){add(i,words[k].start,words[j].end,'long-row');k=j+1;}else k++;}
+   for(let k=0;k+2<words.length;k++)if(words[k].pos==='ADJF'&&words[k+1].pos==='ADJF'&&words[k+2].pos==='ADJF'&&/^\s+$/.test(gap(words[k],words[k+1])+gap(words[k+1],words[k+2]).replace(/\S/g,'x'))){add(i,words[k].start,words[k+2].end,'adjective-pile');k+=2;}
+   const seen=new Map();for(const w of words){if(w.lemma.length<4||SKIP_REPEAT.has(w.lemma)||!['NOUN','VERB','INFN','ADJF','ADVB'].includes(w.pos))continue;if(seen.has(w.lemma)){add(i,w.start,w.end,'lemma-repeat');}else seen.set(w.lemma,w);}
+  }
+  // Three sentences in a row opening with the same word ("Проектирую… Проектировал… Проектирую…").
+  for(let k=2;k<firsts.length;k++)if(firsts[k].lemma===firsts[k-1].lemma&&firsts[k].lemma===firsts[k-2].lemma&&!['и','а','но'].includes(firsts[k].lemma)){add(i,firsts[k].start,firsts[k].end,'start-repeat');k+=2;}
+ });
+ return issues;
+}
+export const MORPH_RULES=RULES;

package/src/spell.mjs

@@ -0,0 +1,87 @@
+import {spawn} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+// Spelling by the hunspell binary on this server: the text never leaves it.
+// Finding misspelled words is cheap, suggestions are not (~0.3 s per word), so they are two steps:
+// a short-lived `hunspell -l` per request finds the words, a long-lived `hunspell -a` suggests fixes.
+const dict=name=>fileURLToPath(import.meta.resolve(name)).replace(/\.js$/,'');
+export const DEFAULT_DICTS=[dict('dictionary-ru'),dict('dictionary-en')].join(',');
+const LETTERS=/^[A-Za-zА-Яа-яЁё]+(?:-[A-Za-zА-Яа-яЁё]+)*$/;
+const spellError=(code,message)=>Object.assign(new Error(message),{status:503,code});
+
+// Words worth checking: letters with inner hyphens; links, e-mails, abbreviations, words with digits
+// and English contractions (isn't, couldn’t) are skipped.
+export function words(text,{limit=20000}={}){
+ const seen=new Set(),clean=String(text).replace(/https?:\/\/\S+|www\.\S+|[\w.+-]+@[\w-]+\.[\w.-]+/g,' ');
+ for(const [w] of clean.matchAll(/(?<![\w-])[A-Za-zА-Яа-яЁё]+(?:[-'’][A-Za-zА-Яа-яЁё]+)*(?![\w-])/g))if(w.length>1&&!/['’]/.test(w)&&w!==w.toUpperCase()&&seen.size<limit)seen.add(w);
+ return [...seen];
+}
+
+// Own words: a form is accepted when it shares the stem and differs by a short ending; for verbs the stem drops -ть/-ться.
+const stem=e=>/(?:ться|ть|ти|чь)$/.test(e)?e.replace(/(?:ться|ть|ти|чь)$/,''):e.slice(0,-1);
+export function known(word,entries){const w=word.toLowerCase();return entries.some(entry=>{const e=String(entry).toLowerCase(),s=stem(e);return w===e||e.length>=5&&w.startsWith(s)&&w.length-s.length<=5;});}
+
+// One `hunspell -l` per request: it prints the misspelled words and exits when stdin closes.
+export function misspelled(list,{dicts=DEFAULT_DICTS,timeout=10000}={}){
+ const input=list.filter(w=>LETTERS.test(w));
+ if(!input.length)return Promise.resolve([]);
+ return new Promise((resolve,reject)=>{
+  const child=spawn('hunspell',['-l','-i','utf-8','-d',dicts],{stdio:['pipe','pipe','ignore']});let out='',timedOut=false;
+  const timer=setTimeout(()=>{timedOut=true;child.kill('SIGKILL');},timeout);
+  child.stdout.setEncoding('utf8').on('data',chunk=>{out+=chunk;});
+  child.on('error',e=>{clearTimeout(timer);reject(Object.assign(spellError('spell_unavailable','Проверка орфографии недоступна'),{cause:e}));});
+  child.on('close',code=>{clearTimeout(timer);if(timedOut||code!==0)return reject(spellError('spell_failed','Проверка орфографии не удалась'));resolve([...new Set(out.split('\n').filter(Boolean))]);});
+  child.stdin.on('error',()=>{});
+  child.stdin.end(input.join('\n')+'\n');
+ });
+}
+
+// A long-lived `hunspell -a` for suggestions. Safety:
+// - only letter words go in, each as one line behind "^", so text can never become a hunspell command;
+// - own words are never added to hunspell, so nothing is remembered between requests;
+// - one word at a time: hunspell answers every input line with a blank line, so answers cannot mix;
+// - a hung or broken process is killed and started again; it is also recycled after `recycle` words.
+export class Suggester{
+ constructor({dicts=DEFAULT_DICTS,wordTimeout=3000,recycle=2000,cacheSize=5000,maxPending=50}={}){Object.assign(this,{dicts,wordTimeout,recycle,cacheSize,maxPending});this.cache=new Map();this.queue=Promise.resolve();this.child=null;this.used=0;this.pending=0;}
+ #start(){
+  const child=spawn('hunspell',['-a','-i','utf-8','-d',this.dicts],{stdio:['pipe','pipe','ignore']});
+  // An idle hunspell must not keep the program alive: a pending answer has its own timer.
+  child.unref();child.stdin.unref?.();child.stdout.unref?.();
+  const state={child,buf:'',waiting:null,banner:true};
+  child.stdout.setEncoding('utf8').on('data',chunk=>{state.buf+=chunk;this.#drain(state);});
+  child.on('error',()=>this.#fail(state));child.on('close',()=>this.#fail(state));child.stdin.on('error',()=>this.#fail(state));
+  this.child=state;this.used=0;return state;
+ }
+ #drain(state){
+  if(state.banner){const nl=state.buf.indexOf('\n');if(nl<0)return;state.buf=state.buf.slice(nl+1);state.banner=false;}
+  for(;;){
+   const end=state.buf.startsWith('\n')?0:state.buf.indexOf('\n\n');if(end<0)return;
+   const answer=state.buf.slice(0,end);state.buf=state.buf.slice(end?end+2:1);
+   // An answer nobody asked for means hunspell and we are out of step: start over.
+   const w=state.waiting;if(!w)return this.#fail(state);state.waiting=null;w.resolve(answer);
+  }
+ }
+ #fail(state){if(this.child===state)this.child=null;state.dead=true;state.child.kill('SIGKILL');const w=state.waiting;state.waiting=null;w?.reject(spellError('spell_failed','Подбор вариантов не удался'));}
+ #ask(word){
+  let state=this.child;if(!state||state.dead||this.used>=this.recycle){if(state)this.#fail(state);state=this.#start();}
+  this.used++;
+  return new Promise((resolve,reject)=>{
+   const timer=setTimeout(()=>this.#fail(state),this.wordTimeout);
+   state.waiting={resolve:v=>{clearTimeout(timer);resolve(v);},reject:e=>{clearTimeout(timer);reject(e);}};
+   state.child.stdin.write('^'+word+'\n');
+  });
+ }
+ // word → up to five suggestions; correct words and words hunspell cannot fix give [].
+ suggest(word){
+  if(typeof word!=='string'||word.length>40||!LETTERS.test(word))return Promise.resolve([]);
+  if(this.cache.has(word))return Promise.resolve(this.cache.get(word));
+  if(this.pending>=this.maxPending)return Promise.reject(Object.assign(spellError('busy','Сервер занят, попробуйте позже'),{status:503}));
+  this.pending++;
+  const run=this.queue.then(()=>this.#ask(word)).then(answer=>{
+   const m=/^& \S+ \d+ \d+: (.*)$/m.exec(answer),list=m?m[1].split(', ').slice(0,5):[];
+   if(this.cache.size>=this.cacheSize)this.cache.delete(this.cache.keys().next().value);
+   this.cache.set(word,list);return list;
+  }).finally(()=>{this.pending--;});
+  this.queue=run.catch(()=>{});return run;
+ }
+ close(){if(this.child)this.#fail(this.child);}
+}