sygnal 6.5.0 → 7.0.0

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

@@ -17,6 +17,15 @@
  *   onRender    (PLAN-4 CT-1) the controls the instance renders: its own vtree, up to the
  *               isolated child components, through ./controls' vnode -> control map
  *   onDispose   prunes the instance
+ *   (PLAN-10 D522, read from the instance view at inspect() time, no core change) viewOnly (the
+ *               component function has no statics), entry (an app's root), app (which run() the
+ *               instance belongs to), shown: false (a hidden Switchable page and below), the
+ *               instance ids on children entries and in events[type].emitterIds / selectorIds.
+ *               D530: contextConsumes from InstanceView.reads (the keys the latest render read);
+ *               diagnostics keep their `timestamp`.
+ *               `key` (PLAN-10 P-2, D544): the static 'file#name' (D521) that sygnal/vite stamps on
+ *               the component function in dev (a non-enumerable `__sygnalKey`), when it is there;
+ *               the runtime itself has no source file
  *   (PLAN-4 2-C) the action log (./actionLog: actionHooks, a layer of checks/next.ts) feeds
  *               inspect({ actions }): the recent actions (the last RECENT_MAX, any instance)
  * Selectors come from the DOM check (real DOM) or from renderComponent (mock
@@ -205,6 +214,8 @@ const slim = (d: any): InspectDiagnostic => {
   if (d.component) out.component = d.component
   if (d.fix) out.fix = d.fix
   if (d.docsUrl) out.docsUrl = d.docsUrl
+  // PLAN-10 P-1: when it was reported (runtime diagnostics are reported once per process)
+  if (typeof d.timestamp === 'number') out.timestamp = d.timestamp
   if (d.data !== undefined) {
     // keep it JSON-safe (data can hold errors, vnodes, ...)
     try { out.data = JSON.parse(JSON.stringify(d.data)) } catch (_) { /* drop */ }
@@ -316,12 +327,55 @@ function childrenOf(r: Rec, all: Rec[]): InspectChild[] {
     if (c.parentId !== r.id) continue
     const key = `${c.name}\u0000${via[c.kind]}`
     const entry = out.get(key)
-    if (entry) entry.count = (entry.count || 1) + 1
-    else out.set(key, {name: c.name, via: via[c.kind], count: 1})
+    if (entry) entry.count = entry.ids!.push(c.id)
+    else out.set(key, {name: c.name, via: via[c.kind], count: 1, ids: [c.id]})
   }
   return [...out.values()]
 }
 
+/** the statics sygnal-check reads (its STATIC_PROPS): a component function with none is view-only */
+const STATICS = ['intent', 'model', 'initialState', 'isolatedState', 'context', 'calculated', 'connections', 'resources', 'route', 'head', 'uses', 'timers', 'persist', 'viewTransitions', 'browser', 'agent']
+
+/** PLAN-10 D522: no statics and nothing the core added (renderComponent's test intent, a behavior's model) */
+function isViewOnly(c: any): boolean {
+  const def = c && c.__next && c.__next.def
+  if (!def || def.intent || (def.handlers && def.handlers.size) || def.initialState !== undefined) return false
+  const fn = def.view
+  return !!fn && STATICS.every(k => fn[k] === undefined)
+}
+
+/** PLAN-10 P-2 (D544): the static key sygnal/vite's dev transform stamped on the component function */
+function stampedKey(c: any): string | undefined {
+  const fn = c && c.__next && c.__next.def && c.__next.def.view
+  const k = fn && fn.__sygnalKey
+  return typeof k === 'string' ? k : undefined
+}
+
+/** PLAN-10 D530: the context keys the instance's latest render read (InstanceView.reads); every key when it read them all */
+function contextReadsOf(c: any): string[] {
+  const v = c && c.__next
+  const reads: ReadonlySet<string> | null | undefined = v && v.reads
+  if (!reads) return []
+  const out = [...reads].filter(k => k !== '\u0000all')
+  if (reads.has('\u0000all')) { try { for (const k of Object.keys(v.context || {})) if (!out.includes(k)) out.push(k) } catch (_) { /* no context */ } }
+  return out
+}
+
+/** PLAN-10 D522: the app (run()) of each instance: the index of its root among the live roots, oldest first */
+function appsOf(all: Rec[]): Map<Rec, number> {
+  const byId = new Map(all.map(r => [r.id, r]))
+  const roots = all.filter(r => r.parentId === null).sort((a, b) => Number(a.id) - Number(b.id))
+  const index = new Map(roots.map((r, i) => [r, i]))
+  const out = new Map<Rec, number>()
+  for (const r of all) {
+    let top: Rec | undefined = r
+    for (let n = 0; top && top.parentId !== null && n < 10000; n++) top = byId.get(top.parentId)
+    const i = top && index.get(top)
+    if (i !== undefined) out.set(r, i)
+  }
+  return out
+}
+
 /** The app graph of the live component instances (see ./public.d.ts). */
 export function inspect(options: InspectOptions = {}): InspectGraph {
   // report SYG105 (info) for EVENTS types selected but never emitted so far
@@ -340,22 +394,29 @@ export function inspect(options: InspectOptions = {}): InspectGraph {
   const ids = options.ids && new Set(options.ids.map(String))
   const recs = ids ? all.filter(r => ids.has(r.id)) : all
   const names = new Set(recs.map(r => r.name))
+  const apps = appsOf(all)
 
   const components: InspectComponent[] = recs.map(r => {
     const c = r.instance
     const calculated = c && c.calculated && typeof c.calculated === 'object' ? Object.keys(c.calculated) : []
     const selectors = selectorsOf(r, options, diags)
     const controls = controlsOf(r, selectors)
+    const key = stampedKey(c)
     return {
       name: r.name,
       id: r.id,
+      ...(key ? {key} : {}),
       parentId: r.parentId,
       kind: r.kind,
+      ...(isViewOnly(c) ? {viewOnly: true as const} : {}),
+      ...(r.parentId === null ? {entry: true as const} : {}),
+      ...(apps.has(r) ? {app: apps.get(r)} : {}),
+      ...(c && c.__next && c.__next.shown === false ? {shown: false as const} : {}),
       actions: actionsOf(r),
       stateKeys: stateKeysOf(c, calculated),
       calculated,
       contextProvides: c && isPlainObject(c.context) ? Object.keys(c.context) : [],
-      contextConsumes: null,
+      contextConsumes: contextReadsOf(c),
       eventsEmitted: [...r.eventsEmitted],
       eventsSelected: [...r.eventsSelected],
       children: childrenOf(r, all),
@@ -368,11 +429,12 @@ export function inspect(options: InspectOptions = {}): InspectGraph {
 
   const cache = cacheOf(recs) || {}
   const events: InspectGraph['events'] = {}
-  const ev = (type: string) => events[type] || (events[type] = {emitters: [], selectors: []})
+  // names once each (as before); PLAN-10 D522: every instance's id in emitterIds / selectorIds
+  const ev = (type: string) => events[type] || (events[type] = {emitters: [], selectors: [], emitterIds: [], selectorIds: []})
   const add = (list: string[], name: string) => { if (!list.includes(name)) list.push(name) }
   for (const c of components) {
-    for (const t of c.eventsEmitted) add(ev(t).emitters, c.name)
-    for (const t of c.eventsSelected) add(ev(t).selectors, c.name)
+    for (const t of c.eventsEmitted) { const e = ev(t); add(e.emitters, c.name); e.emitterIds!.push(c.id) }
+    for (const t of c.eventsSelected) { const e = ev(t); add(e.selectors, c.name); e.selectorIds!.push(c.id) }
   }
   // emitted on the bus by something that isn't a listed component (e.g. a driver, a pruned component)
   if (!ids) for (const t of busTypes) ev(t)

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

@@ -28,6 +28,7 @@ import {watchMutation} from './state'
 import {checkRequest} from './replies'
 import {check as checkFetch} from './fetch'
 import {checkSentCommand} from './elementCommands'
+import {audited} from './timingAudit'
 import {checkCollection} from './collections'
 import {eventEmitted, actionListener as recentActions} from './inspect'
 import {actionHooks} from './actionLog'
@@ -444,6 +445,8 @@ export function nextHooks(_api: any): any {
     onAction(iv: any, a: any) { log.onAction(iv, a) },
     wrapHandler(iv: any, type: string, sink: string, fn: any) {
       let h = log.wrapHandler(iv, type, sink, fn) || fn
+      // 7.0 timing audit (SYG257, opt-in; checks/timingAudit.ts): checked per call, so turning it on later counts
+      if (on() && sink != 'STATE' && typeof h == 'function') h = audited(fac(iv), type, sink, h)
       // SYG222: the STATE reducers, wrapped (today the check rewrote the instance's model)
       if (on() && sink == 'STATE' && typeof fn == 'function') h = watchMutation(fac(iv), type, h)
       return h === fn ? undefined : h

package/src/extra/diagnostics/checks/public.d.ts

@@ -40,6 +40,18 @@ export interface DiagnosticCheck {
  */
 export function configureStrict(on?: boolean): void
 
+/**
+ * 7.0 timing audit (SYG257, info), for migrating 6.x code: report each output sink that reads a
+ * top-level state field its action's STATE changed (since 7.0 it gets the new value; 6.x gave it
+ * the old one; read props.previousState for the old one). true / false, or undefined for the
+ * default (globalThis.__SYGNAL_TIMING_AUDIT__ === true). Also renderComponent(C, { timingAudit })
+ * and sygnal({ diagnostics: { timingAudit: true } }). Diagnostics must be on.
+ */
+export function configureTimingAudit(on?: boolean): void
+
+/** Whether the timing audit is on. */
+export function isTimingAuditEnabled(): boolean
+
 /** Whether the runtime strict checks are on. */
 export function isStrictEnabled(): boolean
 
@@ -96,9 +108,23 @@ export function getCodeInfo(code: string): DiagnosticCodeInfo | undefined
 
 /** How an action is dispatched. */
 /** 'agent' (static, PLAN-6 K-1): only the component's `agent` declaration dispatches it */
-export type InspectActionTrigger = 'intent' | 'next' | 'reply' | 'builtin' | 'agent' | 'unknown'
+/**
+ * 'behavior' (static, PLAN-10 A-8): a `uses` entry's action nothing else triggers that the behavior
+ * may dispatch itself where the checker can't list it (a package behavior, an open model, ...)
+ */
+export type InspectActionTrigger = 'intent' | 'next' | 'reply' | 'builtin' | 'agent' | 'behavior' | 'unknown'
 
-export interface InspectAction {
+/**
+ * PLAN-10 A-4 (static only): a source position, 1-based. `file` (relative to the working
+ * directory) only when it isn't the component's file.
+ */
+export interface InspectLocation {
+  line: number
+  column: number
+  file?: string
+}
+
+export interface InspectAction extends Partial<InspectLocation> {
   name: string
   /**
    * 'intent': returned by the component's intent. 'builtin': BOOTSTRAP,
@@ -112,18 +138,56 @@ export interface InspectAction {
   trigger: InspectActionTrigger
   /** sinks of the model entry (STATE, EVENTS, EFFECT, PARENT, custom drivers); [] without a model entry */
   sinks: string[]
+  /** the `uses` key of the behavior that owns it ('pager' for 'pager.NEXT') */
+  behavior?: string
+  /** static, PLAN-10 A-4: the model entry (line/column on the action: the intent property, else this) */
+  modelAt?: InspectLocation
+  /**
+   * static, PLAN-10 A-7 (actions with a STATE sink only): the top-level state keys the STATE
+   * reducer(s) may write (a behavior's: its slice); [] when it never changes state; null when unknown
+   */
+  writes?: string[] | null
+  /** static, PLAN-10 A-7: a STATE reducer may return undefined (removes a Collection item) */
+  removes?: true
 }
 
-export interface InspectChild {
+export interface InspectChild extends Partial<InspectLocation> {
   name: string
-  via: 'tag' | 'collection' | 'switchable' | 'slot'
+  /**
+   * 'layout' (static, PLAN-10 A-9): Vike's shell, a +Wrapper / +Layout rendering the next +Layout in
+   * or a +Page it applies to (Wrapper(s) > Layout(s) > Page); no location (no JSX site)
+   */
+  via: 'tag' | 'collection' | 'switchable' | 'slot' | 'layout'
   /** Collection: the `from` state field, when known */
   from?: string | null
   /** runtime: number of live instances behind this entry (e.g. Collection items) */
   count?: number
+  /** runtime, PLAN-10 D522: the ids of those instances */
+  ids?: string[]
+  /**
+   * static, PLAN-10 A-3: the id of the component it renders (resolved through the import); null when
+   * it isn't in the graph (a package, a widget, a file not scanned, a dynamic value)
+   */
+  id?: string | null
+  /** static, PLAN-10 A-1: a literal `state` lens (`<Greeting state="host" />`) */
+  state?: string
+  /** static, PLAN-10 A-2: the package the tag is imported from ('sygnal/ui') */
+  external?: string
+  /** static, PLAN-10 A-2: a widget tag (defineWidget, fromZag, fromReact, the sygnal/ui Zag parts) */
+  widget?: true
+}
+
+/** PLAN-10 A-5 (static): a CHILD.select(Child) call in an intent */
+export interface InspectChildSelect extends InspectLocation {
+  /** the selected component's name as written */
+  child: string | null
+  /** its id; null when it isn't in the graph */
+  id: string | null
+  /** the intent actions whose stream contains the call (the receivers of the child's PARENT sink) */
+  actions: string[]
 }
 
-export interface InspectSelector {
+export interface InspectSelector extends Partial<InspectLocation> {
   /** CSS selector passed to DOM.select() (chained selects joined with a space) */
   selector: string
   /** event types listened to; null when unknown (runtime, real DOM) */
@@ -139,10 +203,12 @@ export interface InspectSelector {
   isolationHit: string | null
   /** PLAN-4 CT-1: the control this selector is (its key), when it is `[data-control="<Key>"]` */
   control?: string
+  /** the `uses` key of the behavior that listens to it */
+  behavior?: string
 }
 
 /** PLAN-4 CT-1: a control (controls()) a component renders */
-export interface InspectControl {
+export interface InspectControl extends Partial<InspectLocation> {
   /** the control's key (rendered as data-control="<name>") */
   name: string
   /** the intrinsic tag of a tag spec; null for a spec object */
@@ -157,10 +223,14 @@ export interface InspectDiagnostic {
   code: string
   severity: DiagnosticSeverity
   component?: string
+  /** static, PLAN-10 A-3: the id of the component it is attached to */
+  componentId?: string
   message: string
   fix?: string
   docsUrl?: string
   data?: any
+  /** runtime only: when it was reported (ms since the epoch; each is reported once per process) */
+  timestamp?: number
   /** static only */
   file?: string
   line?: number
@@ -215,6 +285,12 @@ export interface InspectComponent {
   name: string
   /** runtime: instance number (as a string); static: 'file:line' of the definition */
   id: string
+  /**
+   * static, PLAN-10 D521: 'file#name', stable when lines move (hosts key selection and positions by it);
+   * a second component of the same name in one file gets 'file#name#2', and so on. Runtime (PLAN-10 P-2,
+   * D544): the same key when sygnal/vite's dev server stamped the component function, else absent
+   */
+  key?: string
   /** runtime: the parent instance's id; static: null (see the parents' `children`) */
   parentId: string | null
   /** static only: source file, relative to the working directory */
@@ -224,6 +300,32 @@ export interface InspectComponent {
    * component renders it, else how it is first rendered
    */
   kind: 'root' | 'child' | 'collection-item' | 'switchable'
+  /** PLAN-10 A-1 / D522: rendered as a component (or started as an entry) but has no statics */
+  viewOnly?: true
+  /**
+   * static, PLAN-10 A-6: started by run(), defineElement() or a Vike +Page / +Layout / +Wrapper; 'unknown' on the
+   * other roots when an entry call's component can't be resolved (picked at run time).
+   * runtime (D522): true on an app's root instance
+   */
+  entry?: true | 'unknown'
+  /**
+   * static, Vike only (PLAN-10 A-9): on a +Page's component its route ('/orders/@id': from the
+   * filesystem, or the literal string a +route file / the config's `route` sets); null for a Route
+   * Function or a route the checker can't read (with `routeDynamic`) and for _error/+Page. On a
+   * +Layout's / +Wrapper's: the URL prefix of the directory it applies to
+   */
+  route?: string | null
+  /**
+   * static, Vike only (PLAN-10 A-9): every route of a component several +Page files export (`route` is
+   * the first, in path order; null for a dynamic one or the error page); omitted otherwise
+   */
+  routes?: (string | null)[]
+  /** static, Vike only (PLAN-10 A-9): the route is a Route Function or can't be read (route: null) */
+  routeDynamic?: true
+  /** runtime, PLAN-10 D522: the app (run()) it belongs to: its root's index among the live roots, oldest first */
+  app?: number
+  /** runtime, PLAN-10 D522: false on a hidden Switchable page and below it; omitted when shown */
+  shown?: false
   actions: InspectAction[]
   /** state keys (runtime: current state; static: initialState) */
   stateKeys: string[]
@@ -231,14 +333,27 @@ export interface InspectComponent {
   calculated: string[]
   /** context fields this component provides (Component.context) */
   contextProvides: string[]
-  /** context fields its view reads (static only; null at runtime) */
+  /** context fields its view reads (static: the view source; runtime, D530: what its latest render read) */
   contextConsumes?: string[] | null
+  /**
+   * static, PLAN-10 A-7: top-level state keys the view (and its child lenses, calculated and
+   * context functions) reads literally; omitted when none
+   */
+  stateReads?: string[]
+  /** static, PLAN-10 A-7: stateReads may be incomplete (the state used whole somewhere) */
+  stateReadsPartial?: true
   /** EVENTS types this component emits */
   eventsEmitted: string[]
   /** EVENTS types this component selects ('*' = EVENTS.select() without a type) */
   eventsSelected: string[]
   children: InspectChild[]
   selectors: InspectSelector[]
+  /** static, PLAN-10 A-4: where the `context` static's entries are */
+  contextEntries?: Array<InspectLocation & { name: string }>
+  /** static, PLAN-10 A-4: the EVENTS emit and select sites of its intent and model */
+  eventSites?: Array<InspectLocation & { type: string; role: 'emit' | 'select' }>
+  /** static, PLAN-10 A-5: CHILD.select(Child) in its intent */
+  childSelects?: InspectChildSelect[]
   /** PLAN-4 CT-1: the controls it renders (runtime: seen in its renders); omitted when none */
   controls?: InspectControl[]
   /** static only, PLAN-4 GS-2 (G-224): the element commands (ELEMENT sink) its model sends; omitted when none */
@@ -253,7 +368,7 @@ export interface InspectComponent {
 }
 
 /** PLAN-4 GS-2: an element command a model entry sends (static inspect, sygnal-check --graph) */
-export interface InspectCommand {
+export interface InspectCommand extends Partial<InspectLocation> {
   /** the model entry that sends it */
   action: string
   /** the command's method (its first key) */
@@ -275,13 +390,15 @@ export interface InspectAgent {
   description: string | null
   /** the declaration has a read projection */
   read: boolean
-  actions: Array<{ name: string; consequential: boolean; input: boolean }>
+  actions: Array<{ name: string; consequential: boolean; input: boolean } & Partial<InspectLocation>>
+  /** the read-only `agent.queries` tools; omitted when none */
+  queries?: Array<{ name: string; input: boolean } & Partial<InspectLocation>>
   /** spreads: what is listed may be incomplete */
   partial?: true
 }
 
 /** PLAN-4 GS-7: a literal timer spec of a `timers` static (static inspect, sygnal-check --graph) */
-export interface InspectTimer {
+export interface InspectTimer extends Partial<InspectLocation> {
   name: string
   every?: number | null
   after?: number | null
@@ -316,8 +433,12 @@ export interface InspectGraph {
   /** which implementation produced the graph */
   source?: 'runtime' | 'static'
   components: InspectComponent[]
-  /** EVENTS bus: type -> names of the components that emit / select it */
-  events: Record<string, { emitters: string[]; selectors: string[] }>
+  /**
+   * EVENTS bus: type -> names of the components that emit / select it (each name once); emitterIds /
+   * selectorIds (PLAN-10 A-3, D522, D528): the id of every such component (static) or instance
+   * (runtime), not parallel to the names
+   */
+  events: Record<string, { emitters: string[]; selectors: string[]; emitterIds?: string[]; selectorIds?: string[] }>
   /** diagnostics not tied to a listed component */
   diagnostics: InspectDiagnostic[]
   /** runtime, PLAN-3 5-3: makeFetchDriver cache entries, by sink name (empty when no cache) */

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

@@ -0,0 +1,47 @@
+/**
+ * The 7.0 timing audit (SYG257, info): since 7.0 a model entry's STATE runs first and every other
+ * sink gets the state it committed (6.x gave them the state from before the action). For code
+ * written for 6.x, this reports each output sink that reads a top-level state field its action's
+ * STATE changed: it gets the new value now. Fix: read `props.previousState.<field>` where the old
+ * value is meant; a read meant to see the new value needs nothing. Opt-in, because in 7.0-native
+ * code reading the new value is the intent. Turn it on with any of:
+ *   - configureTimingAudit(true)                 (this entry)
+ *   - renderComponent(C, { timingAudit: true })  (tests)
+ *   - sygnal({ diagnostics: { timingAudit: true } })  (sygnal/vite, dev)
+ *   - globalThis.__SYGNAL_TIMING_AUDIT__ = true
+ * The flag lives on the core bridge (shared by every copy of this entry and renderComponent).
+ * Mechanism: the dev hook layer's wrapHandler (checks/next.ts) wraps each non-STATE handler and
+ * gives it the state through a Proxy that notes reads of changed top-level fields. Top-level
+ * fields only (a nested change shows as its top-level field changing); once per component name,
+ * action, sink and field. Nothing in production builds.
+ */
+import {bridge, devReport, once} from './shared'
+
+/** Turn the timing audit on (true), off (false), or back to the default (globalThis.__SYGNAL_TIMING_AUDIT__). */
+export function configureTimingAudit(on?: boolean): void {
+  const core = bridge()
+  if (core) core.timingAudit = on
+}
+
+/** Whether the timing audit is on. */
+export function isTimingAuditEnabled(): boolean {
+  const flag = bridge()?.timingAudit
+  return flag === undefined ? (globalThis as any).__SYGNAL_TIMING_AUDIT__ === true : flag === true
+}
+
+/** handler `h` of `f`'s action `type`, sink `sink`, audited (f: the checks' instance facade) */
+export const audited = (f: any, type: string, sink: string, h: any) => (s: any, d: any, nx: any, p: any, ...r: any[]) => {
+  const was = p?.previousState
+  if (!isTimingAuditEnabled() || !was || was === s || !s || typeof s != 'object' || typeof was != 'object' || Array.isArray(s)) return h(s, d, nx, p, ...r)
+  const view = new Proxy(s, {get(t: any, k: any, rcv: any) {
+    if (typeof k == 'string' && k in was && was[k] !== t[k] && once(`SYG257:${f.name}:${type}:${sink}:${k}`))
+      devReport('SYG257', {
+        component: f,
+        message: `${f.name}'s '${type}' ${sink} read state.${k}, which the same action's STATE changed: since 7.0 it gets the new value (6.x gave it the old one)`,
+        fix: `If it meant the value from before the action, read props.previousState.${k} (the 4th argument); if it meant the new value, nothing to change`,
+        data: {action: type, sink, field: k},
+      })
+    return Reflect.get(t, k, rcv)
+  }})
+  return h(view, d, nx, p, ...r)
+}

package/src/extra/diagnostics/codes.ts

@@ -152,6 +152,9 @@ export const CODE_TITLES: Record<string, string> = {
   SYG127: 'Behavior collision or unresolvable uses entry',
   SYG128: 'Duplicate control key',
   SYG129: "CHILD.select() of a component this one doesn't render",
+  // PLAN-10 X-1 (D512): graph-wide checks, static only (sygnal-check)
+  SYG170: 'Context field read with no provider',
+  SYG171: 'PARENT sink no parent reads',
   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',
@@ -307,6 +310,8 @@ export const CODE_TITLES: Record<string, string> = {
   SYG634: 'latest: true with a computed key',
   // PLAN-3 5-5 (D88)
   SYG635: 'Caching asked for without a queryCache',
+  // PLAN-11 U-1: progress requests (dev entry, fetch.ts)
+  SYG636: "progress that can't be reported as asked",
   // PLAN-4 GS-2: element commands (reported by the dev entry, checks/elementCommands.ts)
   SYG640: 'Element command target not found',
   SYG641: 'Unknown element command',
@@ -366,6 +371,9 @@ export const CODE_TITLES: Record<string, string> = {
   // PLAN-9 X-2: static only (sygnal-check rules/syg253-catalog.js)
   SYG253: 'Misspelled catalog declaration key',
   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)',
+  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',
@@ -427,6 +435,9 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG128: 'error',
   // PLAN-4 4-G2: static only (sygnal-check); listed so the entry knows its title
   SYG129: 'warn',
+  // PLAN-10 X-1: static only (sygnal-check)
+  SYG170: 'warn',
+  SYG171: 'warn',
   SYG221: 'error',
   // PLAN-4 GS-4 (state.ts)
   SYG222: 'warn',
@@ -475,6 +486,8 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   SYG634: 'info',
   // PLAN-3 5-5 (fetch.ts)
   SYG635: 'warn',
+  // PLAN-11 U-1 (fetch.ts)
+  SYG636: 'warn',
   // PLAN-4 GS-2 (checks/elementCommands.ts, through the core bridge; renderComponent too)
   SYG640: 'warn',
   SYG641: 'error',
@@ -591,6 +604,12 @@ export const DEV_CODE_SEVERITY: Record<string, DiagnosticSeverity> = {
   // PLAN-9 X-2: static only (sygnal-check); listed so the entry knows their titles
   SYG253: 'warn',
   SYG254: 'info',
+  // PLAN-12: static only; proven after-state output guard contradiction.
+  SYG256: 'warn',
+  // 7.0: the opt-in timing audit (checks/next.ts; configureTimingAudit)
+  SYG257: 'info',
+  // PLAN-12: static only for legacy (6.x) binding contracts. Sygnal 7 remounts known targets.
+  SYG454: 'warn',
 }
 
 export function getCodeInfo(code: string): DiagnosticCodeInfo | undefined {