@opetope/lint 0.10.1 → 0.12.0

package/README.ru.md

@@ -35,18 +35,19 @@ export default [
 ```
 
 Плагин — это и default export, и именованный `opetopeLint`. Конфигурация регистрирует его в namespace `opetope`,
-поэтому правило называется `opetope/when-predicate`. Для разбора нужен `@typescript-eslint/parser`; он и `eslint`
+поэтому правило называется `opetope/enabled-predicate`. Для разбора нужен `@typescript-eslint/parser`; он и `eslint`
 объявлены peer dependencies.
 
 ## Configs
 
 ### `recommended`
 
-Все правила, которые действуют везде, где пишут на Opetope: `when-predicate`, `define-feature-property-order`,
+Все правила, которые действуют везде, где пишут на Opetope: `enabled-predicate`, `define-feature-property-order`,
 `require-literal-id`, `id-naming`, `no-internal-imports`, `no-snapshot-read-in-render`, `no-snapshot-in-update`,
-`no-redundant-const-tuple`, `no-command-in-deps`, `prefer-effect-current`, `capture-command-cleanup` и `require-declared-models` как error. Правило, которому нужно знать, где хост держит свои файлы, здесь выключено и
-приходит через `layers`; `prefer-model-selection` выключено потому, что число hooks, которое компонент вправе
-держать, каждый проект решает для себя.
+`no-redundant-const-tuple`, `no-command-in-deps`, `prefer-effect-current`, `no-write-after-source-write`,
+`capture-command-cleanup`, `require-declared-models` и `no-retired-vocabulary` как error. Правило, которому нужно знать, где хост держит
+свои файлы, здесь выключено и приходит через `layers`; `prefer-model-selection` выключено потому, что число hooks,
+которое компонент вправе держать, каждый проект решает для себя.
 
 `configs.recommended.rules` целиком — и ровно это поставляется как `@opetope/lint/oxlintrc.json`:
 
@@ -59,14 +60,16 @@ export default [
 | `no-command-in-deps`            | `error`       |                                                 |
 | `no-internal-imports`           | `error`       | плюс сужение через `internalImports({ allow })` |
 | `no-redundant-const-tuple`      | `error`       |                                                 |
+| `no-retired-vocabulary`         | `error`       |                                                 |
 | `no-snapshot-in-update`         | `error`       |                                                 |
 | `no-snapshot-read-in-render`    | `error`       |                                                 |
 | `no-subscribe-outside-models`   | `off`         | `layers({ models })`                            |
+| `no-write-after-source-write`   | `error`       |                                                 |
 | `prefer-effect-current`         | `error`       |                                                 |
 | `prefer-model-selection`        | `off`         | проект, со своим `threshold`                    |
 | `require-declared-models`       | `error`       |                                                 |
 | `require-literal-id`            | `error`       |                                                 |
-| `when-predicate`                | `error`       |                                                 |
+| `enabled-predicate`             | `error`       |                                                 |
 
 Три `off` — это ровно те три, которым нужно знание, которое есть только у проекта: какие каталоги каким слоем
 являются и сколько hooks вправе держать один компонент.
@@ -116,7 +119,7 @@ export default [
 Код приложения и тесты импортируют публичные входы Opetope. Правило запрещает `@opetope/*/internal` и вложенные
 пути в imports, re-exports, литеральных `import()`, незатенённых `require()`, TypeScript import types и
 `import = require`. Type-only импорты тоже проверяются: внутренний тип связывает потребителя с приватным ABI.
-Для запуска настоящего Call модели есть `runCall` из `@opetope/core/testing`, для открытия модели без фичи — `openModel` из `@opetope/runtime/testing`, для создания фикстуры — `command` из `@opetope/react/testing`.
+Для запуска настоящего Command модели есть `runCommand` из `@opetope/core/testing`, для открытия модели без фичи — `openModel` из `@opetope/runtime/testing`, для создания фикстуры — `command` из `@opetope/react/testing`.
 Автоматического исключения для тестов нет. Доверенные файлы реализации библиотеки или интеграции хоста можно
 разрешить явным override; autofix отсутствует, потому что публичная замена зависит от импортированной операции.
 
@@ -124,17 +127,17 @@ export default [
 вычисляемые пути, граф re-exports или пользовательские загрузчики. Локальный `require` не считается загрузчиком
 Node. Применяйте конфигурацию ко всем используемым JavaScript/TypeScript исходникам и тестам.
 
-### `when-predicate`
+### `enabled-predicate`
 
-`when` вклада отвечает фактом видимости этого экземпляра, а не источником, который этот факт несёт (D220). Правило
-читает `when` у вкладов `slot`, `pipe` и `register`, а также любой `when`, чья функция деструктурирует контекст
-вычисления `{ exports, imports, own, read }`, и сообщает о трёх формах:
+`enabled` вклада отвечает фактом видимости этого экземпляра, а не источником, который этот факт несёт (D220).
+Правило читает `enabled` у вкладов `slot`, `pipe` и `register`, а также любой `enabled`, чья функция деструктурирует
+контекст вычисления `{ exports, imports, own, read }`, и сообщает о трёх формах:
 
-| Написано                                   | О чём сообщает                                                                        |
-| ------------------------------------------ | ------------------------------------------------------------------------------------- |
-| `when: ({ imports }) => imports.x.allowed` | возвращает источник; фикс приводит к `({ imports, read }) => read(imports.x.allowed)` |
-| `when: async ({ read }) => read(x)`        | предикат отвечает синхронно; без фикса                                                |
-| `when: () => allowed`                      | `Readable<boolean>` передаётся в `when` как есть, без обёртки; без фикса              |
+| Написано                                      | О чём сообщает                                                                        |
+| --------------------------------------------- | ------------------------------------------------------------------------------------- |
+| `enabled: ({ imports }) => imports.x.allowed` | возвращает источник; фикс приводит к `({ imports, read }) => read(imports.x.allowed)` |
+| `enabled: async ({ read }) => read(x)`        | предикат отвечает синхронно; без фикса                                                |
+| `enabled: () => allowed`                      | `Readable<boolean>` передаётся в `enabled` как есть, без обёртки; без фикса           |
 
 Фикс оборачивает возвращённое обращение к полю в `read(...)` и добавляет `read` в деструктуризацию контекста, если
 его там нет. Именованный контекст читается через себя: `context => context.imports.x.allowed` становится
@@ -143,8 +146,9 @@ Node. Применяйте конфигурацию ко всем использ
 **Граница.** Правило читает формы, а не типы. `({ read }) => read(counter)` над не-boolean источником остаётся
 ошибкой типов, как и `read` над тем, что не является `Readable`. Если обращение к полю контекста вычисления — это
 обычное значение, а не источник, предикат не может изменить свой ответ, и правило сообщает о нём как о написанном
-для источника; вынеси такое решение из `when` или заглуши строку. `when` вне вклада — позиционный
-`(current, previous)` у `effect` или значение источника у `scope.while` — правило не трогает.
+для источника; вынеси такое решение из `enabled` или заглуши строку. `when` — другое поле, и правило не трогает его,
+где бы он ни стоял, — значение источника у `scope.while`; а фильтр изменений у эффекта — вовсе не `when`: это
+`filter`, и D379 дал ему это имя, чтобы одно слово не отвечало на два вопроса.
 
 ### `define-feature-property-order`
 
@@ -189,11 +193,15 @@ const summary = derive([total, label], (value, suffix) => `${value} ${suffix}`);
 
 ```tsx
 import { defineFeature } from '@opetope/runtime';
-import { requiresModels, useModel } from '@opetope/react';
+import { requiresModels, useCommand, useModel } from '@opetope/react';
 
 const Form = () => {
-  const actions = useModel(FormActions);
-  return null;
+  const submit = useCommand(useModel(FormActions).submit);
+  return (
+    <button disabled={submit.inFlight} onClick={() => void submit.run()}>
+      Отправить
+    </button>
+  );
 };
 const DeclaredForm = requiresModels([FormActions])(Form);
 
@@ -303,8 +311,8 @@ Id начинается с буквы и соединяет сегменты и
 Значение, переданное в `update`, читает то состояние, которое собирается заменить, — и составное,
 `update(sessions, { items: sessions.getSnapshot().items, kind: 'loading' })`, и скалярное,
 `update(total, total.getSnapshot() + amount)`. Чтение выполняется там, где написан аргумент, — до записи и на
-состоянии, которое может быть уже закрыто, где `getSnapshot()` бросает `ReadableError`, — а вычисленное значение
-ложится на состояние, которое с тех пор могло уйти вперёд. У формы с апдейтером нет ни одной из этих бед: она
+состоянии, которое могло уже остановиться, где `getSnapshot()` отвечает значением, которое больше никто не
+сдвинет, — а вычисленное значение ложится на состояние, которое с тех пор могло уйти вперёд. У формы с апдейтером нет ни одной из этих бед: она
 читает в момент записи, а у записи, отброшенной вместе с отменённым контекстом, апдейтер не вызывается вовсе
 (D282, D288, D295).
 
@@ -361,12 +369,12 @@ useEffect(() => {
 
 Правило читает массив зависимостей `useEffect`, `useLayoutEffect`, `useInsertionEffect`, `useCallback`, `useMemo` и
 `useImperativeHandle` и сообщает об элементе, который целиком является привязкой хука команды: о переменной
-`useCommand`, о ключе или деструктурированном имени `useCommands` и о поле выбора `useModel`, на котором тот же код
-читает `run`. `x.run` и статусы `x.inFlight` и `x.outcome` — это члены объекта, а не сам объект, и они остаются.
+`useCommand` и о ключе или деструктурированном имени выбора `useModel`, на котором тот же код читает `run`.
+`x.run` и статусы `x.inFlight` и `x.outcome` — это члены объекта, а не сам объект, и они остаются.
 
-Сама запись — форма ещё хуже, и у неё собственное сообщение: `useCommands` строит новый объект на каждом рендере, и
-то же делает `useModel` с выбором, поэтому `[hooks]` и `[order]` меняются на каждом рендере, а не на каждом
-статусе. Ответ здесь — то поле, которое читает колбэк: `hooks.save.run`.
+Сама запись — форма ещё хуже, и у неё собственное сообщение: `useModel` с выбором строит новый объект на каждом
+рендере, поэтому `[hooks]` и `[order]` меняются на каждом рендере, а не на каждом статусе. Ответ здесь — то поле,
+которое читает колбэк: `hooks.save.run`.
 
 Фикс пишется там, где ответ один: колбэк, который дотягивается до привязки единственным путём через `run`, получает
 на месте элемента этот путь — вместе со всем, через что элемент был написан: `as`, `satisfies` или `!` заменяются
@@ -376,8 +384,8 @@ useEffect(() => {
 видит, — написанный в другом месте, держащий сам объект, разбирающий его или читающий член вне этих четырёх —
 получает сообщение и ни одной suggestion.
 
-**Граница.** Имена разрешаются импортом в пределах одного модуля, а не написанием: `useCommand`, `useCommands` и
-`useModel` — это импорты `@opetope/react`, шесть хуков — собственные хуки React, а локальный алиас любого из них —
+**Граница.** Имена разрешаются импортом в пределах одного модуля, а не написанием: `useCommand` и `useModel` —
+это импорты `@opetope/react`, шесть хуков — собственные хуки React, а локальный алиас любого из них —
 `import { useEffect as effect }` — это тот же импорт. React — это модуль, названный ровно `react`; имя `@opetope/*`
 берётся ещё и из относительного импорта, потому что так пакет реэкспортирует собственный вход через barrel, и
 соседний `./scheduling` — React не больше, чем `@host/scheduling`. Хуки React читаются и через namespace, и через
@@ -401,14 +409,15 @@ namespace. Только `const` держит тот хук, которым ег
 Disposer, который возвращает такой колбэк, принадлежит этому узлу и сливается вместе с поколением, которое его
 открыло, — поэтому правило там молчит: это ровно та форма, которую предписывает его собственное сообщение (D299):
 
-| Колбэк                                         | Где                         | Ингресс |
-| ---------------------------------------------- | --------------------------- | ------- |
-| `resource.live({ connect })`                   | член `connect`              | да      |
-| `event(from, subscribe, run)`                  | второй аргумент             | да      |
-| `scope.while` / `scope.switch` / `scope.keyed` | `open`, второй аргумент     | да      |
-| `attach(source, { open })`                     | член `open`                 | да      |
-| `attach(source, { open, close })`              | член `close`                | нет     |
-| `apply`, `load`, `run`, `when`, `key`          | модификаторы тех же вызовов | нет     |
+| Колбэк                                  | Где                         | Ингресс |
+| --------------------------------------- | --------------------------- | ------- |
+| `resource.live({ connect })`            | член `connect`              | да      |
+| `event(source, subscribe, run)`         | второй аргумент             | да      |
+| `scope.while` / `scope.switch`          | `open`, второй аргумент     | да      |
+| `scope.each(source, key, open)`         | `open`, третий аргумент     | да      |
+| `attach(source, { open })`              | член `open`                 | да      |
+| `attach(source, { open, close })`       | член `close`                | нет     |
+| `apply`, `load`, `run`, `filter`, `key` | модификаторы тех же вызовов | нет     |
 
 `resource.load` не открывает подписки и ингресса не имеет вовсе, поэтому `subscribe`, написанный в его `load`,
 сообщается как любая другая подписка руками (D349).
@@ -421,7 +430,7 @@ own: ({ imports, resource }) => ({
     lifetime: 'owner',
     source: imports.exchange,
   }),
-});
+}),
 ```
 
 «Внутри» считается до самого низа: вложенная стрелка, тело `function`, `await` на самой подписке, disposer,
@@ -442,32 +451,137 @@ own: ({ imports, resource }) => ({
 
 ### `prefer-effect-current`
 
-`run` эффекта уже получил то значение, ради которого его запустили. Чтение того же источника через
-`source.getSnapshot()` внутри этого прогона читает его второй раз и ничего не говорит о том, какой это прогон,
-поэтому правило переписывает его в `execution.current` (D296, D323):
+`run` эффекта уже получил то значение, ради которого его запустили, — с D379 первым параметром. Чтение того же
+источника через `source.getSnapshot()` внутри этого прогона читает его второй раз и ничего не говорит о том, какой
+это прогон, поэтому правило переписывает его в этот параметр (D296, D323, D379):
 
 ```js
 // было
-ctx.effect(quotes, execution => publish(quotes.getSnapshot()));
+ctx.effect(quotes, current => publish(quotes.getSnapshot()));
 // стало
-ctx.effect(quotes, execution => publish(execution.current));
+ctx.effect(quotes, current => publish(current));
 ```
 
-Фикс пишет то слово, которое у прогона уже есть: имя контекста для `execution => …` и локальное имя, под которым
-взят `current`, для `({ current }) => …`. Прогон, не назвавший ни того ни другого, писать нечем, и тогда остаётся
-только сообщение.
+Фикс пишет то слово, которое у прогона уже есть: имя, под которым автор связал первый параметр, каким бы оно ни
+было. Прогону, который разобрал само значение на части или не взял параметра вовсе, назвать значение целиком нечем,
+и тогда остаётся только сообщение.
 
-**Два случая, о которых правило сообщает, но не переписывает.** После первого `await` в прогоне `current` — это
+**Два случая, о которых правило сообщает, но не переписывает.** После первого `await` в прогоне параметр — это
 значение, с которым прогон начался, а снимок — значение текущего момента; смена источника обычно перезапускает
-прогон, поэтому обычно они совпадают, — а «обычно» не даёт права на правку. Под `when` они расходятся законно:
-фильтр допускает одни значения и пропускает другие, поэтому источник меняется без перезапуска прогона (D168, D296).
-Запись модификаторов, которую правило прочитать не может — собранную в другом месте, — оно считает несущей предикат.
+прогон, поэтому обычно они совпадают, — а «обычно» не даёт права на правку. Под `filter` они расходятся законно:
+предикат допускает одни значения и пропускает другие, поэтому источник меняется без перезапуска прогона
+(D168, D296, D379). Запись модификаторов, которую правило прочитать не может — собранную в другом месте, — оно
+считает несущей предикат.
 
 Чтение внутри вложенного колбэка прогона — в `timers.delay`, в обработчике подписки — остаётся как есть: этот код
 выполняется позже прогона, и ему нужно значение того момента. Как и всякое правило, которое правит код, это
 разрешает свой контекст точно: `effect`, о котором идёт речь, объявлен на параметре типа `ModelContext` либо на
 контексте `model(Declaration, factory)`, написанном внутри `defineFeature` из `@opetope/runtime` (D309).
 
+### `no-write-after-source-write`
+
+Запись прогона эффекта в ячейку, которую читает его собственный источник, меняет значение, публикуемое этим
+источником, а уведомление синхронно: прогон отменяется внутри самой записи, поэтому каждая следующая запись прогона
+отбрасывается, а `invoke` после неё отклоняется. Первая из отброшенных записей доходит до репортера как `LostWrite`
+— одна на прогон, и в ней сказано, что остальные ушли вместе с ней (D432); отклонённый `invoke` по-прежнему молчит,
+и молчит любая другая потеря записи. Правило сообщает о записи, сдвигающей источник, когда за ней в том же прогоне
+может следовать ещё одна запись (spec §2.11, D288, D365, D432, D447):
+
+```ts
+// сообщается: депозит так и не записан, потому что освобождение ключа завершило прогон
+const key = context.state<string | null>('idempotency-1');
+const deposit = context.state<string | null>(null);
+const source = derive([frames, key], (frame, held) => `${frame}:${String(held)}`);
+
+context.effect(source, (_current, { update }) => {
+  update(key, null);
+  update(deposit, 'deposit-1');
+});
+```
+
+Команда, которую прогон зовёт через `invoke`, пишет под той же властью. `invoke` отдаёт команде отмену прогона,
+поэтому один abort кончает обоих, и запись такой команды в ячейку, которую читает источник прогона, завершает прогон
+ровно так же, как его собственная запись. Запись, до которой прогон после этого дошёл, отбрасывается и попадает в
+`LostWrite` наравне с любой другой (D447), — но чаще прогон в этот момент _ждёт_ этот самый вызов, и тогда обещание,
+которого он ждёт, отменяется, а тело не доходит ни до какой записи. Отброшенной записи там нет, рантайму сообщать не
+о чем, поэтому эту форму находит только правило — и сообщает о вызове там, где он написан:
+
+```ts
+// сообщается: ключ освобождает запись команды, а до депозита под вызовом прогон не доходит
+const key = context.state<string | null>('idempotency-1');
+const deposit = context.state<string | null>(null);
+const source = derive([frames, key], (frame, held) => `${frame}:${String(held)}`);
+const release = context.command(({ update }: ModelCommandContext<void>) => {
+  update(key, null);
+});
+
+context.effect(source, async (_current, { invoke, update }) => {
+  await invoke(release);
+  update(deposit, 'deposit-1');
+});
+```
+
+Виден ли дроп по данным — вопрос отдельный, и именно из-за него такой дефект находили в проде, а не в тесте: цикл
+открывает прогон-наследник для нового значения, если его допускает `filter`, и наследник, повторяющий запись, потерю
+скрывает — ячейка оказывается правильной через второй прогон. Потеря остаётся целиком там, где наследник эту запись
+не повторяет, — а именно так и ведёт себя гард (`if (held === null) return`), — и там, где наследник не открывается
+вовсе: так ведёт себя `filter`, отвергающий новое значение (D329). Запись репортеру приходит в каждой из этих форм,
+включая скрытую: она говорит об отброшенной записи, а не о значении, с которым осталась ячейка (D432).
+
+Фикса нет: какую из двух записей автор хотел сохранить, знает только он, а сообщение называет три выхода — сделать
+запись в источник последней записью прогона; держать накапливаемое вне источника и читать его через `getSnapshot()`,
+что заодно снимает и второй прогон; либо взять `execution.capture(state)` до сдвигающей записи — это единственный
+выход, который спасает саму эту запись целиком, хотя и не спасает ничего написанного после неё. Называет теми же
+словами, какими их печатает запись `LostWrite`, и равенство этих двух текстов держит `ci:source`: правило автор
+читает раньше, чем отчитается хоть один прогон (D319, D432, D442, D447).
+
+**Что доказывается до сообщения.** Три вещи, и четвёртая — там, где сдвигающую запись делает команда; там, где хотя
+бы одна не доказана, правило молчит.
+
+_Объявление._ `effect` объявлен на контексте этой библиотеки — `effect` на параметре типа `ModelContext` либо на
+контексте `model(Declaration, factory)`, написанном внутри `defineFeature` из `@opetope/runtime` (D309). Прогон —
+это функция, которую берёт объявление: написанная там же или связанная с именем в этом модуле.
+
+_Ячейка входит в источник._ Либо источник — это она сама, либо это `derive` из `@opetope/core` — написанный там, где
+его берёт объявление, или удержанный именем в этой области, — чьи зависимости её называют и чей селектор публикует
+значение этой зависимости. Последнее условие и есть вырезка самого закона: запись, после которой опубликованное
+значение осталось равным, не завершает ничего, поэтому селектор, который лишь задаёт вопрос о своей зависимости —
+`held === null ? 'none' : 'some'`, `!held`, `typeof held`, `held ? a : b`, — публикует для одного ключа то же слово,
+что и для другого, и над ним правило молчит. Молчит и над селектором, который зависимость выбрасывает, и над
+селектором, которого этот файл прочитать не может.
+
+_Запись может выполниться после._ Записи сделаны писателем этого прогона, прочитанным под теми же именами, под
+которыми `capture-command-cleanup` читает писателя команды: `execution.update(…)`, `({ update })` или
+`({ update: write })` в списке параметров и `const { update } = execution` в теле. Более поздняя запись обязана
+стоять в том же блоке, в более позднем операторе и без безусловного выхода из прогона между ними: у
+`if (held === null) { update(key, null); return; }` запись под `if` после этой выполниться не может, и о ней не
+сообщается. `break` и `continue` таким выходом не являются: код под ними выполняется.
+
+_Эту запись делает команда._ Там, где сдвигающая запись — это вызов, а не запись, вызов сделан через `invoke` этого
+прогона, прочитанный под теми же именами, что и писатель, а его первый аргумент — имя, за которым в этом модуле
+стоит `context.command(body)`, объявленный на контексте модели: `command` секции `own` у фичи берёт тело вторым и
+писателя не выдаёт (D385, D386). Тело — функция, которую берёт это объявление, написанная там же или связанная с
+именем в этом модуле, и хотя бы одна запись через контекст этого тела называет ячейку этого источника. Более поздняя
+запись прогона обязана следовать за вызовом по тому же правилу, по которому она следует за записью.
+
+**Граница.** Молчание не доказывает, что запись ляжет. За пределами форм выше правило не читает: источник,
+собранный в другой функции; источник, прочитанный с объекта (`deps.sources` — форма рецепта-защёлки); ячейку,
+приехавшую параметром; `derive` над `derive`; писателя, удержанного замыканием. Сдвигающей записью оно считает только
+`update`, поэтому commit в источник — тот же закон, «`update` или commit» — не сообщается; не сообщается и третья
+форма той же потери — `capture`, взятый **после** сдвигающей записи: он бросает собственную отмену прогона и не
+репортится нигде. Две записи одного оператора не последовательность — ветви `if`, плечи тернарного оператора,
+половины `try`, стороны запятой, — как и две записи одного `case`. Запись во вложенном колбэке прогона остаётся как
+есть: когда выполняется таймер или disposer, прогон уже кончился, и у её потери своя причина. Цикл, у которого запись
+в источник стоит последней, теряет первую запись следующего витка, и этого правило не видит.
+
+У вызова своя граница, и это граница одного шага. Команда, приехавшая зависимостью (`invoke(deps.release)`), команда,
+объявленная в другом модуле, команда на контексте, который этот файл разрешить не может, и команда, тело которой
+собрано в другом месте, не называют здесь ничего. Читается ровно один шаг: команда, сдвигающая источник через вторую
+команду, которую зовёт сама, или через `capture` ячейки источника, не сообщается; не сообщается и команда, чьё тело
+пишет в источник писателем, взятым не со своего контекста. И `invoke` прогона, у которого вся потеря — сам вызов
+(записи после вызова нет), тоже не сообщается: там ничего не потеряно — `await` не возвращается, а делать прогону
+больше было нечего (D447).
+
 ### `capture-command-cleanup`
 
 Писатель команды живёт столько же, сколько её вызывающий (D288). Запись в `finally` или `catch` у `try`, который
@@ -477,7 +591,7 @@ ctx.effect(quotes, execution => publish(execution.current));
 
 ```ts
 // сообщается: после отмены вызывающего `busy` остаётся `true`
-ctx.call(async (input, { signal, update }) => {
+ctx.command(async ({ input, signal, update }: ModelCommandContext<Payload>) => {
   update(busy, true);
   try {
     await host.send(input, signal);
@@ -487,7 +601,7 @@ ctx.call(async (input, { signal, update }) => {
 });
 
 // уборка ложится, пока жива модель
-ctx.call(async (input, { capture, signal, update }) => {
+ctx.command(async ({ capture, input, signal, update }: ModelCommandContext<Payload>) => {
   update(busy, true);
   const done = capture(busy);
   try {
@@ -502,16 +616,16 @@ ctx.call(async (input, { capture, signal, update }) => {
 запись отменённого вызова не должна затирать то, что написал более новый вызов. Поэтому сообщение называет оба выхода.
 Уборка, которая обязана выполниться для отменённого вызова, идёт через `capture(state)`, взятый до `await`; ответ,
 который не должен лечь после отмены, — отказ, результат, — стоит в `catch` после `rethrowIfCancelled(cause)`. Там, где
-вызывающий отменяет один прогон, чтобы начать следующий, — поиск, который потребитель запускает заново, Call,
+вызывающий отменяет один прогон, чтобы начать следующий, — поиск, который потребитель запускает заново, Command,
 вызванный прогоном эффекта и отменённый более новым значением, — запись старого прогона и есть та, что лечь не должна,
 и об этом говорит комментарий-отключение.
 
-При `policy: 'parallel'` сообщение commit не советует. Вызовы такой команды перекрываются, поэтому захваченная уборка
-отменённого вызова сняла бы флаг, который ещё держит другой вызов, — флаг, общий для параллельных вызовов, гонится в
-любом случае, — и сообщение говорит держать такое состояние на вызов или оставить ход потребителю через `inFlight`.
-Правило видит политику, только когда `{ policy: 'parallel' }` написан на самом `call`; запись модификаторов,
-собранная в другом месте, читается как очередь по умолчанию, где lane ждёт физического тела и захваченная уборка
-ложится по порядку.
+При `concurrency: 'parallel'` сообщение commit не советует. Вызовы такой команды перекрываются, поэтому захваченная
+уборка отменённого вызова сняла бы флаг, который ещё держит другой вызов, — флаг, общий для параллельных вызовов,
+гонится в любом случае, — и сообщение говорит держать такое состояние на вызов или оставить ход потребителю через
+`inFlight`. Правило видит порядок, только когда `{ concurrency: 'parallel' }` написан на самом `command`; запись
+модификаторов, собранная в другом месте, читается как очередь по умолчанию, где lane ждёт физического тела и
+захваченная уборка ложится по порядку (D387).
 
 Правило — эвристика над синтаксисом и ничего не доказывает о записи, о которой молчит. Писателя тела команды оно
 читает под такими именами: `execution.update(…)`; `({ update })` или `({ update: write })` в списке параметров;
@@ -528,9 +642,9 @@ ctx.call(async (input, { capture, signal, update }) => {
 `true`, и сообщения нет. Поэтому флаг, который обязан сняться при отмене, пишется в `finally` через `capture(state)`.
 Проверка в `finally` ничего не спасает и сообщается по-прежнему, как и проверка `signal.aborted`, которая не бросает и
 не возвращает. `effect`, `event` и остальные реакции правило не трогает: их прогон отменило более новое значение, и
-сброс его записи — ровно то, что нужно (D288). Контекст разрешается точно: `call` параметра типа `ModelContext` либо
-контекста `model(Declaration, factory)` внутри `defineFeature` из `@opetope/runtime` (D309); собственный `call` фичи
-писателя телу не даёт.
+сброс его записи — ровно то, что нужно (D288). Контекст разрешается точно: `command` параметра типа `ModelContext`
+либо контекста `model(Declaration, factory)` внутри `defineFeature` из `@opetope/runtime` (D309); собственный
+`command` фичи писателя телу не даёт.
 
 ### `prefer-model-selection`
 
@@ -545,6 +659,82 @@ ctx.call(async (input, { capture, signal, update }) => {
 выбора и считает каждую выданную модель отдельно: две модели в одном компоненте — это два гранта, а одно и то же
 имя переменной в двух компонентах — два счёта. Фикса нет: форму выбора пишет автор.
 
+### `no-retired-vocabulary`
+
+Слова, снятые волной D365–D411, — каждое названо вместе с тем, которое его заменило. Правило написано ровно на один
+проход миграции: в этом релизе ни у одного из них нет алиаса, поэтому исходник, который всё ещё пишет такое слово,
+просто не мигрирован, а после миграции правило не срабатывает никогда.
+
+| Снято                                                                                                             | Стало                                                       | Решение |
+| ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- | ------- |
+| `invalidate()` у Resource                                                                                         | `reset()`                                                   | D373    |
+| `backpressure` у события                                                                                          | `delivery`                                                  | D374    |
+| `kind` внутри записи доставки                                                                                     | `pending`                                                   | D374    |
+| `key` внутри записи доставки                                                                                      | `by`                                                        | D374    |
+| `activity` у состояния `loading`                                                                                  | `failure`                                                   | D375    |
+| `scope.keyed(source, open, { key })`                                                                              | `scope.each(source, key, open)`                             | D378    |
+| `skipInitial`                                                                                                     | `initial`, с перевёрнутой полярностью                       | D379    |
+| `when` у эффекта                                                                                                  | `filter` **или** `initial`                                  | D379    |
+| `onDispose`                                                                                                       | `finalize`                                                  | D379    |
+| `externalReadable`                                                                                                | `fromExternal`                                              | D380    |
+| `Call`, `ctx.call`, `runCall`                                                                                     | `Command`, `ctx.command`, `runCommand`                      | D385    |
+| `policy`, `queueBy`, `lane`                                                                                       | `concurrency`                                               | D387    |
+| `ctx.calls`, `own.calls`, `useCommands`                                                                           | `ctx.select`, `own.select`, `useModel(Declaration, select)` | D388    |
+| `once`                                                                                                            | `memoize`                                                   | D389    |
+| `from` у `defineCondition`                                                                                        | `source`                                                    | D411    |
+| `when` у вклада                                                                                                   | `enabled`                                                   | D411    |
+| `overflow: 'reject'` у live Resource                                                                              | `overflow: 'drop'`                                          | D411    |
+| `status` у `CommandOutcome`                                                                                       | `kind`                                                      | D411    |
+| `ResourceActivity` из `@opetope/devtools`                                                                         | `ResourceNodeActivity`                                      | D411    |
+| `ResourceDisposer`                                                                                                | `Disposer`                                                  | D411    |
+| `NavigatorPolicy`, `surface.policy`                                                                               | `NavigatorCatalogue`, `surface.catalogue`                   | D411    |
+| `ApplicationConditionBinding`, `ApplicationExecution` и `ApplicationImportBinding` из `@opetope/runtime/internal` | те же имена, из `@opetope/runtime`                          | D411    |
+
+**Одну строку по слову не выполнить, и отчёт договаривает остальное.** `ctx.call` становится `ctx.command`, а
+вместе с ним тело `(input, context) => …` становится телом, которое принимает один свой контекст, — и входу больше
+негде называться: частичного вывода типовых аргументов в TypeScript нет, и `command<Deposit>(…)` не маршрут.
+Единственное место — аннотация деструктурируемого контекста: `({ input, update }: ModelCommandContext<Deposit>)` у
+модели и `({ input, source }: FeatureCommandContext<typeof within, Deposit>)` у фичи, — поэтому отчёт называет эту
+аннотацию рядом со словом. Переименование, выполненное дословно без неё, оставляет это правило молчащим, а сборку
+красной, и каждый отказ при этом стоит на верно написанном коде (D444).
+
+**Автофикса нет, и это решение, а не недоделка (D404).** Часть строк здесь не один-к-одному. `policy`, `queueBy` и
+`lane` схлопываются в одно `concurrency`, чья форма зависит от того, какую комбинацию написала запись: `{ by }`,
+`{ by, lane }` и `{ lane, pending: 'latest' }` — три разных значения из тех же трёх слов. `when` у эффекта
+становится `filter` **или** `initial`, и что именно — вопрос о том, что проверяет предикат:
+`filter: (_current, previous) => previous !== undefined` — это вообще не фильтр, а `initial: false`, и руководство
+автора требует именно этого. А `skipInitial` становится `initial` с перевёрнутой полярностью, то есть единственная
+строка, выглядящая чисто механической, — ровно та, которая скомпилируется и будет значить обратное. Автофикс,
+угадавший неверно, молча перепишет исходник потребителя, а это хуже отказа, — поэтому каждое сообщение называет
+снятое слово, называет замену и прямо говорит там, где замена является выбором.
+
+**Граница.** Принадлежность доказывается символом, а не написанием. Снятый член репортится только на объявляющем
+контексте этой библиотеки — параметре, аннотированном `ModelContext` из `@opetope/core`, или секции `own`,
+написанной там, где её принимает `defineFeature` из `@opetope/runtime`, — и разрешается через алиас или
+деструктурированный член так же, как `no-subscribe-outside-models` разрешает ingress объявленного узла. Снятое имя
+репортится только там, где его экспортирует модуль `@opetope/*`, а там, где имя снято на одном входе и живо на
+другом, модуль спрашивается точно: `ResourceActivity` по-прежнему то, как `@opetope/core` называет фоновую работу
+состояния `ready`, а три имени `@opetope/runtime/internal` — по-прежнему имена, только на том входе, с которого их
+берёт автор. Гейт вклада репортится на секции `provides`, которую принимает `defineFeature` из `@opetope/runtime`, — так
+же, как объявленный узел репортится на `own`; `status` свершившегося ответа — только на `outcome` от `useCommand`
+из `@opetope/react`, а `policy` поверхности — только на значении, объявленном через `defineSurface` из
+`@opetope/navigation/react`. Resource — это значение, объявленное через
+`resource.load` или `resource.live` такого контекста, либо запись, которую отвечает `useResource` из
+`@opetope/react`; его состояние — `state` этой записи или `getSnapshot()` от него.
+`activity` репортится только внутри сужения, доказывающего, что состояние — `loading`: `if`, тернарник или левая
+половина `&&`, написанные про то же самое выражение, — потому что у `ready` это поле осталось.
+
+Молчание здесь и есть смысл. `Call` внутри `'Margin Call'` и внутри ключей каталога переводов, `{ once: true }` у
+`addEventListener`, собственный параметр `policy` хоста и `policy` чужого объекта, `Navigator.reset()` и поле
+`delivery` чужой записи — всё
+это не трогается, как и `when` у фичи и у `scope.while`, где слово не снято вовсе, и `status` чужой записи. Не трогается и то,
+чего правило не видит: Resource, до которого дошли через запись модели, а не через объявление, которое его
+построило; состояние, суженное в `switch` или внутри helper-а; запись опций, собранная в другом модуле. Поэтому
+молчание правила не доказывает, что миграция закончена: вторая половина — компилятор, который теперь печатает
+замену для каждого слова, которое может назвать (D401, D444). Шесть строк выше — слова, которые носила запись
+опций, и каждая такая запись называет своё снятое слово, чтобы отказ нёс замену: `skipInitial`, `when` и
+`onDispose` у эффекта, `backpressure` у события, `when` у вклада и `from` у `defineCondition`.
+
 ## Coexistence with key sorting
 
 Хост, который сортирует ключи объектов по алфавиту, разойдётся с `define-feature-property-order`: секции фичи

package/dist/ast.d.ts

@@ -14,5 +14,7 @@ declare function memberFirstStep(node: TSESTree.MemberExpression): string | unde
 declare function isFunctionLike(node: TSESTree.Node): node is FunctionLike;
 /** The name a function is written under: its own, or the binding it is assigned to. */
 declare function functionName(node: TSESTree.Node): string | undefined;
+/** Lexical containment by range: the one question a rule that collects nodes and answers later keeps asking. */
+declare function within(node: TSESTree.Node, outer: TSESTree.Node): boolean;
 export type { FunctionLike };
-export { calleeName, findProperty, functionName, isFunctionLike, memberFirstStep, memberRoot, patternKeys, propertyName, };
+export { calleeName, findProperty, functionName, isFunctionLike, memberFirstStep, memberRoot, patternKeys, propertyName, within, };

package/dist/ast.js

@@ -1,2 +1,2 @@
-import{AST_NODE_TYPES as r}from"@typescript-eslint/utils";function u(t){const{callee:e}=t;if(e.type===r.Identifier)return e.name;if(!(e.type!==r.MemberExpression||e.computed)&&!(e.object.type!==r.Identifier||e.property.type!==r.Identifier))return`${e.object.name}.${e.property.name}`}function i(t){if(!(t.type!==r.Property||t.computed)){if(t.key.type===r.Identifier)return t.key.name;if(t.key.type===r.Literal&&typeof t.key.value=="string")return t.key.value}}function f(t,e){for(const n of t.properties)if(n.type===r.Property&&i(n)===e)return n}function c(t){const e=new Set;for(const n of t.properties){const p=i(n);p!==void 0&&e.add(p)}return e}function y(t){let e=t;for(;e.type===r.MemberExpression;)e=e.object;return e}function a(t){let e=t;for(;e.object.type===r.MemberExpression;)e=e.object;if(!(e.computed||e.property.type!==r.Identifier))return e.property.name}function o(t){return t.type===r.ArrowFunctionExpression||t.type===r.FunctionExpression}function s(t){let e=t;for(;e.parent.type===r.CallExpression||e.parent.type===r.TSAsExpression;)e=e.parent;const{parent:n}=e;return n.type===r.VariableDeclarator&&n.id.type===r.Identifier?n.id.name:i(n)}function m(t){return t.type===r.FunctionDeclaration?t.id?.name:o(t)?(t.type===r.FunctionExpression?t.id?.name:void 0)??s(t):void 0}export{u as calleeName,f as findProperty,m as functionName,o as isFunctionLike,a as memberFirstStep,y as memberRoot,c as patternKeys,i as propertyName};
+import{AST_NODE_TYPES as t}from"@typescript-eslint/utils";function o(r){const{callee:e}=r;if(e.type===t.Identifier)return e.name;if(!(e.type!==t.MemberExpression||e.computed)&&!(e.object.type!==t.Identifier||e.property.type!==t.Identifier))return`${e.object.name}.${e.property.name}`}function i(r){if(!(r.type!==t.Property||r.computed)){if(r.key.type===t.Identifier)return r.key.name;if(r.key.type===t.Literal&&typeof r.key.value=="string")return r.key.value}}function f(r,e){for(const n of r.properties)if(n.type===t.Property&&i(n)===e)return n}function c(r){const e=new Set;for(const n of r.properties){const p=i(n);p!==void 0&&e.add(p)}return e}function y(r){let e=r;for(;e.type===t.MemberExpression;)e=e.object;return e}function a(r){let e=r;for(;e.object.type===t.MemberExpression;)e=e.object;if(!(e.computed||e.property.type!==t.Identifier))return e.property.name}function u(r){return r.type===t.ArrowFunctionExpression||r.type===t.FunctionExpression}function s(r){let e=r;for(;e.parent.type===t.CallExpression||e.parent.type===t.TSAsExpression;)e=e.parent;const{parent:n}=e;return n.type===t.VariableDeclarator&&n.id.type===t.Identifier?n.id.name:i(n)}function m(r){return r.type===t.FunctionDeclaration?r.id?.name:u(r)?(r.type===t.FunctionExpression?r.id?.name:void 0)??s(r):void 0}function d(r,e){return r.range[0]>=e.range[0]&&r.range[1]<=e.range[1]}export{o as calleeName,f as findProperty,m as functionName,u as isFunctionLike,a as memberFirstStep,y as memberRoot,c as patternKeys,i as propertyName,d as within};
 //# sourceMappingURL=ast.js.map

package/dist/ast.js.map

@@ -1 +1 @@
-{"version":3,"file":"ast.js","sources":["../src/ast.ts"],"sourcesContent":["import type { TSESTree } from '@typescript-eslint/utils';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\ntype FunctionLike = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;\n\n/** `slot` and `defineFeature.body` alike: the dotted name of the simple callee shapes an author writes. */\nfunction calleeName(node: TSESTree.CallExpression): string | undefined {\n  const { callee } = node;\n\n  if (callee.type === AST_NODE_TYPES.Identifier) return callee.name;\n\n  if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed) return undefined;\n\n  if (callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier) {\n    return undefined;\n  }\n\n  return `${callee.object.name}.${callee.property.name}`;\n}\n\n/** The static name of a property or a destructured key; a computed or dynamic key has none. */\nfunction propertyName(node: TSESTree.Node): string | undefined {\n  if (node.type !== AST_NODE_TYPES.Property || node.computed) return undefined;\n\n  if (node.key.type === AST_NODE_TYPES.Identifier) return node.key.name;\n\n  if (node.key.type === AST_NODE_TYPES.Literal && typeof node.key.value === 'string') return node.key.value;\n\n  return undefined;\n}\n\n/** The property of an object literal under a static key. */\nfunction findProperty(node: TSESTree.ObjectExpression, name: string): TSESTree.Property | undefined {\n  for (const property of node.properties) {\n    if (property.type === AST_NODE_TYPES.Property && propertyName(property) === name) return property;\n  }\n\n  return undefined;\n}\n\nfunction patternKeys(pattern: TSESTree.ObjectPattern): ReadonlySet<string> {\n  const keys = new Set<string>();\n\n  for (const property of pattern.properties) {\n    const name = propertyName(property);\n\n    if (name !== undefined) keys.add(name);\n  }\n\n  return keys;\n}\n\n/** The identifier at the root of `imports.platform.submitAllowed`. */\nfunction memberRoot(node: TSESTree.MemberExpression): TSESTree.Node {\n  let current: TSESTree.Node = node;\n\n  while (current.type === AST_NODE_TYPES.MemberExpression) current = current.object;\n\n  return current;\n}\n\n/** The first step of `context.imports.platform`, that is `imports`. */\nfunction memberFirstStep(node: TSESTree.MemberExpression): string | undefined {\n  let current = node;\n\n  while (current.object.type === AST_NODE_TYPES.MemberExpression) current = current.object;\n\n  if (current.computed || current.property.type !== AST_NODE_TYPES.Identifier) return undefined;\n\n  return current.property.name;\n}\n\nfunction isFunctionLike(node: TSESTree.Node): node is FunctionLike {\n  return node.type === AST_NODE_TYPES.ArrowFunctionExpression || node.type === AST_NODE_TYPES.FunctionExpression;\n}\n\n/** The binding a function expression is written into, past the wrappers it is passed through. */\nfunction boundName(node: FunctionLike): string | undefined {\n  let current: TSESTree.Node = node;\n\n  while (\n    current.parent.type === AST_NODE_TYPES.CallExpression ||\n    current.parent.type === AST_NODE_TYPES.TSAsExpression\n  ) {\n    current = current.parent;\n  }\n\n  const { parent } = current;\n\n  if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier) {\n    return parent.id.name;\n  }\n\n  return propertyName(parent);\n}\n\n/** The name a function is written under: its own, or the binding it is assigned to. */\nfunction functionName(node: TSESTree.Node): string | undefined {\n  if (node.type === AST_NODE_TYPES.FunctionDeclaration) return node.id?.name;\n\n  if (!isFunctionLike(node)) return undefined;\n\n  const own = node.type === AST_NODE_TYPES.FunctionExpression ? node.id?.name : undefined;\n\n  return own ?? boundName(node);\n}\n\nexport type { FunctionLike };\nexport {\n  calleeName,\n  findProperty,\n  functionName,\n  isFunctionLike,\n  memberFirstStep,\n  memberRoot,\n  patternKeys,\n  propertyName,\n};\n"],"names":["calleeName","node","callee","AST_NODE_TYPES","propertyName","findProperty","name","property","patternKeys","pattern","keys","memberRoot","current","memberFirstStep","isFunctionLike","boundName","parent","functionName"],"mappings":"0DAMA,SAASA,EAAWC,EAA6B,CAC/C,KAAM,CAAE,OAAAC,CAAM,EAAKD,EAEnB,GAAIC,EAAO,OAASC,EAAe,WAAY,OAAOD,EAAO,KAE7D,GAAI,EAAAA,EAAO,OAASC,EAAe,kBAAoBD,EAAO,WAE1D,EAAAA,EAAO,OAAO,OAASC,EAAe,YAAcD,EAAO,SAAS,OAASC,EAAe,YAIhG,MAAO,GAAGD,EAAO,OAAO,IAAI,IAAIA,EAAO,SAAS,IAAI,EACtD,CAGA,SAASE,EAAaH,EAAmB,CACvC,GAAI,EAAAA,EAAK,OAASE,EAAe,UAAYF,EAAK,UAElD,IAAIA,EAAK,IAAI,OAASE,EAAe,WAAY,OAAOF,EAAK,IAAI,KAEjE,GAAIA,EAAK,IAAI,OAASE,EAAe,SAAW,OAAOF,EAAK,IAAI,OAAU,SAAU,OAAOA,EAAK,IAAI,MAGtG,CAGA,SAASI,EAAaJ,EAAiCK,EAAY,CACjE,UAAWC,KAAYN,EAAK,WAC1B,GAAIM,EAAS,OAASJ,EAAe,UAAYC,EAAaG,CAAQ,IAAMD,EAAM,OAAOC,CAI7F,CAEA,SAASC,EAAYC,EAA+B,CAClD,MAAMC,EAAO,IAAI,IAEjB,UAAWH,KAAYE,EAAQ,WAAY,CACzC,MAAMH,EAAOF,EAAaG,CAAQ,EAE9BD,IAAS,QAAWI,EAAK,IAAIJ,CAAI,CACvC,CAEA,OAAOI,CACT,CAGA,SAASC,EAAWV,EAA+B,CACjD,IAAIW,EAAyBX,EAE7B,KAAOW,EAAQ,OAAST,EAAe,kBAAkBS,EAAUA,EAAQ,OAE3E,OAAOA,CACT,CAGA,SAASC,EAAgBZ,EAA+B,CACtD,IAAIW,EAAUX,EAEd,KAAOW,EAAQ,OAAO,OAAST,EAAe,kBAAkBS,EAAUA,EAAQ,OAElF,GAAI,EAAAA,EAAQ,UAAYA,EAAQ,SAAS,OAAST,EAAe,YAEjE,OAAOS,EAAQ,SAAS,IAC1B,CAEA,SAASE,EAAeb,EAAmB,CACzC,OAAOA,EAAK,OAASE,EAAe,yBAA2BF,EAAK,OAASE,EAAe,kBAC9F,CAGA,SAASY,EAAUd,EAAkB,CACnC,IAAIW,EAAyBX,EAE7B,KACEW,EAAQ,OAAO,OAAST,EAAe,gBACvCS,EAAQ,OAAO,OAAST,EAAe,gBAEvCS,EAAUA,EAAQ,OAGpB,KAAM,CAAE,OAAAI,CAAM,EAAKJ,EAEnB,OAAII,EAAO,OAASb,EAAe,oBAAsBa,EAAO,GAAG,OAASb,EAAe,WAClFa,EAAO,GAAG,KAGZZ,EAAaY,CAAM,CAC5B,CAGA,SAASC,EAAahB,EAAmB,CACvC,OAAIA,EAAK,OAASE,EAAe,oBAA4BF,EAAK,IAAI,KAEjEa,EAAeb,CAAI,GAEZA,EAAK,OAASE,EAAe,mBAAqBF,EAAK,IAAI,KAAO,SAEhEc,EAAUd,CAAI,EAJD,MAK7B"}
+{"version":3,"file":"ast.js","sources":["../src/ast.ts"],"sourcesContent":["import type { TSESTree } from '@typescript-eslint/utils';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\ntype FunctionLike = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;\n\n/** `slot` and `defineFeature.body` alike: the dotted name of the simple callee shapes an author writes. */\nfunction calleeName(node: TSESTree.CallExpression): string | undefined {\n  const { callee } = node;\n\n  if (callee.type === AST_NODE_TYPES.Identifier) return callee.name;\n\n  if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed) return undefined;\n\n  if (callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier) {\n    return undefined;\n  }\n\n  return `${callee.object.name}.${callee.property.name}`;\n}\n\n/** The static name of a property or a destructured key; a computed or dynamic key has none. */\nfunction propertyName(node: TSESTree.Node): string | undefined {\n  if (node.type !== AST_NODE_TYPES.Property || node.computed) return undefined;\n\n  if (node.key.type === AST_NODE_TYPES.Identifier) return node.key.name;\n\n  if (node.key.type === AST_NODE_TYPES.Literal && typeof node.key.value === 'string') return node.key.value;\n\n  return undefined;\n}\n\n/** The property of an object literal under a static key. */\nfunction findProperty(node: TSESTree.ObjectExpression, name: string): TSESTree.Property | undefined {\n  for (const property of node.properties) {\n    if (property.type === AST_NODE_TYPES.Property && propertyName(property) === name) return property;\n  }\n\n  return undefined;\n}\n\nfunction patternKeys(pattern: TSESTree.ObjectPattern): ReadonlySet<string> {\n  const keys = new Set<string>();\n\n  for (const property of pattern.properties) {\n    const name = propertyName(property);\n\n    if (name !== undefined) keys.add(name);\n  }\n\n  return keys;\n}\n\n/** The identifier at the root of `imports.platform.submitAllowed`. */\nfunction memberRoot(node: TSESTree.MemberExpression): TSESTree.Node {\n  let current: TSESTree.Node = node;\n\n  while (current.type === AST_NODE_TYPES.MemberExpression) current = current.object;\n\n  return current;\n}\n\n/** The first step of `context.imports.platform`, that is `imports`. */\nfunction memberFirstStep(node: TSESTree.MemberExpression): string | undefined {\n  let current = node;\n\n  while (current.object.type === AST_NODE_TYPES.MemberExpression) current = current.object;\n\n  if (current.computed || current.property.type !== AST_NODE_TYPES.Identifier) return undefined;\n\n  return current.property.name;\n}\n\nfunction isFunctionLike(node: TSESTree.Node): node is FunctionLike {\n  return node.type === AST_NODE_TYPES.ArrowFunctionExpression || node.type === AST_NODE_TYPES.FunctionExpression;\n}\n\n/** The binding a function expression is written into, past the wrappers it is passed through. */\nfunction boundName(node: FunctionLike): string | undefined {\n  let current: TSESTree.Node = node;\n\n  while (\n    current.parent.type === AST_NODE_TYPES.CallExpression ||\n    current.parent.type === AST_NODE_TYPES.TSAsExpression\n  ) {\n    current = current.parent;\n  }\n\n  const { parent } = current;\n\n  if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier) {\n    return parent.id.name;\n  }\n\n  return propertyName(parent);\n}\n\n/** The name a function is written under: its own, or the binding it is assigned to. */\nfunction functionName(node: TSESTree.Node): string | undefined {\n  if (node.type === AST_NODE_TYPES.FunctionDeclaration) return node.id?.name;\n\n  if (!isFunctionLike(node)) return undefined;\n\n  const own = node.type === AST_NODE_TYPES.FunctionExpression ? node.id?.name : undefined;\n\n  return own ?? boundName(node);\n}\n\n/** Lexical containment by range: the one question a rule that collects nodes and answers later keeps asking. */\nfunction within(node: TSESTree.Node, outer: TSESTree.Node): boolean {\n  return node.range[0] >= outer.range[0] && node.range[1] <= outer.range[1];\n}\n\nexport type { FunctionLike };\nexport {\n  calleeName,\n  findProperty,\n  functionName,\n  isFunctionLike,\n  memberFirstStep,\n  memberRoot,\n  patternKeys,\n  propertyName,\n  within,\n};\n"],"names":["calleeName","node","callee","AST_NODE_TYPES","propertyName","findProperty","name","property","patternKeys","pattern","keys","memberRoot","current","memberFirstStep","isFunctionLike","boundName","parent","functionName","within","outer"],"mappings":"0DAMA,SAASA,EAAWC,EAA6B,CAC/C,KAAM,CAAE,OAAAC,CAAM,EAAKD,EAEnB,GAAIC,EAAO,OAASC,EAAe,WAAY,OAAOD,EAAO,KAE7D,GAAI,EAAAA,EAAO,OAASC,EAAe,kBAAoBD,EAAO,WAE1D,EAAAA,EAAO,OAAO,OAASC,EAAe,YAAcD,EAAO,SAAS,OAASC,EAAe,YAIhG,MAAO,GAAGD,EAAO,OAAO,IAAI,IAAIA,EAAO,SAAS,IAAI,EACtD,CAGA,SAASE,EAAaH,EAAmB,CACvC,GAAI,EAAAA,EAAK,OAASE,EAAe,UAAYF,EAAK,UAElD,IAAIA,EAAK,IAAI,OAASE,EAAe,WAAY,OAAOF,EAAK,IAAI,KAEjE,GAAIA,EAAK,IAAI,OAASE,EAAe,SAAW,OAAOF,EAAK,IAAI,OAAU,SAAU,OAAOA,EAAK,IAAI,MAGtG,CAGA,SAASI,EAAaJ,EAAiCK,EAAY,CACjE,UAAWC,KAAYN,EAAK,WAC1B,GAAIM,EAAS,OAASJ,EAAe,UAAYC,EAAaG,CAAQ,IAAMD,EAAM,OAAOC,CAI7F,CAEA,SAASC,EAAYC,EAA+B,CAClD,MAAMC,EAAO,IAAI,IAEjB,UAAWH,KAAYE,EAAQ,WAAY,CACzC,MAAMH,EAAOF,EAAaG,CAAQ,EAE9BD,IAAS,QAAWI,EAAK,IAAIJ,CAAI,CACvC,CAEA,OAAOI,CACT,CAGA,SAASC,EAAWV,EAA+B,CACjD,IAAIW,EAAyBX,EAE7B,KAAOW,EAAQ,OAAST,EAAe,kBAAkBS,EAAUA,EAAQ,OAE3E,OAAOA,CACT,CAGA,SAASC,EAAgBZ,EAA+B,CACtD,IAAIW,EAAUX,EAEd,KAAOW,EAAQ,OAAO,OAAST,EAAe,kBAAkBS,EAAUA,EAAQ,OAElF,GAAI,EAAAA,EAAQ,UAAYA,EAAQ,SAAS,OAAST,EAAe,YAEjE,OAAOS,EAAQ,SAAS,IAC1B,CAEA,SAASE,EAAeb,EAAmB,CACzC,OAAOA,EAAK,OAASE,EAAe,yBAA2BF,EAAK,OAASE,EAAe,kBAC9F,CAGA,SAASY,EAAUd,EAAkB,CACnC,IAAIW,EAAyBX,EAE7B,KACEW,EAAQ,OAAO,OAAST,EAAe,gBACvCS,EAAQ,OAAO,OAAST,EAAe,gBAEvCS,EAAUA,EAAQ,OAGpB,KAAM,CAAE,OAAAI,CAAM,EAAKJ,EAEnB,OAAII,EAAO,OAASb,EAAe,oBAAsBa,EAAO,GAAG,OAASb,EAAe,WAClFa,EAAO,GAAG,KAGZZ,EAAaY,CAAM,CAC5B,CAGA,SAASC,EAAahB,EAAmB,CACvC,OAAIA,EAAK,OAASE,EAAe,oBAA4BF,EAAK,IAAI,KAEjEa,EAAeb,CAAI,GAEZA,EAAK,OAASE,EAAe,mBAAqBF,EAAK,IAAI,KAAO,SAEhEc,EAAUd,CAAI,EAJD,MAK7B,CAGA,SAASiB,EAAOjB,EAAqBkB,EAAoB,CACvD,OAAOlB,EAAK,MAAM,CAAC,GAAKkB,EAAM,MAAM,CAAC,GAAKlB,EAAK,MAAM,CAAC,GAAKkB,EAAM,MAAM,CAAC,CAC1E"}

package/dist/command-hooks.d.ts

@@ -1,6 +1,6 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-/** What a name holds: one hook, a record of them, a selection whose fields may be hooks, or one such field. */
-type HookKind = 'candidate' | 'hook' | 'hooks' | 'selection';
+/** What a name holds: one hook, a selection whose fields may be hooks, or one such field (D388). */
+type HookKind = 'candidate' | 'hook' | 'selection';
 type HookKinds = Map<TSESLint.Scope.Variable, HookKind>;
 /**
  * What a dependency element names: one hook (no key, not a record), one key of a record, or the record itself,

package/dist/command-hooks.js

@@ -1,2 +1,2 @@
-import{AST_NODE_TYPES as o}from"@typescript-eslint/utils";import{apiName as h,localValue as I,variableOf as d,unwrap as p}from"./model-bindings.js";const O=new Set(["inFlight","outcome","run"]),S=["inFlight","outcome"],l=new Set(["hooks","selection"]),g=2,y={member:void 0,optional:!1,text:""},R={accesses:[],opaque:!0};function s(n){const{parent:e}=n;if(!(e.type!==o.MemberExpression||e.object!==n||e.computed)&&e.property.type===o.Identifier)return{key:e.property.name,node:e,optional:e.optional}}function c(n,e,i){return e===void 0||!O.has(e.key)?y:{member:e.key,optional:i||e.optional,text:n.getText(e.node)}}function m(n,e,i){const t=s(e);return!i.record&&i.key===void 0?c(n,t,!1):t===void 0?y:i.key===void 0||t.key===i.key?c(n,s(t.node),t.optional):void 0}function x(n,e){return n.range[0]>=e.range[0]&&n.range[1]<=e.range[1]}function A(n,e,i){if(i===void 0)return R;const t=[];let r=!1;for(const{identifier:f}of e.variable.references){if(f.type!==o.Identifier||!x(f,i))continue;const u=m(n,f,e);u!==void 0&&(u.member===void 0?r=!0:t.push(u))}return{accesses:t,opaque:r}}function M(n,e){for(const{identifier:i}of e.variable.references)if(i.type===o.Identifier&&m(n,i,e)?.member==="run")return!0;return!1}function k(n,e){return e===null?"":n.get(e)??""}function E(n,e){return!e.proved||M(n,e)?e:void 0}function T(n,e,i){const t=d(n,i),r=k(e,t);if(t===null||r==="")return;const f=l.has(r);return E(n,{key:void 0,proved:r==="candidate",record:f,variable:t})}function C(n){const e=p(n.object);if(!(n.computed||n.property.type!==o.Identifier))return e.type===o.Identifier?{key:n.property.name,object:e}:void 0}function _(n,e,i){const t=C(i);if(t===void 0)return;const r=d(n,t.object),f=k(e,r);if(!(r===null||!l.has(f)))return E(n,{key:t.key,proved:f==="selection",record:!1,variable:r})}function j(n,e,i){const t=p(i);return t.type===o.Identifier?T(n,e,t):t.type===o.MemberExpression?_(n,e,t):void 0}function a(n,e,i,t){if(e.type!==o.Identifier)return;const r=d(n,e);r!==null&&i.set(r,t)}function v(n,e,i,t,r){if(e.type!==o.ObjectPattern){a(n,e,i,t);return}for(const f of e.properties)f.type===o.Property&&a(n,f.value,i,r)}function B(n,e){if(e.parent.kind!=="const"||e.init===null)return;const i=I(n,e.init);return i.type===o.CallExpression?i:void 0}function D(n,e,i){const t=B(n,e);if(t===void 0)return;const r=h(n,t.callee,"@opetope/react");r==="useCommand"?a(n,e.id,i,"hook"):r==="useCommands"?v(n,e.id,i,"hooks","hook"):r==="useModel"&&t.arguments.length>=g&&v(n,e.id,i,"selection","candidate")}export{S as STATUS_MEMBERS,j as bindingAt,D as classifyDeclaration,A as usageIn};
+import{AST_NODE_TYPES as o}from"@typescript-eslint/utils";import{apiName as v,localValue as I,variableOf as d,unwrap as p}from"./model-bindings.js";const O=new Set(["inFlight","outcome","run"]),S=["inFlight","outcome"],l=new Set(["selection"]),h=2,y={member:void 0,optional:!1,text:""},g={accesses:[],opaque:!0};function c(n){const{parent:e}=n;if(!(e.type!==o.MemberExpression||e.object!==n||e.computed)&&e.property.type===o.Identifier)return{key:e.property.name,node:e,optional:e.optional}}function a(n,e,i){return e===void 0||!O.has(e.key)?y:{member:e.key,optional:i||e.optional,text:n.getText(e.node)}}function m(n,e,i){const t=c(e);return!i.record&&i.key===void 0?a(n,t,!1):t===void 0?y:i.key===void 0||t.key===i.key?a(n,c(t.node),t.optional):void 0}function R(n,e){return n.range[0]>=e.range[0]&&n.range[1]<=e.range[1]}function x(n,e,i){if(i===void 0)return g;const t=[];let r=!1;for(const{identifier:f}of e.variable.references){if(f.type!==o.Identifier||!R(f,i))continue;const u=m(n,f,e);u!==void 0&&(u.member===void 0?r=!0:t.push(u))}return{accesses:t,opaque:r}}function A(n,e){for(const{identifier:i}of e.variable.references)if(i.type===o.Identifier&&m(n,i,e)?.member==="run")return!0;return!1}function k(n,e){return e===null?"":n.get(e)??""}function E(n,e){return!e.proved||A(n,e)?e:void 0}function M(n,e,i){const t=d(n,i),r=k(e,t);if(t===null||r==="")return;const f=l.has(r);return E(n,{key:void 0,proved:r==="candidate",record:f,variable:t})}function T(n){const e=p(n.object);if(!(n.computed||n.property.type!==o.Identifier))return e.type===o.Identifier?{key:n.property.name,object:e}:void 0}function _(n,e,i){const t=T(i);if(t===void 0)return;const r=d(n,t.object),f=k(e,r);if(!(r===null||!l.has(f)))return E(n,{key:t.key,proved:f==="selection",record:!1,variable:r})}function j(n,e,i){const t=p(i);return t.type===o.Identifier?M(n,e,t):t.type===o.MemberExpression?_(n,e,t):void 0}function s(n,e,i,t){if(e.type!==o.Identifier)return;const r=d(n,e);r!==null&&i.set(r,t)}function B(n,e,i,t,r){if(e.type!==o.ObjectPattern){s(n,e,i,t);return}for(const f of e.properties)f.type===o.Property&&s(n,f.value,i,r)}function C(n,e){if(e.parent.kind!=="const"||e.init===null)return;const i=I(n,e.init);return i.type===o.CallExpression?i:void 0}function D(n,e,i){const t=C(n,e);if(t===void 0)return;const r=v(n,t.callee,"@opetope/react");r==="useCommand"?s(n,e.id,i,"hook"):r==="useModel"&&t.arguments.length>=h&&B(n,e.id,i,"selection","candidate")}export{S as STATUS_MEMBERS,j as bindingAt,D as classifyDeclaration,x as usageIn};
 //# sourceMappingURL=command-hooks.js.map