@yuneta/gobj-ui 7.25.7 → 7.25.9

package/README.md

@@ -2177,9 +2177,52 @@ else.
   gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);   // waits
   // ... the three `nodes` answers land -> ST_TOPICS of `db`
   ```
+- **The loading screen is drawn** (7.25.8): the body is cleared, the drawing
+  destroyed and every toolbar button disabled, as in `ST_SAVING`, because
+  `ST_LOADING` declares none of a screen's actions. A **dialog** left open is
+  the one thing still reachable: its Save (`EV_SAVE_COLUMN`, `EV_SAVE_TOPIC`),
+  a confirmation (`EV_CONFIRMED`), an orphan delete or an import is refused
+  with `the schemas are loading: wait for them` (7.25.9; an i18n key the
+  consumer's locales carry). A write that ends with an error -- a drop
+  included -- still applies a position that waited, as a load does. Out of
+  session a load is not asked at all (no *"not in session"* errors); the
+  reconnect loads.
+- **A dialog is built on ONE model, and a load that replaces it closes it**
+  (7.25.9). Every load that lands bumps `model_gen`; a dialog records the one
+  it was opened on, and its Save, its import Preview/Run, an orphan delete and
+  a confirmation carry it in their kw. When a load lands under a dialog of an
+  older model, the dialog is closed and the operator told
+  `the schemas were read again: open the dialog again`; anything stamped with
+  a replaced model that arrives anyway is refused with the same words. A
+  column form sends every field it shows, so its Save after a reload wrote
+  the OLD record over the newer one -- 7.25.8 told the operator to "try
+  again", which did exactly that. The import plan is forgotten when a load
+  starts. A load that failed or never left replaced nothing, and the dialog
+  stays with what was typed.
+
+  ```js
+  gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);   // form, model_gen N
+  gobj_send_event(editor, "EV_REFRESH", {}, host);                 // Save -> "wait for them"
+  // ... the load lands (model_gen N+1): the form closes, the operator reopens it
+  ```
+- **A load refused IN session keeps the model it was replacing** (7.25.9): a
+  routing adapter's deadline on a slow `nodes` answers -1 while the session
+  is up. The records are put back, the screen and any open dialog stay, the
+  operator is told `cannot read the schemas again: the previous ones stay`,
+  and the reload is owed. Only a first load, with no model before it, ends
+  on the empty screen. A write answered with no record reloads the model and
+  says what it did not send after it
+  (`the treedb did not describe a write back: the writes after it were not sent`).
+- The toolbar offers Diagram, Check, Export, Import, New topic and New column
+  only when the treedb (or topic) the position names is IN the model; after a
+  reload that no longer has it, Back and Refresh remain.
 - A write this view gave up on (a drop, a deadline) whose answer still says it
   was DONE makes the editor read the model again (at once, after the write in
-  flight, or on the reconnect). Through a routing adapter that settled the
+  flight, or on the reconnect), and it is a write for the host too: it
+  publishes `EV_RECORD_WRITTEN` and marks the topic of the record answered.
+  Only the host's `EV_REFRESH` (a Save sends it) forgets what this session
+  wrote; the reloads the editor asks itself (the reconnect's, a late write's)
+  keep the draft chips. Through a routing adapter that settled the
   write on its OWN deadline the late answer does not reach the view -- the
   adapter echoes a node event instead, which this view does not hear -- and
   Refresh is what reads the store.
@@ -2614,6 +2657,22 @@ live region it is both read and announced when it changes.
 > long time and nothing ever rendered it; the claim is gone. Implement it there
 > the day a menu entry needs one.
 
+### Toasts — `yui_shell_show_info` / `_warning` / `_error`
+
+`yui_shell_show_error(shell, "key", {t, timeout})` shows a non-blocking toast
+(5000 ms by default, `timeout: 0` = until closed) and returns `{close()}`. A
+string message of the same kind as a toast still on screen is not stacked
+under it -- there is ONE toast per message -- but each call is a caller of its
+own: it gets its own handle and its own time, and the toast goes when every
+caller has closed its handle or timed out (7.25.8). The ✕ closes it for all.
+
+```js
+const a = yui_shell_show_error(shell, "the connection dropped", {t});             // 5 s
+const b = yui_shell_show_error(shell, "the connection dropped", {t, timeout: 0}); // same toast
+a.close();          // still shown: b holds it
+b.close();          // gone
+```
+
 ### Modals — `yui_shell_show_modal` and the `before_close` veto
 
 `yui_shell_show_modal(shell, $box, opts)` is the standard popup: pass