sygnal 7.0.0 → 7.1.0

package/dist/vike/config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sygnal",
-  "version": "7.0.0",
+  "version": "7.1.0",
   "private": true,
   "type": "module"
 }

package/llms.txt

@@ -7,7 +7,7 @@
 - There is one state tree. A child sees its parent's whole state, or a slice with `state="key"` (or a path: `state="settings.rules"`, `"boards[0].title"`). A Collection item sees one array element.
 - A child belongs to the record its `state` points at (Sygnal 7): when a path or `byId()` target changes, or its record is deleted, the old child is disposed (its DISPOSE gets its last state; its requests, timers and subscriptions are cancelled) and a new one mounts with fresh local state and new DOM (focus and typing inside it are lost). So `<Workspace state={byId('projects', selected.id)} />` needs no key. Same for Collection/VirtualCollection `from` and Switchable `state`. A stable `key` doesn't keep a child across a target change (keep that state in the parent); a custom lens needs `key={record.id}`. Sygnal 6 fixes bindings at mount: use `key={selected.id}` there (SYG454).
 - Every side effect is a sink of a model entry (STATE, EVENTS, PARENT, EFFECT, custom drivers). JSX never has event handlers (`onClick`).
-- Streams are xstream, not RxJS. An intent's DOM selectors only see the component's own JSX, never a child component's.
+- Streams are xstream, not RxJS: `import { xs } from 'sygnal'` (not `import xs from 'xstream'`, the module object under Node ESM / Vite 8: SYG302). An intent's DOM selectors only see the component's own JSX, never a child component's.
 
 ## 2. Component anatomy
 ```jsx
@@ -35,7 +35,7 @@ Counter.model = {
 Counter.onError = (error, { componentName }) => <div className="error">{componentName} failed</div>
 export default Counter
 ```
-- Reducer `(state, data, next, props)`. `data` is the action stream's value. `next('ACTION', data?, delayMs = 10)` dispatches another action of this component `delayMs` after the call, whenever it is called: also later, from a timer or callback in an EFFECT (HTTP goes through `makeFetchDriver`, not `fetch` + `next()`). `props` holds the parent's props plus `state`, `context`, `children`, `slots`.
+- Reducer `(state, data, next, props)`. `data` is the action stream's value. `next('ACTION', data?, delayMs = 10)` dispatches another action of this component only (a child's `next('X')` never reaches a parent's `X`: SYG117; send it up with `PARENT` / `EVENTS`) `delayMs` after the call, whenever it is called: also later, from a timer or callback in an EFFECT (HTTP goes through `makeFetchDriver`, not `fetch` + `next()`). `props` holds the parent's props plus `state`, `context`, `children`, `slots`.
 - Model entry: a function is the STATE reducer. An object `{ STATE, EVENTS, PARENT, EFFECT, LOG, <DRIVER>: fn }` maps each sink to a `(state, data, next, props)` function whose return value goes to that sink. `<SINK>: true` forwards `data` as-is.
 - **STATE runs first in every entry (Sygnal 7)**; every other sink gets the committed state, calculated fields included: `INC: { STATE: s => ({ ...s, n: s.n + 1 }), PARENT: s => ({ n: s.n }) }` (`s.n + 1` would count twice). The state from before the action is `props.previousState` (4th argument): read it for a value STATE cleared or deleted, and in a guard that admits the action: `HTTP: (s, d, next, { previousState }) => (previousState.status === 'working' ? ABORT : { url: '/api/work', ok: 'DONE' })` (`s.status` is already `'working'` there; keep the guard, since STATE's `ABORT` doesn't cancel other sinks; SYG256). The tradeoff: payloads read `state`, guards read `previousState`. When STATE removes the component's own state (`() => undefined`), its other sinks get its last state. Behaviors: the slice and `props.state` are after STATE, the old slice is `props.previousState[key]`. Code for 6 and 7 reads old values as `props.previousState ?? state`. Upgrading 6.x code (every reducer saw the old state): turn on the timing audit, `renderComponent(C, { timingAudit: true })` or `sygnal({ diagnostics: { timingAudit: true } })`, and decide each SYG257. Guide: `node_modules/sygnal/dist/guide/migrating-to-7.md`
 - Built-in actions (model only): `BOOTSTRAP` (once, just after mount), `INITIALIZE` (automatic: sets initialState), `DISPOSE` (unmount). `HYDRATE` is not built in (6.0): SSR data comes from Vike `+data` / `hydrateState`. Declaration statics (`connections`, `resources`, `route`, `head`) are computed from state, with or without a model; a root that declares one needs `initialState` (SYG132). Also reserved as statics: `timers`, `uses`, `persist`, `viewTransitions` (§3).
@@ -167,7 +167,7 @@ Search.model = {
 ```
 - main.js: `run(Search, { HTTP: makeFetchDriver() })` (import both from `'sygnal'`; options `baseUrl headers init timeoutMs`). Request: `{ url, ok, error, key, query, json, multipart, body, method (POST with json/multipart/body, else GET), headers, latest, timeoutMs, parse: 'auto' | 'json' | 'text' | 'response', init: { credentials, mode, cache, ... } }`; other keys (an id) aren't sent and come back on `request`. The `ok` action gets the parsed body; the `error` action gets `{ error, status, body, request }` (non-2xx: `status` + parsed `body`; network error or timeout: `status` undefined, a timeout has `error.name === 'TimeoutError'`). The reply reaches exactly the instance that sent it (two `<Search>`es, every Collection item), so no request ids. Never `HTTP.select`/`HTTP.errors` for your own request (SYG508), never `then`/`catch` keys (SYG610: not sent); an `ok`/`error` name with no model entry is SYG112. Don't call `fetch` in a component, intent or EFFECT. Upload/download progress: `progress: 'UPLOADING'` on the request (`multipart: { file: state.file, title }` builds the multipart/form-data body, never `new FormData()` in a model; the file from `DOM.select('.file').events('change').map(e => e.target.files[0])`) sends `{ phase: 'upload' | 'download', loaded, total, fraction }` steps as that action (`true`: `HTTP.progress(category)`); it goes over XMLHttpRequest; tests: `await t.progress('HTTP', { loaded: 50, total: 100 }, 'UPLOADING')`. Guide: `node_modules/sygnal/dist/guide/http.md` (online: https://sygnal.js.org/guide/http/)
 - `latest: true`: a newer request in the same lane (`key`: a constant name, never an id or URL; default the `ok` action) from the same instance aborts the older ones once it is sent: their replies never arrive after that, but one that lands before it (while the newer input still waits out a debounce) does. `{ abort: 'RESULTS' }` (it names the lane: with a custom `key`, abort that key; or `{ abort: true, key }`) cancels without sending; a removed instance's requests are aborted. **The request sees what STATE stored**: `SHOW: { STATE: (s, id) => ({ ...s, id }), HTTP: (s) => ({ url: '/api/q/' + s.id, ok: 'LOADED' }) }` (or build it from `id`).
-- Other promise APIs: `driverFromAsync(fn)` takes the same reply actions: `{ value, ok: 'DONE', error: 'FAILED' }` calls `fn(value)`; `DONE` gets the result, `FAILED` `{ error, request }` (no `latest`/abort). One-off async work: `EFFECT: async (state, data, next, { signal }) => { ...; next('DONE', result) }` (rejection: SYG214; `signal` aborts on unmount; no concurrency control). A driver is any function `sink$ => source`. Page-wide events: `DOM.select('document' | 'body').events(type)`, CSS-filtered with `DOM.select('document').select('.overlay').events('click')`.
+- Other promise APIs: `driverFromAsync(fn)` takes the same reply actions: `{ value, ok: 'DONE', error: 'FAILED' }` calls `fn(value)`; `DONE` gets the result, `FAILED` `{ error, request }` (no `latest`/abort). One-off async work: `EFFECT: async (state, data, next, { signal }) => { ...; next('DONE', result) }` (rejection: SYG214; `signal` aborts on unmount; no concurrency control). A driver is any function `sink$ => source`; to answer with reply actions (several per request: progress, then ok), `const { replies, reply } = makeReplies(onStop)`, `reply(senderOf(req), req.ok, value)`, return `{ ...replies }` (custom-drivers.md). Page-wide events: `DOM.select('document' | 'body').events(type)`, CSS-filtered with `DOM.select('document').select('.overlay').events('click')`.
 ### WebSocket / SSE (makeSocketDriver + connections)
 ```jsx
 import { ABORT } from 'sygnal'
@@ -192,7 +192,7 @@ Chat.model = {
   DROPPED:   (state, { willReconnect }) => ({ ...state, status: willReconnect ? 'reconnecting' : 'offline' }),  // { code, reason, willReconnect }
 }
 ```
-- main.js: `run(Chat, { WS: makeSocketDriver() })` (options `baseUrl reconnect queueLimit`). Without it the static opens nothing and nothing reports it. Spec keys: `socket` (a path gets ws:/wss: from the page) or `sse` (read-only; `events: { 'price-update': 'PRICE' }` for named events), `message open close error` (all optional reply actions, to this instance only), `reconnect` (`false` = never), `share` (default true: one socket per URL, ref-counted), `protocols`, `withCredentials`, SSE `headers: { authorization: `Bearer ${state.token}` }` (EventSource can't send headers, so the driver reads such a stream with fetch; keep the token in state: a changed header reconnects). `close` fires only for drops the app didn't cause; leaving, a URL change, unmount and dispose close silently, so no connection-generation ids. A room switch must `ABORT` when the room is unchanged (an unchanged connection fires no new `open`). `error` gets `{ error }`. `{ to, json | text | binary }` on a name this instance didn't declare, a closed-for-good or an SSE connection is SYG611. Use the static OR a model-sent `{ connections }`, never both (each is the whole set). Guide: https://sygnal.js.org/guide/sockets/
+- main.js: `run(Chat, { WS: makeSocketDriver() })` (options `baseUrl reconnect queueLimit`). Without it the static opens nothing and nothing reports it. Spec keys: `socket` (a path gets ws:/wss: from the page) or `sse` (read-only; `events: { 'price-update': 'PRICE' }` for named events), `message open close error` (all optional reply actions, to this instance only), `reconnect` (`false` = never), `share` (default true: one socket per URL, ref-counted), `protocols`, `withCredentials`, SSE `headers: { authorization: `Bearer ${state.token}` }` (EventSource can't send headers, so the driver reads such a stream with fetch; keep the token in state: a changed header reconnects); SSE `meta: true` (actions get `{ data, id, event }`), `resume: true | 'param'` (a driver reconnect resumes from the last event id), `staleAfterMs` (silence = a drop that reconnects; `close` gets `stale: true`; heartbeat comments count over fetch). `close` fires only for drops the app didn't cause; leaving, a URL change, unmount and dispose close silently, so no connection-generation ids. A room switch must `ABORT` when the room is unchanged (an unchanged connection fires no new `open`). `error` gets `{ error }`. `{ to, json | text | binary }` on a name this instance didn't declare, a closed-for-good or an SSE connection is SYG611. Use the static OR a model-sent `{ connections }`, never both (each is the whole set). Guide: https://sygnal.js.org/guide/sockets/
 ### Reads that follow state: `resources`
 ```jsx
 function Quote({ state }) {
@@ -215,7 +215,7 @@ Quote.model = {
 - `updates: 'item'` on a write (React Query's `setQueryData`): after a 2xx, before the `ok` action and `invalidates`, the reply becomes `state.item.data` and its cache entry at once, and the item's read in flight is aborted; `updates: { items: (list, reply) => newList }` derives the data. With `invalidates` the read then refetches keeping the written data (`refreshing`). An idle resource is skipped; the `ok` action still gets the reply.
 - Query cache (opt-in, its own export): `run(App, { HTTP: makeFetchDriver({ cache: queryCache({ staleTime: 30000, gcTime: 300000 }) }) })`. A request fetched before shows its cached data at once (`'success'`, `refreshing: true` while it revalidates; nothing is sent while younger than `staleTime`, default 0), identical requests in flight share one fetch, and stale mounted resources refetch on window focus and reconnect. Reply-action GETs use it with `cache: true` or `staleTime`. Per request: `retry: 3` or `{ count, delayMs }` (default 0; network errors, 408, 429, 5xx), `validate: schema` (Standard Schema: zod, valibot), `refetchEvery: 10000` (polling). `{ prefetch: '/api/quotes/2' }` on the sink warms the cache. SSR: `cache.set(request, data)`, `renderToString(App, { cache })`, `cache.dehydrate()` → `queryCache({ initial: snapshot })` (Vike: `pageContext.queryCache` from `+data`). Guide and recipes (list/detail + save, optimistic update, pagination, infinite list, save status): `node_modules/sygnal/dist/guide/resources.md` (online: https://sygnal.js.org/guide/resources/)
 - List/detail + save, cached: `items: (s) => s.view === 'list' && { url: '/api/items', staleTime: 2000 }`, `item: (s) => s.view === 'detail' && { url: '/api/items/' + s.id, staleTime: 2000 }` (declared only while shown; shown again: cached data at once, refetched once stale), `makeFetchDriver({ cache: queryCache() })` in main.js **and** `renderComponent(App, { http: { cache: queryCache() } })` in every test (a `staleTime` without a queryCache is SYG635), the save `{ url, method: 'PUT', json, ok: 'SAVED', error: 'SAVE_FAILED', updates: 'item', invalidates: '/api/items' }`, status `r?.status === 'loading' ? 'Loading…' : r?.refreshing ? 'Updating…' : ''`.
-- In a hidden Switchable page, resources and `connections` pause (fetches abort, sockets close) and resume on show; an entry with `background: true` (`{ url, background: true }`, `{ socket, background: true }`) stays live.
+- In a hidden Switchable page, resources and `connections` pause (fetches abort, sockets close) and resume on show; an entry with `background: true` (`{ url, background: true }`, `{ socket, background: true }`) stays live. Per-page slices: `state={{ projects: 'pages.projects', settings: byId('teams', state.teamId) }}` (key, path, lens or byId per page; each page follows its own binding: another target remakes only that page; unlisted pages share the owner's state; a key that names no page is SYG429).
 ### Router (makeRouter + route) and HEAD
 ```jsx
 // src/routes.js: one module the views import
@@ -246,7 +246,7 @@ TaskPage.model = {   // a page shares the parent's state: no initialState (SYG40
   DONE:  { ROUTER: () => ({ to: 'home', block: false }) },
 }
 ```
-- Links are plain `<a href={href(...)}>`, never click handlers: the driver intercepts same-origin left clicks at the document (not modified clicks, `target`, `download`, `rel="external"`, `data-router-ignore`, other origins). `params` and `query` values are strings; `href()` is typed from the route table (an unknown name or a missing param is a type error; SYG130/SYG131 at run time). `instance={state.route.path}` re-creates the page for `/tasks/1` → `/tasks/2`. Pages derive `resources` from `state.route.params`.
+- Links are plain `<a href={href(...)}>`, never click handlers: the driver intercepts same-origin left clicks at the document (not modified clicks, `target`, `download`, `rel="external"`, `data-router-ignore`, other origins). `params` and `query` values are strings; `href()` is typed from the route table (an unknown name or a missing param is a type error; SYG130/SYG131 at run time). `instance={state.route.path}` re-creates the page for `/tasks/1` → `/tasks/2`. Pages derive `resources` from `state.route.params`. Pages read the route from context (`App.context = { route: (s) => s.route }`), and every declaration static (`resources timers connections head browser`) gets `(state, context)`: `TaskPage.resources = { task: (s, { route }) => `/api/tasks/${route.params.id}` }` (recomputed when the context changes).
 - ROUTER commands: `{ to, params, query, hash, replace, scroll }`, `{ url }`, `{ back: true }`, `{ forward: true }`, `{ go: n }`, `{ block: 'ACTION' | false }` (also stops back/forward; `proceed` navigates anyway), `{ prefetch: 'task', params }` (calls `makeRouter({ prefetch })`). `route` is reserved for the declaration. A bad command is SYG620. The first declarer (the root) gets each route first, so keep guards there.
 - Options: `makeRouter({ routes, base: '/app', mode: 'hash', scroll, focus })`. SSR: `router.current(req.url)` in the seeded state; `renderToString(App, { head: list })` + `renderHead(list)`. Vike: `makeRouter({ routes, navigate })` with `navigate` from `'vike/client/router'`, registered in `pages/+drivers.js`. HEAD: a later-mounted component's title wins; `meta`/`link` merge; a model entry can also send `HEAD: (state, data) => ({ title })`. Guides: https://sygnal.js.org/guide/router/, https://sygnal.js.org/guide/head/
 ### AI (`sygnal/ai`): chat, agents, decisions, composed UI
@@ -316,7 +316,7 @@ it('picks, then removes a task', async () => {
 - `t.simulateAction('LOADED', data)` pushes an action straight into intent → model (all sinks run). Use it for actions without a DOM trigger. **Drivers need no wiring in tests**: the HTTP fake is the real `makeFetchDriver` over an in-memory fetch, so every request stays pending until the test answers it. `t.requests('HTTP')` lists the requests as objects (a string URL is `{ url }`; never `{ abort }`/`{ refresh }`/`{ resources }` values). `await t.respond('HTTP', body, 'RESULTS')` delivers `body` as that request's `ok` action and resolves once it is reduced and rendered; `await t.fail('HTTP', 404 | error, target?)` sends `{ error, status, body, request }` to its `error` action. Target: an action or key name, a resource name, a URL, a partial request (`{ url: '/items/2' }`), or a predicate; none = the newest pending. A request superseded by `latest: true`, aborted or already answered isn't pending, and answering it **throws at the call**: `expect(() => t.respond('HTTP', {}, { query: { q: 'du' } })).toThrow()`. Identical requests (a resource refetch, a second click) match the same targets: `{ nth: 0 }` answers exactly `t.requests('HTTP')[0]` (`-1` the newest; with `request`, counting only its matches), and throws if it isn't pending. A call made while earlier input is still queued (a debounce) waits up to 1s for its request instead. Each send is its own request. The fake can't see `makeFetchDriver({ latest: true })` from main.js: write `latest: true` on the request.
 - Sockets need no driver either: a component with `connections` gets a fake `WS` sink running the real driver on in-memory sockets (`{ socketSink: 'SOCKET' }` for another name). Connections open by themselves; `renderComponent(C, { autoConnect: false })` holds them in `'connecting'` until `await t.open('WS')`. `await t.push('WS', { text: 'hi' })` is a server frame (SSE named event: `t.push('WS', data, { event: 'price-update' })`); `await t.drop('WS', { code: 1011 })` is a close the app didn't make (`close` fires, the retry runs on the test's timers: `await vi.advanceTimersByTimeAsync(1000)`); `t.sent('WS')` lists the `{ to, json }` values; `t.connections('WS')` the declared connections (`name`, `url`, `state`). They throw too when nothing matches.
 - Resources: each fetch is listed as `{ url, ...request, resource: 'quote' }` and answered by resource name, URL or partial request: `await t.respond('HTTP', { text: 'Hi' }, 'quote')`, `await t.fail('HTTP', 500, 'quote')`. A resource request is sent after the state changes; `t.respond` by resource name right after the `simulate*` call that changes it waits for that fetch. Cache: `renderComponent(C, { http: { cache: queryCache({ staleTime: 2000 }) } })` (any driver options); `t.cache('HTTP')` lists `{ key, age, stale, subscribers, data, tags }`; `t.focus()` / `t.online()` fire the refetch triggers; retries and `refetchEvery` run on the test's timers.
-- Router: `renderComponent(App, { router, url: '/tasks/2' })` runs the router's real driver over an in-memory history (a component that declares `route` needs the `router` option). `await t.navigate('/admin')` (as a link click) or `await t.navigate({ to: 'task', params: { id: 1 } })`, `await t.back()` / `t.forward()`, `t.location` (`{ path, search, hash, href }`), `t.sent('ROUTER')` (the commands, not the declarations); a `simulateEvent` click on an `<a>` goes through the router's link handling; `{ block }` stops all of them. HEAD: `t.head()` returns the merged `{ title, meta, link }` (`{ titleTemplate }` option).
+- Router: `renderComponent(App, { router, url: '/tasks/2' })` (the first render is already on `url`: its route goes through the root's route STATE reducer first) runs the router's real driver over an in-memory history (a component that declares `route` needs the `router` option). `await t.navigate('/admin')` (as a link click) or `await t.navigate({ to: 'task', params: { id: 1 } })`, `await t.back()` / `t.forward()`, `t.location` (`{ path, search, hash, href }`), `t.sent('ROUTER')` (the commands, not the declarations); a `simulateEvent` click on an `<a>` goes through the router's link handling; `{ block }` stops all of them. HEAD: `t.head()` returns the merged `{ title, meta, link }` (`{ titleTemplate }` option).
 - TypeScript tests: `renderComponent` infers the state type; for a handle assigned in `beforeEach`, declare `let t: RenderResult<State>` (import the type from `'sygnal'`), not `any`. With the Vite plugin, Vitest gets `sygnal/diagnostics` in its setupFiles automatically; otherwise `import 'sygnal/diagnostics'` in the test.
 - Real DOM (state the user typed or clicked, focus, refs, any CSS selector): `renderComponent(C, { dom: 'real' })` (`'real'`, not `'jsdom'`) in a jsdom test (`// @vitest-environment jsdom`, `npm i -D jsdom`), same `t.*` API in ONE suite (no separate `run()` + jsdom suite). `simulateEvent` then dispatches real events on any CSS selector (`{ value }` types, `'click'` toggles a checkbox/radio and skips disabled buttons, `'focus'`/`'blur'` move focus).
 - Assert on elements: `t.query<HTMLInputElement>(sel)` / `t.queryAll<HTMLInputElement>(sel)` (or typed control tokens; generic types are assertions, and a single query is nullable) also work on the default mock DOM, as read-only snapshots of what the view rendered (`textContent`, `value`, `checked`, `disabled`, `getAttribute`, `classList`, `dataset`, `querySelector`, `closest`; `focus()` throws): `expect(t.query('input[name="plan"]:checked').value).toBe('team')`, `t.query('.save').disabled`, `t.queryAll('.row')`; with `dom: 'real'` they are real elements (`document.activeElement === t.query('input[name="city"]')`). Every wait (`ready`, `next`, `waitForState`, `settle`) resolves once its state is rendered, so query right after the `await` (before the first render, `t.query` throws: `await t.ready()`). `await t.next(a); await t.next(b)` also sees a `b` that arrived while the DOM showed `a`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sygnal",
-  "version": "7.0.0",
+  "version": "7.1.0",
   "description": "An intuitive framework for building fast and small components or applications based on Cycle.js",
   "main": "./dist/index.cjs.js",
   "types": "./dist/index.d.ts",

package/src/core/hosts/switchable.ts

@@ -17,7 +17,7 @@
  */
 import {hosts} from '../registry'
 import {resolve} from './collection'
-import {Inst, shallowEq} from '../instance'
+import {Inst, shallowEq, bindingChanged, known, watch} from '../instance'
 import {Cell, keyCell, lensCell, localCell, pathOf} from '../cell'
 import {isObj} from '../define'
 import {uidPart} from '../../shared'
@@ -39,6 +39,9 @@ function check(owner: Inst, props: Record<string, any>) {
   if (!(cur in of)) fail('SYG416', owner, `Switchable 'current' '${cur}' is not a key of 'of'`, CUR_FIX)
 }
 
+/** F-3: a per-page map (an object that is not a lens or a byId selection: no `get`), or null */
+const mapOf = (st: any) => isObj(st) && typeof st.get != 'function' ? st : null
+
 /** a page's props: the Switchable's, kept by identity while equal (`of` compared shallowly) */
 function sameProps(a: any, b: any) {
   if (!a || !b) return false
@@ -51,6 +54,7 @@ function sameProps(a: any, b: any) {
 export class SwitchableHost {
   pages: Record<string, Page> = {}
   cell: Cell
+  map: any
   cur!: string
   ready = true
   disposed = false
@@ -61,10 +65,11 @@ export class SwitchableHost {
 
   constructor(public owner: Inst, props: Record<string, any>, children: any[], id: string) {
     check(owner, props)
-    const st = props.state, calc = typeof st == 'string' && owner.def.calcNames?.has(pathOf(st)[0])
-    this.cell = typeof st == 'string' ? keyCell(owner.cell, st, calc && owner.def.name, undefined, 'Switchable sub-component')
-      : st !== undefined ? lensCell(owner.cell, st, owner.def.name, (e) => owner.app.appError(owner, e, 'view'))
-      : owner.cell
+    const st = props.state
+    // F-3: `state={{ page: key | lens | byId }}` (not a lens, not a byId selection): each listed
+    // page binds its own target, with a tag child's lifetime rules; the others share the owner's state
+    this.map = mapOf(st)
+    this.cell = this.bind(this.map ? undefined : st)
     this.uidBase = owner.uid(uidPart(id.replace(/.*::(r\.)?/, '')))
     this.props = props
     this.kids = children
@@ -75,9 +80,17 @@ export class SwitchableHost {
     this.setProps(props, children)
   }
 
+  bind(st: any): Cell {
+    const owner = this.owner, calc = typeof st == 'string' && owner.def.calcNames?.has(pathOf(st)[0])
+    return typeof st == 'string' ? keyCell(owner.cell, st, calc && owner.def.name, undefined, 'Switchable sub-component')
+      : st !== undefined ? lensCell(owner.cell, st, owner.def.name, (e) => owner.app.appError(owner, e, 'view'))
+      : owner.cell
+  }
+
   make(name: string, view: any): Inst {
     const o = this.owner, app = o.app, def = app.def(view), scope = app.scope()
-    const inst = new Inst(app, def, o, def.isolated ? localCell(app, this.cell) : this.cell, o.dom && o.dom.isolateSource(o.dom, scope),
+    const c = this.map ? this.bind(this.map[name]) : this.cell
+    const inst = new Inst(app, def, o, def.isolated ? localCell(app, c) : c, o.dom && o.dom.isolateSource(o.dom, scope),
       this.props, this.kids, scope, this.uidBase + '-' + uidPart(name), 'page')
     inst.shown = false
     return inst
@@ -95,15 +108,20 @@ export class SwitchableHost {
       this.kids = children
       for (const n in this.pages) this.pages[n].inst.setProps(props, children)
     }
+    // F-3: a page whose own binding target changed (7.0's rule, per page), or that the owner
+    // disposed because its target was deleted, is made again
+    const m = this.map, nm = this.map = mapOf(props.state)
     // G-317: a lazy() page that has loaded is made again with the loaded component
     for (const n in this.pages) {
       const p = this.pages[n], fn = resolve(p.view, this.owner)
-      if (fn !== p.fn) {
+      if (fn !== p.fn || p.inst.disposed || m && nm && bindingChanged(m[n], nm[n])) {
         const shown = p.inst.shown
-        p.inst.dispose()
+        p.inst.disposed || p.inst.dispose()
         p.inst = this.make(n, p.fn = fn)
         p.inst.shown = shown
       }
+      // the owner disposes a page whose target is deleted, as a tag child; it is made again above
+      if (nm && known(nm[n])) watch(this.owner, p.inst)
     }
     const page = this.pages[cur]
     if (page) {

package/src/core/instance.ts

@@ -31,13 +31,22 @@ import {sameData} from '../cycle/dom/utils'
 
 // v7: a known binding target joins key/id/path in the lifetime identity. Fresh equivalent
 // byId helpers retain identity; opaque lenses need an explicit key for a new target.
-function bindingChanged(a: any, b: any): boolean {
+export function bindingChanged(a: any, b: any): boolean {
   if (a === b) return false
   const x = a?.[BINDING], y = b?.[BINDING]
   return x && y ? !x.every((v: any, i: number) => Object.is(v, y[i]))
     : !!(x || y || typeof a == 'string' || typeof b == 'string' || a === undefined || b === undefined)
 }
 
+/** a binding whose target is known (a key, a byId selection): its deletion ends the child */
+export const known = (b: any) => typeof b == 'string' || b?.[BINDING]
+/** F-3: `owner` watches child (or Switchable page) `k`'s target: notify() disposes it when deleted */
+export function watch(owner: Inst, k: any) {
+  k.bs = bindingState(k)
+  ;(owner.bound ||= new Set()).add(k)
+  owner.app.watchers.add(owner)
+}
+
 function bindingState(k: any): any {
   const c = k.base || k.cell || k.arr
   return c && (c.has?.() ?? c.get() !== undefined) ? (k.cell || k.arr).get() : undefined
@@ -192,7 +201,7 @@ export class Inst {
   // flag they were computed from; its reply streams
   st: Array<[string, string]> | null = null
   sv: Record<string, any> | null = null
-  sS: any; sH: any
+  sS: any; sH: any; sC: any
   rep: any[] | null = null
 
   constructor(
@@ -537,11 +546,7 @@ export class Inst {
         if (k && (k.disposed || (view && k.def && k.def.view !== view) || bindingChanged(k.props?.[binding], props[binding]))) { k.dispose(); this.kids.delete(id); k = undefined }
         if (k) k.setProps(props, children, n, id)
         else this.kids.set(id, k = host ? this.host(host, props, children, id, n) : this.child(view, props, children, id, !!data.props?.resetState))
-        if (typeof props[binding] == 'string' || props[binding]?.[BINDING]) {
-          k.bs = bindingState(k)
-          ;(this.bound ||= new Set()).add(k)
-          this.app.watchers.add(this)
-        }
+        if (known(props[binding])) watch(this, k)
         return
       }
       if (posts[sel] && !(ps ||= []).includes(sel)) ps.push(sel)

package/src/core/statics.ts

@@ -76,17 +76,17 @@ const shownOf = (inst: Inst) => {
 /** recompute the instance's declarations when its state or shown flag changed; send the changed ones */
 export function checkStatics(inst: Inst) {
   if (inst.disposed) return
-  const s = inst.cell.get(), shown = shownOf(inst)
+  const s = inst.cell.get(), shown = shownOf(inst), c = inst.context()
   // no state yet: nothing declared (as the state stream, which skips undefined)
-  if (s === undefined || (s === inst.sS && shown === inst.sH)) return
-  inst.sS = s; inst.sH = shown
+  if (s === undefined || (s === inst.sS && shown === inst.sH && c === inst.sC)) return
+  inst.sS = s; inst.sH = shown; inst.sC = c
   const view = inst.def.view, sv = inst.sv!
   for (const [n, k] of inst.st!) {
     const f = view[k]
     let v: any = f
     try {
-      if (typeof f == 'function') v = f(s)
-      else if (f && typeof f == 'object') { v = {}; for (const r in f) v[r] = f[r](s) }
+      if (typeof f == 'function') v = f(s, c)
+      else if (f && typeof f == 'object') { v = {}; for (const r in f) v[r] = f[r](s, c) }
     } catch (e) {
       // as today: nothing sent; the next value is sent even when equal to the last one
       inst.app.caught(inst, 'SYG216', `${k} threw; nothing sent`, e, 'declaration')

package/src/extra/ai/transports/shared.ts

@@ -65,12 +65,14 @@ export async function post(url: string, body: any, req: any, signal: AbortSignal
  * E-1: `meta` (optional) follows the stream's `id` (the last event id, kept across frames) and
  * `retry` (ms) fields, as EventSource does, for a reconnect
  */
-export async function* sse(res: any, meta?: {id?: string; retry?: number}): AsyncGenerator<{event: string; data: string}> {
+export async function* sse(res: any, meta?: {id?: string; retry?: number; beat?: () => void}): AsyncGenerator<{event: string; data: string}> {
   const reader = res.body.getReader(), dec = new TextDecoder();
   let buf = '', cr = '', done = false;
   try {
     for (;;) {
       const r = await reader.read();
+      // PLAN-13 S-1: any bytes (a heartbeat comment too) show the stream is alive
+      if (!r.done) meta?.beat?.();
       // line ends -> \n (a \r at a chunk's end waits: it may be half of a \r\n)
       let s = cr + (r.done ? '\n\n' : dec.decode(r.value, {stream: true}));
       cr = !r.done && s.endsWith('\r') ? '\r' : '';

package/src/extra/behaviors.ts

@@ -96,10 +96,10 @@ const addTimers = (v: any): void => {
   if (timed.has(v)) return
   timed.add(v)
   let own = v.timers
-  const all = (st: any) => {
+  const all = (st: any, c?: any) => {
     const o: any = {}, f = own
-    if (typeof f == 'function') Object.assign(o, f(st))
-    else if (f && typeof f == 'object') for (const r in f) o[r] = f[r](st)
+    if (typeof f == 'function') Object.assign(o, f(st, c))
+    else if (f && typeof f == 'object') for (const r in f) o[r] = f[r](st, c)
     const u = v.uses
     for (const k in u) {
       const b = u[k], t = b?.timers?.(st?.[k] ?? b.state, b.options, k), rn = (a: any) => a in (b.model || {}) ? k + '.' + a : a

package/src/extra/diagnostics/checks/next.ts

@@ -18,11 +18,12 @@
  *   page after a patch, G-460: on rendered elements), SYG612 (D173: a form
  *   6.0 removed, met at runtime; once per form and component, with a link to the migration
  *   guide), SYG453 (PLAN-9, D470: two children with one identity share one instance), SYG426
- *   (PLAN-9, D471: a lowercase <collection> / <switchable> tag, deprecated in 6.3.0).
+ *   (PLAN-9, D471: a lowercase <collection> / <switchable> tag, deprecated in 6.3.0), SYG117
+ *   (PLAN-13 N-1: next() to an action the component has no model entry for).
  *
  * Only while diagnostics are on (the checks' own rule); production builds never load this.
  */
-import {bridge, devReport, reportSafely, once, onReset, nameOf, isPlainObject} from './shared'
+import {bridge, devReport, reportSafely, once, onReset, nameOf, isPlainObject, didYouMean} from './shared'
 import {DEV_CODE_SEVERITY} from '../codes'
 import {watchMutation} from './state'
 import {checkRequest} from './replies'
@@ -202,6 +203,31 @@ function lowercaseTags(iv: any): void {
   walk(raw.tmpl, 0)
 }
 
+/**
+ * PLAN-13 F-3 SYG429: a Switchable's per-page `state={{ page: … }}` with a key that names no page
+ * (read from the owner's template, as SYG426; 0 production bytes). Once per component and key
+ */
+function switchableMaps(iv: any): void {
+  const raw = iv.i
+  if (!raw?.kids?.size || !raw.tmpl) return
+  const walk = (n: any, d: number): void => {
+    if (!n || typeof n != 'object' || n.$p || d > 300) return
+    const p = n.sel == 'switchable' && n.data?.props, st = p?.state
+    if (st && isPlainObject(st) && typeof st.get != 'function' && isPlainObject(p.of)) {
+      const pages = Object.keys(p.of)
+      for (const k of Object.keys(st)) if (!(k in p.of) && once(`SYG429:${iv.name}:${k}`)) devReport('SYG429', {
+        component: iv.name,
+        message: `${iv.name}'s Switchable state map binds '${k}', which is not one of its pages (${pages.join(', ')}), so that binding is never used${didYouMean(k, pages)}`,
+        fix: 'Use the page name from of={{ … }} as the key, or remove the entry',
+        data: {key: k, pages},
+      })
+    }
+    const kids = n.children
+    if (Array.isArray(kids)) for (const c of kids) walk(c, d + 1)
+  }
+  walk(raw.tmpl, 0)
+}
+
 /** the instance fields the checks read from today's Component instances */
 class Facade {
   _so: any
@@ -430,7 +456,7 @@ export function nextHooks(_api: any): any {
       H.onRender(f, vnode)
       if (!on()) return
       removedTags(f, vnode)
-      try { lowercaseTags(iv) } catch (_) { /* a check never breaks the app */ }
+      try { lowercaseTags(iv); switchableMaps(iv) } catch (_) { /* a check never breaks the app */ }
       // SYG453: only a view with children can render one twice
       if (iv.children().length) try { sharedIdentity(iv, vnode) } catch (_) { /* a check never breaks the app */ }
     },
@@ -460,6 +486,23 @@ export function nextHooks(_api: any): any {
         if (src && src.__sygnalStatic === 'resources') checkFetch(f, sink, v)
       } catch (_) { /* a check never breaks the app */ }
     },
+    // SYG117 (PLAN-13 N-1): next('X') goes to the component's own model only; with no entry
+    // for X it does nothing (an ancestor's entry of that name never runs)
+    onNext(iv: any, type: string) {
+      if (!on() || iv.def.handlers.has(type)) return
+      const name = iv.name
+      if (!once(`SYG117:${name}:${type}`)) return
+      let up: any = live.get(iv.parentId)
+      while (up && !up.def.handlers.has(type)) up = live.get(up.parentId)
+      devReport('SYG117', {
+        component: name,
+        message: `${name} calls next('${type}'), but ${name} has no model entry '${type}', so the action does nothing${up ? `: next() never reaches ${up.name}, which handles '${type}'` : ''}${didYouMean(type, iv.def.handlers.keys())}`,
+        fix: up
+          ? `next() stays in its own component. Send it up instead: give the entry that calls it a PARENT sink (PARENT: (state) => ({ … })) and add ${type}: CHILD.select(${name}) to ${up.name}.intent, or emit EVENTS: event('${type}', …) and select it there`
+          : `Add the entry to ${name}.model (${type}: (state, data) => …), or fix the name to match an existing one`,
+        data: {action: type, ...(up ? {handledBy: up.name} : {})},
+      })
+    },
     onElementCommand(iv: any, cmd: any) {
       if (!on()) return
       const f = fac(iv)

package/src/extra/diagnostics/checks/props.ts

@@ -8,6 +8,9 @@
  * lens (a state field name or a { get, set } object), so it is only reported
  * when the value can't be a lens.
  *
+ * A Switchable page is exempt from the `state` part: it gets the Switchable's props, and their
+ * `state` is the host's binding (PLAN-13 F-3's per-page map is not a lens, and isn't the page's).
+ *
  * Mechanism: onRender reads the component's current (sanitized) props.
  * Reported once per component name and prop.
  */
@@ -39,7 +42,9 @@ export const propsCheck: DiagnosticCheck = {
       })
     }
 
-    if ('state' in props) {
+    // PLAN-13 F-3 follow-up: a Switchable page gets the Switchable's props, whose `state` is the
+    // host's binding (a per-page map too), consumed by the host: not a prop meant for the page
+    if ('state' in props && component.__next?.kind !== 'page') {
       const value = props.state
       const isLens = typeof value === 'string' || (value && typeof value === 'object' && typeof value.get === 'function')
       if (!isLens && value !== undefined && once(`SYG106:${name}:state`)) {

package/src/extra/diagnostics/codes.ts

@@ -146,6 +146,8 @@ export const CODE_TITLES: Record<string, string> = {
   SYG111: 'Controlled input has no input listener',
   SYG115: 'Unknown DOM event shorthand',
   SYG116: 'EVENTS value has no string type',
+  // PLAN-13 N-1: dev entry (checks/next.ts onNext) and sygnal-check
+  SYG117: 'next() names an action with no model entry',
   SYG124: 'Component used as a control or selector',
   SYG125: 'Control given .intent, .model or .initialState',
   SYG126: 'Control rendered but never listened to',
@@ -181,6 +183,8 @@ export const CODE_TITLES: Record<string, string> = {
   // PLAN-5 V-1: VirtualCollection (checks/virtual.ts)
   SYG430: 'VirtualCollection has no bounded height',
   SYG431: 'VirtualCollection items without ids',
+  // PLAN-13 F-3: dev entry (checks/next.ts onRender) and sygnal-check
+  SYG429: 'Switchable state map names no page',
   SYG432: 'VirtualCollection item does not render one element',
   SYG433: 'VirtualCollection scroll target not in the list',
   SYG434: 'Invalid VirtualCollection estimateSize or overscan',
@@ -196,6 +200,8 @@ export const CODE_TITLES: Record<string, string> = {
   SYG202: 'STATE reducer returned undefined',
   // SYG3xx streams & intent construction (1A)
   SYG301: 'RxJS operator used on an xstream stream',
+  // PLAN-13 X-1: static only (sygnal-check)
+  SYG302: "Default import from 'xstream'",
   // SYG4xx collections / switchable / sub-components / context (1A)
   SYG401: "Collection 'from' field is missing or not an array",
   // SYG5xx strict mode / canonical forms (2A; dev-plans/PLAN-1-canonical-forms.md)
@@ -426,6 +432,7 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG112: 'error',
   SYG115: 'warn',
   SYG116: 'error',
+  SYG117: 'warn',
   // PLAN-4 1-D: controls, static (sygnal-check)
   SYG124: 'error',
   SYG125: 'error',
@@ -437,6 +444,10 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG129: 'warn',
   // PLAN-10 X-1: static only (sygnal-check)
   SYG170: 'warn',
+  // PLAN-13 X-1: static only (sygnal-check)
+  SYG302: 'info',
+  // PLAN-13 F-3 (checks/next.ts)
+  SYG429: 'warn',
   SYG171: 'warn',
   SYG221: 'error',
   // PLAN-4 GS-4 (state.ts)

package/src/extra/fetchDriver.ts

@@ -431,6 +431,9 @@ export function makeFetchDriver(options: any = {}) {
       if (E && 'v' in E && !q.validate) write(s, n, R, 'success', E.v, undefined, go);
       else if ((same || q.keepPrevious) && L && SETTLED.test(L.status)) write(s, n, R, L.status, L.data, L.error, true);
       else write(s, n, R, 'loading');
+      // R-1: the write is dispatched synchronously; when it changed the request (a navigation
+      // recomputed the statics and a nested load sent the new one) or paused it, q is stale
+      if (R.q !== q || R.p) return;
       if (go || q.validate) R.i = send(q, s, n, after, R);
     };
 

package/src/extra/fetchEventSource.ts

@@ -13,6 +13,8 @@ import {sse} from './ai/transports/shared';
  * - a non-2xx status or another content type: `error` with readyState CLOSED (no retry; the
  *   driver's reconnect policy decides);
  * - `close()` aborts the request and stops retrying.
+ * - PLAN-13 S-1: `init.lastEventId` seeds the id sent as `Last-Event-ID` (a driver reconnect that
+ *   resumes); `onbeat` (not EventSource's) is called for any bytes read, heartbeat comments too.
  */
 
 const NAMES = ['CONNECTING', 'OPEN', 'CLOSED'];
@@ -27,16 +29,18 @@ export class FetchEventSource {
   onopen: any = null;
   onmessage: any = null;
   onerror: any = null;
+  onbeat: any = null;
   private ls = new Map<string, Set<(e: any) => void>>();
-  private meta: {id?: string; retry?: number} = {id: '', retry: 3000};
+  private meta: {id?: string; retry?: number; beat?: () => void} = {id: '', retry: 3000, beat: () => this.onbeat?.()};
   private ctl: any;
   private timer: any;
   private init: any;
 
-  constructor(url: string, init: {withCredentials?: boolean; headers?: Record<string, string>; fetch?: any} = {}) {
+  constructor(url: string, init: {withCredentials?: boolean; headers?: Record<string, string>; fetch?: any; lastEventId?: string} = {}) {
     this.url = url;
     this.withCredentials = !!init.withCredentials;
     this.init = init;
+    if (init.lastEventId) this.meta.id = init.lastEventId;
     queueMicrotask(() => this.connect());
   }
 

package/src/extra/socketDriver.ts

@@ -41,6 +41,12 @@ import {FetchEventSource} from './fetchEventSource';
  *   changed header reconnects) is read with FetchEventSource (fetch, `options.fetch` if given),
  *   since EventSource can't send headers. An `options.EventSource` (a polyfill, the test fake)
  *   still wins and gets the headers in its init.
+ * - PLAN-13 S-1: SSE `meta: true`: message and `events` actions get `{ data, id, event }`. `resume:
+ *   true | 'param'`: the transport keeps the last event id, and a reconnect the driver makes (after
+ *   EventSource gave up) asks to resume from it: `?lastEventId=` (or `?param=`) on the URL, or
+ *   `Last-Event-ID` on the fetch path (`init.lastEventId`). `staleAfterMs` (SSE and WebSocket): no
+ *   event for that long (over fetch: no bytes, heartbeat comments count) closes the connection as a
+ *   drop (`close` gets `stale: true`), so the reconnect policy applies.
  */
 
 const SCOPE = '__sygnalScope';
@@ -96,19 +102,40 @@ export function makeSocketDriver(options: any = {}) {
     const out = (t: any, data: any, e: any) => {
       try { t.s.send(data); } catch (error) { deliver(e, 'error', {error}); }
     };
+    // S-1: an SSE event as a subscriber gets it (`meta`: with its id and type); the transport
+    // keeps the last id (resume) and counts it as life (staleAfterMs)
+    const got = (t: any, m: any, e: any) => e.sse && e.spec.meta ? {data: parse(m.data), id: m.lastEventId ?? '', event: m.type || 'message'} : parse(m.data);
+    const seen = (t: any, m: any) => { if (m.lastEventId) t.id = m.lastEventId; alive(t); };
     // SSE named events: one listener per name across the subscribers
     const listen = (t: any) => t.s && t.sse && each(t, e => Object.keys(e.spec.events || {}).forEach(name => {
       if (t.on.has(name)) return;
       t.on.add(name);
       const s = t.s;
-      s.addEventListener(name, (m: any) => t.s === s && each(t, x => {
-        const a = x.spec.events?.[name];
-        if (typeof a == 'string' && x.sender !== undefined) reply(x.sender, a, parse(m.data));
-      }));
+      s.addEventListener(name, (m: any) => {
+        if (t.s !== s) return;
+        seen(t, m);
+        each(t, x => {
+          const a = x.spec.events?.[name];
+          if (typeof a == 'string' && x.sender !== undefined) reply(x.sender, a, got(t, m, x));
+        });
+      });
     }));
+    // S-1: staleAfterMs (the smallest of the subscribers'): re-armed by every event; when it fires
+    // the connection is dropped (as if the server had gone) and the reconnect policy applies
+    const alive = (t: any) => {
+      clearTimeout(t.st);
+      const ms = Math.min(...[...t.subs].map(e => e.spec.staleAfterMs).filter(x => x > 0));
+      const s = t.s;
+      if (s && ms < 1 / 0) t.st = setTimeout(() => {
+        if (t.s !== s) return;
+        try { s.close(); } catch (_) {}
+        gone(t, t.sse ? {stale: true} : {code: 1006, reason: 'stale', stale: true});
+      }, ms);
+    };
 
     // the socket closed (or failed to open) without the driver closing it
     const gone = (t: any, info: any) => {
+      clearTimeout(t.st);
       t.s = null;
       t.open = false;
       let again: any;
@@ -126,9 +153,19 @@ export function makeSocketDriver(options: any = {}) {
       const hdr = t.sse && t.spec.headers && typeof t.spec.headers == 'object' ? t.spec.headers : undefined;
       const C = t.sse ? options.EventSource ?? (hdr && typeof g.fetch == 'function' ? FetchEventSource : g.EventSource) : options.WebSocket ?? g.WebSocket;
       if (typeof C != 'function') return;
+      // S-1: resume from the last event id: Last-Event-ID on the fetch path (init.lastEventId, which
+      // a polyfill or the test fake gets too), else a URL parameter
+      // (a parameter the URL already has is replaced, not added again)
+      const r = t.sse && t.id && [...t.subs].map(e => e.spec.resume).find(x => x);
+      let url = t.url;
+      if (r && !hdr) {
+        const p = encodeURIComponent(r === true ? 'lastEventId' : r) + '=', v = p + encodeURIComponent(t.id);
+        const re = new RegExp('([?&])' + p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '[^&#]*');
+        url = re.test(url) ? url.replace(re, '$1' + v) : url + (url.includes('?') ? '&' : '?') + v;
+      }
       let s: any;
       try {
-        s = t.sse ? new C(t.url, {withCredentials: !!t.spec.withCredentials, ...(hdr && {headers: hdr, fetch: options.fetch})}) : new C(t.url, t.spec.protocols);
+        s = t.sse ? new C(url, {withCredentials: !!t.spec.withCredentials, ...(hdr && {headers: hdr, fetch: options.fetch}), ...(r && {lastEventId: t.id})}) : new C(t.url, t.spec.protocols);
       } catch (error) {
         // a URL the constructor rejects never opens: no retry
         each(t, e => deliver(e, 'error', {error}));
@@ -141,12 +178,19 @@ export function makeSocketDriver(options: any = {}) {
       s.onopen = mine(() => {
         t.n = 0;
         t.open = true;
+        alive(t);
         each(t, e => { deliver(e, 'open', {reconnected: !!e.opened}); e.opened = true; });
         const q = t.queue;
         t.queue = [];
         q.forEach((x: any) => t.s === s && out(t, x.data, x.e));
       });
-      s.onmessage = mine((m: any) => { const d = parse(m.data); each(t, e => deliver(e, 'message', d)); });
+      s.onmessage = mine((m: any) => {
+        if (t.sse) seen(t, m); else alive(t);
+        const d = parse(m.data);
+        each(t, e => deliver(e, 'message', e.spec.meta && t.sse ? got(t, m, e) : d));
+      });
+      // S-1: FetchEventSource's bytes (heartbeat comments) count as life
+      s.onbeat = mine(() => alive(t));
       s.onerror = mine((error: any) => {
         each(t, e => deliver(e, 'error', {error}));
         if (t.sse) {
@@ -162,6 +206,7 @@ export function makeSocketDriver(options: any = {}) {
     // closes the driver makes: no `close` action, late events ignored, retry cancelled
     const end = (t: any) => {
       clearTimeout(t.timer);
+      clearTimeout(t.st);
       transports.delete(t.key);
       const s = t.s;
       t.s = null;