sygnal 7.0.0 → 7.2.0-preview.0

package/dist/diagnostics.cjs.js

@@ -137,6 +137,10 @@ const CODE_TITLES = {
     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',
+    // ui-sweep R1: dev entry (checks/behaviors.ts onIntent) and sygnal-check
+    SYG118: 'Host intent replaces a behavior trigger',
     SYG124: 'Component used as a control or selector',
     SYG125: 'Control given .intent, .model or .initialState',
     SYG126: 'Control rendered but never listened to',
@@ -172,11 +176,15 @@ const CODE_TITLES = {
     // 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',
     // PLAN-5 3-H (G-449): sortable over a list shown in another order (checks/sortable.ts)
     SYG435: 'Sortable list shown filtered or in another order',
+    // Temper feedback 2026-10: VirtualCollection (checks/virtual.ts, through the core bridge)
+    SYG436: 'VirtualCollection estimateSize far from the measured row heights',
     // PLAN-6 A-1 (sygnal/ai agent layer)
     SYG440: 'Two agent declarations with the same name',
     SYG441: 'Agent Collection items without unique ids',
@@ -185,8 +193,14 @@ const CODE_TITLES = {
     // SYG2xx state & reducers (1A)
     SYG201: 'STATE reducer dropped keys from the previous state',
     SYG202: 'STATE reducer returned undefined',
+    // sandbox research §6 (dev entry, checks/next.ts)
+    SYG204: 'Root component has no state, so its view never renders',
     // 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' or 'xstream/extra/*'",
+    // Temper feedback 2026-10: static only (sygnal-check; warn under --strict)
+    SYG303: 'STATE.stream with dropRepeats() in an intent',
     // 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)
@@ -198,6 +212,7 @@ const CODE_TITLES = {
     SYG506: "Removed in 6.0: CHILD.select() with a component name",
     SYG507: 'Prop drilled through more than 2 component levels',
     SYG508: 'select()/errors() round trip where reply actions would do',
+    SYG509: 'Clock or randomness read from a global in a handler',
     // SYG9xx internal (0B)
     SYG900: 'A diagnostics check threw',
     // ---- 1E retrofit codes (SYG206-299, 402-499, 601-699, 901-999) ----
@@ -364,12 +379,23 @@ const CODE_TITLES = {
     SYG254: 'Catalog descriptions or options overlap',
     SYG256: 'Output guard rejects the updated state',
     SYG257: 'Output reads a field its action changed (7.0 timing audit)',
+    // record/replay: static only (sygnal-check rules/syg258-clock-in-reducer.js; SYG509 under --strict)
+    SYG258: 'Clock or randomness read from a global in a STATE reducer',
+    // sygnal/yjs (research: dev-plans/research/crdt-state): shared() reports them (dev), SYG260 statically too
+    SYG260: 'undo() or undoable() on a key shared() syncs',
+    SYG261: 'shared() inferred the kind of an empty array',
+    // sygnal/canvas (research: dev-plans/research/canvas-apps): the Canvas reports it (dev)
+    SYG262: 'Canvas data layer rebuilt with equal nodes',
     SYG454: 'State binding changed without a new component identity',
     // 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',
+    // sygnal/api (dev preview)
+    SYG690: 'API contract skew',
+    SYG691: 'Unknown API endpoint',
+    SYG692: 'Sandbox event dropped',
     // 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',
@@ -404,6 +430,7 @@ const STRICT_CODE_SEVERITY = {
     SYG506: 'error',
     SYG507: 'info',
     SYG508: 'warn',
+    SYG509: 'warn',
 };
 // PLAN-3 1-G (G-143): codes only the 'sygnal/diagnostics' dev entry reports. Like the strict
 // table, kept OUT of CODE_SEVERITY (zero bytes in the main bundle); the entry registers them
@@ -415,6 +442,10 @@ const DEV_CODE_SEVERITY = {
     SYG112: 'error',
     SYG115: 'warn',
     SYG116: 'error',
+    SYG117: 'warn',
+    SYG118: 'warn',
+    // sandbox research §6: a root that has no state after it starts (checks/next.ts)
+    SYG204: 'warn',
     // PLAN-4 1-D: controls, static (sygnal-check)
     SYG124: 'error',
     SYG125: 'error',
@@ -426,6 +457,12 @@ const DEV_CODE_SEVERITY = {
     SYG129: 'warn',
     // PLAN-10 X-1: static only (sygnal-check)
     SYG170: 'warn',
+    // PLAN-13 X-1: static only (sygnal-check)
+    SYG302: 'info',
+    // Temper feedback 2026-10: static only (sygnal-check); its strict copy reports it at warn
+    SYG303: 'info',
+    // PLAN-13 F-3 (checks/next.ts)
+    SYG429: 'warn',
     SYG171: 'warn',
     SYG221: 'error',
     // PLAN-4 GS-4 (state.ts)
@@ -549,6 +586,11 @@ const DEV_CODE_SEVERITY = {
     SYG684: 'warn',
     SYG685: 'warn',
     SYG686: 'warn',
+    // sygnal/api: contractFetch() (SYG690); static only: sygnal-check (SYG691)
+    SYG690: 'warn',
+    SYG691: 'warn',
+    // sygnal/sandbox: an EVENTS type not declared in emits, or data its schema rejects (createSandbox, <Sandboxed>)
+    SYG692: 'warn',
     // PLAN-5 V-1: VirtualCollection (checks/virtual.ts, through the core bridge)
     SYG430: 'warn',
     SYG431: 'warn',
@@ -557,6 +599,8 @@ const DEV_CODE_SEVERITY = {
     SYG434: 'warn',
     // PLAN-5 3-H (G-449): sortable (checks/sortable.ts)
     SYG435: 'warn',
+    // Temper feedback 2026-10: VirtualCollection (checks/virtual.ts)
+    SYG436: 'warn',
     // PLAN-6 A-1 (sygnal/ai agent layer)
     SYG440: 'warn',
     SYG441: 'warn',
@@ -597,6 +641,12 @@ const DEV_CODE_SEVERITY = {
     SYG256: 'warn',
     // 7.0: the opt-in timing audit (checks/next.ts; configureTimingAudit)
     SYG257: 'info',
+    // record/replay: static only (sygnal-check); listed so the entry knows its title
+    SYG258: 'warn',
+    // sygnal/yjs: reported with the severity passed (shared() in dev; sygnal-check: SYG260)
+    SYG260: 'warn',
+    SYG261: 'warn',
+    SYG262: 'warn',
     // PLAN-12: static only for legacy (6.x) binding contracts. Sygnal 7 remounts known targets.
     SYG454: 'warn',
 };
@@ -1147,7 +1197,9 @@ const propsCheck = {
                 data: { prop: key },
             });
         }
-        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`)) {
@@ -1774,8 +1826,21 @@ const notACommand = (component, name, cmd) => send('SYG641', {
     fix: `Send { <method>: control or selector, ...options }, e.g. { focus: Email }, or an array of them`,
     data: { command: cmd },
 });
-/** SYG640 (no `el`) or SYG641 (an element, but no command of that name) for `cmd` sent by `component` */
-function reportElementCommand(component, cmd, el) {
+/** does the page have an element matching `target` (a selector or a control) anywhere? */
+const onPage = (target) => {
+    try {
+        return !!globalThis.document?.querySelector(String(target));
+    }
+    catch (_) {
+        return false;
+    }
+};
+/**
+ * SYG640 (no `el`) or SYG641 (an element, but no command of that name) for `cmd` sent by
+ * `component`. `elsewhere`: the target matches outside the sender's own view (renderComponent
+ * passes it from the rendered tree; otherwise the page is asked)
+ */
+function reportElementCommand(component, cmd, el, elsewhere) {
     // a disposed instance's pending commands are dropped silently
     if (component && component._disposed)
         return;
@@ -1789,15 +1854,18 @@ function reportElementCommand(component, cmd, el) {
     const data = { method, command: cmd, ...(control ? { control } : { selector: target == null ? target : String(target) }) };
     if (!el) {
         const missing = target == null || target === '';
+        // Temper 2026-10: say when the element is on the page, only not in the sender's view
+        const outside = !missing && (elsewhere ?? onPage(target));
         return send('SYG640', {
             component,
             message: missing
                 ? `${what} in ${name} has no target (${String(target)}), so the command was dropped`
-                : `${what} in ${name} matched no element: nothing in ${name}'s own view matches ${control ? `the control ${control}` : `'${String(target)}'`} (waited 1 s), so the command was dropped`,
+                : `${what} in ${name} matched no element: nothing in ${name}'s own view matches ${control ? `the control ${control}` : `'${String(target)}'`} (waited 1 s), so the command was dropped` +
+                    (outside ? `. A matching element is rendered outside ${name}'s view (by an ancestor, a child component or another part of the page), and a command reaches only its sender's own elements` : ''),
             fix: missing
                 ? `Give the method a control or a selector: { ${method}: Email }`
-                : `Render the element in ${name}'s view, or send the command from the component that renders it: a child component's elements are isolated from its parent, and a command reaches only its sender's own elements (in a Collection, each item sends its own)`,
-            data,
+                : `Render the element in ${name}'s view, or send the command from the component that renders it: a child component's elements are isolated from its parent, and a command reaches only its sender's own elements (in a Collection, each item sends its own). For an element an ancestor renders, hand it off: emit EVENTS: event('FOCUS_NAME') from ${name} (or send PARENT) and send ELEMENT: { ${method}: … } from the ancestor's entry for it; for one inside a child, the parent can use { ${method}: focusWithin('…') }`,
+            data: outside ? { ...data, outside: true } : data,
         });
     }
     // PLAN-5 W-1: the matched element is a widget's host (selector or control target): SYG142 names
@@ -1995,6 +2063,8 @@ function installWidgetHooks() {
  *   432  an item renders a fragment or text, not one element (once per host)
  *   433  scrollToIndex / scrollToId for an index or id not in the (filtered) list
  *   434  estimateSize / overscan not a positive number (or a function, for estimateSize)
+ *   436  a numeric estimateSize far from the measured row heights (the median of the first 10
+ *        measurements is off by more than 1.3×; once per host)
  */
 const tag = (owner) => `<VirtualCollection> in ${nameOf(owner)}`;
 function reportVirtual(code, owner, x = {}) {
@@ -2045,6 +2115,15 @@ function reportVirtual(code, owner, x = {}) {
             data: x,
         });
     }
+    if (code == 436) {
+        const low = x.measured > x.estimate;
+        return devReport('SYG436', {
+            component,
+            message: `${tag(owner)}: estimateSize={${x.estimate}}, but its rows measure about ${x.measured} px (the median of the first 10 measured)${low ? ', so the rows not rendered yet count as too short: a fast scroll to the end shows blank space until they are measured, and the scrollbar jumps' : ', so the scrollbar shrinks and jumps as rows are measured'}`,
+            fix: `Pass estimateSize={${x.measured}} (the rows' real height; when unsure, err high), or (item, index) => px when rows differ predictably`,
+            data: x,
+        });
+    }
 }
 /** Publish the VirtualCollection hook on the core bridge. Returns an uninstall function. */
 function installVirtualHooks() {
@@ -2062,6 +2141,30 @@ const what$1 = (v) => v === null || v === undefined ? String(v)
             : `a ${typeof v}`;
 const behaviorsCheck = {
     id: 'behaviors',
+    // SYG118 (ui-sweep R1): a host intent action named like a behavior action replaces the trigger
+    // the behavior built from an option the host passed (`triggers: { ACTION: 'option' }` on the
+    // definition). The intent combine (extra/behaviors.ts) removes a host-replaced action from
+    // `_behaviorActions`, so after the intent ran that map tells which ones the host took
+    onIntent(component, names) {
+        const view = component?.view, uses = view?.uses;
+        if (!uses || typeof uses != 'object' || !once('SYG118:' + nameOf(component)))
+            return;
+        const owned = component._behaviorActions || {};
+        for (const key of Object.keys(uses)) {
+            const b = uses[key], tr = b?.triggers;
+            for (const a in tr) {
+                const opt = tr[a], name = key + '.' + a;
+                if (b.options?.[opt] == null || !names.includes(name) || name in owned)
+                    continue;
+                devReport('SYG118', {
+                    component,
+                    message: `${nameOf(component)}'s intent action '${name}' replaces the trigger the behavior builds from its '${opt}' option, so the elements '${opt}' names no longer dispatch '${name}'`,
+                    fix: `List every element in the option instead (${opt}: '${String(b.options[opt])}, .other'), dispatch it from another action with next('${name}'), or leave the '${opt}' option out to replace the trigger on purpose`,
+                    data: { key, action: a, option: opt },
+                });
+            }
+        }
+    },
     onModel(component) {
         const view = component?.view, uses = view?.uses;
         if (!uses || typeof uses != 'object' || !once('SYG127:' + nameOf(component)))
@@ -2506,7 +2609,7 @@ function readingSource(component, sink, source) {
     }
     return wrapped;
 }
-function checkRequest(component, sink, req, modelActions) {
+function checkRequest(component, sink, req, modelActions, handledAbove) {
     if (!req || typeof req !== 'object')
         return;
     const name = nameOf(component);
@@ -2519,17 +2622,21 @@ function checkRequest(component, sink, req, modelActions) {
         seen.add(action);
         if (modelActions.includes(action) || !once(`SYG112:${name}:${action}`))
             continue;
-        const near = suggest(action, modelActions.filter(a => !a.startsWith('__')));
+        // Temper 2026-10: a reply goes only to its sender; an ancestor's entry of that name never runs
+        const up = handledAbove?.(action);
+        const near = up ? undefined : suggest(action, modelActions.filter(a => !a.startsWith('__')));
         devReport('SYG112', {
             component,
             message: (connection
                 ? `${sink} connection '${connection}' names '${action}' as its ${key} reply action, but ${name} has no model entry '${action}', so those events are dropped`
                 : `A ${sink} request names '${action}' as its ${key} reply action, but ${name} has no model entry '${action}', so the reply is dropped`) +
-                (near ? ` (did you mean '${near}'?)` : ''),
-            fix: near
-                ? `Use the existing entry: ${key.startsWith('events.') ? `events: { '${key.slice(7)}': '${near}' }` : `${key}: '${near}'`}`
-                : `Add '${action}' to ${name}.model, e.g. ${action}: (state, data) => ({ ...state, ... }), or fix the name`,
-            data: { action, key, sink, ...(connection ? { connection } : {}), ...(near ? { suggestion: near } : {}), modelActions },
+                (up ? `: replies go only to the component that sent the request, never to ${up}, which handles '${action}'` : near ? ` (did you mean '${near}'?)` : ''),
+            fix: up
+                ? `Let ${up} send it: emit EVENTS: event('...') from ${name} and send the request from ${up}'s entry for it, so the reply comes back to ${up}. For data several components load, declare it once as a resource in ${up} (resources: { name: (state) => ({ url, tags: ['name'] }) }) and re-request with ${sink}: { invalidate: 'name' } from anywhere. Or handle the reply here: add '${action}' to ${name}.model`
+                : near
+                    ? `Use the existing entry: ${key.startsWith('events.') ? `events: { '${key.slice(7)}': '${near}' }` : `${key}: '${near}'`}`
+                    : `Add '${action}' to ${name}.model, e.g. ${action}: (state, data) => ({ ...state, ... }), or fix the name`,
+            data: { action, key, sink, ...(connection ? { connection } : {}), ...(up ? { handledBy: up } : {}), ...(near ? { suggestion: near } : {}), modelActions },
         });
     }
     // SYG508 (strict): a request without reply actions whose replies this instance reads back with select()/errors()
@@ -2808,8 +2915,15 @@ catch (_) {
 function timerSpecProblem(s) {
     if (!s || typeof s != 'object')
         return 'is not an object ({ every, action }, { after, action } or { frame: action })';
-    if ('frame' in s && s.frame)
-        return typeof s.frame == 'string' ? '' : 'frame must be the action name (a string)';
+    if ('frame' in s && s.frame) {
+        if (typeof s.frame != 'string')
+            return 'frame must be the action name (a string)';
+        if (s.step != null && !(s.step > 0))
+            return `step must be a positive number of ms (got ${brief$2(s.step)})`;
+        if (s.keys != null && typeof s.keys != 'object')
+            return `keys must be an object of button: key codes (got ${brief$2(s.keys)})`;
+        return '';
+    }
     if (!s.action || typeof s.action != 'string')
         return 'has no action (a string)';
     if (s.every == null && s.after == null)
@@ -3282,6 +3396,9 @@ function installRxjsHints(proto) {
  * sends nothing.
  */
 const BUILT_IN = /^(BOOTSTRAP|INITIALIZE|DISPOSE|RESOURCE)$/;
+// a behavior's plumbing actions (sygnal/yjs shared(): 'board.LOCAL', 'board.REMOTE') mark their
+// handlers, so they are 'built-in' too (DevTools hides them with INITIALIZE)
+const MARK = Symbol.for('sygnal.builtIn');
 /** now on the test's fake clock when there is one (vi.useFakeTimers()), else Date.now() */
 const clockNow = () => {
     const c = setTimeout.clock;
@@ -3291,7 +3408,8 @@ const clockNow = () => {
  * PLAN-4.6 R4: the same log on the core, from its hooks (04 §3.3) instead of instance
  * patches: onAction opens the record (the core passes the cause: 'intent', 'next', 'reply',
  * 'built-in', 'simulateAction'), wrapHandler sees which sinks produced a value. Same records,
- * same cause rules: a built-in type is 'built-in' unless simulated; an intent action a behavior
+ * same cause rules: a built-in type (or one whose handlers carry Symbol.for('sygnal.builtIn')) is
+ * 'built-in' unless simulated; an intent action a behavior
  * owns is 'behavior'. `only(inst)`: the instances to record (renderComponent: its own tree).
  */
 function actionHooks(listener, only) {
@@ -3313,7 +3431,8 @@ function actionHooks(listener, only) {
             addSink(listener, rec, ['STATE'], 'STATE', undefined);
         },
         onAction(inst, a) {
-            if (only && !only(inst))
+            // 7.2: a runtime setState (time travel, HMR, element props) isn't an action of the log
+            if ((only && !only(inst)) || a.cause == 'setState')
                 return;
             const type = String(a.type), owned = inst.def.behaviorActions;
             const hs = inst.def.handlers.get(type) || [], order = hs.map((h) => h[0]);
@@ -3323,7 +3442,7 @@ function actionHooks(listener, only) {
                 cur.set(inst, [opened, order]);
                 return;
             }
-            const cause = a.cause == 'simulateAction' ? a.cause : BUILT_IN.test(type) ? 'built-in'
+            const cause = a.cause == 'simulateAction' ? a.cause : BUILT_IN.test(type) || hs.some((h) => h[1]?.[MARK]) ? 'built-in'
                 : a.cause == 'next' || a.cause == 'reply' || a.cause == 'agent' ? a.cause
                     : owned && Object.prototype.hasOwnProperty.call(owned, type) ? 'behavior' : 'intent';
             const rec = { type, data: a.data, component: inst.name, instance: String(inst.id), sinks: [], cause, time: clockNow(), ...(a.source !== undefined && { source: a.source }) };
@@ -3875,7 +3994,9 @@ const audited = (f, type, sink, h) => (s, d, nx, p, ...r) => {
  *   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), SYG204 (sandbox
+ *   research §6: a root that has no state after it started, so its view never runs).
  *
  * Only while diagnostics are on (the checks' own rule); production builds never load this.
  */
@@ -4071,6 +4192,36 @@ function lowercaseTags(iv) {
     };
     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) {
+    const raw = iv.i;
+    if (!raw?.kids?.size || !raw.tmpl)
+        return;
+    const walk = (n, d) => {
+        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 {
     constructor(__next) {
@@ -4267,6 +4418,31 @@ function vtReport(dup) {
     }
 }
 /** The hooks one app gets (installChecks publishes this on the bridge). */
+/**
+ * SYG204 (sandbox research §6): the core calls no view while its instance's state is undefined,
+ * and a root gets state only from initialState (or the state an HMR swap keeps), a model-less root's `true`, or
+ * a reducer. Checked once per app after the start settles: the first flush (INITIALIZE included)
+ * and the flush BOOTSTRAP's reducers cause; a root still without state is reported (0 core bytes:
+ * the runtime API's flushed(), no timers).
+ */
+function statelessRoot(api, iv, on) {
+    if (!api?.flushed || iv.state !== undefined)
+        return;
+    const settled = () => api.flushed();
+    // the first flush, then BOOTSTRAP (a microtask after it) and the flush it schedules
+    Promise.resolve().then(settled).then(() => new Promise(r => queueMicrotask(r))).then(settled).then(() => {
+        if (iv.disposed || iv.state !== undefined || !on())
+            return;
+        const name = iv.name, h = iv.def.handlers;
+        const later = [...h.keys()].filter((k) => k != 'INITIALIZE' && k != 'BOOTSTRAP' && h.get(k).some((x) => x[0] == 'STATE'));
+        devReport('SYG204', {
+            component: name,
+            message: `${name} is the root component and has no state after it started (no initialState, and no INITIALIZE or BOOTSTRAP reducer set one), so its view is not called and the page stays empty${later.length ? ` until one of its reducers (${later.slice(0, 3).join(', ')}${later.length > 3 ? ', …' : ''}) sets the state` : ''}`,
+            fix: `Give ${name} an initialState (${name}.initialState = {} for a component with no data of its own), or return the first state from an INITIALIZE reducer`,
+            data: { reducers: later },
+        });
+    }).catch(() => { });
+}
 function nextHooks(_api) {
     const core = bridge(), H = core.hooks;
     const on = () => H.on();
@@ -4293,9 +4469,18 @@ function nextHooks(_api) {
     const vtCheck = vtChecker(() => vtp.size && on());
     // SYG428: the live instances by id, to read a child's parent state
     const live = new Map();
+    // SYG117, SYG112: the nearest ancestor whose model has an entry `type`
+    const handlerAbove = (iv, type) => {
+        let up = live.get(iv.parentId);
+        while (up && !up.def.handlers.has(type))
+            up = live.get(up.parentId);
+        return up;
+    };
     return {
         onCreate(iv) {
             live.set(iv.id, iv);
+            if (iv.isRoot)
+                statelessRoot(_api, iv, on);
             if (!on())
                 return;
             log.onCreate(iv);
@@ -4347,6 +4532,7 @@ function nextHooks(_api) {
             removedTags(f, vnode);
             try {
                 lowercaseTags(iv);
+                switchableMaps(iv);
             }
             catch (_) { /* a check never breaks the app */ }
             // SYG453: only a view with children can render one twice
@@ -4383,12 +4569,30 @@ function nextHooks(_api) {
                 if (sink == 'EVENTS')
                     eventEmitted(f, v);
                 if (src && src.__sygnalReplies === true)
-                    checkRequest(f, sink, v, Object.keys(f.modelMap));
+                    checkRequest(f, sink, v, Object.keys(f.modelMap), (a) => handlerAbove(iv, a)?.name);
                 if (src && src.__sygnalStatic === 'resources')
                     check(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, type) {
+            if (!on() || iv.def.handlers.has(type))
+                return;
+            const name = iv.name;
+            if (!once(`SYG117:${name}:${type}`))
+                return;
+            const up = handlerAbove(iv, type);
+            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, cmd) {
             if (!on())
                 return;