sygnal 6.2.0 → 6.4.0

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

@@ -17,7 +17,8 @@
  *   a Collection's viewTransitionName that isn't an identifier, the same name twice on the
  *   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).
+ *   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).
  *
  * Only while diagnostics are on (the checks' own rule); production builds never load this.
  */
@@ -65,6 +66,18 @@ function removed(component: any, name: string, anchor: string, detail?: string):
   })
 }
 
+/** SYG427: CHILD.select(x) with no component (an import of a name the module doesn't export) */
+function notComponent(f: any, x: any): void {
+  if (!once(`SYG427:${f.name}`)) return
+  const got = x === null ? 'null' : typeof x == 'object' ? 'an object' : String(x)
+  devReport('SYG427', {
+    component: f.name,
+    message: `${f.name}'s intent calls CHILD.select(${got}): that is not a component, so it never emits`,
+    fix: "Pass the child component itself, and check its import: a name its module doesn't export is undefined (Vitest runs on; the browser fails to link the module). Export it: export function Child() { … }",
+    data: {got},
+  })
+}
+
 /** the removed forms a definition shows (statics, view arity, model keys), once per function */
 let seenDefs = new WeakSet<object>()
 // G-332: resetChecks() forgets them (as the once() dedupe)
@@ -94,6 +107,85 @@ function removedTags(f: any, v: any, depth = 0): void {
   if (Array.isArray(kids)) for (const k of kids) removedTags(f, k, depth + 1)
 }
 
+/**
+ * PLAN-9 SYG453 (D470): two children of one view with the same identity (the same component and
+ * `key`, else `id`; `sel::key` in the core) are one instance, rendered in both places. The core
+ * doesn't look (0 production bytes): in the owner's injected vnode that instance's output, a
+ * scoped root (`data.isolate` in the real DOM driver, a `___<scope>` class in the mock DOM), is
+ * the same object twice. Its name and key come from the child whose DOM source has that scope.
+ */
+const scopeOfVnode = (n: any): string | undefined => {
+  const iso = n.data?.isolate
+  if (Array.isArray(iso)) return iso.length ? iso[iso.length - 1]?.scope : undefined
+  const m = typeof n.sel == 'string' && /\.___([^.]+)/.exec(n.sel)
+  return m ? m[1] : undefined
+}
+const scopeOfSource = (dom: any): string | undefined => {
+  const ns = dom?.namespace
+  if (Array.isArray(ns)) return ns[ns.length - 1]?.scope
+  const p = dom?._path
+  const m = Array.isArray(p) && /^\.___(.+)$/.exec(String(p[p.length - 1]))
+  return m ? m[1] : undefined
+}
+function sharedIdentity(iv: any, v: any): void {
+  const seen = new Set<any>(), dup = new Set<string>()
+  const walk = (n: any, d: number): void => {
+    if (!n || typeof n != 'object' || d > 300) return
+    const sc = scopeOfVnode(n)
+    if (sc !== undefined) {
+      if (seen.has(n)) { dup.add(sc); return }
+      seen.add(n)
+    }
+    const kids = n.children
+    if (Array.isArray(kids)) for (const k of kids) walk(k, d + 1)
+  }
+  walk(v, 0)
+  if (!dup.size) return
+  const owner = iv.name
+  for (const sc of dup) {
+    let child: any
+    try { child = iv.children().find((c: any) => scopeOfSource(c.sources?.DOM) === sc) } catch (_) { /* ignore */ }
+    const name = child ? child.name : 'a child component'
+    // the identity's own part of the child's uid (the owner's uid + '-' + its key, id or path)
+    const key = child && typeof child.uid == 'string' && child.uid.startsWith(iv.uid + '-') ? child.uid.slice(iv.uid.length + 1) : undefined
+    if (!once(`SYG453:${owner}:${name}:${key ?? sc}`)) continue
+    devReport('SYG453', {
+      component: owner,
+      message: `${owner} renders ${child ? `<${name}>` : name} in two places with the same identity${key !== undefined ? ` (key or id ${JSON.stringify(key)})` : ''}, so both places show one instance: it has one state, and the second tag's props replace the first's`,
+      fix: `Give each <${child ? name : 'Child'}> a different key (or id) among its parent's children, e.g. key={item.id}; a key on a component is its identity`,
+      data: {child: child ? name : undefined, key},
+    })
+  }
+}
+
+/**
+ * PLAN-9 SYG426 (D471): the lowercase host tags, `<collection>` / `<switchable>` (JSX string tags,
+ * or `h('collection')`), deprecated in 6.3.0; the next major removes them (and registers the hosts
+ * on first use, as Portal). The core doesn't look (0 production bytes): the instance's template
+ * keeps a host marker after reconcile (only `pres` markers are rewritten), and the imported
+ * components' markers carry their function in `data.m`, a string tag's don't. The template is
+ * the raw instance's (`iv.i`: the InstanceView's own field, a dev entry of the same build reads it;
+ * the vnode onRender gets has the hosts' output injected in their place). Once per tag.
+ */
+const HOST_TAGS: Record<string, string> = {collection: 'Collection', switchable: 'Switchable'}
+function lowercaseTags(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 name = typeof n.sel == 'string' && !n.data?.m && HOST_TAGS[n.sel]
+    if (name && once(`SYG426:${n.sel}`)) devReport('SYG426', {
+      component: iv.name,
+      message: `${iv.name} renders the lowercase <${n.sel}> tag, which is deprecated since Sygnal 6.3.0 and will be removed in the next major (it will then render an unknown <${n.sel}> element)`,
+      fix: `import { ${name} } from 'sygnal' and write <${name} …> (sygnal-check --fix does it)`,
+      data: {tag: n.sel, component: name},
+    })
+    const kids = n.children
+    if (Array.isArray(kids)) for (const k of kids) walk(k, d + 1)
+  }
+  walk(raw.tmpl, 0)
+}
+
 /** the instance fields the checks read from today's Component instances */
 class Facade {
   _so: any
@@ -301,7 +393,11 @@ export function nextHooks(_api: any): any {
         get(t: any, k: any) {
           const v = t[k]
           if (k !== 'CHILD' || !v || typeof v.select != 'function') return v
-          return {...v, select: (x: any, ...r: any[]) => { if (typeof x == 'string') removed(f, f.name, 'child-select-name', `CHILD.select('${x}')`); return v.select(x, ...r) }}
+          return {...v, select: (x: any, ...r: any[]) => {
+            if (typeof x == 'string') removed(f, f.name, 'child-select-name', `CHILD.select('${x}')`)
+            else if (typeof x != 'function') notComponent(f, x)
+            return v.select(x, ...r)
+          }}
         },
       })
     },
@@ -311,7 +407,11 @@ export function nextHooks(_api: any): any {
     onRender(iv: any, vnode: any) {
       const f = fac(iv)
       H.onRender(f, vnode)
-      if (on()) removedTags(f, vnode)
+      if (!on()) return
+      removedTags(f, vnode)
+      try { lowercaseTags(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 */ }
     },
     onReducer(iv: any, type: string, prev: any, next: any) {
       H.onReducer(fac(iv), type, prev, next, 'STATE')

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

@@ -6,7 +6,8 @@
  *          or restored. Under Vike's Layout/Wrapper shell (the `__vike` source) the message says
  *          persist isn't supported on Vike pages, layouts or wrappers yet.
  * SYG223 (warn)  — a `pick` / `omit` key of persist() that isn't a key of the component's
- *          `initialState` static (a typo: that key is never saved, or never left out).
+ *          `initialState` static or of its `uses` (a behavior's slice, such as a chat's), so it is
+ *          a typo: that key is never saved, or never left out.
  * Once per component name. Mechanism: onModel reads the static `view.persist` (the persist()
  * value carries its options) and `view.initialState`.
  */
@@ -38,7 +39,8 @@ export const persistCheck: DiagnosticCheck = {
     }
     const o = p.options, init = view.initialState
     if (!o || !init || typeof init != 'object') return
-    const keys = Object.keys(init)
+    // a behavior's slice (`uses = { chat: chat() }`) is a state key too
+    const keys = [...Object.keys(init), ...Object.keys(view.uses || {})]
     for (const opt of ['pick', 'omit']) {
       for (const k of Array.isArray(o[opt]) ? o[opt] : []) {
         if (keys.includes(k) || !once(`SYG223:${name}:${opt}:${k}`)) continue

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

@@ -36,12 +36,20 @@ const underTest = (c: any) => {
   const dom = c?.sources?.[c.DOMSourceName || 'DOM']
   return !!dom && typeof dom == 'object' && '_hub' in dom
 }
-// G-620: an LLM / chat sink gets the chat driver's fix, not makeFetchDriver's
-const driverFix = (sink: string) =>
-  `Pass a driver named ${sink} to run(): ` + (/^(LLM|CHAT|AI|ASSISTANT)$/.test(sink)
-    ? `run(App, { ${sink}: makeChatDriver({ transport: openResponses({ baseURL: 'http://localhost:11434/v1', model: 'llama3.2' }) }) }) (from 'sygnal/ai'; uiMessageStream('/api/chat') for an AI SDK server)`
-    : `run(App, { ${sink}: makeFetchDriver() }) for HTTP, or driverFromAsync(fn) / your own driver`) +
-  `. Check the spelling against the drivers you pass`
+// G-620: the usual driver for a known sink name (an LLM / chat sink gets the chat driver's fix,
+// SW the service worker's), the generic text for any other name
+const DRIVER_FOR: Array<[RegExp, (sink: string) => string]> = [
+  [/^(LLM|CHAT|AI|ASSISTANT)$/, (s) => `run(App, { ${s}: makeChatDriver({ transport: openResponses({ baseURL: 'http://localhost:11434/v1', model: 'llama3.2' }) }) }) (from 'sygnal/ai'; uiMessageStream('/api/chat') for an AI SDK server)`],
+  [/^(SW|SERVICE_WORKER)$/, (s) => `run(App, { ${s}: makeServiceWorkerDriver('/sw.js', { enabled: import.meta.env.PROD }) }) (enabled: false keeps the driver, with no service worker, on a dev server)`],
+  [/^(HTTP|API|FETCH)$/, (s) => `run(App, { ${s}: makeFetchDriver() })`],
+  [/^(WS|SOCKET)$/, (s) => `run(App, { ${s}: makeSocketDriver() })`],
+]
+const driverFix = (sink: string) => {
+  const known = DRIVER_FOR.find(([re]) => re.test(sink))
+  return `Pass a driver named ${sink} to run(): ` +
+    (known ? known[1](sink) : `run(App, { ${sink}: makeFetchDriver() }) for HTTP, or driverFromAsync(fn) / your own driver`) +
+    `. Check the spelling against the drivers you pass`
+}
 
 export const wiringCheck: DiagnosticCheck = {
   id: 'wiring',

package/src/extra/diagnostics/codes.ts

@@ -276,6 +276,13 @@ export const CODE_TITLES: Record<string, string> = {
   SYG423: 'Context change skipped a view whose output it changes',
   SYG424: 'Duplicate Collection item id',
   SYG425: 'isolatedState slice lacks initialState keys',
+  // PLAN-9 (D471): checks/next.ts; dev entry and sygnal-check
+  SYG426: 'Deprecated lowercase marker tag',
+  // checks/next.ts and sygnal-check: a component reference that is not a function (an import of
+  // a name the module doesn't export is undefined under Vitest)
+  SYG427: 'CHILD.select() of something that is not a component',
+  // PLAN-9 (D470): checks/next.ts; dev entry
+  SYG453: 'Two children with the same identity share one instance',
   SYG601: "Retired in 6.0: Missing or invalid sources",
   SYG602: 'Intent is not a function',
   SYG603: 'Intent returned an invalid value',
@@ -339,6 +346,29 @@ export const CODE_TITLES: Record<string, string> = {
   // PLAN-6 A-2: experimentalExposeWebMcp (src/extra/ai/webmcp.ts; dev)
   SYG674: 'WebMCP not available',
   SYG676: 'WebMCP registerTool rejected',
+  // ---- PLAN-9 compose (A: src/extra/ai/compose/; dev, reported with the severity passed) ----
+  SYG161: 'Catalog container render is a component with a model',
+  SYG162: 'Catalog part with neither component nor render',
+  SYG250: 'Layout names an unknown part or slot',
+  SYG251: 'Invalid param value in a layout',
+  SYG252: 'Record param from() does not return an array of { value }',
+  SYG450: 'Catalog in names an unknown container or slot',
+  SYG451: 'Composed has no catalog or from is not a composition',
+  SYG452: 'Layout lists a node key twice',
+  SYG681: 'Compose backend option problem',
+  // PLAN-9 B-1/B-2: compose.decisions() (src/extra/ai/compose/decisions.ts; explicit severities)
+  SYG680: 'Part is LLM-only under a decision backend',
+  SYG682: 'Decision model answered outside the criteria',
+  // PLAN-9 B-3: compose.llm() (src/extra/ai/compose/llm.ts; the compose status becomes 'error')
+  SYG683: 'LLM layout invalid after repair',
+  // PLAN-9 X-2: static only (sygnal-check rules/syg253-catalog.js)
+  SYG253: 'Misspelled catalog declaration key',
+  SYG254: 'Catalog descriptions or options overlap',
+  // PLAN-9 H: chat client tools and ask (src/extra/ai/chat/behavior.ts, compose/ask.ts, compose/render.ts)
+  SYG160: 'Result part rendered outside a card',
+  SYG684: 'Client tool shadows an agent tool',
+  SYG685: 'Answer for a tool call that is not open',
+  SYG686: 'Ask catalog without a result part',
   // PLAN-4 GS-3: a11y lane (static only, sygnal-check)
   SYG701: 'Click listener on a non-interactive element',
   SYG702: 'Form field without an accessible label',
@@ -457,6 +487,12 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG423: 'warn',
   SYG424: 'warn',
   SYG425: 'warn',
+  // PLAN-9 (checks/next.ts): D471 a lowercase <collection> / <switchable> tag (deprecated in 6.3.0)
+  SYG426: 'warn',
+  // checks/next.ts: CHILD.select(undefined), usually a missing export
+  SYG427: 'error',
+  // PLAN-9 (checks/next.ts): D470 key identity, two children with one identity
+  SYG453: 'warn',
   SYG612: 'error',
   // PLAN-4 D131 (element.ts, through the core bridge; a console warning in dev with diagnostics off)
   SYG644: 'warn',
@@ -497,6 +533,16 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   // PLAN-6 A-2 (experimentalExposeWebMcp reports them with an explicit severity)
   SYG674: 'info',
   SYG676: 'warn',
+  // PLAN-9 B-1/B-2 (compose.decisions() reports them with an explicit severity)
+  SYG680: 'info',
+  SYG682: 'warn',
+  // PLAN-9 B-3 (compose.llm)
+  SYG683: 'error',
+  // PLAN-9 H (chat client tools and ask; reported with the severity passed)
+  SYG160: 'warn',
+  SYG684: 'warn',
+  SYG685: 'warn',
+  SYG686: 'warn',
   // PLAN-5 V-1: VirtualCollection (checks/virtual.ts, through the core bridge)
   SYG430: 'warn',
   SYG431: 'warn',
@@ -528,6 +574,19 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG153: 'warn',
   SYG730: 'warn',
   SYG731: 'warn',
+  // ---- PLAN-9 compose (A: src/extra/ai/compose/, reported with the severity passed, dev) ----
+  SYG161: 'error',
+  SYG162: 'error',
+  SYG250: 'warn',
+  SYG251: 'warn',
+  SYG252: 'warn',
+  SYG450: 'warn',
+  SYG451: 'warn',
+  SYG452: 'warn',
+  SYG681: 'error',
+  // PLAN-9 X-2: static only (sygnal-check); listed so the entry knows their titles
+  SYG253: 'warn',
+  SYG254: 'info',
 }
 
 export function getCodeInfo(code: string): DiagnosticCodeInfo | undefined {

package/src/extra/fetchDriver.ts

@@ -81,6 +81,12 @@ import {validateWith} from './standardSchema';
  *   the socket driver's backoff; the failure (with `attempts`) is delivered once, at the end.
  * - `validate: schema` (a Standard Schema): the parsed body is validated (and transformed); a
  *   failure is an error with `issues`.
+ * - D472 (G-757): `batch: [request, …]` sends those requests in parallel instead of this one (each
+ *   inherits its fields; its own `json` / `body` / `parse` win) and `combine(bodies, requests)`
+ *   merges their parsed bodies into the one reply; `split(request, error)` turns a failed one (or
+ *   the request itself) into requests sent again in parallel and combined, at most 3 deep. One
+ *   failure fails the request once (`error.status` / `error.body`). No cache entry sharing, no
+ *   per-part retry. The test fake (`_whole`) sends and answers it as one request. decide() uses it.
  * - dispose / sink completion aborts everything in flight.
  * - `fetch` is read at request time (options.fetch, else globalThis.fetch), so test stubs work.
  * - PLAN-3 5-1 (H-9): renderComponent's HTTP fake runs this driver over an in-memory fetch;
@@ -137,6 +143,15 @@ const autoParse = async (res: any) => {
   return text ? JSON.parse(text) : null;
 };
 
+/** a non-2xx response */
+const bad = (res: any) => res.ok === false || res.status < 200 || res.status > 299;
+/** the failure of a non-2xx response: `status`, `body` (parsed with 'auto') */
+const httpError = async (res: any, href: string) => {
+  let body: any;
+  try { body = await autoParse(res); } catch (_) {}
+  return Object.assign(new Error(`HTTP ${res.status}${res.statusText ? ' ' + res.statusText : ''}: ${href}`), {status: res.status, body});
+};
+
 const PARSERS: Record<string, (res: any) => any> = {
   auto: autoParse,
   json: res => res.json(),
@@ -144,6 +159,8 @@ const PARSERS: Record<string, (res: any) => any> = {
   response: res => res,
 };
 
+const parserOf = (pz: any) => typeof pz == 'function' ? pz : PARSERS[pz] || autoParse;
+
 const pickInit = (init: any) => {
   const out: any = {};
   if (init && typeof init == 'object') INIT_KEYS.forEach(k => { if (init[k] !== undefined) out[k] = init[k]; });
@@ -379,15 +396,23 @@ export function makeFetchDriver(options: any = {}) {
       if (abort) return cancel(r => r.scope === scope && (!('category' in req) || r.category === category));
       if (rn !== undefined || (!pf && (latest ?? options.latest))) cancel(rk === undefined ? r => r.rk === undefined && r.scope === scope && r.category === category : r => r.sender === sender && r.rk === rk);
 
-      const href = withQuery((options.baseUrl || '') + (url ?? ''), query);
-      const base = options.init, own = init;
-      const h = mergeHeaders(options.headers, base?.headers, own?.headers, headers);
-      let b = body ?? own?.body;
-      if (json !== undefined) {
-        b = JSON.stringify(json);
-        if (!Object.keys(h).some(k => k.toLowerCase() == 'content-type')) h['content-type'] = 'application/json';
-      }
-      const m = method || own?.method || base?.method || (b !== undefined ? 'POST' : 'GET');
+      const base = options.init;
+      // a request's URL and fetch() init (the batch's sub-requests inherit the request's fields)
+      const prep = ({url, method, headers, query, json, body, init: own}: any) => {
+        const h = mergeHeaders(options.headers, base?.headers, own?.headers, headers);
+        let b = body ?? own?.body;
+        if (json !== undefined) {
+          b = JSON.stringify(json);
+          if (!Object.keys(h).some(k => k.toLowerCase() == 'content-type')) h['content-type'] = 'application/json';
+        }
+        return [withQuery((options.baseUrl || '') + (url ?? ''), query), {...pickInit(base), ...pickInit(own), method: method || own?.method || base?.method || (b !== undefined ? 'POST' : 'GET'), headers: h, body: b}];
+      };
+      const [href, fetchInit] = prep(req);
+      const m = fetchInit.method;
+      // D472: `batch` (sub-requests sent in parallel) and `split` (a failed request sent again in
+      // parts, at most 3 deep), their parsed bodies merged by `combine` into one reply. The test
+      // fake (_whole) answers such a request as one
+      const {batch, split, combine = (x: any) => x} = options._whole ? {} as any : req;
       const k = C?.key(req, rn !== undefined || pf);
       const id = ++seq;
       const r: any = {category, scope, sender, rk};
@@ -421,18 +446,10 @@ export function makeFetchDriver(options: any = {}) {
         const tries = pol.count ?? 3;
         F = {id, k, q: req, s: new Set(), n: 0};
         if (k !== undefined) C.f.set(k, F);
-        const pz = parse || options.parse || 'auto';
-        const parser = typeof pz == 'function' ? pz : PARSERS[pz] || autoParse;
+        const parser = parserOf(parse || options.parse);
         // the global fetch is called as a method: a detached window.fetch throws "Illegal invocation"
         const g: any = globalThis;
         const doFetch = options.fetch || (typeof g.fetch == 'function' && ((u: string, i: any) => g.fetch(u, i)));
-        const fetchInit = {
-          ...pickInit(base),
-          ...pickInit(own),
-          method: m,
-          headers: h,
-          body: b,
-        };
         // the outcome, to every request waiting on this fetch (the failure once, after the last attempt)
         const end = (e: any, x?: any, status?: number) => {
           done(F);
@@ -454,23 +471,37 @@ export function makeFetchDriver(options: any = {}) {
             // 5-1 (H-9): renderComponent's fake learns which request (and resource) the next fetch is for
             options._tap?.(req, rn, pf);
             // called synchronously, so a test sees the call right after the sink emitted
-            p = Promise.resolve(doFetch(href, {...fetchInit, signal: ctl.signal}));
+            p = batch ? Promise.resolve() : Promise.resolve(doFetch(href, {...fetchInit, signal: ctl.signal}));
+            if (batch || split) {
+              // D472: parts in parallel; a failed one split again when `split` says how
+              const one = (q: any, d: number, first?: any): Promise<any> => {
+                const [u, i] = prep({...req, ...q});
+                return (first || Promise.resolve(doFetch(u, {...i, signal: ctl.signal}))).then(async (res: any) => {
+                  if (bad(res)) {
+                    const e = await httpError(res, u);
+                    const qs = d < 3 && live() && split?.(q, e);
+                    if (qs?.length > 1) return all(qs, d + 1);
+                    throw e;
+                  }
+                  return parserOf(q.parse || parse || options.parse)(res);
+                });
+              };
+              const all = (qs: any[], d: number) => Promise.all(qs.map(q => one(q, d))).then(bodies => combine(bodies, qs));
+              p = (batch ? all(batch, 0) : one(req, 0, p)).then(v => ({b: v}));
+            }
           } catch (e) {
             p = Promise.reject(e);
           }
           p.then(async (res: any) => {
+            if (batch || split) return live() && (k !== undefined && !F.z && C.put(k, req, res.b), end(0, res.b, 200));
             if (!live()) return;
             // R4-3: anything that throws here (a non-Response, a parser) fails the request
             try {
               const st = res.status;
-              if (res.ok === false || st < 200 || st > 299) {
-                let errBody: any;
-                try { errBody = await autoParse(res); } catch (_) {}
+              if (bad(res)) {
+                const e = await httpError(res, href);
                 if (!live() || ((st == 408 || st == 429 || st > 499) && again(res))) return;
-                const e: any = new Error(`HTTP ${st}${res.statusText ? ' ' + res.statusText : ''}: ${href}`);
-                e.status = st;
-                e.body = errBody;
-                return end(e, {status: st, body: errBody});
+                return end(e, {status: st, body: e.body});
               }
               let v: any;
               try { v = await parser(res); } catch (e) { return live() && end(e, {status: st}); }
@@ -480,7 +511,7 @@ export function makeFetchDriver(options: any = {}) {
             } catch (e) {
               live() && end(e);
             }
-          }, (e: any) => { live() && !again() && end(e); });
+          }, (e: any) => { live() && (e?.status ? end(e, {status: e.status, body: e.body}) : !again() && end(e)); });
         };
         go();
       }

package/src/extra/lens.ts

@@ -0,0 +1,15 @@
+/*
+ * PLAN-9 (D463): byId(field, id, idKey = 'id'), a { get, set } lens to the element of the array
+ * `state[field]` whose `idKey` is `id`: a record part's state (`state: (node) => byId('projects',
+ * node.params.id)`), or any child's `state={byId('todos', 3)}`. get: the element (undefined when it
+ * is gone); set: the array with that element replaced (the state unchanged when it is gone).
+ * Side-effect free.
+ */
+export const byId = (field: string, id: any, idKey = 'id') => ({
+  get: (s: any) => (Array.isArray(s?.[field]) ? s[field].find((x: any) => x?.[idKey] === id) : undefined),
+  set: (s: any, v: any) => {
+    const a = s?.[field]
+    if (!Array.isArray(a) || !a.some((x: any) => x?.[idKey] === id)) return s
+    return {...s, [field]: a.map((x: any) => (x?.[idKey] === id ? v : x))}
+  },
+})

package/src/extra/pwa.ts

@@ -18,6 +18,8 @@ export interface ServiceWorkerCommand {
 
 export interface ServiceWorkerOptions {
   scope?: string;
+  /** false: register nothing, ignore commands, emit nothing (a dev server: `enabled: import.meta.env.PROD`) */
+  enabled?: boolean;
 }
 
 export interface InstallPrompt {
@@ -47,7 +49,7 @@ export function makeServiceWorkerDriver(
   return function serviceWorkerDriver(sink$: Stream<ServiceWorkerCommand>): ServiceWorkerSource {
     const events = new EventTarget();
 
-    if (typeof navigator !== 'undefined' && 'serviceWorker' in navigator) {
+    if (options.enabled !== false && typeof navigator !== 'undefined' && 'serviceWorker' in navigator) {
       navigator.serviceWorker
         .register(scriptUrl, {scope: options.scope})
         .then((reg) => {

package/src/extra/reducers.ts

@@ -5,6 +5,8 @@
  * shorthand factories for the most frequent reducer shapes.
  */
 
+import {ABORT, isAbort} from '../shared'
+
 // ── set() ──────────────────────────────────────────────────────────
 /**
  * Create a reducer that merges a partial update into state.
@@ -40,13 +42,17 @@ export function toggle<S = any>(field: keyof S & string): (state: S) => S {
 }
 
 // event(type, payload?) → EVENTS sink fn for the object form:
-// `ACTION: { EVENTS: event('TYPE', (state, data) => payload) }` (static payloads allowed)
+// `ACTION: { EVENTS: event('TYPE', (state, data) => payload) }` (static payloads allowed).
+// A payload function that returns ABORT sends nothing, as ABORT does from any other sink.
 export function event(
   type: string,
   payload?: any | ((state: any, data: any, next: Function, props: any) => any)
-): (state: any, data: any, next: Function, props: any) => { type: string; data: any } {
+): (state: any, data: any, next: Function, props: any) => { type: string; data: any } | typeof ABORT {
   return typeof payload === 'function'
-    ? (state, data, next, props) => ({ type, data: payload(state, data, next, props) })
+    ? (state, data, next, props) => {
+      const d = payload(state, data, next, props)
+      return isAbort(d) ? ABORT : { type, data: d }
+    }
     : () => ({ type, data: payload })
 }
 
@@ -66,6 +72,6 @@ export function event(
 export function emit(
   type: string,
   data?: any | ((state: any, actionData: any, next: Function, props: any) => any)
-): { EVENTS: (state: any, actionData: any, next: Function, props: any) => { type: string; data: any } } {
+): { EVENTS: (state: any, actionData: any, next: Function, props: any) => { type: string; data: any } | typeof ABORT } {
   return { EVENTS: event(type, data) }
 }

package/src/extra/ssr.ts

@@ -163,14 +163,14 @@ function withResources(def: any, state: any): any {
 }
 
 // PLAN-4 GS-9: uid(name?) as on the client: the root is 'u'; a child component adds its path in
-// the parent's view (or its `id` prop), as getComponentIdFromElement and instantiateSubComponents
+// the parent's view (or its vnode `key`, else its `id` prop, D456), as getComponentIdFromElement and instantiateSubComponents
 // in the core do; a Collection item adds its key, a Switchable page its name; anything but
 // each part encoded by uidPart (G-214); in the root option anything but [A-Za-z0-9_-] becomes '_'
 // (as run() does). SSR ids = hydration ids
 const makeUid = (base: string) => (n?: string) => n ? base + '-' + n : base
 function childUid(uid: string, vnode: any, path: string): string {
-  const id = vnode.data?.props?.id
-  return uid + '-' + uidPart(('::' + ((id && JSON.stringify(id).replaceAll('"', '')) || path)).replace(/.*::(r\.)?/, ''))
+  const id = vnode.key ?? vnode.data?.props?.id
+  return uid + '-' + uidPart(('::' + ((id != null && JSON.stringify(id).replaceAll('"', '')) || path)).replace(/.*::(r\.)?/, ''))
 }
 
 // G-567: a view that returns a string or a number renders it as text (core/instance.ts view());

package/src/extra/testing.ts

@@ -1754,6 +1754,8 @@ export function renderComponent(
         // 5-3: focus / online come from t.focus() / t.online() only
         _on: (f: any) => { signals.add(f); return () => signals.delete(f); },
         _tap: (req: any, res?: string, pf?: any) => { tapped = [req, res, pf]; },
+        // D472: a batch / split request (a large decide()) is one fetch here, answered as one
+        _whole: true,
         fetch: (url: string, init: any) => new Promise((resolve, reject) => {
           const [req, res, pf] = tapped || [{url}];
           tapped = undefined;

package/src/extra/widget.ts

@@ -171,14 +171,14 @@ function rewrite(n: any, o: any, path: string): any {
   return r
 }
 
-/** widget markers among a Portal's children (the core doesn't walk them) */
+/** widget markers among a Portal's children (the core doesn't walk them): `pres.widget.$k`, which the
+ * Portal's rewrite calls (core/markers/portal.ts; G-751: either may be registered first) */
 const inPortal = (c: any[], o: any, x: string): any[] =>
   c.map((n, i) => n?.sel == 'widget' ? rewrite(n, o, x + '.' + i) : n?.children ? {...n, children: inPortal(n.children, o, x + '.' + i)} : n)
+;(rewrite as any).$k = inPortal
 
 export function defineWidget(def: any): any {
   pres.widget ||= rewrite
-  const p: any = pres.portal
-  if (p && !p.$w) ((pres.portal = (n: any, o: any, x: string) => p({...n, children: inPortal(n.children || [], o, x)}, o, x)) as any).$w = 1
   const w: any = () => {}, commands: any = {}
   // D200: any name, `close` and `togglePopover` too (the core passes a widget command the options)
   for (const m in def.commands) commands[m] = (el: any, o: any) => el[W] && def.commands[m](el[W].i, o || {}, el)