sygnal 5.4.0 → 6.0.0

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

@@ -0,0 +1,109 @@
+/**
+ * PLAN-5 W-1: widget diagnostics (dev entry; `defineWidget` in src/extra/widget.ts carries no text).
+ *
+ * The widget module calls `__SYGNAL_DIAGNOSTICS__.widget(code, widgetTag, owner, extra)`:
+ *   140  dispatch(name) (mount's third parameter) — SYG140 (warn) when `name` is not in the widget's `events`: sygnal-check and
+ *        the docs read `events`, so an undeclared name is a typo or a missing declaration
+ *   143  the widget tag used as a selector (DOM.select(DatePicker), `${DatePicker}`) — SYG143
+ *        (warn, once per widget): it matches nothing
+ *   144  a host mounted — SYG144 (info, once per widget): a declared event name the host element
+ *        also fires natively (`'change'` on an `<input>` host), so the intent sees both; not
+ *        for the first-party Zag parts (`def.$own`: Menu's `select`, D211)
+ *   660/661/662  mount / update / unmount threw (`extra` is the error) — SYG660–662 (error);
+ *        661 with a fifth argument (G-580): the widget reported the error through mount's
+ *        error(e) (its own timer or callback), worded as such (data.phase 'error')
+ *   669  fromZag (G-410): its render returned Sygnal components / widget tags / special JSX
+ *        (`extra`: their tags, e.g. ['<Badge>', '<Transition>']) — SYG669 (warn, once per widget)
+ * It returns the reported diagnostic (the widget module logs a bare `[Sygnal SYG66x]` otherwise).
+ *
+ * SYG141 (listening to an event a widget doesn't declare) is static only (sygnal-check): the
+ * runtime doesn't see which listener a selector serves. SYG142 for an undeclared command sent to a
+ * widget's host is reported by the element command check (checks/elementCommands.ts).
+ */
+import {devReport, once, unsee, nameOf} from './shared'
+import {DEV_CODE_SEVERITY} from '../codes'
+
+/** a widget's name for messages: `name` from its definition, else its host tag */
+export const widgetName = (w: any): string => w?.def?.name ? `widget ${w.def.name}` : `widget <${w?.def?.tag || 'div'}>`
+
+const ids = new WeakMap<object, number>()
+let next = 0
+const idOf = (w: any): number => {
+  let id = ids.get(w)
+  if (id === undefined) ids.set(w, id = ++next)
+  return id
+}
+
+const PHASE: Record<number, string> = {660: 'mount', 661: 'update', 662: 'unmount'}
+
+export function reportWidget(code: number, w: any, owner?: any, x?: any, reported?: any): any {
+  const name = widgetName(w), component = owner ? nameOf(owner) : name
+  if (code == 140) {
+    if (w.events.includes(x) || !once(`SYG140:${idOf(w)}:${x}`)) return
+    return devReport('SYG140', {
+      component,
+      message: `${name} dispatched '${x}', which is not one of its declared events (${w.events.length ? w.events.join(', ') : 'it declares none'})`,
+      fix: `Add '${x}' to the widget's events (defineWidget({ events: [${[...w.events, x].map((e: string) => `'${e}'`).join(', ')}] })), or dispatch a declared name`,
+      data: {event: x, events: w.events},
+    })
+  }
+  if (code == 143) {
+    if (!once(`SYG143:${idOf(w)}`)) return
+    return devReport('SYG143', {
+      component: name,
+      message: `${name} was used as a selector (DOM.select(${w.def.name || 'Widget'}) or in a template string); a widget tag matches nothing`,
+      fix: `Give the widget a className and select that (<${w.def.name || 'Widget'} className="due" />, DOM.select('.due')), or make it a control: controls({ Due: ${w.def.name || 'Widget'} })`,
+    })
+  }
+  if (code == 144) {
+    // D211: not for Sygnal's own parts (Menu's `select` is its documented event)
+    if (!x || w.def.$own || !once(`SYG144:${idOf(w)}`)) return
+    const native = w.events.filter((e: string) => 'on' + e in x)
+    if (!native.length) return
+    return devReport('SYG144', {
+      component: name,
+      message: `${name} declares ${native.map((e: string) => `'${e}'`).join(', ')}, which its <${x.localName}> host also fires natively, so a listener gets both the widget's events and the element's`,
+      fix: `Name the widget's event differently (e.g. 'pick' for a date picker's change), or read only what both carry`,
+      data: {events: native, element: x.localName},
+    })
+  }
+  if (code == 669) {
+    // G-470: once per widget tag, counted only when reported (not with diagnostics off)
+    const k = `SYG669:${idOf(w)}`
+    if (!once(k)) return
+    const d = devReport('SYG669', {
+      component: name,
+      message: `${name}'s fromZag render returned ${x.join(', ')}; the adapter patches its render outside the component tree, so they don't run there (a component isn't instantiated, a widget doesn't mount, special JSX renders as an unknown element)`,
+      fix: `Render plain elements in the fromZag render (with Zag's prop getters spread on them), pass data in through the widget's props, and put components, widgets and special JSX around the widget tag in the view`,
+      data: {found: x},
+    })
+    if (!d) unsee(k)
+    return d
+  }
+  const phase = PHASE[code]
+  if (!phase) return
+  const sev = DEV_CODE_SEVERITY[`SYG${code}`]
+  // G-580: a 661 from error(e) is not a throwing update()
+  const by = code == 661 && reported
+  const d = devReport(`SYG${code}`, {
+    component,
+    message: (by ? `${name} reported an error through error(e) (mount's fourth parameter)` : `${name}'s ${phase}() threw`) + `: ${x?.message ?? x}` +
+      (code < 662 ? `; ${owner ? `${nameOf(owner)}'s onError fallback renders in its place` : 'it is not mounted'}` : ''),
+    fix: code < 662
+      ? `Fix ${by ? 'the failure the widget reports through error(e) (its own timer, callback or redraw)' : `the widget's ${phase}()`}, or give ${owner ? nameOf(owner) : 'the component'} an .onError for a custom fallback`
+      : `Fix the widget's unmount()`,
+    data: {phase: by ? 'error' : phase, error: x},
+    severity: sev,
+  })
+  // the error with its stack (the text is printed by report() in 'warn' mode, collected otherwise)
+  if (d) console.error(x)
+  return d
+}
+
+/** Publish the widget hook on the core bridge. Returns an uninstall function. */
+export function installWidgetHooks(): () => void {
+  const c = (globalThis as any).__SYGNAL_DIAGNOSTICS__
+  if (!c) return () => {}
+  c.widget = reportWidget
+  return () => { if (c.widget === reportWidget) c.widget = undefined }
+}

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

@@ -1,13 +1,19 @@
 /**
  * SYG101 — intent action has no model entry (warn)
  * SYG102 — model entry has no intent trigger (info; it may still be reached
- *          with next(), which is only known at call time)
+ *          with next(), which is only known at call time). An action a request
+ *          names as a reply action, or `connections` names (`ok: 'LOADED'`, PLAN-3) counts as
+ *          triggered: replyNamesOf() reads the names from the sink functions'
+ *          source. A behavior's own actions (D199: in `_behaviorActions`) are not
+ *          reported
+ * SYG609 — a model sink or an intent source has no driver (warn; see below)
  *
  * Mechanism: onIntent records the intent's action names per component;
  * onModel (always called right after, once per instance) compares them with
  * the normalized model map (shorthand already expanded by the core).
  * Synthetic actions (`__*`, e.g. renderComponent's `__TEST_ACTION__`) and the
- * built-ins BOOTSTRAP/INITIALIZE/HYDRATE/DISPOSE/READY are never reported.
+ * built-ins BOOTSTRAP/INITIALIZE/DISPOSE/READY are never reported (HYDRATE is an
+ * ordinary action since 6.0).
  * Under renderComponent, intent streams injected for model actions (so that
  * simulateAction can dispatch them by their real names) are listed on the
  * intent object's non-enumerable `__sygnalTestActions` property. They are not
@@ -15,10 +21,25 @@
  * for those model actions (the test dispatches them with simulateAction).
  */
 import type {DiagnosticCheck} from '../index'
-import {report, once, isInternalAction, nameOf, didYouMean} from './shared'
+import {report, once, isInternalAction, nameOf, didYouMean, replyNamesOf} from './shared'
 
 const intentActions = new WeakMap<object, string[]>()
 
+// SYG609 (G-110, PLAN-2 E2): sinks/sources that no driver provides. Sinks the core handles
+// itself never need one. renderComponent (mock DOM source) records such sinks and fakes such
+// sources (t.requests / t.respond), so its components are skipped.
+// PLAN-4 GS-2: ELEMENT (element commands) is built in; GS-5: PERSIST is persist()'s (an EFFECT)
+const NO_DRIVER_NEEDED = /^(STATE|EFFECT|PARENT|READY|DOM|CHILD|ELEMENT|PERSIST)$/
+const DRIVER_NAME = /^[A-Z][A-Z0-9_]*$/
+// (`in`, not a read: the DOM source's shorthand Proxy returns a function for any property)
+const underTest = (c: any) => {
+  const dom = c?.sources?.[c.DOMSourceName || 'DOM']
+  return !!dom && typeof dom == 'object' && '_hub' in dom
+}
+const driverFix = (sink: string) =>
+  `Pass a driver named ${sink} to run(): 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',
 
@@ -26,8 +47,44 @@ export const wiringCheck: DiagnosticCheck = {
     intentActions.set(component, actionNames || [])
   },
 
+  // SYG609: an intent that reads a source no driver provides (`HTTP.select(...)` with no HTTP
+  // driver) would crash with "Cannot read properties of undefined": say why first
+  sources(component, sources) {
+    if (underTest(component) || typeof Proxy != 'function') return
+    const name = nameOf(component)
+    return new Proxy(sources, {
+      get(t: any, k: any) {
+        if (typeof k == 'string' && !(k in t) && DRIVER_NAME.test(k) && once(`SYG609:${name}:source:${k}`)) {
+          report('SYG609', {
+            component,
+            message: `${name}.intent reads the ${k} source, but no driver named ${k} was passed to run(), so it is undefined`,
+            fix: driverFix(k),
+            data: {name: k, kind: 'source', drivers: Object.keys(t).filter(n => DRIVER_NAME.test(n))},
+          })
+        }
+        return t[k]
+      },
+    })
+  },
+
   onModel(component, modelMap) {
     const name = nameOf(component)
+    // SYG609: a sink no driver receives is dropped silently by run()
+    if (!underTest(component)) {
+      const own = new Set<string>(component?.sourceNames || [])
+      for (const action of Object.keys(modelMap || {})) {
+        for (const sink of modelMap[action] || []) {
+          if (own.has(sink) || NO_DRIVER_NEEDED.test(sink) || sink === component?.stateSourceName) continue
+          if (!once(`SYG609:${name}:sink:${sink}`)) continue
+          report('SYG609', {
+            component,
+            message: `Model entry '${action}' sends to the ${sink} sink, but no driver named ${sink} was passed to run(), so every value sent there is dropped`,
+            fix: driverFix(sink),
+            data: {name: sink, kind: 'sink', action, drivers: [...own].filter(n => DRIVER_NAME.test(n))},
+          })
+        }
+      }
+    }
     const intent$ = component && component.intent$
     const injected = new Set<string>(
       (intent$ && typeof intent$ === 'object' && intent$.__sygnalTestActions) || [])
@@ -46,18 +103,17 @@ export const wiringCheck: DiagnosticCheck = {
       })
     }
 
-    // A single-stream intent (intent returns one action$ stream) has no
-    // action names to compare against.
-    if (intent$ && typeof intent$.addListener === 'function') return
-
-    const hmr = ([] as string[]).concat(component?.hmrActions || [])
+    const replies = replyNamesOf(component)
+    // D199: a behavior's own actions ('tip.SHOW') are its business: a timer, next() or a reply
+    // may trigger them (the behavior-owned map, behaviors.ts)
+    const owned = component?._behaviorActions || {}
     for (const action of modelActions) {
-      if (isInternalAction(action) || actions.includes(action) || hmr.includes(action) || injected.has(action)) continue
+      if (isInternalAction(action) || actions.includes(action) || injected.has(action) || replies.has(action) || action in owned) continue
       if (!once(`SYG102:${name}:${action}`)) continue
       report('SYG102', {
         component,
         message: `Model entry '${action}' has no intent action with that name${didYouMean(action, actions)}`,
-        fix: `Add '${action}' to ${name}.intent, or remove the model entry. If it is only dispatched with next('${action}'), ignore this`,
+        fix: `Add '${action}' to ${name}.intent, name it in a request (ok: '${action}'), or remove the model entry. If it is only dispatched with next('${action}'), ignore this`,
         data: {action, intentActions: actions},
       })
     }

package/src/extra/diagnostics/codes.ts

@@ -20,10 +20,18 @@
  * (Comments are attached to type-only declarations so the TypeScript emit
  * drops them — keeps them out of the published bundle and the size gate.)
  *
- * Severity:
- *   - 'error' — throws (or is rethrown, enriched) at the call site
- *   - 'warn'  — console + collected (when diagnostics mode is 'warn')
+ * Severity (PLAN-2 1-B, G-044):
+ *   - 'error' — the operation failed: thrown at the call site, or caught there
+ *               (reducer, EFFECT, view, sub-component) and logged with
+ *               console.error while the app keeps running
+ *   - 'warn'  — likely mistake, behaviour continues: console + collected
+ *               (when diagnostics mode is 'warn')
  *   - 'info'  — collected only; surfaced through inspect / test helpers
+ *   A call site may report a lower severity than the default (SYG405 for
+ *   Collection/Switchable children, SYG406 handled by onError: 'warn').
+ *   Every code surfaces under its own code: an error thrown by fail() and
+ *   caught by a reducer/EFFECT/instantiation handler is reported under the
+ *   thrown code (legacy.caught), not the handler's.
  *
  * Ranges (see dev-plans/PLAN-1.md §2):
  *   SYG1xx  Wiring: intent <-> model <-> view <-> events
@@ -32,6 +40,7 @@
  *   SYG4xx  Collections, Switchable, sub-components, context
  *   SYG5xx  Strict mode / canonical-form violations
  *   SYG6xx  Drivers & run configuration
+ *   SYG7xx  Accessibility (a11y; static only, sygnal-check, PLAN-4 GS-3)
  *   SYG9xx  Internal invariants
  *
  * ---------------------------------------------------------------------------
@@ -93,7 +102,7 @@ export const CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG402: 'error',
   SYG403: 'error',
   SYG404: 'error',
-  SYG405: 'warn',
+  SYG405: 'error',
   SYG406: 'error',
   SYG407: 'error',
   SYG408: 'error',
@@ -116,6 +125,9 @@ export const CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG605: 'error',
   SYG606: 'error',
   SYG607: 'error',
+  SYG608: 'warn',
+  SYG609: 'warn',
+  SYG610: 'error',
   SYG901: 'error',
   SYG902: 'error',
   SYG903: 'error',
@@ -132,6 +144,40 @@ export const CODE_TITLES: Record<string, string> = {
   SYG106: 'Parent prop is overwritten by a reserved view argument',
   SYG110: 'Intent selector not present in the component view',
   SYG111: 'Controlled input has no input listener',
+  SYG115: 'Unknown DOM event shorthand',
+  SYG116: 'EVENTS value has no string type',
+  SYG124: 'Component used as a control or selector',
+  SYG125: 'Control given .intent, .model or .initialState',
+  SYG126: 'Control rendered but never listened to',
+  SYG127: 'Behavior collision or unresolvable uses entry',
+  SYG128: 'Duplicate control key',
+  SYG129: "CHILD.select() of a component this one doesn't render",
+  SYG112: 'Reply action has no model entry',
+  SYG130: 'href() names no route or leaves out a param',
+  SYG131: 'Route params the pattern does not use',
+  SYG132: 'Declaration static that is never sent',
+  SYG133: 'SPA router inside a Vike app',
+  // PLAN-5 W-1: widgets (defineWidget; checks/widgets.ts, checks/elementCommands.ts; SYG141 static only)
+  SYG140: 'Widget dispatched an undeclared event',
+  SYG141: 'Listener for an event the widget does not declare',
+  SYG142: 'Widget command not declared',
+  SYG143: 'Widget tag used as a selector',
+  SYG144: 'Widget event the host element also fires natively',
+  // PLAN-5 B-1 (3-D): the sortable behavior (checks/sortable.ts; sortable.ts calls the bridge's sortable hook)
+  SYG145: 'Sortable item without its id attribute',
+  SYG146: 'Sortable item or handle selector matches nothing',
+  SYG147: 'Sortable list key is not an array in the host state',
+  // PLAN-5 3-F G-419: a Collection's viewTransitionName (checks/next.ts)
+  SYG148: 'Collection viewTransitionName is not a CSS identifier',
+  SYG149: 'Two items with the same view-transition name',
+  // PLAN-5 V-1: VirtualCollection (checks/virtual.ts)
+  SYG430: 'VirtualCollection has no bounded height',
+  SYG431: 'VirtualCollection items without ids',
+  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',
   // SYG2xx state & reducers (1A)
   SYG201: 'STATE reducer dropped keys from the previous state',
   SYG202: 'STATE reducer returned undefined',
@@ -140,13 +186,14 @@ export const CODE_TITLES: Record<string, string> = {
   // 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)
-  SYG501: 'View uses positional arguments',
-  SYG502: 'STATE reducer signals no change without ABORT',
+  SYG501: "Removed in 6.0: view with positional arguments",
+  SYG502: 'Retired in 6.0: STATE reducer signals no change without ABORT',
   SYG503: 'Side effect in a STATE reducer that returns ABORT',
-  SYG504: "'ACTION | SINK' shorthand model key",
+  SYG504: "Removed in 6.0: 'ACTION | SINK' model key",
   SYG505: 'Non-canonical EVENTS emit',
-  SYG506: 'CHILD.select() with a string component name',
+  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',
   // SYG9xx internal (0B)
   SYG900: 'A diagnostics check threw',
   // ---- 1E retrofit codes (SYG206-299, 402-499, 601-699, 901-999) ----
@@ -155,9 +202,9 @@ export const CODE_TITLES: Record<string, string> = {
   SYG208: 'Calculated field depends on an unknown key',
   SYG209: 'Circular calculated field dependency',
   SYG210: 'INITIALIZE used with a sink other than STATE',
-  SYG211: 'Invalid model shorthand entry',
+  SYG211: "Retired in 6.0: Invalid model shorthand entry",
   SYG212: 'Model entry is not a function or an object of sinks',
-  SYG213: 'Duplicate model entry for the same action and sink',
+  SYG213: "Retired in 6.0: Duplicate model entry for the same action and sink",
   SYG214: 'EFFECT handler threw',
   SYG215: 'next() delay is not a number',
   SYG216: 'Reducer threw',
@@ -165,6 +212,22 @@ export const CODE_TITLES: Record<string, string> = {
   SYG218: 'Reducer returned an unsupported type',
   SYG219: 'EFFECT handler returned a value',
   SYG220: 'Calculated field threw',
+  SYG221: 'set() called with a string',
+  SYG222: 'STATE reducer returned the same object after it was mutated in place',
+  SYG223: 'persist pick or omit names a key that is not in initialState',
+  SYG224: 'persist on a component that is not the root',
+  SYG226: 'Undo track, resetOn or coalesce names an unknown action',
+  // PLAN-5 F-1: the form behavior (checks/forms.ts)
+  SYG230: 'Form field name not in values',
+  SYG231: 'form() schema is not a Standard Schema',
+  SYG232: 'Form submit dropped while one is in progress',
+  SYG233: 'Form value missing from the schema output',
+  SYG234: 'Form submit action has no model entry',
+  SYG235: 'Form check names an unknown field or sets reply fields',
+  SYG236: 'Form array rows without an id',
+  SYG237: 'Two forms in one component listen on the same form selector',
+  // PLAN-5 2-R (G-393; checks/state.ts; dev entry)
+  SYG238: 'Root component with a model but no initial state',
   SYG402: 'Context is not an object',
   SYG403: 'Invalid context entry',
   SYG404: 'Context stream errored',
@@ -176,24 +239,86 @@ export const CODE_TITLES: Record<string, string> = {
   SYG410: "Invalid sub-component 'state' prop",
   SYG411: "Collection 'of' is missing or not a component",
   SYG412: "Invalid Collection 'from' prop",
-  SYG413: 'Unnamed component factory not found',
-  SYG414: 'Component not found',
+  SYG413: "Retired in 6.0: Unnamed component factory not found",
+  SYG414: "Retired in 6.0: Component not found",
   SYG415: "Switchable 'of' is missing or invalid",
   SYG416: "Switchable 'current' is missing or invalid",
   SYG417: 'Portal target not found',
   SYG418: 'Invalid Collection sort prop',
-  SYG419: "Invalid switchable() 'name$' parameter",
+  SYG419: "Retired in 6.0: Invalid switchable() 'name$' parameter",
   SYG420: 'JSX tag is undefined',
-  SYG601: 'Missing or invalid sources',
+  SYG421: 'Invalid data (dataset) key',
+  SYG422: 'Invalid timer spec',
+  // PLAN-4.6 R4: the core's dev checks (checks/next.ts; dev entry)
+  SYG423: 'Context change skipped a view whose output it changes',
+  SYG424: 'Duplicate Collection item id',
+  SYG425: 'isolatedState slice lacks initialState keys',
+  SYG601: "Retired in 6.0: Missing or invalid sources",
   SYG602: 'Intent is not a function',
   SYG603: 'Intent returned an invalid value',
-  SYG604: 'Invalid hmrActions',
-  SYG605: "Intent action name contains '|'",
+  SYG604: "Retired in 6.0: Invalid hmrActions",
+  SYG605: "Retired in 6.0: Intent action name contains '|'",
   SYG606: 'calculated is not an object',
-  SYG607: 'State source not found',
-  SYG901: 'Sub-component sink stream errored',
-  SYG902: 'EFFECT stream errored',
-  SYG903: 'Component factory returned invalid sinks',
+  SYG607: "Retired in 6.0: State source not found",
+  SYG608: 'Strict mode requested without the diagnostics entry',
+  SYG609: 'Sink or source has no driver',
+  SYG610: "Request has a 'then' or 'catch' key",
+  SYG611: 'Socket message not sent or connection not opened',
+  // PLAN-4.6 R4 (D173): a form 6.0 removed, met at runtime (checks/next.ts; dev entry)
+  SYG612: 'Removed in 6.0',
+  SYG620: 'Router command not performed',
+  // PLAN-3 5-3: makeFetchDriver's cache, invalidation and validation (dev entry; SYG634 static only)
+  SYG630: 'Cached request is not idempotent',
+  SYG631: 'validate is not a Standard Schema',
+  SYG632: 'invalidate matched nothing',
+  SYG633: 'abort names a lane the requests do not use',
+  SYG634: 'latest: true with a computed key',
+  // PLAN-3 5-5 (D88)
+  SYG635: 'Caching asked for without a queryCache',
+  // PLAN-4 GS-2: element commands (reported by the dev entry, checks/elementCommands.ts)
+  SYG640: 'Element command target not found',
+  SYG641: 'Unknown element command',
+  // PLAN-4 GS-5: persist() (src/extra/persist.ts reports SYG642 with an explicit severity, like SYG611)
+  SYG642: 'Persisted state could not be restored or saved',
+  // PLAN-4 GS-7: timers (checks/timers.ts; dev entry)
+  SYG643: 'Declaration static with no driver to take it',
+  // PLAN-4 D131: sygnal/element (reported through the core bridge when diagnostics are on)
+  SYG644: 'Custom element prop hides an HTMLElement member',
+  // PLAN-4 GS-12 (D129): View Transitions (checks/viewTransitions.ts; dev entry)
+  SYG645: "viewTransitions that can't run",
+  // PLAN-5 W-1: a widget's mount / update / unmount threw (checks/widgets.ts; dev entry)
+  SYG660: 'Widget mount threw',
+  SYG661: 'Widget update threw or reported an error',
+  SYG662: 'Widget unmount threw',
+  // PLAN-5 B-3: browser sources (makeBrowserDriver; checks/browserSources.ts; dev entry)
+  SYG663: 'Invalid browser-source spec or command',
+  SYG664: 'Browser source not in the driver',
+  SYG665: 'Browser source failed with no error action',
+  // PLAN-5 W-2 (D203): the adapter entries (sygnal/react, sygnal/zag, sygnal/ui/menu|select|combobox): SYG666 from
+  // sygnal/vite (an entry imported without its optional peer dependencies), SYG667 thrown by
+  // fromZag / fromReact
+  SYG666: 'Adapter peer dependency missing',
+  SYG667: 'Invalid adapter argument',
+  // PLAN-5 2-R (G-383, G-387)
+  SYG668: 'Browser source has no element to observe',
+  // PLAN-5 2-T (G-410): Sygnal components / widget tags / special JSX inside a fromZag render
+  SYG669: 'Sygnal component inside a fromZag render',
+  // 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',
+  SYG703: 'Image without alt text',
+  SYG704: 'Link without href used as a button',
+  SYG705: 'Button without an accessible name',
+  SYG706: 'Positive tabIndex',
+  SYG707: 'Unknown ARIA attribute or invalid role',
+  SYG708: 'Label or ARIA reference to an id that is not rendered',
+  // PLAN-5 2-T (D211): Zag UI parts (sygnal-check rules/a11y/syg722-ui-name.js)
+  SYG722: 'Menu, Select or Combobox without an accessible name',
+  // PLAN-5 B-1 (3-D): static only (sygnal-check)
+  SYG724: 'Sortable handle not keyboard-accessible, or no live region',
+  SYG901: "Retired in 6.0: Sub-component sink stream errored",
+  SYG902: "Retired in 6.0: EFFECT stream errored",
+  SYG903: "Retired in 6.0: Component factory returned invalid sinks",
   // ---- end 1E retrofit codes ----
 }
 
@@ -202,13 +327,133 @@ export const CODE_TITLES: Record<string, string> = {
 // entry registers them (registerCodes) and its reports pass the severity
 // explicitly. sygnal-check keeps the same table in sygnal-check/src/codes.js.
 export const STRICT_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
-  SYG501: 'warn',
+  SYG501: 'error',
   SYG502: 'warn',
   SYG503: 'warn',
-  SYG504: 'warn',
+  SYG504: 'error',
   SYG505: 'warn',
-  SYG506: 'warn',
+  SYG506: 'error',
   SYG507: 'info',
+  SYG508: '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
+// and passes the severity explicitly.
+// PLAN-3 1-D: SYG112 (a reply action has no model entry) too.
+// PLAN-3 2-A: SYG611 too, though makeSocketDriver reports it (legacy error(), severity passed
+// explicitly): kept out of CODE_SEVERITY so the core bundle doesn't pay for an opt-in driver.
+export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
+  SYG112: 'error',
+  SYG115: 'warn',
+  SYG116: 'error',
+  // PLAN-4 1-D: controls, static (sygnal-check)
+  SYG124: 'error',
+  SYG125: 'error',
+  SYG126: 'info',
+  // PLAN-4 GS-1: behaviors (checks/behaviors.ts)
+  SYG127: 'error',
+  SYG128: 'error',
+  // PLAN-4 4-G2: static only (sygnal-check); listed so the entry knows its title
+  SYG129: 'warn',
+  SYG221: 'error',
+  // PLAN-4 GS-4 (state.ts)
+  SYG222: 'warn',
+  // PLAN-4 GS-5 (checks/persist.ts; sygnal-check statically)
+  SYG223: 'warn',
+  SYG224: 'error',
+  // PLAN-4 GS-8 (undo.ts reports it when diagnostics are on; sygnal-check statically)
+  SYG226: 'warn',
+  // PLAN-5 F-1: the form behavior (checks/forms.ts; form.ts calls the bridge's form hook)
+  SYG230: 'warn',
+  SYG231: 'error',
+  SYG232: 'info',
+  SYG233: 'warn',
+  SYG234: 'warn',
+  SYG235: 'warn',
+  SYG236: 'warn',
+  SYG237: 'warn',
+  SYG238: 'warn',
+  SYG421: 'error',
+  SYG611: 'error',
+  // PLAN-3 5-4b: router (SYG620 is reported by the router itself, like SYG611) and G-167
+  SYG130: 'error',
+  SYG131: 'warn',
+  SYG132: 'warn',
+  SYG133: 'warn',
+  SYG620: 'error',
+  // PLAN-3 5-3 (fetch.ts)
+  SYG630: 'warn',
+  SYG631: 'error',
+  SYG632: 'info',
+  SYG633: 'warn',
+  // static only (sygnal-check); listed so the entry knows its title
+  SYG634: 'info',
+  // PLAN-3 5-5 (fetch.ts)
+  SYG635: 'warn',
+  // PLAN-4 GS-2 (checks/elementCommands.ts, through the core bridge; renderComponent too)
+  SYG640: 'warn',
+  SYG641: 'error',
+  // PLAN-4 GS-5 (persist.ts, through legacy warn(): printed in production too)
+  SYG642: 'warn',
+  // PLAN-4 GS-7 (timers.ts): an invalid timer spec (not started); timers / connections /
+  // resources declared with no driver registered
+  SYG422: 'error',
+  SYG643: 'warn',
+  // PLAN-4.6 R4 (checks/next.ts): D168 context-tracking safety net, D169 duplicate ids, D174 kept
+  // slice, D173 removed forms
+  SYG423: 'warn',
+  SYG424: 'warn',
+  SYG425: 'warn',
+  SYG612: 'error',
+  // PLAN-4 D131 (element.ts, through the core bridge; a console warning in dev with diagnostics off)
+  SYG644: 'warn',
+  // PLAN-4 GS-12 (viewTransitions.ts): the static set, but the app's DOM driver isn't makeViewTransitionDOMDriver()
+  SYG645: 'warn',
+  // PLAN-5 W-1: widgets (checks/widgets.ts, checks/elementCommands.ts; SYG141 static only, listed
+  // so the entry knows its title)
+  SYG140: 'warn',
+  SYG141: 'warn',
+  SYG142: 'error',
+  SYG143: 'warn',
+  SYG144: 'info',
+  // PLAN-5 B-1 (3-D): the sortable behavior (checks/sortable.ts)
+  SYG145: 'warn',
+  SYG146: 'warn',
+  SYG147: 'warn',
+  // PLAN-5 3-F G-419 (checks/next.ts: onHostProps, onPatch)
+  SYG148: 'warn',
+  SYG149: 'warn',
+  SYG660: 'error',
+  SYG661: 'error',
+  SYG662: 'error',
+  SYG663: 'error',
+  SYG664: 'error',
+  SYG665: 'warn',
+  SYG666: 'error',
+  SYG667: 'error',
+  SYG668: 'warn',
+  SYG669: 'warn',
+  // PLAN-5 V-1: VirtualCollection (checks/virtual.ts, through the core bridge)
+  SYG430: 'warn',
+  SYG431: 'warn',
+  SYG432: 'warn',
+  SYG433: 'warn',
+  SYG434: 'warn',
+  // PLAN-5 3-H (G-449): sortable (checks/sortable.ts)
+  SYG435: 'warn',
+  // PLAN-4 GS-3: a11y lane, static only (sygnal-check; warn, also under --strict; error with --a11y=error, D144); listed so the entry knows its title
+  SYG701: 'warn',
+  SYG702: 'warn',
+  SYG703: 'warn',
+  SYG704: 'warn',
+  SYG705: 'warn',
+  SYG706: 'warn',
+  SYG707: 'warn',
+  SYG708: 'warn',
+  SYG722: 'warn',
+  // PLAN-5 B-1 (3-D): static only (sygnal-check)
+  SYG724: 'warn',
 }
 
 export function getCodeInfo(code: string): DiagnosticCodeInfo | undefined {