npm - @rsconcept/rstool - Versions diffs - 0.2.0 → 0.3.0 - Mend

@rsconcept/rstool 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/docs/CONCEPTUAL-SCHEMA.md +78 -0
package/docs/CONSTITUENTA.md +37 -55
package/docs/DIAGNOSTICS.md +85 -130
package/docs/DOMAIN.md +68 -91
package/docs/GRAMMAR-REF.md +35 -86
package/docs/MODEL-TESTING.md +57 -0
package/docs/PORTAL-API.md +22 -36
package/docs/README.md +14 -12
package/docs/SYNTAX.md +49 -104
package/docs/TYPIFICATION.md +41 -60
package/package.json +1 -1
package/skills/README.md +6 -8
package/skills/rstool-helper/EXAMPLES.md +83 -106
package/skills/rstool-helper/GUIDE.md +68 -108
package/skills/rstool-helper/REFERENCE.md +1 -0
package/skills/rstool-helper/SKILL.md +5 -8

package/docs/GRAMMAR-REF.md CHANGED Viewed

@@ -1,98 +1,47 @@
-# Grammar reference (pointers)
+# Грамматика: короткая карта
-Below is a compact token map agents can use without opening the grammar. For full grammar see `@rsconcept/domain` package.
+Этого обычно достаточно агенту. Полная грамматика живет в `@rsconcept/domain`.
-## Token classes
+## Токены
-| Class           | Tokens / examples                                          |
-| --------------- | ---------------------------------------------------------- |
-| Whitespace      | space, tab, newline                                        |
-| Integer literal | `0`, `42`                                                  |
-| Empty set       | `∅`                                                        |
-| Integer set     | `Z`                                                        |
-| Globals         | `X#`, `C#`, `S#`, `D#`, `F#`, `P#`, `A#`, `T#`, `N#`, `R#` |
-| Locals          | `x`, `ξ`, `μ2`, `y1`                                       |
-| Punctuation     | `(`, `)`, `[`, `]`, `{`, `}`, `,`, `;`                     |
-| Comment         | none — RSLang has no comments inside formal expressions    |
+- Литералы: `0`, `42`, `Z`, `∅`.
+- Алиасы: `X#`, `C#`, `S#`, `D#`, `F#`, `P#`, `A#`, `T#`, `R#`.
+- Локальные переменные: `x`, `ξ`, `μ2`, `y1`.
+- Скобки и разделители: `()`, `[]`, `{}`, `,`, `;`.
+- Комментариев в формальных выражениях нет.
-## Set / structural operators
+## Операторы
-| Token                | Symbol                     |
-| -------------------- | -------------------------- |
-| Union                | `∪`                        |
-| Intersection         | `∩`                        |
-| Difference           | `\`                        |
-| Symmetric difference | `∆`                        |
-| Cartesian product    | `×`                        |
-| Boolean              | `ℬ`                        |
-| Sum set              | `red`                      |
-| Singleton            | `bool`                     |
-| Desingleton          | `debool`                   |
-| Small projection     | `pr1`, `pr1,3`, …          |
-| Large projection     | `Pr1`, `Pr2,4`, …          |
-| Filter               | `Fi1[D](S)`, `Fi1,2[D](S)` |
-| Cardinality          | `card`                     |
+- Множества: `∪`, `∩`, `\`, `∆`, `×`, `ℬ`.
+- Структуры: `red`, `bool`, `debool`, `pr1`, `Pr1`, `Fi1[D](S)`, `card`.
+- Предикаты: `∈`, `∉`, `⊆`, `⊂`, `⊄`, `=`, `≠`, `<`, `≤`, `>`, `≥`.
+- Связки: `¬`, `&`, `∨`, `⇒`, `⇔`.
+- Кванторы: `∀`, `∃`.
-## Predicates
+Мультииндексы парсятся как список натуральных чисел: `pr1,3`, `Pr2,4`, `Fi1,2[D](S)`.
-| Token            | Symbol |
-| ---------------- | ------ |
-| Membership       | `∈`    |
-| Non-membership   | `∉`    |
-| Inclusion        | `⊆`    |
-| Strict inclusion | `⊂`    |
-| Non-inclusion    | `⊄`    |
-| Equality         | `=`    |
-| Inequality       | `≠`    |
-| Less             | `<`    |
-| Less-or-equal    | `≤`    |
-| Greater          | `>`    |
-| Greater-or-equal | `≥`    |
+## Декларации
-## Logical connectives
+- Терм-функция: `F# ::= [<params>] <body STE>`.
+- Предикат-функция: `P# ::= [<params>] <body LE>`.
+- Параметр: `α ∈ <STE>`.
+- Вызов: `F#[<arg1>, <arg2>]`.
-| Token       | Symbol |
-| ----------- | ------ |
-| Negation    | `¬`    |
-| Conjunction | `&`    |
-| Disjunction | `∨`    |
-| Implication | `⇒`    |
-| Equivalence | `⇔`    |
+## Приоритеты
-## Quantifiers
+1. Вызовы функций, проекции, `ℬ`, `bool`, `debool`, `red`, `card`.
+2. `×`.
+3. `*`.
+4. `+`, `-`.
+5. `∪`, `∩`, `\`, `∆`.
+6. Предикаты: `∈`, `=`, `<`, ...
+7. `¬`.
+8. `&`.
+9. `∨`.
+10. `⇒`.
+11. `⇔`.
-| Token       | Symbol |
-| ----------- | ------ |
-| Universal   | `∀`    |
-| Existential | `∃`    |
+## Когда читать исходники
-## Declarators
-| Token                 | Form                                              |
-| --------------------- | ------------------------------------------------- |
-| Function declaration  | `F# ::= [<params>] <body STE>`                    |
-| Predicate declaration | `P# ::= [<params>] <body LE>`                     |
-| Parameter declaration | `α ∈ <STE>` (commas separate; commas inside `[]`) |
-| Function call         | `F#[<arg1>, <arg2>, …]`                           |
-## Precedence (from highest to lowest)
-1. Function calls, projections, boolean
-2. Cartesian product `×`
-3. Multiplicative `*`
-4. Additive `+`, `-`
-5. Set operators `∪`, `∩`, `\`, `∆`
-6. Predicates (`∈`, `=`, `<`, …)
-7. Negation `¬`
-8. Conjunction `&`
-9. Disjunction `∨`
-10. Implication `⇒`
-11. Equivalence `⇔`
-Multi-index tokens inside projections / filters are parsed as a comma-separated list of natural numbers.
-## When to consult the full grammar
-- Grammar conflicts or surprising error positions — read `rslang.grammar` directly.
-- Adding new operators or precedence rules — must be done in the domain package, not in rstool.
-- Lezer terms / token IDs — see `@rsconcept/domain/src/rslang/parser/token.ts` and `parser.terms.ts`.
+- Позиция ошибки неожиданная.
+- Нужны Lezer terms/token IDs: `@rsconcept/domain/src/rslang/parser/token.ts`, `parser.terms.ts`.

package/docs/MODEL-TESTING.md ADDED Viewed

@@ -0,0 +1,57 @@
+# Тестирование определений через концептуальную модель
+Концептуальная модель (`КМ`) полезна как маленький стенд для проверки семантики выражений. Если агент не уверен, что формула означает именно нужную операцию, не угадывай по виду выражения: создай минимальную схему, задай тестовые значения для неопределяемых конституент и вычисли результат.
+## Когда использовать
+- Неочевидны `S#` против `D#`, проекции `Pr*` / `pr*`, фильтры `Fi*`, `red`, `bool`, `debool`.
+- Формула синтаксически корректна, но есть сомнение в семантике результата.
+- Нужно проверить, что аксиома действительно ловит ошибочные данные.
+- Пользователь просит надежно изменить важное определение, а пример данных можно сделать маленьким.
+Для простой проверки типизации сначала используй `analyzeExpression`. КМ нужна, когда вопрос зависит от интерпретации данных и вычисленного значения.
+## Минимальный цикл
+1. Создай отдельную `createSession` или изолированную копию текущей сессии.
+2. Добавь только нужные поставщики: `X#`, `C#`, `S#` и проверяемые `D#` / `F#` / `P#` / `A#`.
+3. Проверь формулы через `analyzeExpression` и `addOrUpdateConstituenta`.
+4. Задай значения базисов и структур через `setConstituentaValue` или `setConstituentaValues`.
+5. Вычисли проверяемую формулу через `evaluateExpression` или сохраненную конституенту через `evaluateConstituenta`.
+6. Сравни результат с ожидаемым значением; если есть несколько зависимых определений, запусти `recalculateModel`.
+## Что задавать руками
+`basic`, `constant`, `structure` можно интерпретировать напрямую. `term`, `function`, `predicate`, `axiom`, `statement` должны вычисляться из формулы, поэтому их напрямую не задавай.
+Пример формы данных:
+```ts
+const TUPLE_ID = -111;
+tool.setConstituentaValues(sessionId, {
+  items: [
+    { target: 1, value: { 0: 'ann', 1: 'bob', 2: 'cat' } },
+    { target: 2, value: [[TUPLE_ID, 0, 1], [TUPLE_ID, 0, 2]] }
+  ]
+});
+```
+Здесь `X1` получает подписи элементов, а `S1: ℬ(X1×X1)` получает множество пар по индексам элементов `X1`.
+## Скрипты-тесты
+Если проверка влияет на поведение схемы или есть риск регрессии, вынеси ее в маленький скрипт или colocated `*.test.ts`:
+1. Собери минимальную сессию с нужными конституентами.
+2. Задай тестовые значения неопределяемых конституент.
+3. Вычисли целевые конституенты.
+4. Проверь `success`, `status`, `diagnostics.length` и само `value`.
+Тест должен проверять смысл формулы, а не только отсутствие диагностик. Для аксиом отдельно проверяй положительный и отрицательный набор данных: корректная модель должна давать истинную аксиому, ошибочная — `AXIOM_FALSE` или диагностируемый сбой вычисления.
+## Ограничения
+- Маленькая КМ проверяет семантику на выбранных данных, но не доказывает определение для всех моделей.
+- Не подменяй предметное соглашение тестом: если смысл `S#` не ясен, уточни `convention` или спроси пользователя.
+- Не добавляй искусственные конституенты в рабочую схему только ради теста. Держи scratch-сессию или тестовый скрипт отдельно.

package/docs/PORTAL-API.md CHANGED Viewed

@@ -1,45 +1,31 @@
-# Portal REST API (read-only reference)
+# Portal REST API
-When an agent needs to **inspect existing** RSForms, OSS, or RSModels persisted on the Portal, use the REST API on `api.portal.acconcept.ru`. The rstool library itself never calls the Portal API — it always works on in-memory sessions. This document is for agents that combine rstool sessions with data fetched from a live Portal.
+Справка только для чтения существующих КС, ОСС и RSModel. `rstool` сам не ходит в REST API: он работает с in-memory сессиями.
-## Hosts
+## Хосты
-- **UI:** `https://portal.acconcept.ru/`
-- **REST API:** `https://api.portal.acconcept.ru/`
+- UI: `https://portal.acconcept.ru/`
+- REST API: `https://api.portal.acconcept.ru/`
-## Path rewrite rules
+## Пути
-| Portal UI path                   | REST target                                             |
-| -------------------------------- | ------------------------------------------------------- |
-| `/rsforms/:id`                   | `GET /api/rsforms/:id` (metadata: owner, titles)        |
-| `/rsforms/:id` (full payload)    | `GET /api/rsforms/:id/details`                          |
-| `/rsforms/:id` (a saved version) | `GET /api/library/:id/versions/:version`                |
-| `/oss/:id`                       | `GET /api/oss/:id` (and the sibling OSS viewset routes) |
-| `/models/:id`                    | `GET /api/models/:id` (RSModel router)                  |
+- `/rsforms/:id` в UI → `GET /api/rsforms/:id` для метаданных.
+- Полная КС → `GET /api/rsforms/:id/details`.
+- Версия КС → `GET /api/library/:id/versions/:version`.
+- ОСС → `GET /api/oss/:id` и соседние routes viewset.
+- Модель → `GET /api/models/:id`.
+- OpenAPI JSON → `GET https://api.portal.acconcept.ru/schema`.
-## OpenAPI
+## Как перенести КС в rstool
-Machine-readable schema:
+1. Получи `GET /api/rsforms/:id/details`.
+2. Создай `createSession`.
+3. Перенеси конституенты через `addOrUpdateConstituenta`: `alias`, `cstType`, `definitionFormal`, `term`, `definitionText`, `convention`.
+4. Работай локально: анализ, правки, вычисления.
+5. Для передачи результата используй `exportSession`.
-```
-GET https://api.portal.acconcept.ru/schema
-```
+## Не делай
-Prefer `/schema` for JSON. The Swagger UI is separate.
-## What rstool consumes
-rstool itself works with in-memory sessions via `RSToolAgent` or the stdio wrapper. To bridge between the REST payload and a rstool session, the typical flow is:
-1. `GET /api/rsforms/:id/details` to fetch the persisted RSForm.
-2. Convert the response (constituents, formal definitions, term, convention, etc.) into a series of `addOrUpdateConstituenta` calls inside a fresh `createSession`.
-3. Operate offline: analyse, edit, evaluate, then `exportSession` for hand-off.
-There is no backend write path in rstool: edits never round-trip to the Portal automatically. Publish changes back to the Portal through the existing Portal UI or REST writes.
-## Don'ts
-- Do not scrape the SPA HTML.
-- Do not pass UI hash params (`?tab=editor`, etc.) to REST.
-- Do not call `/api/rsforms/:id/details` for trivial metadata — `GET /api/rsforms/:id` is cheaper.
-- Do not assume the API host is the same as the UI host in production — they are different.
+- Не парси HTML SPA.
+- Не переноси UI query/hash вроде `?tab=editor` в REST.
+- Не запрашивай `/details`, если нужны только метаданные.

package/docs/README.md CHANGED Viewed

@@ -1,15 +1,17 @@
-# rstool docs
+# Документация rstool
-Standalone English reference distilled from the Portal manuals and `CONTEXT.md`. Bundled with `@rsconcept/rstool` so external agents never need to read the Portal frontend source tree.
+Краткая русская справка для агентов.
-| File | Read when |
-|------|-----------|
-| [`DOMAIN.md`](DOMAIN.md) | You need the Concept Portal vocabulary (constituenta, conceptual schema/model, OSS, synthesis). |
-| [`CONSTITUENTA.md`](CONSTITUENTA.md) | You are upserting constituents — fields, `cstType` table, validation rules, recommended order. |
-| [`SYNTAX.md`](SYNTAX.md) | You are constructing RSLang expressions — operators, quantifiers, parameterised functions, examples. |
-| [`TYPIFICATION.md`](TYPIFICATION.md) | You are interpreting `AnalysisResult.type` / `valueClass` or constructing template expressions with radicals. |
-| [`DIAGNOSTICS.md`](DIAGNOSTICS.md) | You received `analysis.diagnostics` and need to map error codes to fixes. |
-| [`PORTAL-API.md`](PORTAL-API.md) | You need to fetch an existing RSForm/OSS/RSModel from the live Portal REST API. |
-| [`GRAMMAR-REF.md`](GRAMMAR-REF.md) | You need a compact token / precedence table; the full grammar lives in `@rsconcept/domain`. |
+## Какой файл читать
-For the rstool agent contract itself (methods, types, stdio protocol) see [`../skills/rstool-helper/REFERENCE.md`](../skills/rstool-helper/REFERENCE.md).
+- **DOMAIN.md** — термины Portal: конституента, концептуальная схема/модель, ОСС, синтез.
+- **CONCEPTUAL-SCHEMA.md** — проектирование и ревью концептуальных схем.
+- **CONSTITUENTA.md** — структура и правила конституент.
+- **SYNTAX.md** — операторы, кванторы, функции и примеры выражений.
+- **TYPIFICATION.md** — типизация (`AnalysisResult.type`, `valueClass`).
+- **MODEL-TESTING.md** — проверка семантики определений на маленьких концептуальных моделях.
+- **DIAGNOSTICS.md** — диагностики анализа и способы исправления ошибок.
+- **PORTAL-API.md** — объекты REST API Portal.
+- **GRAMMAR-REF.md** — краткая карта токенов и приоритетов.
+Контракт агента `rstool` см. в `../skills/rstool-helper/REFERENCE.md`.

package/docs/SYNTAX.md CHANGED Viewed

@@ -1,139 +1,84 @@
-# RSLang syntax reference
+# Синтаксис RSLang
-Use this when constructing or repairing RSLang expressions. For full grammar tokens see `GRAMMAR-REF.md`. For typification rules see `TYPIFICATION.md`.
+Читай, когда строишь или исправляешь `definitionFormal`. Токены и приоритеты — в `GRAMMAR-REF.md`, типизация — в `TYPIFICATION.md`.
-## Identifier rules
+## Имена и литералы
-- **Globals** (concept aliases): uppercase Latin letter + digits — `X1`, `C2`, `S3`, `D11`, `F7`, `P4`, `A6`, `T9`, `N12`. The leading letter must match the constituent's role.
-- **Radicals**: identifiers starting with `R` — used inside template parameterised expressions to denote arbitrary typifications (`R1`, `R2`).
-- **Locals** (bound variables): lowercase Latin or Greek letter, optionally with digits — `x`, `ξ`, `μ2`, `y1`.
-- **Special identifiers** — reserved tokens (`Z`, `∅`, operators).
+- Глобальные алиасы: `X1`, `C2`, `S3`, `D11`, `F7`, `P4`, `A6`, `T9`; буква совпадает с ролью.
+- Радикалы: `R1`, `R2` — шаблонные ступени в параметрах.
+- Локальные переменные: `x`, `ξ`, `μ2`, `y1`.
+- Целые: `0`, `42`; отрицательного литерала нет, пиши `0 - 5`.
+- `Z` — множество целых, `∅` — пустое множество с типизацией `ℬ(R0)`.
-## Literals
+## Теоретико-множественные выражения (STE)
-- **Integers**: digit sequence, no negative literal: `0`, `42`. Negation is a binary subtraction `0 - n`.
-- **Integer set**: `Z`.
-- **Empty set**: `∅` (typification `ℬ(R0)` — set of arbitrary element structure).
+- `D1 ∪ D2`, `D1 ∩ D2`, `D1 \ D2`, `D1 ∆ D2` — операции над множествами.
+- `X1 × X2` — декартово произведение.
+- `ℬ(X1)` — булеан, множество всех подмножеств.
+- `(a, b, c)` — кортеж, арность минимум 2.
+- `{a, b, c}` — перечисление.
+- `bool(a)` — синглетон, `debool(S)` — извлечение единственного элемента.
+- `red(S)` — суммарное множество; `S` должно иметь ступень `ℬ(ℬ(H))`.
+- `pr1(tuple)` — малая проекция кортежа.
+- `Pr1(S)` — большая проекция множества кортежей.
+- `Fi1[D](S)` — фильтр по принадлежности выбранной проекции в `D`.
-## Set-theoretic expressions
+Мультииндексы разрешены: `pr1,3(...)`, `Pr2,4(S1)`, `Fi1,2[D1](S1)`.
-| Construct            | Syntax              | Notes                                           |
-| -------------------- | ------------------- | ----------------------------------------------- |
-| Union                | `D1 ∪ D2`           |                                                 |
-| Intersection         | `D1 ∩ D2`           |                                                 |
-| Difference           | `D1 \ D2`           |                                                 |
-| Symmetric difference | `D1 ∆ D2`           |                                                 |
-| Cartesian product    | `X1 × X2`           | typification: tuple                             |
-| Boolean / power set  | `ℬ(X1)`             | set of all subsets                              |
-| Tuple                | `(a, b, c)`         | ordered, n ≥ 2                                  |
-| Enumeration          | `{a, b, c}`         | unordered, n ≥ 1                                |
-| Singleton            | `bool(a)` ≡ `{a}`   |                                                 |
-| Desingleton          | `debool({a})` ≡ `a` | only for one-element sets                       |
-| Sum set              | `red(S1)`           | union of inner sets; `S1` must be a set of sets |
-| Small projection     | `pr1((a1, …, an))`  | returns `a1`                                    |
-| Large projection     | `Pr1(S1)`           | set of first components of tuples in `S1`       |
-| Filter               | `Fi1[D1](S1)`       | subset of `S1` whose first projection ∈ `D1`    |
+## Логические выражения (LE)
-Indices `1` may be any natural number or comma-separated multi-index (`pr1,3((a1, a2, a3, a4)) = (a1, a3)`, `Fi1,2[D1](S1)`).
+- Предикаты множеств: `ξ ∈ S`, `ξ ∉ S`, `S1 = S2`, `S1 ≠ S2`, `S1 ⊆ S2`, `S1 ⊂ S2`, `S1 ⊄ S2`.
+- Арифметические предикаты: `=`, `≠`, `<`, `≤`, `>`, `≥` над `Z`.
+- Связки: `¬A`, `A & B`, `A ∨ B`, `A ⇒ B`, `A ⇔ B`.
-## Logical expressions
+`TRUE` и `FALSE` в экспликации КС не используют.
-### Set-theoretic predicates
+## Кванторы
-| Predicate        | Syntax    |
-| ---------------- | --------- |
-| Membership       | `ξ ∈ S`   |
-| Non-membership   | `ξ ∉ S`   |
-| Set equality     | `S1 = S2` |
-| Set inequality   | `S1 ≠ S2` |
-| Inclusion        | `S1 ⊆ S2` |
-| Strict inclusion | `S1 ⊂ S2` |
-| Non-inclusion    | `S1 ⊄ S2` |
+- `∀ξ∈D1 (LE(ξ))` — всеобщность.
+- `∃ξ∈D1 (LE(ξ))` — существование.
+- `∀(ξ1, ξ2)∈S1 (LE(ξ1, ξ2))` — объявление кортежа.
+- `∀ξ1, ξ2∈D1 (LE(ξ1, ξ2))` — сокращение вложенных кванторов.
-### Arithmetic predicates (typification `Logic`)
+Скобки вокруг `LE` можно опустить для атомарного логического выражения.
-`a = b`, `a ≠ b`, `a < b`, `a ≤ b`, `a > b`, `a ≥ b`.
+## Арифметика
-### Connectives
+`a + b`, `a - b`, `a * b` дают `Z`. `card(S)` возвращает мощность конечного множества.
-| Connective  | Syntax  |
-| ----------- | ------- |
-| Negation    | `¬A`    |
-| Conjunction | `A & B` |
-| Disjunction | `A ∨ B` |
-| Implication | `A ⇒ B` |
-| Equivalence | `A ⇔ B` |
+## Параметризованные выражения
-The constants `TRUE` and `FALSE` are **not** used inside schema explications.
-## Quantifiers
-| Form          | Syntax                       |
-| ------------- | ---------------------------- |
-| Universal     | `∀ξ∈STE (LE(ξ))`             |
-| Existential   | `∃ξ∈STE (LE(ξ))`             |
-| Tuple binding | `∀(ξ1, ξ2)∈STE (LE(ξ1, ξ2))` |
-| Variable list | `∀ξ1, ξ2 ∈ STE (LE(ξ1, ξ2))` |
-Parentheses around `LE` may be omitted for atomic logical expressions.
-## Arithmetic
-Operations `a + b`, `a - b`, `a * b` form set-theoretic expressions with typification `Z`. Negative numbers are computed, never literal.
-`card(S)` returns the integer cardinality of `S` (always finite in practice).
-## Parameterised expressions
-### Term-function declaration
-```
+```text
 F1 ::= [α1∈STE1, α2∈STE2(α1)] STE(α1, α2)
-```
-- Inside `[]` is an ordered list of parameter declarations separated by commas.
-- A parameter is declared with `∈`: `local_var ∈ domain`.
-- A declared variable can appear in subsequent parameter domains and in the result STE.
-### Predicate-function declaration
-```
 P1 ::= [α1∈STE1, α2∈STE2(α1)] LE(α1, α2)
 ```
-The only difference from a term-function is that the body is a logical expression.
+- В `[]` идут параметры через `∈`.
+- Параметр доступен в следующих доменах и теле.
+- Вызов позиционный: `F1[ξ1, S1]`, `P1[ξ1\ξ2, ξ3]`.
+- `F#` возвращает теоретико-множественное выражение, `P#` — логическое.
-### Calling parameterised functions
+## Радикалы
-`F1[ξ1, S1]`, `P1[ξ1\ξ2, ξ3]` — arguments are positional and listed in square brackets after the function name. Argument typifications are checked against parameter typifications. Result is an STE (term-function) or LE (predicate-function).
-### Template expressions
-Functions that use radicals as parameter typifications are templates:
-```
+```text
 F2 ::= [α1∈R1×R2, α2∈R1] α2 = pr1(α1)
 ```
-- Radical values are **inferred** from the call-site argument typifications. All inferred values for the same radical index must agree.
-- Different radical indices are independent.
-- Radicals may only appear in parameter domains — never in the result expression.
+- `R#` выводится по типизациям аргументов в месте вызова.
+- Все вхождения одного `R#` должны совпасть.
+- Радикалы допустимы только в доменах параметров.
-## Examples
+## Примеры
 - `¬α ∈ S1`
-- `D1 ∈ S1 ⇒ 2 + 2 = 5`
 - `D1 ⊆ D2 ⇔ ∀x∈D1 x∈D2`
 - `∀x∈D1 ∃y∈D2 (x, y)∈S1 & (x, x)∈S1`
 - `(4 + 5) * 3`, `card(X1) > 5`
-- `ℬ(2) = {{}, {1}, {2}, {1, 2}}`
 - `pr2((5, 4, 3, 2, 1)) = 4`
 - `red({{1, 2, 3}, {3, 4}}) = {1, 2, 3, 4}`
-- `Fi2[{2, 4}]({((1, 2), (3, 4), (5, 6))}) = {((1, 2), (3, 4))}`
-## Correctness model
+## Корректность
-- Expression checking happens in the **global context**: known typifications and bijective portability of every referenced identifier. Unknown identifiers are errors.
-- Set-theoretic rules follow from bijective portability of the membership predicate — an element must match the typification of the set it is tested against.
-- Logical consistency cannot generally be checked automatically. The existence of an interpretation example in a conceptual model is a basis for accepting consistency.
-- All formal definitions must be **bijectively portable**: values are independent of any bijective replacement of undefined-concept interpretations.
+- Анализ идет в глобальном контексте: все алиасы должны быть известны и типизированы.
+- Формальные определения должны быть биективно переносимыми (гарантируется семантическим анализатором).
+- Логическая непротиворечивость проверяется примером интерпретации в модели.

package/docs/TYPIFICATION.md CHANGED Viewed

@@ -1,84 +1,65 @@
-# Typification reference
+# Типизация
-Distilled from `help-rslang-typification`, `help-rslang-expression-structure`, and `help-rslang-expression-parameter`. Agents must understand grades to interpret `AnalysisResult.type` and to construct correct expressions.
+Читай, когда разбираешь `AnalysisResult.type`, `valueClass` или радикалы.
-## Grades
+## Ступени
-A genus-structure expression `ξ` has typification (a _structure_) if `ξ ∈ H` holds, where `H` is a valid **grade**. Grades are built recursively:
+Выражение типизировано, если его значения принадлежат ступени `H`.
-| Grade            | Form                 | Notes                                    |
-| ---------------- | -------------------- | ---------------------------------------- |
-| Element          | `Xi`, `Ci`           | grade of an undefined concept's elements |
-| Integer          | `Z`                  | grade of integer arithmetic results      |
-| Tuple of arity n | `(H1 × H2 × … × Hn)` | ordered structured grade                 |
-| Set              | `ℬ(H)`               | set of values of grade `H`               |
+- `Xi`, `Ci` — элемент базисного или константного множества.
+- `Z` — целое число.
+- `(H1 × H2 × ... × Hn)` — кортеж.
+- `ℬ(H)` — множество значений ступени `H`.
-The empty set `∅` has typification `ℬ(R0)` — a set with arbitrary element structure. The radical `R0` ensures it conforms to any element grade in context.
+`∅` имеет типизацию `ℬ(R0)`: пустое множество подстраивается под контекст.
-## Extended typifications
+## Дополнительные типизации
-Beyond set-theoretic grades, RSLang uses two additional grade-like markers:
+- `Logic` — логические выражения: аксиомы, высказывания, тела предикат-функций.
+- `Hr <- [H1, H2, ..., Hi]` — параметризованная типизация функций: результат и аргументы.
-- **Logic** — typification of logical expressions (axioms, statements, predicate bodies) that evaluate to TRUE or FALSE.
-- **Parameterised** — typification of term-functions and predicate-functions:
+## Радикалы
-  ```
-  Hr 🠔 [H1, H2, …, Hi]
-  ```
+`R1`, `R2`, ... — шаблонные ступени.
-  where `Hr` is the result typification (an STE grade or `Logic`) and `H1 … Hi` are the argument typifications.
+- Значение `R#` выводится по аргументам в месте вызова.
+- Все вхождения одного `R#` должны дать одну ступень.
+- Разные `R#` независимы.
+- Радикалы можно писать только в доменах параметров; в теле результата будет `radicalUsage`.
-## Radicals
+## `AnalysisResult.type`
-Template parameterised expressions may contain notations `R1, R2, …` (and `R0` for `∅`). Each radical corresponds to an arbitrary grade that is **inferred** from the typifications of the arguments at the point of use.
+`type` приходит как JSON анализатора: `Record<string, unknown> | null`.
-- All occurrences of the same radical index must resolve to the same grade.
-- Radicals with different indices are independent.
-- Radicals may only appear in parameter domains, **not in the result expression**.
+Правила:
-## Encoded shape in `AnalysisResult.type`
+1. Сначала проверь `analysis.success === true` и `analysis.type !== null`.
+2. Не разбирай объект вручную; используй helpers из `@rsconcept/domain`.
+3. `valueClass` уточняет вычислимость: `Value`, `Property`, `Invalid`.
-The contract exposes `type: Record<string, unknown> | null` because typifications are JSON-encoded by the analyzer. Useful properties exposed by `@rsconcept/domain` helpers:
+Полезные API: `TypeID`, `TypePath`, `makeTypePath`, `parseTypeText(...)`.
-- `TypeID` enum: `Element`, `Integer`, `Tuple`, `Boolean`, `Logic`, `Functional` — discriminates the top-level shape.
-- `TypePath` (sequence of indices) addresses positions inside a tuple-of-sets-of-tuples structure; use `makeTypePath` to construct.
-- `parseTypeText(...)` parses an ASCII representation `B(X1)`, `(X1×X2)`, etc., into a `Typification`.
+## `S#` и `D#`
-For agents inspecting types from rstool output:
+- У `structure` (`S#`) `definitionFormal` читается как типизация. `ℬ(X1×X1)` описывает множество пар.
+- У `term` (`D#`) `definitionFormal` читается как определение. `X1×X1` строит декартов продукт.
-1. Check `analysis.success === true` and `analysis.type !== null`.
-2. Use `analysis.type` (object) only as opaque input to `@rsconcept/domain` helpers — do not pattern-match it manually.
-3. The `valueClass` companion indicates `Value`, `Property` (non-computable membership only), or `Invalid`.
+Для отношений предпочитай `S#` с `ℬ(X1×X1)` и конвенцией; выводимые понятия делай через `Pr*`, `Fi*`, фильтры и функции.
-## Typification on `S#` vs definition on `D#`
+## Операции
-- On a **`structure`** (`S#`), `definitionFormal` is read as **typification**. Subexpressions such as `X1×X1` describe **element shape** (here: one pair of base elements).
-- On a **`term`** (`D#`), the same token sequence is a **definition** evaluated in the model. `X1×X1` alone is the Cartesian product — all ordered pairs from `X1` — not the typification of a relation stored in `S#`.
+Создают ступень: `ℬ(H)`, `H1 × H2`, `(a, b)`, `{a, b}`, `bool(a)`.
-Prefer `S#` with `ℬ(X1×X1)` plus `convention` for relations; derive `D#` with `Pr*`, `Fi*`, filters, etc.
+Требуют подходящую ступень:
-## Forming structures vs. derived structures
+- `red(S)` — нужно `S : ℬ(ℬ(H))`.
+- `debool(S)` — нужно одноэлементное множество.
+- `pr1(tuple)`, `Pr1(S)` — нужна достаточная арность.
+- `Fi1[D](S)` — `D` должен соответствовать выбранной проекции.
-Forming operations build a new grade:
+## Частые ошибки
-- `ℬ(H)` — power set
-- `H1 × H2` — Cartesian product
-- `(a, b, c)` — tuple
-- `{a, b, c}` — enumeration
-- `bool(a)` — singleton
-Derived structures consume a grade:
-- `red(S)` — union of inner sets; requires `S : ℬ(ℬ(H))`
-- `debool({a})` — extracts the single element of a singleton
-- `pr1((a1, …, an))`, `Pr1(S)` — projections (multi-indices allowed: `pr1,3`, `Pr2,4`)
-- `Fi1[D](S)` — filters by membership in `D`; multi-index variants must match parameter arity
-## Common typification pitfalls
-- Negative integer literals do not exist — use `0 - n`.
-- `debool(S)` fails if `S` is not a singleton.
-- Tuple projections require the argument to be a tuple of sufficient arity; `pr3((a, b))` is an error.
-- Filter parameter list arity must match the multi-index in `Fi[...]`.
-- A radical in the **result expression** of a template is a hard error (`radicalUsage`).
-- An `axiom` or `statement` must have typification `Logic`; non-logical formal definitions raise `expectedLogic`.
+- `debool(S)` без гарантии синглетона.
+- `pr3((a, b))`: индекс вне арности.
+- `Fi1,2[D](S)`: параметр `D` не совпал с двумя проекциями.
+- `A#` и `T#` не имеют `Logic`: будет `expectedLogic`.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rsconcept/rstool",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Agent-facing library for incremental RSForm construction, RSLang analysis, diagnostics, modeling, and evaluation. Wraps @rsconcept/domain with a deterministic session contract and stdio wrapper.",
   "license": "MIT",
   "author": "IRBorisov",