sygnal 5.3.7 → 6.0.0

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

@@ -0,0 +1,55 @@
+/**
+ * Strict mode: canonical-form checks (PLAN-1 workstream 2A,
+ * dev-plans/PLAN-1-canonical-forms.md). Runtime half; sygnal-check --strict
+ * implements every rule statically.
+ *
+ * Off by default. Turn it on with any of:
+ *   - configureStrict(true)                    (this entry)
+ *   - renderComponent(C, { strict: true })     (tests)
+ *   - globalThis.__SYGNAL_STRICT__ = true      (e.g. injected by a dev tool)
+ * and diagnostics must be on (strict reports go through the same core).
+ * The flag lives on the core bridge object, so it is shared by every copy of
+ * this entry and by renderComponent.
+ *
+ * | Code   | Rule (canonical form)                    | Runtime mechanism                       |
+ * |--------|------------------------------------------|-----------------------------------------|
+ * | SYG508 | reply actions, not select()/errors()     | replies.ts: a request with a category   |
+ * |        | round trip (PLAN-3 §1.1)                 | the same instance select()ed on a       |
+ * |        |                                          | reply-capable source                    |
+ *
+ * SYG501 (positional views) and SYG504 ('ACTION | SINK' keys) are forms Sygnal 6.0 removed
+ * (D164): at run time they are SYG612 (checks/next.ts, strict or not); `sygnal-check --strict`
+ * still reports them under their own codes, with --fix. SYG502 is retired (PLAN-4 GS-4). SYG503,
+ * SYG505, SYG506, SYG507: static only (sygnal-check --strict).
+ *
+ * Every finding is reported once per component name (+ action / key).
+ * The SYG5xx severities are registered here (registerCodes) and passed
+ * explicitly, so the main bundle doesn't carry them (D29).
+ */
+import type {DiagnosticCheck} from '../index'
+import {CODE_TITLES, STRICT_CODE_SEVERITY, registerCodes} from '../codes'
+import type {DiagnosticSeverity} from '../codes'
+import {bridge} from './shared'
+
+registerCodes(Object.keys(STRICT_CODE_SEVERITY).map(code =>
+  [code, STRICT_CODE_SEVERITY[code], CODE_TITLES[code]] as [string, DiagnosticSeverity, string]))
+
+/**
+ * Turn runtime strict checks on (true), off (false), or back to the default
+ * (undefined → globalThis.__SYGNAL_STRICT__ === true).
+ */
+export function configureStrict(on?: boolean): void {
+  const core = bridge()
+  if (core) core.strict = on
+}
+
+/** Whether runtime strict checks are on. */
+export function isStrictEnabled(): boolean {
+  const flag = bridge()?.strict
+  return flag === undefined ? (globalThis as any).__SYGNAL_STRICT__ === true : flag === true
+}
+
+/** The strict check's runtime half is SYG508 (replies.ts); this entry keeps the flag. */
+export const strictCheck: DiagnosticCheck = {
+  id: 'strict',
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Timers and declaration statics without a driver (PLAN-4 GS-7). Dev-entry-only codes
+ * (DEV_CODE_SEVERITY):
+ *
+ * SYG643 — a component declares a static that only a registered driver acts on (`timers`:
+ *          makeTimerDriver(), `connections`: makeSocketDriver(), `resources`: makeFetchDriver(),
+ *          `browser`: makeBrowserDriver())
+ *          and no source of the app takes it (no `__sygnalStatic` marker for it), so nothing
+ *          happens and nothing else says so. Also closes PLAN-3's "connections without a driver
+ *          report nothing" gap. (`route` and `head` are left out: renderComponent asks for the
+ *          router itself, and `head` is also collected by renderToString without a driver.)
+ * SYG422 — a timer spec makeTimerDriver() can't run (non-positive `every`, negative `after`,
+ *          `every` with `after`, no action, `frame` that isn't an action name): it isn't started.
+ *          The driver calls `__SYGNAL_DIAGNOSTICS__.timerSpec(name, spec, componentName)`, which
+ *          installTimerHooks() sets.
+ */
+import type {DiagnosticCheck} from '../index'
+import {bridge, devReport, once, nameOf} from './shared'
+
+const NEEDS: Record<string, string> = {
+  timers: 'makeTimerDriver()',
+  connections: 'makeSocketDriver()',
+  resources: 'makeFetchDriver()',
+  browser: 'makeBrowserDriver()',
+}
+const KEY: Record<string, string> = {timers: 'TIMER', connections: 'WS', resources: 'HTTP', browser: 'BROWSER'}
+
+const brief = (v: any) => { try { return JSON.stringify(v) } catch (_) { return String(v) } }
+
+/** why a timer spec can't run ('' when it can; mirrors timers.ts's valid()) */
+export function timerSpecProblem(s: any): string {
+  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 (!s.action || typeof s.action != 'string') return 'has no action (a string)'
+  if (s.every == null && s.after == null) return 'has neither every nor after'
+  if (s.every != null && s.after != null) return 'has both every and after'
+  if (s.every != null) return s.every > 0 && s.every < 1 / 0 ? '' : `every must be a positive number of ms (got ${brief(s.every)})`
+  return s.after >= 0 && s.after < 1 / 0 ? '' : `after must be a number of ms, 0 or more (got ${brief(s.after)})`
+}
+
+function checkSpec(name: string, spec: any, component?: string) {
+  const problem = timerSpecProblem(spec) || 'is invalid'
+  if (!once(`SYG422:${component}:${name}:${brief(spec)}`)) return
+  devReport('SYG422', {
+    component,
+    message: `Timer '${name}' ${problem}; it is not started`,
+    fix: `Declare ${name}: { every: 100, action: 'TICK' }, { after: 5000, action: 'EXPIRE' } or { frame: 'FRAME' } (falsy to stop it)`,
+    data: {name, spec},
+  })
+}
+
+/** install the hook makeTimerDriver() calls for an invalid spec (removed by the returned function) */
+export function installTimerHooks(): () => void {
+  const core = bridge()
+  if (!core) return () => {}
+  core.timerSpec = checkSpec
+  return () => { if (core.timerSpec === checkSpec) core.timerSpec = undefined }
+}
+
+export const timersCheck: DiagnosticCheck = {
+  id: 'timers',
+
+  onModel(component) {
+    const sources = component?.sources, view = component?.view
+    if (!sources || typeof sources != 'object' || !view) return
+    const names = component.sourceNames || Object.keys(sources)
+    for (const k in NEEDS) {
+      if (view[k] == null) continue
+      if (names.some((n: string) => sources[n]?.__sygnalStatic === k)) continue
+      const name = nameOf(component)
+      if (!once(`SYG643:${name}:${k}`)) continue
+      devReport('SYG643', {
+        component,
+        message: `${name} declares ${name}.${k}, but no ${NEEDS[k]} driver is registered, so ${k == 'timers' ? 'its timers never run' : k == 'connections' ? 'its connections never open' : k == 'browser' ? 'its browser sources never start' : 'its resources are never fetched'}`,
+        fix: `Register the driver: run(App, { ${KEY[k]}: ${NEEDS[k]} })`,
+        data: {static: k, driver: NEEDS[k]},
+      })
+    }
+  },
+}

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

@@ -0,0 +1,47 @@
+/**
+ * View Transitions (PLAN-4 GS-12, D129). Dev-entry-only code (DEV_CODE_SEVERITY):
+ *
+ * SYG645 — a component declares `viewTransitions`, but its app's DOM driver can't run them (run()'s
+ *          default makeDOMDriver, not makeViewTransitionDOMDriver()), so its actions patch at once
+ *          and nothing else says so. The helper marks its IsolateModule (`vtDriver`). Not reported
+ *          for renderComponent's mock DOM (no IsolateModule) or its `dom: 'real'` container
+ *          (`.sygnal-test`): tests don't animate.
+ *          Also (G-228): the static is not an array (`true`, `'MOVE'`): no action is listed (the core
+ *          reads it with `includes?.()`, so a string matches substrings; anything else matches none).
+ */
+import type {DiagnosticCheck} from '../index'
+import {devReport, once, nameOf} from './shared'
+
+export const viewTransitionsCheck: DiagnosticCheck = {
+  id: 'viewTransitions',
+
+  onModel(component) {
+    const list = component?.view?.viewTransitions
+    if (list == null) return
+    if (!Array.isArray(list)) {
+      const name = nameOf(component)
+      if (!once(`SYG645:${name}`)) return
+      const actions = Object.keys(component.model || {}).filter(a => !a.includes('|'))
+      devReport('SYG645', {
+        component,
+        message: `${name}.viewTransitions is not an array (it is ${typeof list == 'string' ? `'${list}'` : typeof list}), so no action is listed for a View Transition`,
+        fix: `List the action names in an array: ${name}.viewTransitions = [${(typeof list == 'string' ? [list] : actions.slice(0, 2)).map(a => `'${a}'`).join(', ') || "'ACTION'"}] (an array of action names)`,
+        data: {value: list},
+      })
+      return
+    }
+    if (!list.length) return
+    const im = component.sources?.[component.DOMSourceName || 'DOM']?._isolateModule
+    // the core's DOM source proxy answers any unknown key with an event shorthand (a function)
+    if (typeof im != 'object' || !im || im.vtDriver) return
+    if (typeof document != 'undefined' && document.querySelector?.('.sygnal-test')) return
+    const name = nameOf(component)
+    if (!once(`SYG645:${name}`)) return
+    devReport('SYG645', {
+      component,
+      message: `${name} declares ${name}.viewTransitions (${list.map((a: any) => `'${a}'`).join(', ')}), but the app's DOM driver can't run View Transitions, so those actions patch without one`,
+      fix: `Give run() the View Transition DOM driver: run(App, { DOM: makeViewTransitionDOMDriver('#root') })`,
+      data: {actions: list},
+    })
+  },
+}

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

@@ -0,0 +1,73 @@
+/**
+ * PLAN-5 V-1: `<VirtualCollection>` diagnostics (dev entry; src/extra/virtual.ts carries no text).
+ *
+ * The VirtualCollection host calls `__SYGNAL_DIAGNOSTICS__.virtual(code, owner, extra)`:
+ *   430  the container has no bounded height: `extra.reason` 'height' (laid out 0 px tall) or
+ *        'grows' (as tall as all its rows and taller than the viewport, so it would render every
+ *        row); the window is clamped to the viewport (once per host and reason)
+ *   431  items without `id` (index keys; once per host)
+ *   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)
+ */
+import {devReport, nameOf} from './shared'
+
+const tag = (owner: any) => `<VirtualCollection> in ${nameOf(owner)}`
+
+export function reportVirtual(code: number, owner: any, x: any = {}): any {
+  const component = owner ? nameOf(owner) : 'VirtualCollection'
+  if (code == 430) {
+    const grows = x.reason == 'grows'
+    return devReport('SYG430', {
+      component,
+      message: grows
+        ? `${tag(owner)} grows with its rows (it is ${Math.round(x.height)} px tall, as tall as all of them), so it is not a scroll container; only the rows within the viewport's height render`
+        : `${tag(owner)} is 0 px tall, so no row is in view`,
+      fix: 'Give its className a bounded height (height or max-height, e.g. .rows { height: 400px }, or flex: 1 with min-height: 0 in a flex column); it scrolls itself (overflow-y: auto)',
+      data: x,
+    })
+  }
+  if (code == 431) {
+    return devReport('SYG431', {
+      component,
+      message: `${tag(owner)} has items without an id (${x.count} items): they are keyed by their index, so a row's instance and measured height follow its position, not its item, when items are added, removed or reordered`,
+      fix: "Give every item a unique id (e.g. rows: data.map((r, i) => ({ id: r.key ?? i, ...r })))",
+      data: x,
+    })
+  }
+  if (code == 432) {
+    return devReport('SYG432', {
+      component,
+      message: `${tag(owner)}: its item component ${x.component} renders a fragment or text, so its rows can't be measured, positioned or given aria-posinset`,
+      fix: `Make ${x.component}'s view return one element (wrap its content in a <div> or <li>)`,
+      data: x,
+    })
+  }
+  if (code == 433) {
+    const what = 'id' in x ? `id ${JSON.stringify(x.id) ?? String(x.id)}` : `index ${x.index}`
+    return devReport('SYG433', {
+      component,
+      message: `${tag(owner)}: ${'id' in x ? 'scrollToId' : 'scrollToIndex'} for ${what}, which is not in its list (${x.count} rows after filter); it didn't scroll`,
+      fix: 'id' in x
+        ? 'Send the id of an item in the array the filter keeps: { scrollToId: \'.rows\', id }'
+        : `Send an integer index from 0 to ${Math.max(0, x.count - 1)} into the shown (filtered, sorted) rows: { scrollToIndex: '.rows', index }`,
+      data: x,
+    })
+  }
+  if (code == 434) {
+    return devReport('SYG434', {
+      component,
+      message: `${tag(owner)}: ${x.prop}={${typeof x.value == 'string' ? JSON.stringify(x.value) : String(x.value)}} is not ${x.prop == 'overscan' ? 'a number ≥ 0; 5 is used' : 'a positive number or a function; 32 is used'}`,
+      fix: x.prop == 'overscan' ? 'Pass overscan={5} (rows rendered beyond each edge)' : 'Pass estimateSize={32} (about a row\'s height in px), or (item, index) => px',
+      data: x,
+    })
+  }
+}
+
+/** Publish the VirtualCollection hook on the core bridge. Returns an uninstall function. */
+export function installVirtualHooks(): () => void {
+  const c = (globalThis as any).__SYGNAL_DIAGNOSTICS__
+  if (!c) return () => {}
+  c.virtual = reportVirtual
+  return () => { if (c.virtual === reportVirtual) c.virtual = undefined }
+}

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

@@ -0,0 +1,121 @@
+/**
+ * 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). 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/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
+ * user intent actions (never reported as SYG101), and SYG102 is not reported
+ * for those model actions (the test dispatches them with simulateAction).
+ */
+import type {DiagnosticCheck} from '../index'
+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',
+
+  onIntent(component, actionNames) {
+    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) || [])
+    const actions = (intentActions.get(component) || []).filter(a => !injected.has(a))
+    intentActions.delete(component)
+    const modelActions = Object.keys(modelMap || {})
+
+    for (const action of actions) {
+      if (isInternalAction(action) || modelActions.includes(action)) continue
+      if (!once(`SYG101:${name}:${action}`)) continue
+      report('SYG101', {
+        component,
+        message: `Intent action '${action}' has no model entry, so it never does anything${didYouMean(action, modelActions)}`,
+        fix: `Add '${action}' to ${name}.model, or remove it from ${name}.intent`,
+        data: {action, modelActions},
+      })
+    }
+
+    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) || 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, 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},
+      })
+    }
+  },
+}