@opetope/runtime 0.1.0 → 0.2.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
@@ -437,17 +442,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:

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 нет.
 
@@ -437,17 +442,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. Контексты:

package/package.json

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