sygnal 7.0.0 → 7.1.0

package/CHANGELOG.md

@@ -2,6 +2,132 @@
 
 All notable changes to Sygnal are listed here. Versions follow [semantic versioning](https://semver.org). Releases before 5.4.0 are described in the [GitHub releases](https://github.com/tpresley/sygnal/releases) and tags.
 
+## 7.1.0 — 2026-10-20
+
+Fixes and additions from building an app (Temper's Tune UI) on 7.0 ([PLAN-13](dev-plans/PLAN-13.md)):
+an invalidation / navigation race, declaration statics that see the context, per-page Switchable
+state, SSE resume and dead-stream detection, reply helpers for hand-written drivers, and more
+precise `sygnal-check` findings. All additive.
+
+**Measured impact.** Size: the kanban gate is (a) 42,982 B with `nativeGlobalThis: false` (7.0.0:
+42,844 B; budget 43,000 B, 18 B headroom) and (b) 38,987 B by default. Statics with context cost
+19 B and the per-page Switchable map 126 B (it reuses the owner's binding watch for a page whose
+record is deleted); everything else is in drivers, the dev diagnostics entry, the test helper or
+`sygnal-check`, and adds nothing to an app that doesn't use it. The perf count gate is within its
+limits.
+
+**Companion packages.**
+- **`sygnal-check` 0.12.0:** SYG117 (`next()` to an action with no entry here), SYG302 (`import xs
+  from 'xstream'`, with `--fix`), SYG429 (a Switchable state map key that names no page); reply names
+  through request helpers and consts; SYG256 sees past helper calls in other fields; `next` followed
+  into helpers, imported ones included; context reads in the statics count for SYG170; `replyKeys`
+  in the config file. Its caret range doesn't reach 0.12.0 from `^0.11.0`, so update the dev
+  dependency.
+- **`create-sygnal-app` 2.10.0:** templates depend on `sygnal` ^7.1.0 and `sygnal-check` ^0.12.0, use
+  a system font stack (no Google Fonts) and scaffold a `.gitignore`.
+- **VS Code extension 0.9.0:** bundles `sygnal-check` 0.12.0.
+- **Claude Code plugin 0.2.1:** the `sygnal-dev` skill covers 7.1 (statics with context, per-page
+  Switchable state, SSE resume, reply helpers, `import { xs } from 'sygnal'`).
+
+### Added
+
+- **SYG117: `next()` to an action the component has no entry for (PLAN-13 N-1).** `next('X')`
+  reaches only its own component's model, so a child's `next('ENTER')` for an action only its
+  parent handles silently did nothing. The dev checks (`sygnal/diagnostics`, 0 production bytes)
+  warn on the first such `next()` per component and name, naming the ancestor that handles it and
+  the fix (send it up with `PARENT` or `EVENTS`), or the closest entry for a typo. `sygnal-check`
+  reports a literal `next('X')` with no entry `X` in the same component (with a rename fix for a typo).
+
+- **sygnal-check reads reply names through request helpers and consts (PLAN-13 C-1).** An object
+  argument with a reply key of a call a sink returns is a request (`req('/a', { ok: 'GOT_A' })`,
+  `api.get_run(args, { ok: 'RUN' })`, any callee), a returned const is followed (`HTTP: () => SNAP`),
+  and so are `connections` specs and SSE `events` maps held in consts. SYG102 no longer reports
+  their reply actions as unreachable, SYG112 checks the names, SYG152 and `--graph` see the requests.
+
+- **SYG256 sees past helper calls in other fields (PLAN-13 C-2).** A call in the STATE reducer
+  stopped the proof, so a leave-guard like `EDIT: { STATE: (s, d) => ({ ...s, dirty: true, edit:
+  { ...s.edit, [keyOf(s)]: d } }), ROUTER: (s) => s.dirty ? ABORT : … }` went unreported. A call
+  (or a function) inside a plain field's value now only makes that field unknown; calls in a test,
+  a spread or a computed key of the written object, and any assignment, still keep the check out.
+
+- **create-sygnal-app: no Google Fonts, and a `.gitignore` (PLAN-13 T-1).** The vite, vite-pwa and
+  astro templates loaded Inter from Google Fonts; every template now uses a system font stack and
+  loads nothing remote. No template wrote a `.gitignore` (npm leaves it out of the package): each
+  ships `gitignore`, scaffolded as `.gitignore` (`node_modules`, `dist`, `.vite`, `.astro`,
+  `*.local`, `dev-dist` for the PWA). The release smoke checks both.
+
+- **SYG302: `import xs from 'xstream'` (PLAN-13 X-1).** Under Node ESM and Vite 8 (a `"type":
+  "module"` package) xstream's CommonJS default import is the module object, so a custom driver's
+  `xs.create` is undefined. The docs, llms.txt and the skill use `import { xs } from 'sygnal'`
+  (the accessibility guide's sample was the last default import), the custom-drivers guide says
+  why, and `sygnal-check` reports the default import (info) with a `--fix`.
+
+- **`makeReplies()` and `senderOf()` for drivers you write (PLAN-13 D-1).** The reply-action
+  protocol `makeFetchDriver`, `driverFromAsync` and the socket driver use is exported and typed
+  (`ReplySender`, `ReplyChannel`): spread `replies` into the source, `reply(senderOf(req), type,
+  data)` as often as needed (progress, then a result), and abort a disposed sender's work in
+  `onStop`. The custom-drivers guide has an upload driver that replies more than once.
+
+- **SSE event ids, resuming and dead streams (PLAN-13 S-1).** On a `connections` spec: `meta:
+  true` gives SSE `message` / `events` actions `{ data, id, event }`; `resume: true | 'param'`
+  keeps the last event id and makes a reconnect the driver makes (after EventSource gave up, e.g. a
+  proxy 502, or a non-2xx on the `headers` path) resume from it, as `Last-Event-ID` over fetch or
+  `?lastEventId=` (or `?param=`) on the EventSource URL; `staleAfterMs` (SSE and WebSocket) closes
+  a connection that stays silent that long as a drop (`close` gets `stale: true`) so the reconnect
+  policy applies; over fetch, heartbeat comments count. `t.push(sink, data, { id })` gives a test
+  event its id. No bytes for apps without a socket driver.
+
+- **Declaration statics see the context (PLAN-13 F-1).** `resources`, `timers`, `connections`,
+  `head` and `browser` get `(state, context)` and are computed again when the component's context
+  changes (by identity, D603; an unrelated write re-runs nothing). A routed page reads `route` from
+  context (`App.context = { route: (s) => s.route }`, `TaskPage.resources = { task: (s, { route })
+  => … }`) instead of keeping a copy of the params in its own state. Server rendering passes the
+  context to `resources` and `head` too; the types take it as the second parameter; `sygnal-check`
+  counts context reads in the statics for SYG170. Core: +19 B (kanban gzip).
+
+- **Per-page Switchable state (PLAN-13 F-3).** `state` takes a map from page names to bindings
+  (`state={{ projects: 'pages.projects', settings: byId('teams', state.teamId) }}`): each listed
+  page binds its own key, path, lens or byId selection with a tag child's lifetime rules (another
+  target makes only that page again; a deleted target disposes it on its last state), and the
+  pages not listed share the owner's state. A key that names no page is the new **SYG429** (dev
+  checks and `sygnal-check`, with a rename fix). Types infer the page names from `of`. Core:
+  +126 B (kanban gzip), leaving 18 B of the 43,000 B budget with F-1.
+
+- **Deep-link tests start on their route (PLAN-13 F-2).** `renderComponent(App, { router, url })`
+  applies the root's `route` entry's STATE reducer to the initial state with the `url`'s route
+  before the first render: `initialState`'s `router.current()` ran at module load, so a test used
+  to render `/` first and send its requests. The entry's other sinks (a guard's redirect) still run
+  once, when the router answers. Tests only; no core change.
+
+- **sygnal-check follows `next` into helpers (PLAN-13 C-3).** A model that passes `next` to a
+  function (`advance(state, next)`), imported or in the same file and with any parameter name, has
+  that function's `next('X')` calls counted as its own, 3 calls deep: SYG102 sees the targets, and
+  SYG117 reports a bad one in the helper's file. A helper it can't read (a package) makes the
+  targets unknown, so SYG102 drops to info. The language server re-checks the component when the
+  helper changes.
+
+- **`replyKeys` in sygnal-check's config (PLAN-13 C-4).** A custom driver's own reply keys
+  (`cancelled: 'UP_CANCELLED'`) can be listed in `sygnal-check.config.json`, for every sink
+  (`["cancelled"]`) or per sink (`{ "UPLOAD": ["progress", "cancelled"] }`): their actions count for
+  SYG102 and are checked by SYG112. Without the setting, a request key the checker doesn't know
+  whose value names a model entry makes that entry's SYG102 info, pointing at `replyKeys`.
+
+### Fixed
+
+- **Follow-ups from trying the PLAN-13 build in Temper.** A Switchable page with a per-page
+  `state` map no longer reports SYG106 for the Switchable's own `state` prop (every page did, so
+  `expectNoDiagnostics()` failed). The `sygnal-check` command line reads `replyKeys` (check,
+  `--fix`, `--graph`, `--base`; the API and the language server already did). SSE `resume` replaces
+  an id parameter the URL already has instead of adding a second one. An `every` timer ticks once
+  per interval under a test clock that freezes `Date.now()` while timers run (Playwright's
+  `setFixedTime()`): its drift-free delays had grown by one interval per tick (1, 3, 6, 10 s).
+- **An invalidation no longer resends a resource's old request after a navigation (PLAN-13 R-1).**
+  When a write's `ok` action navigated (`ROUTER`) and its `invalidates` (a URL prefix or a tag)
+  matched a resource of a lens- or key-bound page, the page's new request was sent and then the
+  invalidation sent the old one in the same lane, cancelling the new one: the new page showed the
+  old record. A load now stops when the resource's request changed (or it was paused) while it
+  wrote its loading state; refresh, polling and focus refetches go through the same path.
+
 ## 7.0.0 — 2026-10-19
 
 **Read [Migrating to 7.0](https://sygnal.js.org/guide/migrating-to-7/) before upgrading.** 7.0

package/dist/astro/server.cjs.js

@@ -3063,7 +3063,7 @@ function withUses(def, state) {
  * state reads from the cache ('success' with the cached data), else 'loading' ('idle' for a
  * falsy request), as the client's first paint does with the same (hydrated) cache
  */
-function withResources(def, state) {
+function withResources(def, state, ctx) {
     state = withUses(def, state);
     const res = def && def.resources;
     if (!res || !state || typeof state !== 'object' || Array.isArray(state))
@@ -3074,7 +3074,7 @@ function withResources(def, state) {
             continue;
         let q;
         try {
-            q = typeof res[n] === 'function' ? res[n](state) : res[n];
+            q = typeof res[n] === 'function' ? res[n](state, ctx) : res[n];
         }
         catch (_) { }
         const E = q && ssrCache ? ssrCache.get(ssrCache.key(q, 1)) : undefined;
@@ -3121,15 +3121,33 @@ function viewFailed(def, err, name) {
     }
     return vnode;
 }
-function collectHead(def, state) {
+function collectHead(def, state, ctx) {
     const h = def && def.head;
     if (!heads || !h)
         return;
     try {
-        heads.push(typeof h === 'function' ? h(state) : h);
+        heads.push(typeof h === 'function' ? h(state, ctx) : h);
     }
     catch (_) { }
 }
+/**
+ * PLAN-13 F-1: the context a component sees (its parent's, plus its own entries computed on
+ * `state`). The statics get it as on the client; for `resources` it is computed on the state
+ * before the resources are filled in (a context entry can't read the component's own resource)
+ */
+function contextOf(def, state, parent) {
+    const own = def.context || {}, out = { ...parent };
+    for (const key of Object.keys(own)) {
+        const f = own[key];
+        if (typeof f === 'function' && state != null) {
+            try {
+                out[key] = f(state);
+            }
+            catch (_) { }
+        }
+    }
+    return out;
+}
 /**
  * Render a Sygnal component to an HTML string.
  *
@@ -3170,20 +3188,10 @@ function renderRoot(componentDef, options) {
     const uid = (options.uid || 'u').replace(/[^\w-]+/g, '_');
     const ownState = state !== undefined ? state : componentDef.initialState;
     // 5-5: the view sees its resources; the hydration script keeps the state as it was given
-    const resolvedState = withResources(componentDef, ownState);
-    collectHead(componentDef, resolvedState);
+    const resolvedState = withResources(componentDef, ownState, contextOf(componentDef, ownState, context));
     // Build context: merge parent context with component's own context definitions
-    const componentContext = componentDef.context || {};
-    const mergedContext = { ...context };
-    for (const key of Object.keys(componentContext)) {
-        const contextFn = componentContext[key];
-        if (typeof contextFn === 'function' && resolvedState != null) {
-            try {
-                mergedContext[key] = contextFn(resolvedState);
-            }
-            catch (_) { }
-        }
-    }
+    const mergedContext = contextOf(componentDef, resolvedState, context);
+    collectHead(componentDef, resolvedState, mergedContext);
     // Call the view function
     let vnode;
     try {
@@ -3394,19 +3402,9 @@ function renderSubComponent(vnode, context, parentState, uid) {
         // State passed directly
         childState = stateProp;
     }
-    childState = withResources(componentDef, childState);
+    childState = withResources(componentDef, childState, contextOf(componentDef, childState, context));
     // Build child context
-    const childContext = { ...context };
-    const componentContext = componentDef.context || {};
-    for (const key of Object.keys(componentContext)) {
-        const contextFn = componentContext[key];
-        if (typeof contextFn === 'function' && childState != null) {
-            try {
-                childContext[key] = contextFn(childState);
-            }
-            catch (_) { }
-        }
-    }
+    const childContext = contextOf(componentDef, childState, context);
     // Extract slots from children
     const slots = {};
     const defaultSlotChildren = [];
@@ -3428,7 +3426,7 @@ function renderSubComponent(vnode, context, parentState, uid) {
             slots.default = [];
         slots.default.push(...defaultSlotChildren);
     }
-    collectHead(componentDef, childState);
+    collectHead(componentDef, childState, childContext);
     // Call the view function
     let result;
     try {
@@ -3645,19 +3643,10 @@ function renderSwitchable(vnode, context, parentState, uid) {
  * Internal helper: render a component def to a VNode (not HTML string).
  */
 function renderToStringInternal(componentDef, state, context, uid) {
-    const resolvedState = withResources(componentDef, state !== undefined ? state : componentDef.initialState);
-    const componentContext = componentDef.context || {};
-    const mergedContext = { ...context };
-    for (const key of Object.keys(componentContext)) {
-        const contextFn = componentContext[key];
-        if (typeof contextFn === 'function' && resolvedState != null) {
-            try {
-                mergedContext[key] = contextFn(resolvedState);
-            }
-            catch (_) { }
-        }
-    }
-    collectHead(componentDef, resolvedState);
+    const own = state !== undefined ? state : componentDef.initialState;
+    const resolvedState = withResources(componentDef, own, contextOf(componentDef, own, context));
+    const mergedContext = contextOf(componentDef, resolvedState, context);
+    collectHead(componentDef, resolvedState, mergedContext);
     let vnode;
     try {
         vnode = componentDef({