@opetope/runtime 0.1.1 → 0.4.0

package/docs/spec.md

@@ -57,8 +57,8 @@ const catalogCatalogFeature = defineFeature({
     ...calls(imports.platform, ['resolveItem']), // host methods as Calls, one to one
   }),
   exports: ({ own }) => ({ resolveItem: own.resolveItem }), // for features that import this definition
-  provides: ({ port, own }) => ({
-    resolve: port(resolveItemPort, own.resolveItem), // the port for whoever requires it
+  provides: ({ port }) => ({
+    resolve: port(resolveItemPort, ({ own }) => own.resolveItem), // the port for whoever requires it
   }),
 });
 ```
@@ -105,17 +105,18 @@ const createFormFeature = defineFeature({
     order: model(OrderModel, { platform: imports.platform }, (ctx, { platform }) => createOrderModel(ctx, platform)),
     lookup: requires.resolveItem, // inside `own` a port stays a ref
   }),
-  // here `own` is already materialized: both the port and the model field arrived as live `Call`s
-  exports: ({ own }) => ({ lookup: own.lookup, submit: own.order.submit }),
+  // consumers get the public lookup Call; submit stays inside this feature
+  exports: ({ own }) => ({ lookup: own.lookup }),
   provides: ({ slot, pipe }) => ({
     // a contribution is a value, an instance factory or a pipe descriptor; `priority` and `when` go in the options
-    content: slot(orderFormContentSlot, ({ exports, model }) => ({
+    content: slot(orderFormContentSlot, ({ own, model }) => ({
       Component: CreateForm,
       // the contribution's UI model: created per mount, and it sees the `props` of exactly that mount
       models: [
         model(OrderActions, (ctx, props: Readable<OrderFormProps>) => ({
           submit: ctx.call({
-            run: (amount: number, { invoke }) => invoke(exports.submit, { amount, itemId: props.getSnapshot().itemId }),
+            run: (amount: number, { invoke }) =>
+              invoke(own.order.submit, { amount, itemId: props.getSnapshot().itemId }),
           }),
         })),
       ],
@@ -181,7 +182,7 @@ publication barrier. All of it belongs to the runtime and its integration layer.
 | `id`        | What the feature is called             | `'feature.entity'`, dots only, no suffixes                                                                                                                       |
 | `imports`   | What the outside gives me              | a record of `defineHostContract` contracts and other feature definitions; `optional(x)` is a weak edge, `onDemand(hostContract)` defers binding to the first use |
 | `requires`  | Which port I need                      | a record of `port` or `optional(port)`; each `requires.x` is a ref, and the `Call` appears on the instance                                                       |
-| ref vs Call | What is visible at which stage         | `own` and the outer `provides` factory see refs; `exports` and nested contribution factories see materialized instance values                                    |
+| ref vs Call | What is visible at which stage         | the `own` builder sees dependency refs; `provides` sees only builders; `exports`, port selectors and contribution factories see materialized instance values     |
 | `own`       | What I own                             | builder: `model`, `call`, `calls`, `lane`, `effect`, `event`, `resource`, `stream`, `scope`, `attach`                                                            |
 | `exports`   | What I hand to features that import me | `({ own }) => a record of Call, Readable and Resource` computed when the instance opens                                                                          |
 | `provides`  | What I offer to extension points       | `({ port, slot, pipe, register, own }) => ...`                                                                                                                   |
@@ -269,14 +270,18 @@ the second factory argument is a readonly map of resolved values with inferred t
 source, or `model(Decl, create)` for none. Only authentic imports and call refs of the current feature are accepted;
 optional imports retain `Readable<Lookup<…>>`. Raw host objects, port declarations, foreign refs and model refs do
 not form dependency entries. A named factory may declare its own dependency interface without seeing the feature
-context. `provides.port(SubmitPort, { from: own.order, select: order => order.submit })` selects an authentic call
-once from the materialized model before publication and adds the provider's lifetime fence, including passthrough
-calls. A local call ref still uses `port(SubmitPort, own.submit)` (D169).
+context. `port(SubmitPort, ({ own }) => own.order.submit)` selects an authentic call from the current instance's
+`own` once during preparation, before readiness and contribution publication, and adds the provider's lifetime
+fence, including passthrough calls. `port(SubmitPort, ({ own }) => own.submit)` selects a call declared directly in
+`own`. The selector receives only `{ own }`; its result must be an authentic Call exposed by a value it selects
+from this `own`, including a model field. Foreign Calls and plain functions are rejected. Direct refs and
+`{ from, select }` descriptors are not accepted. Retirement during a selector prevents later selectors from running
+and drains the work already owned (D255).
 
 A contribution has two kinds of model, both declared with the same `defineModel`. `own` models live with the feature
 instance and are served to a mount automatically. A contribution's UI model lives with the mount: it is listed in the
 contribution's `models`, its factory receives the `Readable` of that mount's props as its second argument and either
-takes fields as they are (`submit: exports.submit`) or wraps them in `ctx.call` when the UI contract differs in
+takes fields as they are (`submit: own.order.submit`) or wraps them in `ctx.call` when the UI contract differs in
 input, in result shape or in the number of feature calls. There is no separate View concept.
 
 ### 2.3 UI
@@ -290,7 +295,9 @@ takes them as they are, with a `props` adapter it takes exactly the adapter's re
 
 `opetope/require-declared-models` in `@opetope/lint` recommended checks visible `slot` contributions and model readers within one module. It resolves import aliases and local bindings, including named components. Imported implementations and dynamic declarations remain unverified; no diagnostic does not prove their requirements complete (D250).
 
-Hooks: `useModel`, `useReadable`, `useSelector`, `useCommand`, `useCommands`, `useResource`. Components: `Slot`, and
+Every mount is a boundary: a contribution whose render or commit throws is contained there, reported to the feature
+that published it, and replaced by the content of `ContributionBoundary` — one host policy declared once, above every
+slot, never per slot (D256). Hooks: `useModel`, `useReadable`, `useSelector`, `useCommand`, `useCommands`, `useResource`. Components: `Slot`, and
 `FeatureBoundary` from `@opetope/react/integration`, which holds a feature open and renders `fallback` or `error`.
 Both of its branches take either a node or a render callback: `children` receives the ready instance typed by the
 demand, `error` receives `{ error, retry }`, only the branch that is shown runs, and a ready consumer needs no
@@ -386,6 +393,17 @@ the call site. The optional `cleanupFailure` carries the same two words as `open
 the host that chooses `quarantine` keeps a failed cleanup as an exact frontier on `FeatureError.retryCleanup`
 instead of a report, and the devtools control port can then retry it (D182).
 
+The root of the application is where a host states what a failed contribution shows, once for every mount below it:
+
+```tsx
+// bootstrap/root.tsx — the application root, above every slot
+const Root = () => (
+  <ContributionBoundary error={({ error, retry }) => <FailedContribution error={error} onRetry={retry} />}>
+    <Slot target={applicationSurface} />
+  </ContributionBoundary>
+);
+```
+
 ---
 
 ## 3. Public vocabulary
@@ -437,17 +455,26 @@ remain. Resource retry and feature-demand retry keep their own meaning. The form
 `event` the source and the carrier of type inference are positional: `resource(from, target, {…})`,
 `stream(from, target, {…})`, `event(from, subscribe, {…})`; the key order inside the options object is free. One
 option carries the same word for both: a stream requires `backpressure: latest()` and an `event` admits it. The
-methods of `provides`: `port`, `slot`, `pipe`, `register`; contributions take the target first, a value or an
+outer `provides` factory receives exactly `{ port, slot, pipe, register }`: only builders, with no `own` or other
+instance values. `port(Port, ({ own }) => own.model.call)` records the target at declaration and selects a Call
+when the instance prepares. Contributions take the target first, a value or an
 instance factory second, and options third: `slot(target, contribution, { priority, when })`,
 `pipe(target, { fold }, { priority, when })`, `register(target, entry, { priority, when })`, where `pipe`'s second
 argument is a descriptor because a bare function would be indistinguishable from the instance factory. The
-contribution factory context is `{ exports, imports, instance, model, own }`, and its `model(Decl, create)` builds
-the mount's UI model, where `create` receives `(ctx, props)`. `when` is a `Readable<boolean>` or a predicate of the
-instance — `({ exports, imports, own, read }) => boolean` — whose `read` records what the answer depends on: while
+`register` factory receives `{ own, imports }`; a `slot` factory receives `{ own, imports, model }`, where
+`model(Decl, create)` builds the mount's UI model and `create` receives `(ctx, props)`. These contexts contain only
+the fields named here: there is no `exports` or `instance`, and `register` has no model builder (D255).
+In either nested factory, `own` contains this instance's materialized models, calls and resources, just as in `exports`.
+`register(target, ({ own }) => ({ key: 'submit', value: own.order.submit }))` can publish a private model call
+without an `exports` section. Both port selectors and contribution factories select live values through their
+own callback context. Attachments, scopes, effects and events
+have no readable value form; unselected entries do not prevent access to the model or call alongside them.
+`when` is a `Readable<boolean>` or a predicate of the
+instance — `({ own, imports, read }) => boolean` — whose `read` records what the answer depends on: while
 the answer is `false` the contribution does not enter the target's `entries`. In that evaluation context `own` is
-the materialized form `exports` sees, so a model field is a `Readable` and not the ref the factory context carries.
+the materialized form `exports` sees, so a model field is a `Readable` and not the ref returned by the `own` builder.
 A `pipe` descriptor's `fold` receives that same evaluation context as its third argument —
-`(value, meta, { exports, imports, own, read }) => …` — bound to the instance once when the contribution publishes
+`(value, meta, { own, imports, read }) => …` — bound to the instance once when the contribution publishes
 and called only by a `fold`, never at declaration or preload; `target.fold(value, meta, read?)` accepts the reader
 as its third parameter, so `computed({ read: read => target.fold(0, undefined, read) })` subscribes both to
 `entries` and to everything the handlers read; without a reader the handlers read the current snapshot. Contexts:
@@ -591,6 +618,21 @@ Each law is proved by package tests and survives renaming.
   thrown away — the second StrictMode copy, an abandoned concurrent pass, a subtree suspended by a lazy sibling —
   creates nothing at all, so nothing has to be swept, adopted or rebuilt, and a child layout effect never sees a
   closed mount.
+- **Contained contributions.** A mount is the boundary of the contribution it renders (D256). A render or commit that
+  throws — the component, an ungranted model, a source read, the creation of the mount's own UI models — stops there,
+  is reported to the feature that published the contribution, and never reaches the boundary of the host. The other
+  mounts of the same target and the rest of the tree keep rendering. Containment is unconditional; what a failed mount
+  shows is the `error` content of `ContributionBoundary`, declared once above every slot, and nothing at all without
+  it; that content lives in a stable ref, so an inline error branch re-renders no mount and content replaced
+  mid-failure lands on the next one. Its `retry` remounts the subtree, so the models of the contribution are created again rather than reused. Error
+  content is foreign code too: a failure inside it is contained by a second boundary that exists only after the first
+  failure, reported the same way, and leaves the mount empty instead of escalating.
+- **Named failures.** A contained failure names itself (D257): `contribution` is the published entry,
+  `<feature>.<provides key>`, `target` is the slot it rendered in, and `feature` is the publishing feature or
+  `undefined` for a test fixture. The error content receives the three next to the raw `error` and its `retry`; the
+  reporter receives them on a `ContributionError` whose `cause` is that same error, with code `render-failed` for the
+  contribution and `error-content-failed` for error content that failed in its place. A contained failure that was a
+  cancellation stays one: the wrapper carries the same brand, so `isCancellation` answers as it did before.
 - **Structural readers.** `Readable`, `Resource` and the demand source are structural contracts, so a host may
   implement one with an object whose members are methods. Every hook calls them through the object it was handed and
   never as a detached function, so an adapter may rely on its own `this` (D199).

package/docs/spec.ru.md

@@ -55,8 +55,8 @@ const catalogCatalogFeature = defineFeature({
     ...calls(imports.platform, ['resolveItem']), // методы хоста как Call, один к одному
   }),
   exports: ({ own }) => ({ resolveItem: own.resolveItem }), // для фич, импортирующих это определение
-  provides: ({ port, own }) => ({
-    resolve: port(resolveItemPort, own.resolveItem), // порт для тех, кто его требует
+  provides: ({ port }) => ({
+    resolve: port(resolveItemPort, ({ own }) => own.resolveItem), // порт для тех, кто его требует
   }),
 });
 ```
@@ -103,17 +103,18 @@ const createFormFeature = defineFeature({
     order: model(OrderModel, { platform: imports.platform }, (ctx, { platform }) => createOrderModel(ctx, platform)),
     lookup: requires.resolveItem, // в `own` порт остаётся ref-ом
   }),
-  // здесь `own` уже материализован: и порт, и поле модели пришли живыми `Call`
-  exports: ({ own }) => ({ lookup: own.lookup, submit: own.order.submit }),
+  // потребители получают публичный Call lookup; submit остаётся внутри этой фичи
+  exports: ({ own }) => ({ lookup: own.lookup }),
   provides: ({ slot, pipe }) => ({
     // вклад это значение, фабрика экземпляра или дескриптор pipe; `priority` и `when` в опциях третьим
-    content: slot(orderFormContentSlot, ({ exports, model }) => ({
+    content: slot(orderFormContentSlot, ({ own, model }) => ({
       Component: CreateForm,
       // UI-модель вклада: создаётся на каждое монтирование и видит `props` именно этого монтирования
       models: [
         model(OrderActions, (ctx, props: Readable<OrderFormProps>) => ({
           submit: ctx.call({
-            run: (amount: number, { invoke }) => invoke(exports.submit, { amount, itemId: props.getSnapshot().itemId }),
+            run: (amount: number, { invoke }) =>
+              invoke(own.order.submit, { amount, itemId: props.getSnapshot().itemId }),
           }),
         })),
       ],
@@ -179,7 +180,7 @@ publication barrier. Всё это принадлежит runtime и его inte
 | `id`        | Как фича называется                         | `'feature.entity'`, только точки, без суффиксов                                                                                                                        |
 | `imports`   | Что мне дадут снаружи                       | запись из `defineHostContract` контрактов и определений других фич; `optional(x)` это слабое ребро, `onDemand(hostContract)` откладывает подключение до первого вызова |
 | `requires`  | Какой порт мне нужен                        | запись `port` или `optional(port)`; каждое `requires.x` это ref, а `Call` появляется у экземпляра                                                                      |
-| ref vs Call | Что видно в какой стадии                    | `own` и внешняя фабрика `provides` видят refs; `exports` и вложенные фабрики вкладов видят материализованные значения экземпляра                                       |
+| ref vs Call | Что видно в какой стадии                    | builder `own` видит refs зависимостей; `provides` видит только builders; `exports`, селекторы портов и фабрики вкладов видят готовые значения экземпляра               |
 | `own`       | Чем я владею                                | builder: `model`, `call`, `calls`, `lane`, `effect`, `event`, `resource`, `stream`, `scope`, `attach`                                                                  |
 | `exports`   | Что я отдаю фичам, которые меня импортируют | `({ own }) => запись Call, Readable и Resource` на открытии экземпляра                                                                                                 |
 | `provides`  | Что я предлагаю точкам расширения           | `({ port, slot, pipe, register, own }) => ...`                                                                                                                         |
@@ -267,13 +268,17 @@ input, а не автоматически переданным токеном о
 используется та же запись, без зависимостей — `model(Decl, create)`. Принимаются только подлинные импорты и call
 refs текущей фичи; optional-импорты сохраняют `Readable<Lookup<…>>`. Сырые объекты хоста, декларации портов,
 чужие refs и refs моделей не являются элементами зависимостей. Именованная фабрика может объявить свой интерфейс
-зависимостей, не видя контекста фичи. `provides.port(SubmitPort, { from: own.order, select: order => order.submit })`
-один раз выбирает подлинный вызов из готовой модели до публикации и добавляет фенс провайдера, включая
-переданные напрямую вызовы. Локальный call ref по-прежнему использует `port(SubmitPort, own.submit)` (D169).
+зависимостей, не видя контекста фичи. `port(SubmitPort, ({ own }) => own.order.submit)` один раз выбирает подлинный
+вызов из `own` текущего экземпляра при подготовке, до readiness и публикации вкладов, и добавляет фенс провайдера,
+включая переданные напрямую вызовы. `port(SubmitPort, ({ own }) => own.submit)` выбирает вызов, объявленный прямо
+в `own`. Селектор получает только `{ own }`; результатом должен быть подлинный Call из значения, выбранного им
+в этом `own`, в том числе из поля модели. Чужие Calls и обычные функции отвергаются. Прямые refs и дескрипторы
+`{ from, select }` не принимаются. Retirement внутри селектора прекращает запуск следующих селекторов и дренирует
+уже владеемую работу (D255).
 
 Моделей у вклада два вида, и обе объявлены одним `defineModel`. Модели `own` живут с экземпляром фичи и служатся
 монтированию автоматически. UI-модель вклада живёт с монтированием: она перечислена в `models` вклада, её фабрика
-получает вторым аргументом `Readable` пропсов этого монтирования и берёт поля как есть (`submit: exports.submit`)
+получает вторым аргументом `Readable` пропсов этого монтирования и берёт поля как есть (`submit: own.order.submit`)
 или оборачивает их в `ctx.call`, когда контракт UI отличается входом, формой результата или числом фичевых вызовов.
 Отдельного понятия View нет.
 
@@ -290,7 +295,9 @@ per-mount UI-модель обязан объявить тот компонен
 
 `opetope/require-declared-models` из recommended `@opetope/lint` проверяет видимые `slot`-вклады и readers моделей в пределах одного модуля. Он учитывает aliases импортов и локальные bindings, включая именованные компоненты. Импортированные реализации и динамические объявления остаются непроверенными; отсутствие диагностики не доказывает полноту их требований (D250).
 
-Хуки: `useModel`, `useReadable`, `useSelector`, `useCommand`, `useCommands`, `useResource`. Компоненты: `Slot` и `FeatureBoundary`
+Каждое монтирование — граница: сбой рендера или коммита вклада остаётся на нём, уходит в reporter опубликовавшей его
+фичи и заменяется содержимым `ContributionBoundary` — одной политикой хоста, объявленной один раз над всеми слотами,
+а не на каждый слот (D256). Хуки: `useModel`, `useReadable`, `useSelector`, `useCommand`, `useCommands`, `useResource`. Компоненты: `Slot` и `FeatureBoundary`
 из `@opetope/react/integration`, который держит фичу открытой и показывает `fallback` или `error`. Обе ветви
 принимают либо узел, либо render-колбэк: `children` получает готовый экземпляр, типизированный по `demand`, `error`
 получает `{ error, retry }`, выполняется только показанная ветвь, и готовому потребителю не нужны второй
@@ -386,6 +393,17 @@ devtools-плане, отдельного объявления группы не
 провалившуюся уборку точным фронтиром на `FeatureError.retryCleanup` вместо отчёта, и порт управления devtools может
 её повторить (D182).
 
+Корень приложения — место, где хост один раз говорит, что показывает упавший вклад, для всех монтирований ниже:
+
+```tsx
+// bootstrap/root.tsx — корень приложения, выше любого слота
+const Root = () => (
+  <ContributionBoundary error={({ error, retry }) => <FailedContribution error={error} onRetry={retry} />}>
+    <Slot target={applicationSurface} />
+  </ContributionBoundary>
+);
+```
+
 ---
 
 ## 3. Публичный словарь
@@ -437,17 +455,26 @@ scope: отдельный концепт, а не второе имя фичи.
 `event`, `resource`, `stream`, `scope.while`, `scope.switch`, `scope.keyed`, `attach`. У `resource`,
 `stream` и `event` источник и носитель вывода типа позиционные: `resource(from, target, {…})`,
 `stream(from, target, {…})`, `event(from, subscribe, {…})`; порядок ключей в объекте опций свободен. Одна опция
-несёт для обоих одно слово: `stream` требует `backpressure: latest()`, а `event` его допускает. Методы `provides`:
-`port`, `slot`, `pipe`, `register`; у вкладов цель первым аргументом, значение или фабрика экземпляра вторым, опции
+несёт для обоих одно слово: `stream` требует `backpressure: latest()`, а `event` его допускает. Внешняя фабрика
+`provides` получает ровно `{ port, slot, pipe, register }`: только builders, без `own` и других значений экземпляра.
+`port(Port, ({ own }) => own.model.call)` записывает цель при объявлении, а Call выбирает при подготовке экземпляра.
+У вкладов цель первым аргументом, значение или фабрика экземпляра вторым, опции
 третьим: `slot(target, contribution, { priority, when })`, `pipe(target, { fold }, { priority, when })`,
 `register(target, entry, { priority, when })`, причём у `pipe` второй аргумент это дескриптор, потому что голую
-функцию было бы не отличить от фабрики экземпляра. Контекст фабрики вклада это `{ exports, imports, instance, model, own }`, и его
-`model(Decl, create)` строит UI-модель монтирования, где `create` получает `(ctx, props)`. `when` это
-`Readable<boolean>` или предикат экземпляра — `({ exports, imports, own, read }) => boolean`, — чей `read`
+функцию было бы не отличить от фабрики экземпляра. Фабрика `register` получает `{ own, imports }`, а фабрика
+`slot` — `{ own, imports, model }`, где `model(Decl, create)` строит UI-модель монтирования и `create` получает
+`(ctx, props)`. Контексты содержат только перечисленные поля: `exports` и `instance` отсутствуют, а у `register`
+нет построителя моделей (D255). В обеих вложенных фабриках `own` содержит материализованные модели, вызовы и
+ресурсы этого экземпляра, как в `exports`. `register(target, ({ own }) => ({ key: 'submit', value: own.order.submit }))`
+публикует вызов внутренней модели без секции `exports`. Селекторы портов и фабрики вкладов выбирают готовые
+значения через собственный контекст колбэка. У вложений, scopes,
+effects и events нет доступной для чтения формы значения; невыбранные поля не мешают обращаться к соседней
+модели или вызову. `when` это
+`Readable<boolean>` или предикат экземпляра — `({ own, imports, read }) => boolean`, — чей `read`
 записывает, от чего зависит ответ: пока ответ `false`, вклад не входит в `entries` цели. В этом контексте
 вычисления `own` дан в материализованной форме, которую видит `exports`: поле модели это `Readable`, а не ref из
-контекста фабрики. `fold` дескриптора `pipe` получает третьим аргументом тот же контекст вычисления —
-`(value, meta, { exports, imports, own, read }) => …`, — связанный с экземпляром один раз при публикации вклада и
+builder `own`. `fold` дескриптора `pipe` получает третьим аргументом тот же контекст вычисления —
+`(value, meta, { own, imports, read }) => …`, — связанный с экземпляром один раз при публикации вклада и
 вызываемый только сверткой, а не при объявлении или предзагрузке; а `target.fold(value, meta, read?)` принимает
 читателя третьим параметром, поэтому `computed({ read: read => target.fold(0, undefined, read) })` подписывается и
 на `entries`, и на всё, что прочитали обработчики; без читателя обработчики читают текущий snapshot. Контексты:
@@ -599,6 +626,21 @@ scope: отдельный концепт, а не второе имя фичи.
   рендер — вторая копия StrictMode, прерванный concurrent-проход, поддерево, приостановленное ленивым соседом, — не
   создаёт ничего, поэтому подметать, усыновлять и пересобирать нечего, а layout-эффект ребёнка никогда не видит
   закрытое монтирование.
+- **Изолированные вклады.** Монтирование — граница того вклада, который оно рендерит (D256). Сбой рендера или
+  коммита — компонента, невыданной модели, чтения источника, создания собственных UI-моделей монтирования —
+  останавливается на нём, уходит в reporter опубликовавшей вклад фичи и не доходит до границы хоста. Остальные
+  монтирования той же цели и остальное дерево продолжают рендериться. Изоляция безусловна; что показывает упавшее
+  монтирование, задаёт содержимое `error` у `ContributionBoundary`, объявленного один раз над всеми слотами, и без
+  него — ничего; содержимое живёт в стабильной ссылке, поэтому инлайновая ветвь ошибки не перерисовывает
+  монтирования, а переписанное во время сбоя содержимое попадает в следующий сбой. Его `retry` перемонтирует поддерево, поэтому модели вклада создаются заново, а не переиспользуются.
+  Содержимое ошибки — тоже чужой код: его сбой держит вторая граница, существующая только после первого сбоя, он
+  сообщается тем же путём и оставляет монтирование пустым вместо эскалации.
+- **Названный сбой.** Изолированный сбой называет себя (D257): `contribution` — опубликованная запись вида
+  `<фича>.<ключ provides>`, `target` — слот, в котором она рендерилась, `feature` — опубликовавшая фича или
+  `undefined` у тестовой фикстуры. Содержимое ошибки получает эти три рядом с сырым `error` и его `retry`, а
+  reporter — на `ContributionError`, у которого в `cause` та же ошибка, с кодом `render-failed` для вклада и
+  `error-content-failed` для содержимого ошибки, упавшего вместо него. Изолированный сбой, бывший отменой, остаётся
+  отменой: обёртка несёт тот же бренд, поэтому `isCancellation` отвечает как прежде.
 - **Структурные читатели.** `Readable`, `Resource` и источник спроса это структурные контракты, поэтому хост вправе
   реализовать их объектом, члены которого — методы. Любой хук зовёт их через тот объект, который ему передали, и
   никогда как оторванную функцию, поэтому адаптер вправе опираться на свой `this` (D199).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opetope/runtime",
-  "version": "0.1.1",
+  "version": "0.4.0",
   "engines": {
     "node": ">=20.19.0"
   },
@@ -52,10 +52,10 @@
     }
   ],
   "devDependencies": {
-    "@opetope/core": "0.1.1"
+    "@opetope/core": "0.4.0"
   },
   "peerDependencies": {
-    "@opetope/core": "0.1.1"
+    "@opetope/core": "0.4.0"
   },
   "sideEffects": false,
   "description": "Feature composition and owned lifecycles for Opetope.",