tutuca 1.0.0-beta.1 → 1.0.0-beta.2

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## 1.0.0-beta.2
+
+Messages are delivered by identity as well as by path, following the tree model in
+`spec/tree`: a reply, a `sendAt` or a notification's next hop no longer reaches whatever
+component took the path in the meantime. See [`docs/paths.md`](docs/paths.md).
+
+### Breaking
+
+- **Asks are answered in an `answers` section.** `answers: { load: { ok, error, unhandled } }`
+  replaces the `xReplyOk` / `xReplyError` / `xHandlerNotFound` messages, and a send can't forge
+  one. `ctx.ask` returns a request id, which the answer's handler reads as `ctx.request`.
+  Stories answer asks with `step.answer`, tests with `driver.answer`. The lint checks the
+  section and warns about an ask a message emits with no answers for it.
+- **An ask handler only answers.** It's called with the ask's arguments and `ctx.readOnly()`,
+  a frozen view of the asker's scope, path, source key and `now` / `random` / `uuid`, with
+  nothing to send with. The ask starts once the task that asked commits, so a failed task
+  never starts one, and its answer runs as a task of its own; an answer that throws fails only
+  itself.
+- **A task made outside a handler is addressed with `task.prepare(root)`.**
+  `Host.prepareTask` is gone.
+- **A message's context stages what its handler sends** in its own list, which the host
+  queues once the task commits.
+
+### Changes
+
+- **Messages carry a sender and a receiver `Address`**, each a path and the identity it
+  reached. Every component instance has an identity, fresh when it's made or when a handler
+  returns a new one, and kept by updates. `ctx.reply(name, args)` sends to the sender of the
+  message being handled; `HOST` is the sender of DOM events and ask answers. A task whose
+  receiver was replaced is dropped and reported `stale`; one whose path reaches no component is
+  reported `orphaned`.
+- **Notifications bubble in one turn.** Their hops are the sender's ancestors when the
+  bubble starts and run back to back, ahead of the queue. An ancestor without a handler passes
+  one on silently; one that no hop handled is reported `unhandled` once, at the root.
+- **A message with no handler is a no-op that's reported** (`Host.notify("unhandled", { task,
+  message })`), whatever sent it, a DOM event included: components compose dynamically, so a
+  view can send a message its component lacks.
+- **The host reports instead of throwing**: a render that throws is `renderFailed`, an event
+  the DOM can't route is `eventFailed`, and a stopped host drops late tasks.
+- A handler's `emits` contract counts only what that handler emitted.
+- `sourceKey` is `null` for a sender in another branch.
+- Records and `oneOf` defaults meet the constraints of what they are made of: a record key
+  whose default breaks its constraints throws `NoDefaultError` naming the key, and a `oneOf`
+  makes its first alternative.
+
+### Fixes
+
+- Morphing matches vnodes only to the nodes render made, so nodes other code puts in a
+  rendered element (an extension, a third-party widget, a foreign comment) stay in place.
+- Routing and drags read `data-eid`, `data-dragtype` and the drag marks as attributes instead of
+  through `dataset`, which MathML elements lack, so a click on a formula reaches its handler.
+- The vdom prebuilds constant children and elements once per view, and decides by itself
+  which attributes must stay dynamic.
+
 ## 1.0.0-beta.1
 
 Tutuca 1.0 is a rewrite. It keeps the core ideas of 0.x, but the API, the view language and the